Piers Cawley wrote:
"TSa (Thomas Sandla▀)" <[EMAIL PROTECTED]> writes:

Piers Cawley wrote:

My preference is for:
   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!";

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

Reply via email to