Raku Weekly Notes

token directive {
    :my $foo = "in command";
    <command> <subject> <value>?
}

token prove-nondeterministic-parsing {
    :my $threshold = rand;
    'maybe' \s+ <it($threshold)>
}

grammar g {
    regex r1 {
        { my $foo; ...} # `$foo` 在该 block 的结尾超出作用域。
        ...
        { say $foo;   } # `$foo` 不在作用域中。
    }
}

grammar i {
    my $foo;
    regex r1   { ... } # 在 `r1` 内部, `$foo` 被识别出。
    ...
    regex r999 { ... } # 但是在 r999 中也是。
}

say Regex.^mro; (Regex) (Method) (Routine) (Block) (Code) ...

#!/usr/bin/env raku

ROLL:
for 1..10 -> $r {
    given (1..6).roll {
        when 6 {
            say "Roll $r: you win!";
            last ROLL;
        }
        default {
            say "Roll $r: sorry...";
        }
    }
    LAST {
        say "You either won or lost - this runs either way";
    }
}

constant N = 5;
for flat (1..6).roll xx * Z 1..N -> $_, $n {
    print "roll $n: $_ ";

    when 6 {
        put "(won)";
        last;
    }

    default {
        put "(lost)";
    }

    LAST {
        print "result: ";
        when 6 { put "winner :)" }
        default { put "loser :(" }
    }
}

#!/usr/bin/env raku


sub MAIN($x)
{
    say "$x squared is { $x*$x }";
}

#!/usr/bin/env raku

sub MAIN(Complex $x)
{
    say "$x squared is { $x*$x }";
}

sub MAIN(Complex(Str) $x) {
    say "$x 的平方为 { $x * $x }";
}

#!/usr/bin/env raku

sub MAIN ( Complex(Real) $x ) {
    say "$x squared is { $x*$x }";
}

class WordCount {
    has %!words; # Tried with both . and !

    method new($string) {
        my %words;
        my @sentence = split(/\s+/, $string);
    
        for @sentence -> $word {
            %words{$word}++;
        }
    return self.bless(:%words);
  }

    method sayCounts() {
        my @keys = keys(%!words);
        for @keys -> $key {
            say $key ~ " " ~ %!words{$key};
        }
    }
}

sub MAIN {
  my $sentence = "the boy jumped over the dog";
  my $wordCount = WordCount.new($sentence);
  $wordCount.sayCounts();
}

class WordCount {
    has Int %.words is default(0);

    method new($string) {
        my Int %words;

        for $string.split(/\s+/) -> $word {
            %words{$word}++;
        }

        self.bless(:%words)
    }

    method gist {
        %.words.map({.value ~ " " ~ .key}).join("\n")
    }
}

my $word-count = WordCount.new('the boy jumped over the dog');
say $word-count;

my %w = a => 1;
%w.map({ say $_.^name }) # OUTPUT«Pair␤»

%.words.map({.value ~ " " ~ .key}).join("\n")

%.words.kv.map( -> $word, $count { "$word $count" } ).join("\n")

%.words.map( -> (:key($word), :value($count)) { "$word $count" } ).join("\n")

my @lines = "a.txt".IO.lines;
for @lines -> $line {
    my @words = $line.split(/\s+/);
    say $line unless @words[1..*].grep(* eq 0).elems > 6;
}

my @lines = "a.txt".IO.lines;
my %hash;

for @lines -> $line {
    $line.match(/^(.*?)(\d+'-'\d+)/);
    %hash{$0} ~= $1 ~ " ";
}

for %hash.kv -> $key, $value {
    say $key, $value;
}

my @lines = "a.txt".IO.lines;
my %hash;

for @lines -> $line {
    $line.match(/(\d+\.\d+)\s+\(\s+(\S+)/);
    %hash{$0} ~= $1 ~ " ";
}

for @lines -> $line {
    $line.match(/(\d+\.\d+)\s+\(\s+(\S+)/);

    for %hash.kv -> $key, $value {
        say $line if $0 ~~ $key && $1 ~~ $value.words.min;
    }
}

my @lines   = "a.txt".IO.lines;
my @inlines = "in.txt".IO.lines;
my %hash;

for @lines -> $line {
    $line.match(/^chr(\d+)\s+(\w+)\s+(\d+)\s+(\d+)/);
    %hash{$0~$1~$2~$3} = $0 ~ " " ~ $2 ~ " " ~ $3;
}

for @inlines -> $line {
    $line.match(/^(\d+)\s+(\d+)/);

    for %hash.values -> $value {
        say $line
        if $0 ~~ $value.words[0]
        && $1 <= $value.words[1].Num
        && $1 <= $value.words[2].Num;
    }
}

@get (-) @project

class Employee {
    subset Salary         of Real where * > 0;
    subset NonEmptyString of Str  where * ~~ /\S/; # 至少一个非空白符号

    has NonEmptyString $.name    is rw;
    has NonEmptyString $.surname is rw;
    has Salary         $.salary  is rw;

    method gist {
        return qq:to[END];
        Name:    $.name
        Surname: $.surname
        Salary:  $.salary
        END
    }
}
my $employee = Employee.new();

given $employee {
    .name    = 'Sally';
    .surname = 'Ride';
    .salary  = 200;
}

say $employee;

# Output:
# Name:    Sally
# Surname: Ride
# Salary:  200

my $filename = "sample.txt";
my $seconds_since_epoch = $filename.IO.accessed;
my $readable_timestamp  = DateTime.new($filename.IO.accessed);

say "File '$filename' was last accessed at '$readable_timestamp', which is {$seconds_since_epoch.Num} seconds since the epoch";

my @seq  = (rand_fa_seq() for ^10);
my @qual = (rand_qual()   for ^10);

@seq.raku.say;
@qual.raku.say;

sub rand_fa_seq
{
    return join("", roll(20,"ACGT".comb));
}

sub rand_qual
{
    return join("", roll(20,"EFGHIJ".comb))
}

sub rand-fa-seq($n = 20) { <A C G T>.roll($n).join }
sub rand-qual($n = 20)   { <E F G H I J>.roll($n).join }

my @seq  = rand-fa-seq() xx 10;
my @qual = rand-qual() xx 10;

sub nth_term (Int $n) { $n + round sqrt $n }

say nth_term $_ for 1 .. 22;

my @y = ($_**2 + 1 for 1 .. 10);

my @non_squares = grep {sqrt($_) != floor(sqrt($_))}, 1 .. 30;

sub odd(Int $n) {return $n % 2}
@evens = ($_ * 2 if .&odd for 0..100);

my @non_squares = ($_ if .sqrt != .sqrt.Int for 1 .. 30);

$fh.print: "0123456789A";   # prints '0123456789A' to the file

$fh.print("0123456789A");   # prints '0123456789A' to the file

$fh.print: "012", "345", "6789A";   # prints '0123456789A' to the file
$fh.print("012", "345", "6789A");   # prints '0123456789A' to the file

my @a = <012 345 6789A>;

$fh.print(@a);   # prints '0123456789A' to the file
$fh.print: @a;   # prints '0123456789A' to the file

$fh.print(@a);   # Works
$fh.print: @a;   # Works!
$fh.print @a;    # ERROR!

print @a;  # Prints '0123456789A' (no newline, just like Perl 5)
print(@a); # Ditto
print: @a; # Prints '012 345 6789A' followed by a newline (at least in REPL)

print  @a, @a; # Error (Two terms in a row)
print: @a, @a; # Prints '012 345 6789A 012 345 6789A' followed by a newline (in REPL)

print @a;

print: @a, @a;

$fh.print: @a, @a; # Prints '0123456789A0123456789A' to the file

say $*ERR: 'hello world'; # $*ERR.say('hello world')

my %hash =
    two   => 2,
    three => 3,
    one   => 1,
;

for %hash.sort(*.key)».kv -> ($key, $value) {
    say "'$key' => '$value'";
}

for %hash.sort -> (:$key, :$value) {
    say "'$key' => '$value'";
}

for %hash.sort -> $pair (:$key, :$value) {
    say $pair;
    say $key === $pair.key and $value === $pair.value; # True␤
}

# :$key is short for :key($key)
for %hash.sort -> (:key($k), :value($v)) {
    say "'$k' => '$v'";
}

class C { has $.a; has $.b; has $.c; has $!private-value }
my $c = 5;
my $obj = C.new(:a<A>,:b(1),:$c);

given $obj -> ( :$a, :b($b), :$c) ) {
    say "$a $b $c";   # A 1 5
}

# ignore $.a by using an unnamed scalar
given $obj -> ( :a($), :$b, :$c ) { ... }

# places any unspecified public attributes in %others
given $obj -> ( :$a, :$b, *%others ) {
    .say for keys %others; # c␤
}

# 忽略任何未指定的属性
# useful to allow subclasses to add more attributes
# 或仅仅丢弃掉任何你不关心的值
given $obj -> ( :$a, :$b, *% ) { ... }

# 失败，因为它没有处理公用的 c 属性
# in the sub-signature
given $obj -> ( :$a, :$b ) { ... }

for 'one' => 1, 1/3
->
  # Type is an alias to the object type
  ::Type Any $_ # Any is the default type requirement

  # the public attributes of the object
  (
    ::A-Type Any :key(   :numerator(   $a ) ),
    ::B-Type Any :value( :denominator( $b ) ) where $b >= 1,
  )
{
  my Type $obj = $_; # new variable declared as having the same type
  my A-Type $new-a = $a;
  my B-Type $new-b = $b;

  # could have used $_.^name or .^name instead of Type.^name
  # so you don't actually have to add the alias to the signature
  # to get the name of the arguments type
  say Type.^name, ' ', $_;
  say '  ', A-Type.^name, ' ', $a;
  say '  ', B-Type.^name, ' ', $b;
}

Pair one => 1
  Str one
  Int 1
Rat 0.333333
  Int 1
  Int 3

*.key
{ .key } # { $_.key }
-> $_ { .key } # basically what the previous line turns into
{ $^placeholder-var.key }
sub ($_) { .key }
&a-subroutine-reference # you would have to create the subroutine though

&infix:<+> # the subroutines responsible for the numeric addition operator
&[+] # ditto

&prefix:<++>
&postfix:<++>

# etc

# 无法正常排序
my  @s = [2443,5,33, 90, -9, 2, 764];
say @s.sort;     # 2443 5 33 90 -9 2 764
say @s.WHAT;     # (Array)
say @s.raku;     # [[2443, 5, 33, 90, -9, 2, 764]]<>

# 正常排序
my  $array = [2443,5,33, 90, -9, 2, 764];
say $array.sort; #  -9 2 5 33 90 764 2443
say $array.WHAT; # (Array)
say $array.raku; # [2443, 5, 33, 90, -9, 2, 764]

my  @s = (2443,5,33,90,-9,2,764);
say @s.sort;     # -9 2 5 33 90 764 2443
say $array.WHAT; # (Array)
say @s.raku;     # [2443, 5, 33, 90, -9, 2, 764]<>

my @s = [2443, 5, 33, 90, -9, 2, 764];

@s[0].sort.say

my $1 = -> $a { splice($a,1,3,[1,2,3]); $a };
say (^6).map( { $_ < 4 ?? 0 !! $_ } ).Array;
# [0 0 0 0 4 5]
say (^6).map( { $_ < 4 ?? 0 !! $_ } ).Array.$1;
# [0 1 2 3 4 5]

say (^6).map( { $_ < 4 ?? 0 !! $_ } ).Array.(-> $a { splice($a,1,3,[1,2,3]); $a })
Invocant requires a type object of type Array, but an object instance was passed.  Did you forget a 'multi'?

say (^6).map( { $_ < 4 ?? 0 !! $_ } ).Array.&(-> $a { splice($a,1,3,[1,2,3]); $a })
# 输出 [0 1 2 3 4 5]

my @numbers = <4 8 16 16 23 42>;
.say for @numbers[0..2]; # this works
# 4
# 8
# 15

# but this doesn't
my $range = 0..2;
.say for @numbers[$range];
# 16

# On Fri Jul 2016, gfldex wrote:
my @numbers =  <4 8 15 16 23 42>; my $range = 0..2; .say for @numbers[$range];

# OUTPUT«16»
# expected:
# OUTPUT«4\n 8\n 15»


# 这是对的, 并且还跟 "Scalar container implies item" 规则有关.
# Changing it would break things like the second evaluation here:

my @x = 1..10; my @y := 1..3; @x[@y]
# (2 3 4)

@x[item @y]
# 4

# 注意在签名中 range 可以被绑定给 @y, 而特殊的 Range 可以生成一个像 @x[$(@arr-param)] 的表达式
# 这在它的语义中是不可预期的。

# 同样, 绑定给 $range 也能提供预期的结果
my @numbers =  <4 8 15 16 23 42>; my $range := 0..2; .say for @numbers[$range];
# OUTPUT«4␤8␤15␤»

# 这也是预期的结果, 因为使用绑定就没有标量容器来强制被当成一个 item 了。
# So, all here is working as designed.

.say for @numbers[@($range)]
# 4
# 8
# 15

# Bind the symbol `numbers` to the value 1..10:
my \numbers = [0,1,2,3,4,5,6,7,8,9,10];

# Bind the symbol `rangeA` to the value 1..10:
my \rangeA  := 1..10;
# Bind the symbol `rangeB` to the value 1..10:
my \rangeB   = 1..10;

# Bind the symbol `$rangeC` to the value 1..10:
my $rangeC  := 1..10;

# Bind the symbol `$rangeD` to a Scalar container
# and then store the value 1..10 in it:`
my $rangeD   = 1..10;

# Bind the symbol `@rangeE` to the value 1..10:
my @rangeE  := 1..10;

# Bind the symbol `@rangeF` to an Array container and then
# store 1 thru 10 in the Scalar containers 1 thru 10 inside the Array
my @rangeF   = 1..10;

say numbers[rangeA];  # (1 2 3 4 5 6 7 8 9 10)
say numbers[rangeB];  # (1 2 3 4 5 6 7 8 9 10)
say numbers[$rangeC]; # (1 2 3 4 5 6 7 8 9 10)
say numbers[$rangeD]; # 10
say numbers[@rangeE]; # (1 2 3 4 5 6 7 8 9 10)
say numbers[@rangeF]; # (1 2 3 4 5 6 7 8 9 10)