in reply to Re^3: IO::Lambda: call for participation
in thread IO::Lambda: call for participation

In short, context is an alternative stack. Contrary to values on the normal, everyday perl stack, that come and go as subroutines are being called, context is retained within a lambda. Predicates use context instead of the perl stack to receive their parameters. In the following code 

context $a, $b, $c;
predicate1 {
predicate2 {
}}

[download]
Both predicate1 and predicate2 use values $a, $b, $c from the context, even though predicate2 is called after code that called predicate1 is finished. That code is identical to the following: 

context $a, $b, $c;
predicate1 {
context $a, $b, $c;
predicate2 {
}}

[download]

From the architectural point of view, context is syntactic sugar. The same effects can be achieved without using it, but at the price of more complex and/or ugly code.

Replies are listed 'Best First'.
Re^5: IO::Lambda: call for participation
by zby (Vicar) on Jan 05, 2009 at 20:30 UTC
    What is lacking here as well as in the original docs is how context is used - this only says about how it is created.
[reply]
      Hmm... I'll answer my best and you please tell me if that answers the question. First, context is accessed as context() property, in get-style:  my ( $a, $b, $c) = context and in set-style:  context $a, $b, $c.

      When one is concerned only with calling predicate functions, such as tail() or read(), context is usually only set, and is not read. It's not impossible, just unneeded.

      However, when one needs to write a custom function, that is on the receiving end of context, then the function needs to read the data passed through context. For example, you need to write a wrapper over IO::Lambda::sleep() that also prints number of seconds to sleep: 

      sub my_sleep(&)
{
   print "sleeping ", context, "seconds\n";
   &sleep(shift);
}

      [download]
      And that is about it. If the caller wants to restart the call by 
      context 5;
my_sleep { again if $again }

      [download]
      then the framework makes sure that 5 is still stored in the context, as my_sleep is called from within again().

      Does that answers the question?

[reply]
[d/l]
[select]
        Yes - that explains context. Now I also found it in the docs. Initially I was looking in Context - now I see it is described in Predicates.

        I hope you don't mind that I'll ask another question - what is the signature of sleep? The documentation says "sleep($deadline) Executes after $deadline". So here is what I would expect to work: 

        sub my_sleep(&)
{
   ( $deadline ) = context;
   print "sleeping ", $deadline, "seconds\n";
   &sleep($deadline);
}

        [download]
        But from the example you gave above (and the other ones in the POD) it seems that actually sleep takes the $deadline from the context and the parameter passed to it is actually a callback - is that right or I am totally confused? What does it do with the passed callback?

        After having written that I read Re^5: IO::Lambda: call for participation - and it partially answers this and again I can see it described in the Predicates section. Somehow I did not notice it at the first reading - maybe I expected the predicates to be really simple mathematical logic predicates.

[reply]
[d/l]
[select]

In Section Meditations