Piers Cawley wrote:
>  "TSa (Thomas Sandlaß)" <Thomas.Sandlass@[...].com> writes:
>  
>  
> >Piers Cawley wrote:
> >
> >>My preference is for:
> >>    Boo
> >>    Boo
> >>    Can't dereferene literal numeric literal 42 as a coderef.
> >
> >How do you reach the second 'Boo'? Iff -> does not create a Sub
> >but a Block instance then Luke's code can be interpreted as a
> >much smarter version of
>  
>  
>  I really wish you'd quote in more detail, it makes it a real PITA to go back
>  and find the explanatory code.  

Sorry, but I try to quote only the text that I'm really referring to,
not the transitive closure of the thread at that point. If I cut
too much here, I apologize.


>      sub foo () {
>        return -> { return 42 }
>      }

What I do not understand right now is, how the first
return is handled. As Luke pointed out, the inner return
inevitably makes the current invocation of &foo return.
But you argue, that ->  suspends the current invocation
of foo and returns it as continuation. How does that fit
the pointy sub of a for loop? Is the surrounding sub
suspended as well? And then one could continue right there?

sub forfoo ()
{
    for 0..9 ->  $x
    {
       return $x;
    }
}

my $y = forfoo(); # suspends forfoo in first loop?

say $y; # prints 0, and suspends forfoo in second loop

say **$y; # prints the remaining invocations of &forfoo?


I figure that the implementation is actually straight
forward. The pointy sub catches the return exception
and handles it by suspending &forfoo and returning the
resulting continuation.


>      my $code =   foo();
>      #          ^--- continuations points to the RHS of the assignment
>      say "Boo!";
>      $code();
>  
>  So, this is what happens.
>  
>  1. foo() returns a coderef to the RHS of the assignment.
>  2. The coderef gets assigned to $code.
>  3. say "Boo!"
>  4. We invoke the coderef, which returns 14 to continuation which was current
>     when it was created.
>  5. That means 42 gets returned to the RHS of the assignment
>  6. say "Boo!"
>  7. Try to invoke the literal 42.

Hmm, I see in both cases an MMD to &postfix:<( )>  with
the then current value of $code as invocant. In the
first run the target is &postfix:<( )> :( Ref of Block :)
and in the second case it's &postfix:<( )> :( Int :).
If the latter is defined to die, so be it. I opt for
just returning the value. Which produces the fallout that

$y = 42();

Is first of all valid syntax, and dispatches at runtime
unless the compiler can proof at compile time that there
can't possibly be an implementation at runtime. Thus one
could write:

multi sub *postfix:<( )>  ( 42 ) # or ( Int $x where $x eq '42' )
{
    return 66; # == hex 42
}

A pragma like 'use hexliterals' might actually implement a
general version of this idea.
-- 
TSa (Thomas Sandlaß)