I kind of want something like, to borrow JSON-like syntax and gloss over namespacing issues:
(foo .
{type: listy-cons-cell
head: bar
tail: (baz quux)})
You can have vectors, hash maps, and sets in addition to lists, symbols, and keywords.
($define! foo
($bindings->environment
(bar "Hello World")
(baz 1234)
(qux #f)))
($remote-eval bar foo) ==> "Hello World"
foo ==> #[environment]
($provide! ($struct struct? destruct $get)
($define! (struct-intro struct? struct-elim)
(make-encapsulation-type))
($define! destruct
($lambda (struct)
(cdr (struct-elim struct))))
($define! $get
($vau (struct member) e
($let ((record (car (struct-elim (eval struct e)))))
(eval member record))))
($define! zip
($lambda (keys values)
($if ($and? (null? keys) (null? values))
()
(cons (list (car keys) (car values)) (zip (cdr keys) (cdr values))))))
($define! $struct
($vau kvpairs env
($let* ((keys (map car kvpairs))
(values (map ($lambda (pair) (eval (cadr pair) env)) kvpairs))
(record (apply (wrap $bindings->environment) (zip keys values))))
(struct-intro (cons record values))))))
($define! foo
($struct
(bar "Hello World")
(baz (+ 12 43))
(qux #f))) ==> #inert
(struct? foo) ==> #t
(pair? foo) ==> #f
(environment? foo) ==> #f
(destruct foo) ==> ("Hello World" 55 #f)
($get foo bar) ==> "Hello World"
($get foo baz) ==> 55
($get foo qux) ==> #f
($get foo foo) ==> ERROR: Unbound symbol: foo
foo ==> #[encapsulation]
Klisp (essentially complete implementation of Kernel): https://github.com/dbohdan/klisp
With a vertical script like japanese you could easily rotate the whole program 90 degrees to the right (as shown at the bottom of the landing page)
https://web.archive.org/web/20240904091932/https://lookalive...
{
"#!join": [
[
"A triangle with side of ",
"#& side",
" and base of ",
"#& base",
"has a hypotenuse of",
{
"#!sqrt": [
[
{
"#!sum": [
[
"#!multiply side side",
"#!multiply base base"
]
]
}
]
]
}
]
]
} (eq (mul (a a)) (pow (a 2)))
eq
mul
a a
pow
a 2I should trademark this name.
Our visual system has the ability to detect implied straight lines (and other simple geometric outlines) from very small clues.
Therefore "seeing" the vertical lines implied by the indentation is effortless - so it's immediately obvious which elements belong to each other.
Indentation is an incredibly valuable "brain" hack that manages to instantly communicate hierarchy, not something to be sneered at.
We have no such innate ability to match parenthesis - determining hierarchy in a jumble of open and close parenthesis requires precise counting or, typically these days, tool/editor/IDE support.
Really? How do you see the difference between "TAB" and "SPACE SPACE TAB"?
eq (mul a a)
(pow a 2)
defun min (a b)
(if (a < b) a b)
phoe-krk•5h ago
Traditional S-expressions, by their definition, ignore most of whitespace; additionally, reading sexprs is always a linear operation without the need to backtrack by more than one character.
The suggestion from this post violates both assumptions by introducing a 2D structure to code. To quote this post's examples, it requires the multiline string in
to be fully read before TRD-ATOM. It also forces the reading function to jump up and down vertically in order to read the structure in The author also states that is less readable than Then there's the ending passage:> we hope that the introduced complexity is justified by the data readability expressed this way.
I cannot force myself to read this post as anything but a very poor Befungesque joke.
tgv•5h ago
derriz•1h ago
hyperhello•1h ago
derriz•1h ago
Actually, I'd suggest a slight improvement: x*x = x^2
unstruktured•4h ago
tearflake•1h ago
velcrovan•4h ago
f1shy•3h ago
I’ve seen dozens of attempts to make S-Exp “better” even the original M-Exp. I also did some experiments myself. But at the end, I come back to goo’ol s-exp. Seems to be a maximum (or minimum) found just perchance.
tearflake•1h ago
exeldapp•18m ago