76 lines
1.1 KiB
Markdown
76 lines
1.1 KiB
Markdown
# puyo 3 (this time it's nameful)
|
|
|
|
## semantics
|
|
single-threaded, dynamically-typed (because lol), multiple named returns by default, pass-by-value
|
|
|
|
functions take and return a map ALWAYS
|
|
|
|
Values:
|
|
- function
|
|
- number (f64)
|
|
- map (HashMap<Symbol, >)
|
|
|
|
## examples
|
|
`double x = x * 2`
|
|
```rust
|
|
double = fn([x] [x]) (
|
|
^x = x * 2;
|
|
);
|
|
```
|
|
|
|
`apply f x = f x`
|
|
```rust
|
|
;; same as apply = fn([f x] [x]) ( ... )
|
|
fn apply([f x] [x]) (
|
|
^x = f x;
|
|
);
|
|
|
|
;; f would have to be like fn([a] [a]) ( ... )
|
|
```
|
|
|
|
```scheme
|
|
(define (make-counter)
|
|
(let ([i 0])
|
|
(lambda ()
|
|
(set! i (+ i 1))
|
|
i)))
|
|
```
|
|
```rust
|
|
fn make_counter([] [inc]) (
|
|
i = 0;
|
|
^inc = fn([] [i]) (
|
|
i = i + 1;
|
|
^i = i;
|
|
);
|
|
|
|
;; or fn ^inc(...)
|
|
)
|
|
```
|
|
|
|
`desat hsla = { hsla with s := hsla.s / 2 }`
|
|
```rust
|
|
;; omitting the return means it's the same
|
|
fn desat([h s l a]) (
|
|
^s = ^s / 2;
|
|
)
|
|
```
|
|
|
|
`compose f g x = f (g x)`
|
|
```rust
|
|
fn compose([f g x] [x]) (
|
|
^x = g x;
|
|
^x = f x;
|
|
)
|
|
|
|
f = fn([x]) (^x = x + 2;);
|
|
g = fn([x]) (^x = x * 3;);
|
|
f2 = f;
|
|
|
|
compose f g x == (((compose f) g) x) == compose {f: f2, g} x == compose {x} f g
|
|
```
|
|
|
|
`id x = x`
|
|
```rust
|
|
fn id([x]) ()
|
|
```
|