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 <> 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 <> 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


*~ La mejor manera de librarse de la tentación es caer en ella**. ~ Oscar
Wilde* ~

Reply via email to