Code object with its own lexical scope
Block is a code object meant for small-scale code reuse. A block is created syntactically by a list of statements enclosed in curly braces.
Without an explicit signature or placeholder arguments, a block has
$_ as a positional argument
my = ;say .^name; # OUTPUT: «Block␤»say ('hello'); # OUTPUT: «HELLO␤»
A block can have a Signature between
<-> and the block:
my = -> , = 2 ;say (40); # OUTPUT: «42␤»
my = <-> , ;my (, ) = (2, 4);(, );say ; # OUTPUT: «4␤»
Blocks that aren't of type
Routine (which is a subclass of
Block) are transparent to return.
The last statement is the implicit return value of the block.
say .(); # OUTPUT: «1␤»
Bare blocks in sink context are automatically executed:
say 1;say 3;
Block inherits from class Code, which provides the following routines:
multi method ACCEPTS(Code: Mu )
Usually calls the code object and passes
$topic as an argument. However, when called on a code object that takes no arguments, the code object is invoked with no arguments and
$topic is dropped. The result of the call is returned.
method arity(Code: --> Int)
Returns the minimum number of positional arguments that must be passed in order to call the code object. Any optional or slurpy parameters in the code object's
Signature do not contribute, nor do named parameters.
sub argless()sub args(, ?)sub slurpy(, , *)say .arity; # OUTPUT: «0␤»say .arity; # OUTPUT: «1␤»say .arity; # OUTPUT: «2␤»
method assuming(Callable : |primers)
Callable that implements the same behavior as the original, but has the values passed to .assuming already bound to the corresponding parameters.
my sub slow();# takes only one parameter and as such wont forward $nsub bench();say .assuming(10000000).; # OUTPUT: «(10000000 7.5508834)␤»
For a sub with arity greater than one, you can use
* for all of the positional parameters that are not "assumed".
sub first-and-last ( , )my = .assuming( *, 'Smith' );.( 'Joe' ); # OUTPUT: «Name is Joe Smith␤»
You can handle any combination of assumed and not assumed positional parameters:
sub longer-names ( , , , )my = .assuming( *, *, 'Public', * );.( 'Joe', 'Q.', 'Jr.'); # OUTPUT: «Name is Joe Q. Public Jr.␤»
Named parameters can be assumed as well:
sub foo.assuming(13, :42foo)(24, :72bar); # OUTPUT: «13 24 42 72␤»
# We use a Whatever star for the invocant:my = Str.^lookup('comb').assuming: *, /P \w+/;say comber 'Perl is awesome! Python is great! And PHP is OK too';# OUTPUT: «(Perl Python PHP)␤»my =.assuming: 'Perl 6';say learner :6months; # OUTPUT: «It took me 6 months to learn Perl 6␤»
method count(Code: --> Real)
Returns the maximum number of positional arguments that may be passed when calling the code object. For code objects that can accept any number of positional arguments (that is, they have a slurpy parameter),
count will return
Inf. Named parameters do not contribute.
sub argless()sub args(, ?)sub slurpy(, , *)say .count; # OUTPUT: «0␤»say .count; # OUTPUT: «2␤»say .count; # OUTPUT: «Inf␤»
multi method signature(Code: --> Signature)
Signature object for this code object, which describes its parameters.
sub a(Int , Str ) ;say .signature; # OUTPUT: «(Int $one, Str $two)␤»
method cando(Capture )
Returns a list of candidates that can be called with the given Capture. Since
Code objects do not have any multiple dispatch, this either returns a list with the object, or an empty list.
multi method Str(Code: --> Str)
Will produce a warning. Use
sub marine()say ~; # OUTPUT: «marine␤»say .Str; # OUTPUT: «marine␤»
method file(Code: --> Str)
Returns the name of the file in which the code object was declared.
method line(Code: --> Int)
Returns the line number in which the code object was declared.
method CALL-ME(Callable : |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.
does Callablemy = A;say a(); # OUTPUT: «called␤»