Source
List of features
- Array
arr := [a, b, c] with lookup arr[0] and lookup with array of indices arr[[0, 0]]
- Object
obj := {x: a, y: b}
- Number (f64)
n := 5.3
- Boolean
t := true
- Link
link { 1 2 "hi" false }
- Custom Rust objects using
Arc<Mutex<Any>>
- Functions without return
fn foo() { ... } and with return fn foo() -> { ... return x }
- Functions as mathematical expresisons
f(x) = x / (x - 1)
- Optional namespaces with shared aliases
ns program::example::test
- Lifetime checker (no garbage collector is needed)
fn foo(mut a, b: 'a) { a.x = b }
- Return lifetime
fn id(x: 'return) -> { return x }
- Mutability checker
fn foo(mut a) { bar(mut a) }
- Checks type at runtime when mutating variable
a = 2.0 // ERROR: Expected assigning to number
- Objects inserts new key with
a.x := 0 and checks existence and type with a.x = 0
- Named argument syntax based on snake case
foo(bar: b) is equal to foo__bar(b)
- If expression
a := if b < c { 0 } else { 1 }
- For loop
for i := 0; i < 10; i += 1 { ... }
- Short For loop
for i 10 { ... } and with offset for i [2, 10) { ... }
- Infer range from loop body
for i { println(list[i]) }
- Packed loop
for i, j { println(list[i][j]) }
∑/sum, ∏/prod, min, max, sift, ∃/any, ∀/all loops- Secrets derived from loops
why(any i { list[i] > 3 })
- Link loop
- Infinite loop
loop { ... }
- Unlabeled break
loop { break } and unlabeled continue loop { continue }
- Labeled break
'a: loop { break 'a } and labeled continue 'a: loop { continue 'a }
- Use
return as a variable without exiting return = 8
- Dynamic modules
m := unwrap(load("script.dyon")) then call(m, "main", [])
- Import to module prelude
m := unwrap(load(source: "script.dyon", imports: [window, graphics]))
- Add a custom Rust function using
Module::add
- Option values with
none() or some(x)
- Result values with
ok(x) or err(x)
? operator to propagate errors, e.g. x := foo()?, maps option to result automaticallyunwrap(x) prints trace of propagated errorfunctions() returns sorted list of all available functions in a module- Optional type system
fn could(list: []) -> f64
- Ad-hoc types
fn players() -> [Player str] { ... }
- Current objects
fn render() ~ world { ... }
- Go-like coroutines with
go thread := go foo()
- In-types concurrency
receiver := in foo with for-in loops for x in a {print(x[0]}
- Closures
\(x) = x + 1
- Grab expressions
\(x) = (grab a) + x
- Lazy invariants
fn intersect(a: [] => [], b: [] => []) -> [] { ... }
- Simple refinement types
(vec4) -> vec4
- 4D vectors with
f32 precision (x, y, z, w)
- 4D matrices with
f32 precision mat4 {1,2,3,4; 5,6,7,8; 9,10,11,12; 13,14,15,16}
- Un-loop for 4D vectors
vec4 i f(i)
- Unpack 4D vectors
f(xy v)
- Swizzle 4D vectors
(yxz v, 1)
- HTML hex colors
#fab3ee
- Meta parsing
- Macros for embedding in Rust
dyon_fn!{fn say_hello() { println!("hi!"); }}
Motivation and goals
The idea was to make a simple, but convenient scripting language that integrated well with Rust.
- During the first week of coding, a way to do lifetime checking on function arguments was discovered
- A different approach to code organization was explored by adding the ability to dynamically load modules
- For nice error handling, added option, result and
? operator
- To test the design of the language, created a demo for interactive coding
- Mutability check to improve readability
- Short For loop to improve readability and performance
- Mathematical loops and Unicode symbols to improve readability
- Go-like coroutines to add multi-thread support
- 4D vectors with unpack and swizzle to make 2D and 3D programming easier
- Html hex colors to make copying colors from image editors possible
- Optional type system to help scaling a project
- Ad-hoc types for extra type safety
- Current objects to improve prototyping and tailored environments
- Macros for easier embedding with Rust
- Secrets to automatically derive meaning from mathematical loops
- Closures that can be printed out, use current objects and grab from closure environment
- Type safety for secrets, easy load/save of Dyon data
- Link loop for easier and faster code generation and templates
- In-types for easy cross thread communication
Main goals:
- Integrate well with Rust
- Flexible way of organizing code
Performance will be optimized for the cycle:
coding -> parsing -> running -> debugging -> coding
Sub goals:
Non-goals:
- Rust equivalent performance
- Replace Rust to build libraries
- Interfacing with other languages than Rust
Tags:
language
Last modified 16 December 2024