Raku 中的变量

my $square = 9 ** 2;
my @array  = 1, 2, 3;   # Array variable with three elements
my %hash   = London => 'UK', Berlin => 'Germany';

class FailHash is Hash {
    has Bool $!final = False;

    multi method AT-KEY ( ::?CLASS:D: Str:D \key ){
        fail X::OutOfRange.new(:what("Hash key"), :got(key), :range(self.keys)) if $!final && !self.EXISTS-KEY(key);
        callsame
    }

    method finalize() {
        $!final = True
    }
}

my %h is FailHash = oranges => "round", bananas => "bendy";
say %h<oranges>;
# OUTPUT «round␤»
%h.finalize;
say %h<cherry>;
CATCH { default { put .^name, ': ', .Str } }
# OUTPUT «X::OutOfRange: Hash key out of range. Is: cherry, should be in (oranges bananas)»

my $foo = 5;            # item assignment
say $foo.perl;          # 5

my @bar = 7, 9;         # list assignment
say @bar.WHAT;          # Array
say @bar.perl;          # [7, 9]

(my $baz) = 11, 13;     # list assignment
say $baz.WHAT;          # Parcel
say $baz.perl;          # (11, 13)

my @array;
@array = my $num = 42, "str";   # item assignment: uses declarator
say @array.perl;                # [42, "str"] (an Array)
say $num.perl;                  # 42 (a Num)

my $num;
my @array = $num = 42, "str";    # item assignment: uses expression
say @array.perl;                 # [42, "str"] (an Array)
say $num.perl;                   # 42 (a Num)

my ( @foo, $bar );
@foo = ($bar) = 42, "str";       # list assignment: uses parens
say @foo.perl;                   # [42, "str"] (an Array)
say $bar.perl;                   # $(42, "str")  (a Parcel)

my ( @array, $num );
@array = $num = 42, "str";    # list assignment
say @array.perl;              # [42, "str"] (an Array)
say $num.perl;                # [42, "str"] (an Array)

my \degrees = pi / 180;
my \θ       = 15 * degrees;

θ = 3; # Dies with the error "Cannot modify an immutable Num"

sub logged(&f, |args) {
    say('Calling ' ~ &f.name ~ ' with arguments ' ~ args.perl);
    my \result = f(|args);
    #  ^^^^^^^ not enforcing any context here
    say(&f.name ~ ' returned ' ~ result.perl);
    return |result;
}

my $lexical   = 1;
my $*dynamic1 = 10;
my $*dynamic2 = 100;

sub say-all() {
    say "$lexical, $*dynamic1, $*dynamic2";
}

# prints 1, 10, 100
say-all();

{
    my $lexical   = 2;
    my $*dynamic1 = 11;
    $*dynamic2    = 101; # 注意,这儿没有使用 my 来声明

    # prints 1, 11, 101
    say-all();
}

# prints 1, 10, 101
say-all();

sub foo() {
    $*FOO // 'foo';
}

say foo; # -> 'foo'

my $*FOO = 'bar';

say foo; # -> 'bar'

class Point {
    has $.x;
    has $.y;

    method Str() {
        "($!x, $!y)"
    }
}

say "$?FILE: $?LINE"; # prints "hello.pl: 23" if this is the 23 line of a
                      # file named "hello.pl".

constant $?TABSTOP = 4; # this causes leading tabs in a heredoc or in a POD
                        # block's virtual margin to be counted as 4 spaces.

class Point {
    has $.x;
    has $.y;

    method Str() {
        "($.x, $.y)" # 注意我们这次使用 . 而不是 !
    }
}

class SaySomething {
    method a() { say "a"; }
    method b() { $.a; }
}

SaySomething.b; # prints "a"

for ^4 {
    say "$^seconds follows $^first";
}

sub say-it    { say $^a; } # valid
sub say-it()  { say $^a; } # invalid
              { say $^a; } # valid
-> $x, $y, $x { say $^a; } # 非法, 已经有参数列表 $x,$y,$x 了

say { $:add ?? $^a + $^b !! $^a - $^b }( 4, 5 ) :!add
# OUTPUT:
# -1

=begin Foo
...
=end Foo

#after that, $=Foo gives you all Foo-Pod-blocks

use MONKEY-TYPING;

augment slang Regex {  # derive from $~Regex and then modify $~Regex
    token backslash:std<\Y> { YY };
}

my $amazing-variable = "World";
say "Hello $amazing-variable!"; # Hello World!

{
    my $foo = "bar";
    say $foo; # -> "bar"
}
say $foo; # !!! "Variable '$foo' is not declared"

my $location = "outside";

sub outer-location {
    # Not redefined:
    say $location;
}

outer-location; # -> "outside"

sub in-building {
    my $location = "inside";
    say $location;
}

in-building;    # -> "inside"
outer-location; # -> "outside"

sub new-location {
    my $location = "nowhere"
    outer-location;
}

new-location; # -> "outside"

module M {
    our $Var;
    # $Var available here
}

# Available as $M::Var here.

my (@a, $s, %h);

my (Str $a, Str $b, Int $c) = <a b>;
say [$a, $b, $c].perl;
# OUTPUT«["a", "b", Int]␤»

sub f { 1,2,3 };
my ($a) = f;
say $a.perl;
# OUTPUT«1␤»

my ($,$a,$,%h) = ('a', 'b', [1,2,3], {:1th});
say [$a, %h].perl;
# OUTPUT«["b", {:th(1)}]␤»

has method x( ) { }

method x( ) { }

my %operations =
    half   => anon sub half($x)   { $x / 2  },
    square => anon sub square($x) { $x * $x },
    ;
say %operations<square>.name;       # square
say %operations<square>(8);         # 64

sub a {
    state @x;
    state $l = 'A';
    @x.push($l++);
};

say a for 1..6;

({ state $i = 1; $i++.say; } xx 3).map: {$_(), $_()}; # says 1 then 2 thrice

my @a;
sub f() {
    state $i;
    $i++;
    @a.push: "k$i" => $i # <-- .clone goes here
};
f for 1..3;
dd @a; # «Array $var = $[:k1(3), :k2(3), :k3(3)]»

sub code(){ state $i = 0; say ++$i; $i };
await
    start { loop { last if code() >= 5 } },
    start { loop { last if code() >= 5 } };

# OUTPUT«1␤2␤3␤4␤4␤3␤5␤»
# OUTPUT«2␤1␤3␤4␤5␤»
# many other more or less odd variations can be produced

say "1-a 2-b 3-c".subst(:g, /\d/, {<one two three>[$++]});
# OUTPUT«one-a two-b three-c␤»

raku -ne 'say ++$ ~ " $_"' example.txt

raku -e '{ say ++$; say $++  } for ^5'
# OUTPUT«1␤0␤2␤1␤3␤2␤4␤3␤5␤4␤»

sub foo() {
    given ++$ {
        when 1 {
            say "one";
        }
        when 2 {
            say "two";
        }
        when 3 {
            say "three";
        }
        default {
            say "many";
        }
    }
}

foo() for ^3;
# OUTPUT«one␤two␤three␤»

sub foo($x) {
    say (@).push($x);
}

foo($_) for ^3;

# OUTPUT:
# [0]
# [0 1]
# [0 1 2]

sub foo($x) {
    my $v = @;
    $v[$x] = $x;
    say $v;
}

foo($_) for ^3;

# OUTPUT:
# [0]
# [0 1]
# [0 1 2]

sub foo($x) {
    say (%).push($x => $x);
}

foo($_) for ^3;

# OUTPUT:
# 0 => 0
# 0 => 0, 1 => 1
# 0 => 0, 1 => 1, 2 => 2

sub foo($x) {
    my $v = %;
    $v{$x} = $x;
    say $v;
}

foo($_) for ^3;

# OUTPUT:
# 0 => 0
# 0 => 0, 1 => 1
# 0 => 0, 1 => 1, 2 => 2

# don't do this
use MONKEY-TYPING;

augment class Int {
    method is-answer { self == 42 }
}
say 42.is-answer;       # True

my $in = 0; # temp will "entangle" the global variable with the call stack
            # that keeps the calls at the bottom in order.

sub f(*@c) {
    (temp $in)++;
     "<f>\n"
     ~ @c>>.indent($in).join("\n")
     ~ (+@c ?? "\n" !! "")
     ~ '</f>'
};

sub g(*@c) {
    (temp $in)++;
    "<g>\n"
    ~ @c>>.indent($in).join("\n")
    ~ (+@c ?? "\n" !! "")
    ~ "</g>"
};

print g(g(f(g()), g(), f()));

# OUTPUT:
# <g>
#  <g>
#   <f>
#    <g>
#    </g>
#   </f>
#   <g>
#   </g>
#   <f>
#   </f>
#  </g>
# </g>

my $answer = 42;

{
    let $answer = 84;
    die if not Bool.pick;
    CATCH {
        default { say "it's been reset :(" }
    }
    say "we made it 84 sticks!";
}

say $answer;

my Int $x = 42;
$x = 'a string'; # throws an X::TypeCheck::Assignment error
CATCH { default { put .^name, ': ', .Str } }
# OUTPUT: X::TypeCheck::Assignment: Type check failed in assignment to $x; expected Int but got Str ("a string")

my Int $x;
say $x.^name;    # Int
say $x.defined;  # False

my Real $product is default(1);
say $product;                       # 1
$produce *= 5;
say $product;                       # 5
$product = Nil;
say $product;                       # 1

use variables :D;
my Int $i;
# OUTPUT«===SORRY!=== Error while compiling <tmp>␤Variable definition of type Int:D (implicit :D by pragma) requires an initializer ...
my Int $i = 1; # that works
{ use variables :_; my Int $i; } # 在这个 block 中关掉它

for <a b c> { say $_ }  # sets $_ to 'a', 'b' and 'c' in turn
say $_ for <a b c>;     # same, even though it's not a block
given 'a'   { say $_ }  # sets $_ to 'a'
say $_ given 'a';       # same, 尽管这不是一个块

.say;                   # 与 $_.say 相同

say "Looking for strings with non-alphabetic characters...";

for <ab:c d$e fgh ij*> {
    .say if m/<!alpha>/;
}

Looking for strings with non-alphabetic characters...
ab:c
d$e
ij*

'abc 12' ~~ /\w+/;  # 设置 $/ 为一个Match 对象
say $/.Str;         # abc

use XML::Grammar; # panda install XML
XML.Grammar.parse("<p>some text</p>");
say $/;

# OUTPUT:
# ｢<p>some text</p>｣
#  root => ｢<p>some text</p>｣
#   name => ｢p｣
#   child => ｢some text｣
#    text => ｢some text｣
#    textnode => ｢some text｣
#  element => ｢<p>some text</p>｣
#   name => ｢p｣
#   child => ｢some text｣
#    text => ｢some text｣
#    textnode => ｢some text｣

$0          # same as $/[0]
$1          # same as $/[1]
$<named>    # same as $/<named>

'abbbbbcdddddeffg' ~~ / a (b+) c (d+ef+) g /;
say $/[0]; # ｢bbbbb｣
say $/[1]; # ｢dddddeff｣

say $0; # ｢bbbbb｣
say $1; # ｢dddddeff｣

say @().join; # bbbbbdddddeff

'I.... see?' ~~ / \w+ $<punctuation>=[ <-[\w\s]>+ ] \s* $<final-word> = [ \w+ . ] /;
say $/<punctuation>; # ｢....｣
say $/<final-word>;  # ｢see?｣

say $<punctuation>; # ｢....｣
say $<final-word>;  # ｢see?｣

say %().join;  # "punctuation     ....final-word  see?"

for '.' {
    .Str.say when !.IO.d;
    .IO.dir()>>.&?BLOCK when .IO.d # lets recurse a little!
}

my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 64 );