Yes, let is just a simpler form of withs, but it's worth using because it signals that you only need one var and therefore skips extra parens.
withs is the sequential form of with, where you'd like each variable available in defining later variables within the with. You have to say:
arc> (withs (x 1 y (* x 2)) (+ x y))
..but you can use the simpler with in:
arc> (with (x 1 y 2) (+ x y))
Not only can you, you should. Using the most general form when a simpler form will do is akin to crying wolf; it's very useful when reading code to be able to tell simpler parts from more complex parts at a single glance.
So use with to signal that you're defining multiple variables at once. Use withs to signal that there's a dependency between the definitions. If there's no dependency, with is more idiomatic. And if there's only one variable, let is more idiomatic. Finally, a withs with multiple bodies and a trivial body is easier to read if you put the final expressions into the body. This:
(withs (x 1
y (f x z))
y)
is better written as:
(withs (x 1)
(f x z))
and therefore:
(let x 1
(f x z))
(and further to (f 1 z), but let's pretend x is being bound to something less trivial.)
Even if a body is a little more complex:
(withs (x complex-expr1
y (complex-expr2 x)
z (complex-expr3 y))
(car z))
it's sometimes nicer to read as:
(withs (x complex-expr1
y (complex-expr2 x))
(car (complex-expr3 y)))
let, with and withs are nothing but macros, so if you avoid using them you're giving up the benefits of lisp. Might as well go back to a weaker language. In general, my idea when learning lisp was: "Since I come from an imperative background my tendency is to define intermediate variables. Therefore I will start by avoiding all temporaries, and only after I get it working will I insert the fewest possible temporaries to make the code readable." It's stood me in good stead.
Thank you for writing up such a clear explanation.
There are definitely safety benefits to using the simplest form. But I would prefer to use the most general form (withs) because I won't need to worry about using the most idiomatic form or to switch from one form to another as the program changes. It frees me to worry about other things.
Being able to tell simpler parts from more complex parts at a single glance isn't as much of a concern for me. I noticed I don't go back to even read code of programs that didn't solve a big enough problem. The programs reach a dead end and don't develop further. There are more important things to worry about when writing a program.
Also note what let, with, and withs offer could be provided in other languages too. Them being implemented as macros in Arc is incidental. You're not giving up the benefits of lisp by not using them.
