Re: [stack] A question on joy syntax.

I tried to define ifte as it is implemented in joy1 and I found this:

[T] [A] [B]
ifte == [[[stack] dip] dip
               [dip swap] dip] dip    #save stack and run T
            choice [unstack] dip i; # restore stack and choose  
between A and B

The stack is saved before the execution of [T] and restored before the
execution of [A] or [B]. The test in this case is non destructive;  
the stack
is unchanged before choosing between A and B.

The way you implmented ifte is as follows:

[T] [A] [B]
ifte == [[i] dip] dip  #run T
             choice i;     # choose between A and B

Obviously your implementation is faster, but the test in this case
is destructive; the stack can be modified greatly depending on T.

Is it more difficult or easier to reason with destructive tests?

Taoufik

On Mar 1, 2007, at 9:17 PM, Rahul wrote:

> I have been looking through the joy papers, and have
> this confusion:
>
> The help on ifte says:
>
> ifte [B] [T] [F] -> ...
> Executes B. If that yields true, then executes T
> else executes F.
>
> Now the help on = says:
> = X Y -> B
> Either both X and Y are numeric or both are strings
> or symbols. Tests whether X equal to Y. Also supports
> float.
>
> I assumed that '=' will consume two arguments off the stack,
> and leave the true or false on top.
>
> the joy interp seems to support this.
>
> 1 2 = .
> false
> .
>
> Now, if I use the same inside an ifte
> 1 5 [1 =] [dup *] [dup +] ifte .
> 10
>
> The doubt I have is this:
> as soon as [1 =] is executed, I would expect '5' off the stack,
> so the [dup +] should have actually found '1' on the stack and given
> me 2.
>
> I checked this too: which seems to do fine.
> 5 [true] [dup *] [dup +] ifte .
> 25
>
> Is there a reason for this? Is for some reason the stack
> invariant when executing ifte condition?
> The below seems to verify it.
>
> 5 6 [pop 1 =] [dup *] [dup +] ifte .
> 12
> .
> 5
>
> But I cant find any info on this.
> The other quoted programs does not seem to share the invariant stack
> behavior:
> ================================
> i [P] -> ...
> Executes P. So, [P] i == P.
>
> 1 2 [1 +] i .
> 3
> .
> 1
>
> Could some one please explain why this is so? or guide me to the
> docs that explains it?
>
> rahul.
>
>
> 



[Non-text portions of this message have been removed]