role Callable

Invocable code object

role Callable { ... }

Role for objects which support calling them. It's used in Block, Routine, Sub, Method, Submethod and Macro types.

Callables can be stored in &-sigiled containers, the default type constraint of such a container is Callable. A signature object can be used to force a check against the signature of the Callable to be stored into the container.

my &a = {;}# Empty block needs a semicolon 
my &b = -> {};
my &c = sub () {};
sub foo() {};
my &d = &foo;
my &f:(Int= sub bar(Int{}# Not yet implemented 
my &f:(Str= -> Str {};       # Not yet implemented 

Methods

method CALL-ME

method CALL-ME(Callable:D $self: |arguments)

This method is required for postfix:«( )» and postfix:«.( )». It's what makes an object actually call-able and needs to be overloaded to let a given object act like a routine. If the object needs to be stored in a &-sigiled container, is has to implement Callable.

class A does Callable {
    submethod CALL-ME(|c){ 'called' }
}
my &a = A;
say a(); # OUTPUT: «called␤» 

method assuming

method assuming(Callable:D $self: |primers)

Returns a Callable that implements the same behaviour as the original, but has the values passed to .assuming already bound to the corresponding parameters.

my sub slow($n){ my $i = 0$i++ while $i < $n$i };
 
# takes only one parameter and as such wont forward $n 
sub bench(&c){ cnow - ENTER now };
 
say &slow.assuming(10000000).&bench# OUTPUT: «(10000000 7.5508834)␤» 

Operators

infix:<∘>

The function composition operator infix:<∘> or infix:<o> combines two functions, so that the left function is called with the return value of the right function. If the .count of the left function is more than 1, the return value of the right function will be slipped into the left function.

sub f($p){ say 'f'$p / 2 }
sub g($p){ say 'g'$p * 2 }
 
my &composed = &f  &g;
say composed 2# OUTPUT: «g␤f␤2␤» 
# equivalent to: 
say 2.&g.&f;
# or to: 
say f g 2;
sub f($a$b$c{ [~$c$b$a }
sub g($str){ $str.comb }
my &composed = &f  &g;
say composed 'abc'# OUTPUT: «cba␤» 
# equivalent to: 
say f |g 'abc';

Type graph

Type relations for Callable
perl6-type-graph Callable Callable Mu Mu Any Any Any->Mu ForeignCode ForeignCode ForeignCode->Callable ForeignCode->Any Code Code Code->Callable Code->Any WhateverCode WhateverCode WhateverCode->Code Block Block Block->Code Routine Routine Routine->Block Method Method Method->Routine Macro Macro Macro->Routine Sub Sub Sub->Routine Submethod Submethod Submethod->Routine Regex Regex Regex->Method

Stand-alone image: vector