=begin pod :kind("Type") :subkind("class") :category("basic")

=TITLE class Block

=SUBTITLE Code object with its own lexical scope

    class Block is Code { }

A C<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. The literal for
creating an empty block is C<{;}>.

Without an explicit signature or placeholder arguments, a block has C<$_>
as a positional argument, which defaults to the outer scope's C<$_>. Thus it
will inherit the L<topic|/language/variables#index-entry-topic_variable> if there is any.

    my $block = { uc $_; };
    say $block.^name;           # OUTPUT: «Block␤»
    say $block('hello');        # OUTPUT: «HELLO␤»
    say {;}.signature;          # OUTPUT: «(;; $_? is raw = OUTER::<$_>)␤»

A block can have a L«C<Signature>|/type/Signature» between C<< -> >> or C<< <-> >>
and the block:

    my $add = -> $a, $b = 2 { $a + $b };
    say $add(40);               # OUTPUT: «42␤»

If the signature is introduced with C<< <-> >>, then the parameters are marked
as C<rw> by default:
X«|<->»

    my $swap = <-> $a, $b { ($a, $b) = ($b, $a) };
    my ($a, $b) = (2, 4);
    $swap($a, $b);
    say $a;                     # OUTPUT: «4␤»

Blocks that aren't of type L«C<Routine>|/type/Routine» (which is a subclass of C<Block>) are
transparent to L«C<return>|/syntax/return».

    sub f() {
        say <a b c>.map: { return 42 };
                       #   ^^^^^^   exits &f, not just the block
    }

The last statement is the implicit return value of the block.

    say {1}.(); # OUTPUT: «1␤»

Bare blocks are automatically executed in the order they appear:

    say 1;                # OUTPUT: «1␤»
    {
        say 2;            # OUTPUT: «2␤»; executed directly, not a Block object
    }
    say 3;                # OUTPUT: «3␤»


=end pod

# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
