| I am not a Lisp expert by any stretch, but let's clarify a few things: 1. Just for the sake of other readers, we agree that the code you quoted does not compile, right? 2. `let` is analogous to a scope in other languages (an extra set of {} in C), I like using it to keep my variables in the local scope. 3. `let` is structured much like other function calls. Here the first argument is a list of assignments, hence the first double parenthesis (you can declare without assigning,in which case the double parenthesis disappears since it's a list of variables, or `(variable value)` pairs). 4. The rest of the `let` arguments can be seen as the body of the scope, you can put any number of statements there. Usually these are function calls, so (func args) and it is parenthesis time again. I get that the parenthesis can get confusing, especially at first. One adjusts quickly though, using proper indentation helps. I mostly know lisp trough guix, and... SKILL, which is a proprietary derivative from Cadence, they added a few things like inline math, SI suffixes (I like that one), and... C "calling convention", which I just find weird: the compiler interprets foo(something) as (foo something). As I understand it, this just moves the opening parenthesis before the preceding word prior to evaluation, if there is no space before it. I don't particularly like it, as that messes with my C instincts, respectively when it comes to spotting the scope. I find the syntax more convoluted with it, so harder to parse (not everything is a function, so parenthesis placement becomes arbitrary): let( (bar-x(bar(x))
quux-y(quux(y)))
foo(bar-x quux-y z)
)
|