The reason for this difference is let behaviour: let binds a symbol to a value *inside* let expression but first saves values of binding symbols and once evaluated the expression it restores previous symbols values saved.
So, when you wrap a expression in a let binding you are protecting the symbols values for further modification, each internal wrapping with let gives you a layer of protection. In first version you protect the expression in a let wrapping, the expression (the let body) may change symbols in any way because after being evaluated (let's say when exiting let function) the symbol value of symbols bound by let will be restored to previus value. But *inside* the clause changes happen! : (let X 0 # let binds symbol X to 0 *inside* let expression (the following line) (for Y 3 (inc 'X) (prinl X)) # in this let expression every change to symbol X takes effect, in particular incrementing it ) # after execution of let expression binding symbols are restored to saved value (in this case without more information it shoud be NIL) But in second version you add an extra protection layer to the expression by wrapping it in a let binding, as always expressions may change symbols inside let expression but now they are protected by a internal let layer which "hides changing effects" : (let X 0 # let binds symbol X to 0 *inside* let expression (the following lines) (for Y 3 (let X (inc 'X) # but now you have an extra let protecction layer which binds X thus protecting it for changes made in inner let expression by saving current X value (0) (prinl X) # this is inner let expression, prints the value of inner X binding (which is always 1 because is always incrementing 0 by 1 as we will see) ) # at this point let restores value of symbol X to previous value , which is 0 as set by outer let binding ) # so each step of for loop symbol X has value 0 (because is setted by outer let and restored by inner let) and thus get incremeted to 1 ) So as you can see let is used to isolate actions without affecting current symbol values, you can think of it as "hiding actions" You can think about it in terms of lambda applications which may be easier to understand (if you're interested let me know ;-) As picolisp seem not to have a let* like in classical lisp I assume let bindings are done in parallel as traditionally let behaves in classical lisp, sure Alex can state it clearly On Thu, Feb 2, 2017 at 7:20 PM, dean <deangwillia...@gmail.com> wrote: > Just to illustrate what I meant... > : (let X 0 > (for Y 3 > (let X (inc 'X) (prinl X)))) > 1 > 1 > 1 > -> 1 > > On 2 February 2017 at 18:16, dean <deangwillia...@gmail.com> wrote: > >> Thank you very much for the advice....I've just used that and it's worked >> a treat.... >> >> : (let X 0 >> (for Y 3 >> (inc 'X) (prinl X))) >> 1 >> 2 >> 3 >> -> 3 >> > -- Andrés *~ La mejor manera de librarse de la tentación es caer en ella**. ~ Oscar Wilde* ~