CPS::Governor (3pm)

Objects based on this abstract class are used by the \*(C`gk*\*(C' variants of the \s-1CPS\s0 functions, to control their behavior. These objects are expected to provide a method, \*(C`again\*(C', which the functions will use to re-invoke iterations of loops, and so on. By providing a different implementation of this method, governor objects can provide such behaviours as rate-limiting, asynchronisation or parallelism, and integration with event-based \s-1IO\s0 frameworks.

Must be called on a subclass which implements the \*(C`again\*(C' method. Returns a new instance of a governor object in that class.

Because this is an abstract class, instances of it can only be constructed on a subclass which implements the following methods: Execute the function given in the \*(C`CODE\*(C' reference $code, passing in the arguments @args. If this is going to be executed immediately, it should be invoked using a tail-call directly by the \*(C`again\*(C' method, so that the stack does not grow arbitrarily. This can be achieved by, for example:

 @_ = @args;
 goto &$code;

Alternatively, the Sub::Call::Tail may be used to apply syntactic sugar, allowing you to write instead:

use Sub::Call::Tail; ... tail $code->( @args );

A Governor With A Time Delay

Consider the following subclass, which implements a \*(C`CPS::Governor\*(C' subclass that calls \*(C`sleep()\*(C' between every invocation.

package Governor::Sleep

use base qw( CPS::Governor );

sub new { my $class = shift; my ( $delay ) = @_;

my $self = $class->SUPER::new; $self->{delay} = $delay;

return $self; }

sub again { my $self = shift; my $code = shift;

sleep $self->{delay};

# @args are still in @_ goto &$code; }

• Sub::Call::Tail - Tail calls for subroutines and methods

Paul Evans <[email protected]>