kasdeya
kasdeya
Show content
one thing that really trips me up about Lisp syntax is dealing with comparison operators like > and <. for arithmetic operators I can kinda deal with them by thinking about them like this:
(+ 1 variable) ; this plus-ones the variable
as opposed to this:
(+ variable 1) ; this applies plus to the variable and one (much harder to think about)
but with comparison operators:
(< 1 variable)
;; hmm okay so (< 1 variable) means (variable < 1) right? or wait no it's (1 < variable), isn't it? it doesn't less-than-one the variable, it greater-than-ones the variable... I think?
super confusing. I keep vacillating between “Lisp’s syntax is actually genius” and “macros are cool and the syntax is simple but nothing is worth the tradeoff of how hard this is to read and write”
1
0
1
I think my current thoughts are: matching parenthesis is very very error prone and often leads to errors that are extremely difficult to track down. also it’s very difficult to read or write this language. both of those are very serious downsides
it seems like Rust’s macro system lets you operate on trees of data, instead of individual tokens, which sounds almost as good as Lisp’s macro system
Lisp’s syntax is very very simple but that comes at the cost of both readability and writeability. it does let you make macros in a straightforward way, which is very very cool, but so does Rust from what I understand. Lisp is definitely a dramatically worse language than a hypothetical scripting language that has Rust’s macro system
but, I don’t think a language like that exists yet, so instead Lisp is… a very painful tradeoff, and maybe useful for niche cases when you want to create your own DSL and metaprogramming in a language like Python or Lua isn’t good enough
1
0
2