Raku 手册

$ zef install Linenoise

sudo apt install rlwrap

 $ p6doc
You want to maintain the index?
To build an index for 'p6doc -f'

          p6doc build

To list the index keys
          p6doc list

To display module name(s) containing key
          p6doc lookup

To show where the index file lives
          p6doc path-to-index

What documentation do you want to read?
Examples: p6doc Str
          p6doc Str.split p6doc faq
          p6doc path/to/file

Set the POD_TO_TEXT_ANSI if you want to use ANSI escape sequences to enhance text

You can list some top level documents:
          p6doc -l

You can also look up specific method/routine/sub definitions:
          p6doc -f hyper
          p6doc -f Array.push

You can bypass the pager and print straight to stdout:
          p6doc -n Str

docker run --rm -it -p 31415:3000 jjmerelo/perl6-doc

===SORRY!=== Error while compiling:
Variable '$s' is not declared
------> <BOL>⏏$

> my $r
(Any)

{
    my $a = 12;
    say $a; # -> 12
}

say $a; # -> Variable '$a' is not declared

> my ($a, @b, %c);

say "Hello";
#`[ This is a comment.
The compiler will ignore it.
But you, the reader, cannot ignore it ]
say "Good bye";

> say 14 #`{ a { b } c }, 12;
1412

> say #`( Yeah, right. Why bother commenting the code? ) "Whatever...";
Whatever...

> say 14; #`({ hidden-comment })
14

> 2 + 2; # -> 4

> my $a = 3; my $b = 2;
> $a - $b; # -> 1

my $i = 10; say "{ $i++ } $i"; # -> 10 11
   $i = 10; say "{ ++$i } $i"; # -> 11 11

my $i = 10; say "{ $i-- } $i"; # -> 10 9
   $i = 10; say "{ --$i } $i"; # -> 9 9

> 2 * 7; # -> 14

> 8 / 4; # -> 2

> 8 div 4; # -> 2

> my $s = 5; # -> 5
> $s = 10;   # -> 10

my $a = 42;  # (1)
my $b = $a;  # (1)
$a += 10;    # (2)
say "$a $b";

my $a = 42;  # (1)
my $b := $a; # (1)
$a += 10;    # (2)
say "$a $b";

my $a = 42;      # (1)
my $b := $a + 0; # (1)
$a += 10;        # (2)
say "$a $b";

> $b++; # -> Error
> 12++ # -> Just as this is an error

$b := 4;

>  $b = 14;
Cannot assign to an immutable value

> my $name = "Arne";          # -> Arne
> my $hello = "Hello, $name"; # -> Hello, Arne
> my $hello = 'Hello, $name'; # -> Hello, $name

> «Hello, $name».raku; # -> ("Hello", "Arne")

> <<Hello, $name>>.raku; # -> ("Hello,", "Arne")

> <Hello, $name>.raku; # -> ("Hello,", "\$name")

> my @a = 1,2,3; say "@a";   # -> @a
> my @a = 1,2,3; say "@a[]"; # -> 1 2 3

> my %a; say "%a{}";             # -> %a
> my %a; %a<a> = 12; say "%a{}"; # -> a 12

> my $hello = "Hello, { $name }";

> say "I am almost { $age + 1 } years old.";

> my $t = "abc" ~ "def";
abcdef

12       # Integer
12.8     # A number
1.12e+20 # Floating point
2+4i     # A Complex number

12A
1.12e
2+4j

> say pi; # -> 3.141592653589793

> my \z = 2;   # -> 2
> say z + 100; # -> 102
> z= 2
Cannot modify an immutable Int (1) in block <unit> at <unknown file> line 1

> "False".Bool; # -> True
> so "False";   # -> True
> ? "False"     # -> True ## The space is optional
> "False".so    # -> True

> ! True;  # -> False
> ! False; # -> True

> ! 10;    # -> False
> ! 0;     # -> True
> ! "ABC"; # -> False
> ! "";    # -> True

> if ! $value == 15

> if $value != 15

> unless $value == 15

> not 1 - 1; # -> not (1 - 1) -> not 0
True

> ! 1 - 1; # -> (!1) - 1 -> False - 1 -> 0 - 1
-1

> 1 and 6;        # -> 6
> True and 0;     # -> 0
> True and False; # -> False

> my $a = 1; $a++ and $a++ and $a++ and $a++; # -> 4
> my $b = 0; $b++ and $b++ and $b++ and $b++; # -> 0

> True  || False; # -> True
> True  || True;  # -> True
> False || False; # -> False

> True xor False;  # -> True
> False xor False; # -> False

> True xor True;                      # -> Nil
> True xor True xor False;            # -> Nil
> False xor False xor False xor True; # -> True
> False ^^ False ^^ False ^^ True;    # -> True

> my $value = 1;
> ! $value == 15;   # -> False
> not $value == 15; # -> True

> 1 + 2 * 3 + 4; # -> 1 + ( 2 * 3 ) + 4; # -> 11
> (1 + 2) * (3 + 4) # -> 3 * 7;          # -> 21

> my $a = 12;
> $a = "hello, world!";

> my $i of Int = 42;
> my Int $i = 42;    # The same

> my Int @a;
> my @a of Int;

> my Int %h;
> my %h of Int;

> 12.^name;                 # -> Int
> "12".^name;               # -> Str
> my $i = 12; say $i.^name; # -> Int
> $i = "AB"; say $i.^name;  # -> Str
> True.WHAT;                # -> Bool

> 12.^name; # -> Int  # A scalar value
> 12.WHAT; # -> (Int) # A one-element list

> my Int %hash; say %hash.of; # -> (Int)
> my Str %hash; say %hash.of; # -> (Str)
> my @a;        say @a.of;    # -> (Mu)
> my Int @a;    say @a.of;    # -> (Int)

> my Numeric $a; say $a.^name; # -> Numeric
> $a = 3; say $a.^name;        # -> Int
> $a.VAR.of;                   # -> (Numeric)
> say $a.VAR.of.^name;         # -> Numeric

> say Int.^mro; # -> ((Int) (Cool) (Any) (Mu))

> Real.^mro
No such method 'mro' for invocant of type 'Perl6::Metamodel::ParametricRoleGroupHOW'
    in block <unit> at <unknown file> line 1

> Numeric.^mro
No such method 'mro' for ...

> my $b = "b"; $b = Nil;   # -> (Any)
> my Int $i = 4; $i = Nil; # -> (Int)

> my Int $i = 4; $i = Int; # -> (Int)

> my $a = Any; # -> (Any)

> my Int $i = Any;
Type check failed in assignment to $i; expected Int but got Any (Any)

> my Int $i = Nil; # -> (Int)
> my Int $i = Int; # -> (Int)

> my $a = Any; say $a; # -> (Any)

> my $a = Any; say ": $a";
Use of uninitialized value of type Any in string context.

> say 100000000000000000000000000000000000000000000000000000 > Inf
False

> say -100000000000000000000000000000000000000000000000000000 < -Inf
False

> Inf + 1;    # -> Inf
> -Inf - 1;   # -> -Inf
> -Inf + Inf; # -> NaN
> Inf * 0;    # -> NaN

my Int:U $i;

> $a = Nil
  (Int:U)

> $a = Int
  (Int)

$a = 1
Type check failed in assignment to $a; expected Int:U but got Int (1)
  in block <unit> at <unknown file> line 1

> say Int.defined; # -> False
> say 12.defined;  # -> True

> my $a; say $a.defined;     # -> False
> my $a = 1; say $a.defined; # -> True

> my $string1 = "12"; my $string2 = "13";
> my $sum1 = $string1 + $string2; # Addition
25

> $sum1.^name;
Int

> my $sum2 = $string1 ~ $string2; # String concatenation
1213

> $sum2.^name;
Str

> my Int $a = 12; my Int $b = 13;
> my $c = $a ~ $b;
1213

> my Int $d = $a ~ $b;
Type check failed in assignment to $d; expected Int but got Str ("1213")
    in block <unit> at <unknown file> line 1

> "12".Numeric.^name    # -> Int # Integer
> "12.1".Numeric.^name  # -> Rat # Rational number
> "5e+10".Numeric.^name # -> Num # Floating point

> +("12").^name   # -> Int
> +("12.1").^name # -> Rat

> "abc".Numeric
Cannot convert string to number: ...

> "12".Int.^name  # -> Int # Integer
> "12".Rat.^name  # -> Rat # Rational number
> "12".Num.^name  # -> Num # Floating point
> 12.1.Str.^name  # -> Str # String; "12.1"
> ~(12.1).^name   # -> Str # String; "12.1" # Prefix ~

> "12.1".Int; # -> 12

> 12.Str;
> ~12;

> "AS".Int
Cannot convert string to number: ...

> try "AS".Int
Nil

> my $text = "AS";
> try $possibly-an-int.Int;
Nil

> try $possibly-an-int.Int // 0;
0

> my $zero = 0;
> try $zero.Int;
0

my $zero = 0;
if try $zero.Int {
    ...
}

> my $zero = 0;
> say "OK" if try $zero.Int.defined; # -> OK

> say (a => 3) cmp (a => 4); # -> Less
> say 4 cmp 4.0;             # -> Same
> say 'b' cmp 'a';           # -> More

> "a" unicmp "B"; # -> Less
> "A" unicmp "b"; # -> Less

> "A" unicmp "a"; # -> More
> "A" unicmp "A"; # -> Same
> "a" unicmp "A"; # -> Less

> say 'a' leg 'b'; # -> Less
> say 'a' leg 'a'; # -> Same
> say 'b' leg 'a'; # -> More

> 11 leg 2; # -> Less
> 11 cmp 2; # -> More

> say 1 <=> 2;   # -> Less
> say 2 <=> 2.0; # -> Same
> say 2 <=> 1;   # -> More

> 2 <=> "sj"
Cannot convert string to number: ...

> 1 before 1;         # -> False
> 1 before 2;         # -> True
> 111 before 21;      # -> False
> "111" before "21";  # -> True

> "ab" after "aaaa"; # -> True

> 111 before 21;     # -> False
> "111" before "21"; # -> True

> my $a = 42;
> my $b = $a;
> $a =:= $b; # -> False

> my $a = 42;
> my $b := $a;
> $a =:= $b; # -> True

> my $a = 3;  # -> 3
> my $b := 3; # -> 3
> $a === $b;  # -> True
> 1 === 1.0;  # -> False

> my $a = 12; $a.WHAT === Int; # -> True

> my $a = 12; $a.^name === Int; # -> False

> my $a = 12; $a.isa(Int); # -> True

> my $a = "Hi" but False; # -> Hi
> say $a;                 # -> Hi
> say so $a;              # -> False

> my $c = 156 but False; # -> 156
> say so $c;             # -> False
> $c++;                  # -> 157
> say so $c;             # -> True

say "\$x = |\$x.Str |\$x.Int |\$x.Bool|+\$x |\$x+0";
say "----------------+-------+-------+-------+-------+----";

print-it("10 but 0",     10 but 0);
print-it("10 but 'ten'", 10 but 'ten');
print-it("10 but False", 10 but False);
print-it("10 but True",  10 but True);

print-it("0 but 10",    0 but 10);
print-it("0 but 'ten'", 0 but 'ten');
print-it("0 but False", 0 but False);
print-it("0 but True",  0 but True);

print-it("'ten' but 0",     'ten' but 0);
print-it("'ten' but 10",    'ten' but 10);
print-it("'ten' but False", 'ten' but False);
print-it("'ten' but True",  'ten' but True);

print-it("True but 0", True but 0);
print-it("True but 10", True but 10);
print-it("True but 'ten'", True but 'ten');
print-it("True but False", True but False);

print-it("False but 0", False but 0);
print-it("False but 10", False but 10);
print-it("False but 'ten'", False but 'ten');
print-it("False but True", False but True);

sub print-it ($label, $expression) {
    print $label, "\t|";
    print trap-it($expression.Str), "\t|";
    print trap-it($expression.Int), "\t|";
    print trap-it($expression.Bool), "\t|";
    print trap-it(+$expression), "\t|";
    print trap-zero($expression);
    say "";
}

sub trap-it ($expression) {
    my $result;
    try { $result = $expression.gist; }

    return $!
      ?? "ERR"
      !! $result;
}

sub trap-zero ($expression) {
    my $result;
    try { $result = ($expression + 0).gist; }

    return $!
      ?? "ERR"
      !! $result;
}

> my $a = "Hi" but False; say $a.^name;  # -> Str+{<anon|6>}
> my $b = "Hi" does False; say $b.^name; # -> Str+{<anon|7>}

> my $a = "Hi"; $a but False; say $a.^name;  # -> Str
> my $b = "Hi"; $b does False; say $b.^name; # -> Str+{<anon|9>}

for ^5 {
    say "I like school.";
}

I like school.
I like school.
I like school.
I like school.
I like school.

for 5 {
    say "I like school.";
}

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

.say; # same as $_.say

> $val.say for (1 .. 10) -> $val
===SORRY!=== Error while compiling: Variable '$val' is not declared.
Did you mean '&val'?
------> <BOL>⏏$val.say for ("aa" .. "bb") -> $val

for (1 .. 10) -> $val {
    $val.say;
}

say "Country: $_" for @countries;

> { .say; .say } for 1 .. 10;

> ( .say; .say ) for 1 .. 10;

for 1 .. 10 -> $i {
    say $i;
}

do-something($_) for 1 .. 10; # 1 .. 10 # 10 iterations
do-something($_) for ^10; # 0 .. 9      # 10 iterations

if $hour == 17 {
    say "Time to go home";
} elsif $hour == 8 {
    say "Time to go to work";
}

if $time == 17 {
    say "Time to go home";
} elsif $time == 8 {
    say "Time to go to work";
} else {
    say "Stay put!";
}

say "Not OK" if not $a;
say "Not OK" unless $a; # The same

for ( 0, "2", 3/11, pi, "hello") -> $input {
    with   $input.Numeric { say "Number: $input";     }
    orwith $input.Str     { say "Str: $input";        }
    else                  { say "??: <unknown type>"; }
}

$ raku orwith
Number: 0
Number: 2
Number: 0.272727
Number: 3.141592653589793
Str: hello

# This says "Yes"
if 0 { say "No" } orwith Nil { say "No" } orwith 0 { say "Yes" };

for (1, "2", Any, Nil, Int, pi, "hello") -> $input {
    without $input { print "Not OK: "; .say: }
}

$ raku without
Not OK: (Any)
Not OK: Nil
Not OK: (Int)

> my $variable = 12; say "$_ is of type { .^name } with $variable;
12 is of type Int

> my $answer; say "undefined answer" without $answer;
undefined answer

for ^5 {
    once { say "once"; }
    say "many ($_)";
}

$ raku for-once
once
many (0)
many (1)
many (2)
many (3)
many (4)

for ^5 {
    next if $_ == 2;
    say "many ($_)";
}

$ raku for-next
many (0)
many (1)
many (3)
many (4)

for ^Inf {
    last if $_ == 5;
    say "many ($_)";
}

$ raku for-last
many (0)
many (1)
many (2)
many (3)
many (4)

my $sum;

for 1 .. 1000 -> $i {
    $sum += $i;
    redo if $sum.is-prime;
}

say "Sum: $sum";

$ raku loop-redo
Sum: 546089

FIRST-ONE:
for 1 .. 20 -> $a {
    NEXT-ONE: for 0 .. 2 -> $b {
        next FIRST-ONE if ($a + $b).is-prime;
        next NEXT-ONE if ($a + $b) % 3;
        say "$a -> $b";
    }
}

$ raku loop-labels
6 -> 0
8 -> 1
9 -> 0
12 -> 0
14 -> 1
15 -> 0
18 -> 0
20 -> 1

> say 1200.base(8); # -> 2260
> say 170.base(2);  # -> 10101010
> say 256.base(16); # -> FF

> say("12", "34"); # -> 1234
> say "12", "34";  # -> 1234

> say 1200.base(8); # -> 2260
> say 1200.base: 8; # -> 2260

> say "FF".parse-base(16); # -> 255

> say "FF".parse-base(16).base(16); # -> FF

> say pi;       # -> 3.14159265358979
> say pi.^name; # -> Num

> pi.say; # -> 3.141592653589793

> say e; # -> 2.718281828459045

> say tau;      # -> 6.283185307179586
> say tau / pi; # -> 2

> my $one-third = 1/3; # -> 0.333333

> say $one-third * 3; # -> 1

> my $one-third = 1/3; # -> 0.333333
> $one-third.^name;    # -> Rat
> 0.3.^name;           # -> Rat

> (1/3).nude; # -> (1 3)
> (0.1).nude; # -> (1 10)
> 0.2.nude;   # -> (1 5)

> say (3/9).nude;  # -> (1 3)
> say (8/16).nude; # -> (1 2)

> my $sum = 1/2 + 1/3; # -> 0.833333
> say $sum.nude;       # -> (5 6)

> say 1.7.round;     # -> 2
> say (−0.5 ).round; # -> 0
> say ( .5 ).round;  # -> 1

> say 1.07.round(0.1); # -> 1.1
> say 21.round(10);    # -> 20

> say 1.2.truncate;  # -> 1
> say truncate -1.2; # -> -1

> say "1.99".floor; # > 1
> say "-1.9".floor; # -> -2

> say "1".ceiling;    # -> 1
> say "-0.9".ceiling; # -> 0
> say "42.1".ceiling; # -> 43

> say 10 gcd 12; # -> 2

> say 10 lcm 12; # -> 60
> say 10 lcm 2;  # -> 10
> say 2 lcm 3;   # -> 6

> say 0b00001.msb; # -> 0
> say 0b00011.msb; # -> 1
> say 0b00101.msb; # -> 2
> say 0b01010.msb; # -> 3
> say 0b10011.msb; # -> 4

> say (0/0).isNaN; # -> True

> say (0/0).Num === NaN; # -> True

> say 10 % 3; # -> 1 # 3 * 3 + 1
> say 11 % 3; # -> 2 # 3 * 3 + 2
> say 12 % 3; # -> 0 # 4 * 3 + 0

> say 12 % "3.1"; # -> 2.7

> say 7 mod 3; # -> 1  # 2 * 3 + 1
> say 8 mod 3; # -> 2  # 2 * 3 + 2
> say 9 mod 3; # -> 0  # 3 * 3 + 0

> say 9 %% 3;       # -> True
> say 11 %% 3;      # -> False
> say 9.3 %% "3.1"; # -> True

> say sqrt(9);       # -> 3
> say sqrt(-1);      # -> NaN
> say sqrt(-1 + 0i); # -> 0+1i

> $power.exp($base);

> say exp 3;     # -> 20.085536923187668
> say 3.exp;     # -> 20.085536923187668
> say 2.exp(3);  # -> 9
> say exp(2, 3); # -> 9

> say 2 ** 3; # -> 8
> say 3 ** 2; # -> 9
> say e ** 3; # -> 20.085536923187664

> say e ** 3 - exp 3; # -> -3.552713678800501e-15

> say expmod(4, 2, 5); # -> 1 ## The same as: 4 ** 2 mod 5
> say 7.expmod(2, 5); # -> 4  ## The same as: 7 ** 2 mod 5;

> say log(10);    # -> 2.302585092994046
> say log(10, e); # -> 2.302585092994046

> say exp 2.302585092994046; # -> 10.000000000000002

> say log(10, pi);                 # -> 2.0114658675880612
> say exp(2.0114658675880612, pi); # -> 10.000000000000002

> say log10(1001);  # -> 3.0004340774793183
> say log(1001,10); # -> 3.0004340774793183

> say "abcde".chop; # -> abcd

> say "abcde".chop(2); # -> abc

> my @a = (1 .. 110); say @a.gist;
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 ...]

> my $a; say $a.gist;
(Any)

> my @a = (1,2,3, (4,5,6),7,8,9); say @a.Str;

> say @a.gist
[1 2 3 (4 5 6) 7 8 9]

> my $a; say $a.Str
Use of uninitialized value $a of type Any in string context.

> say (1/3).raku; # -> <1/3>

> my $a; say "The value is: $a";
Use of uninitialized value of type Any in string context.

> say "The value is: { $a }";
Use of uninitialized value of type Any in string context.

> say "The value is: { $a.gist }";
The value is: (Any)

> say "The value is: { $a.raku }";
The value is: Any

> say "foo { $a // "Undefined" } bar"
foo Undefined bar

> put ^10; # -> 0 1 2 3 4 5 6 7 8 9
> say ^10; # -> ^10

> put "{ ^10 }"; # -> 0 1 2 3 4 5 6 7 8 9
> say "{ ^10 }"; # -> 0 1 2 3 4 5 6 7 8 9

> printf("%s\n", "Tom", 11222);
Your printf-style directives specify 1 argument, but 2 arguments were supplied
  in block <unit> at <unknown file> line 1

> printf("Hello %s, and %s.\n", "Tom", "Welcome");
Hello Tom, and Welcome.

> printf('Hello %2$s, and %1$s.' ~ "\n", "Tom", "Welcome");
Hello Welcome, and Tom.

> printf('Hello %1$s, and %1$s.' ~ "\n", "Tom");
Hello Tom, and Tom.

> printf '|%6s|', 12;    # -> | 12|
> printf '|%*s|', 6, 12; # -> | 12|

> printf('Hello %2$s, and %1$s.' ~ "\n", "Tom", "Welcome");
Hello Welcome, and Tom.

> say sprintf('Hello %2$s, and %1$s.', "Tom", "Welcome");
Hello Welcome, and Tom.

> my $t1 = $string.fmt($format);
> my $t2 = sprintf($format, $string); # Exactly the same

> say 1200.fmt("%o"); # -> octal
2260

> say 1200.fmt("Octal: %o"); # More verbose.
Octal: 2260

> say 1200.fmt('Decimal: %1$d - Octal: %1$o');
Decimal: 1200 - Octal: 2260

my $name = prompt "What's your name? ";
say "Hi, $name! Nice to meet you!";

loop {
    my $name = prompt "Enter a value (or return to exit): " or exit;
    say "Value $name is of the type { $name.^name }.";
}

$ raku prompt-type
Enter a value (or return to exit): Allan
Value Allan is of the type Str.
Enter a value (or return to exit): 12
Value 12 is of the type IntStr.
Enter a value (or return to exit): "12"
Value "12" is of the type Str.
Enter a value (or return to exit):

> my Int $a = prompt;
1234            # <- This is user input
> say $a.^name; # -> IntStr

> my Str $a = prompt;
1234            # <- This is user input
> say $a.^name; # -> IntStr

> my Int $a = prompt;
foo             # <- This is user input
Type check failed in assignment to $a; expected Int but got Str ("foo")

> say IntStr.^mro; # -> ((IntStr) (Int) (Str) (Cool) (Any) (Mu))
> say Str.^mro;    # -> ((Str) (Cool) (Any) (Mu))
> say Int.^mro;    # -> ((Int) (Cool) (Any) (Mu))

> say IntStr.^mro.raku; # -> (IntStr, Int, Str, Cool, Any, Mu)

say "abc".chars; # -> 3

say chars(pi); # -> 17

my $s = "1234567890";
say $s.chop($s.chars -1); # -> 1

my $s = "A\c[Combining Ring Above]";    # -> Å
say $s.chars;                           # -> 1
say "A\c[Combining Ring Above]" eq "Å"; # -> True

say "12øøæåsaåsæ".codes; # -> 11
say "12øøæåsaåsæ".chars; # -> 11

say "A\c[Combining Ring Above]".codes; # -> 1
say "A\c[Combining Ring Above]".chars; # -> 1

say "O\c[Combining Ring Above]".codes; # -> 2
say "O\c[Combining Ring Above]".chars; # -> 1

say "A\c[Combining Ring Above]".uniname;
# LATIN CAPITAL LETTER A WITH RING ABOVE

say "abc".uniname;
# LATIN SMALL LETTER A

say "\c[LATIN SMALL LETTER A]"; # -> a
say "\c[Latin Small Letter a]"; # -> a

say "O\c[Combining Ring Above]".uninames;
# (LATIN CAPITAL LETTER O COMBINING RING ABOVE)

say "O\c[Combining Ring Above]".uninames.raku;
# ("LATIN CAPITAL LETTER O", "COMBINING RING ABOVE").Seq

say ‘»ö«’.uninames.raku;
# «("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "LATIN SMALL LETTER O WITH DIAERESIS", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK").Seq»

say "LATIN SMALL LETTER A".uniparse; # -> a

uniparse("LATIN SMALL LETTER A WITH VERTICAL LINE BELOW AND ACUTE");
#  Unrecognized character name [LATIN SMALL LETTER A WITH VERTICAL LINE BELOW AND ACUTE]
#    in block <unit> at <unknown file> line 1

"A".ord;    # -> 65
"Abba".ord; # -> 65

"Abb".ords; # -> (65 98 98)

say "A\c[Combining Ring Above]".ords; # -> (197)
say "O\c[Combining Ring Above]".ords; # -> (79 778)

say "O\c[Combining Ring Above]".ord; # -> 79

say 65.chr;   # -> A ## Decimal
say 0x41.chr; # -> A ## Hexadecimal

say <67 97 109 101 108 105 97>.chrs; # -> Camelia

say (79, 778).chrs.ords;                   # -> (79 778)
say "O\c[Combining Ring Above]".chrs.ords; # -> (79 778)

say 197.chr;             # -> Å
say (65, 778).chrs;      # -> Å
say (65, 778).chrs.ords; # -> (197)

say "abc123".substr-eq("c123", 3); # -> False ## As "123" ne "c123"
say "abc123".substr-eq("c123", 2); # -> True ## As "c123" eq "c123"

my $s = "abc"; $s.substr-rw(1, 1) = "Q"; $s.say;  # -> aQc
my $s = "abc"; substr-rw($s, 1, 1) = "Q"; $s.say; # -> aQc

my $s = "abc"; $s.substr-rw(1, 1) = "QQQ"; $s.say; # -> aQQc

my $s = "abc"; $s.substr-rw(1, 0) = "ZZ"; $s.say; # -> aZZbc

my $string = "abc*123*ABC";
my $partial := $string.substr-rw(4, 3);
say "$string - $partial"; ## -> abc*123*ABC - 123

$partial = "9876543210";
say "$string - $partial"; ## -> abc*9876543210*ABC - 987

$string = "123|abc|456";
say "$string - $partial"; ## -> 123|abc|456 - abc

say "this is IT!".lc; # -> this is it!

say "this is IT!".tc; # -> This is IT!

say "this is IT!".tclc; # -> This is it!

say "this is IT!".uc; # -> THIS IS IT!

say "this is IT!".fc; # -> this is it!

say "Saß".uc;  # -> "SASS"
say "Sass".uc; # -> "SASS"

say "this is IT!".wordcase; # -> This Is It!

say "this is IT!".wordcase(:where({ .chars == 2 }) );              # -> this Is It!
say "this is IT!".wordcase(:filter(&uc), :where({ .chars == 2 })); # -> this IS IT!

say '1 $aaaaa 17'.words; # -> (1 $aaaaa 17)
say qw/1 $aaaaa 17/;     # -> (1 $aaaaa 17)

my $aaaaa = "X";
say "1 $aaaaa 17"words; # -> (1 X 17)
say qqw/1 $aaaaa 17/;   # -> (1 X 17)

"abc";
abc

"abc".indent: 2;
  abc
"abc".indent(3);
   abc
"abc".indent: 10;
          abc

> say (1,2,3)[0].^name;       # -> Int
> say ("1","2","3")[0].^name; # -> Str

> say <1 2 3 4>[0].^name; # -> IntStr
> say <1.2 2 3>[0].^name; # -> RatStr
> say <A12 2 3>[0].^name; # -> Str

> my $a = <12>; say $a.^name;   # -> IntStr
> my ba = <12.1>; say $b.^name; # -> RatStr

> my $a = "12"; say $a.^name; # -> Str
> say <<$a>>.^name;           # -> IntStr

> say val($a).^name; # -> IntStr

> say val("12").^name;   # -> IntStr
> say val("12.1").^name; # -> RatStr
> say val(12).^name;
Value of type Int uselessly passed to val()

> my $number-of-elements = @d.elems;
> my $number-of-elements = elems @d;

> say +("a" .. "z"); # -> 26

> say ("a" .. "z").end; # -> 25

my @a; say @a.end; # -> -1

> my @a;
> say @a.elems; # -> 0
> say @a.end;   # -> -1

> my @b = (1);
> say @b.elems; # -> 1
> say @b.end;   # -> 0

> @b[10] = 's';
> say @a.elems; # -> 10
> say @a.end;   # -> 11

my @stack = ...;

@stack.unshift($customer-id); # Add one element to the stack

my $current = @stack.pop;     # Get one element from the stack

my @queue = ...;

@queue.push($customer-id);  # Add one element to the queue

my $current = @queue.shift; # Get one element from the queue

> my @list1 = 1,2,3,4,5;
[1 2 3 4 5]

> my @list2 = 8,9;
[8 9]

> @list1.push(@list2);
[1 2 3 4 5 [8 9]]

> @list1.push(|@list2); # push the individual values, and not the list
[1 2 3 4 5 8 9]

> (1, (2, (3, 4)), 5).flat;
(1 2 3 4 5)

> my @a = (1,2);            # -> [1 2]
> my @b = (1, 2, @a, 1, 2); # -> [1 2 [1 2] 1 2]
> @b.flat;                  # -> (1 2 [1 2] 1 2)

> @b».List.flat;  # Unicode version
> @b>>.List.flat; # ASCII version

> (1 .. 10).map({ $^a + $^b });

> @a.map( { .sqrt } );

> (1..10).map( *.sqrt );
(1 1.4142135623730951 1.7320508075688772 2 2.23606797749979)

> (1..10).map(* + 1); # -> (2 3 4 5 6 7 8 9 10 11)

> say (1 .. 25).grep(! *.is-prime);

> my @a = ((1,2),(3,(4,5)));

> @a.map( * +1 );     # -> (3 3)
> @a.deepmap( * +1 ); # -> [(2 3) (4 (5 6))]

my $a = 1;
my $b = 2;

my $tmp = $a; $a = $b; $b = $tmp;

($a, $b) = ($b, $a);

($a, $b) .= reverse;

> my @a[3;3;3];
> @a[3;3;3] = 12
Index 3 for dimension 3 out of range (must be 0..2)
  in block <unit> at <unknown file> line 1

>  my @a[3;3] = ((1,2,3), (4,5,6), (7,8,9))
[[1 2 3] [4 5 6] [7 8 9]]

my @foo[2;3] = ( < 1 2 3 >, < 4 5 6 > ); # Array with fixed dimensions
say @foo.shape;                          # -> (2 3)
my @bar = ( < 1 2 3 >, < 4 5 6 > );      # Normal array (of arrays)
say @bar.shape;                          # -> (*)

> (1, 2, 1, 2, 3,4,5,6,1).repeated;
(1 2 1)

> (1, 2, 1, 2, 3,4,5,6,1).repeated.sort.squish;
(1 2)

> say (1 .. 25).grep(* % 3);
(1 2 4 5 7 8 10 11 13 14 16 17 19 20 22 23 25)

> say (1 .. 25).grep(! *.is-prime);
(1 4 6 8 9 10 12 14 15 16 18 20 21 22 24 25)

> say (1, 1.5, 2, 2.5, 3, 3.5, 4).grep(Int);
(1 2 3 4)

> say (1000 .. Inf).first(*.is-prime);
1009

> say (0.1 .. 0.9).first(*.is-prime);
Nil

> say (1 ..^ 1000).first(:end, *.is-prime);
997

> (1 .. Inf).head
1

> (-1 .. Inf).head(2)
(-1 0)

> <a b c d 12>.head
a

> <a b c d 12>.tail
12

> (-Inf .. Inf).tail
Cannot tail a lazy list
  in block <unit> at <unknown file> line 1

> (-Inf .. Inf).head
-Inf

> rand; # -> 0.4214056307236411
> rand; # -> 0.7753853239550014

> 100.rand; # -> 51.322528184845

> @colours.pick;   # From an array
> (10 .. 99).pick; # From a range

> ("red", "blue", "green", "yellow").pick

> (10 .. 99).pick(10);

> ("red", "blue", "green", "yellow").pick(2);
(red yellow)

> ("red", "blue", "green", "yellow").pick(9);
(green yellow red blue)

> <red blue green yellow>pick(*);
(green yellow blue red)

> say (1 .. 6).pick for ^3 5
2
5

> (1 .. 6).pick.fmt("%d ").print for ^10; say "";
1 5 3 6 2 1 5 6 2 1

> say join(" ", ( (1 .. 6).pick for ^10) );
5 4 3 6 4 4 4 5 6 2

> say (1 .. 6).pick xx 10
(6 5 5 4 4 6 6 2 4 2)

> say (1 .. 6).pick xx 10
(6 3 3 6 6 5 5 4 5 2)

> (1..6).roll(3); # -> (1 4 6)
> (1..6).roll(3); # -> (1 2 6)
> (1..6).roll(3); # -> (3 3 6)

> (1..6).roll; # -> 6

> (1..6).roll(*); # -> (3 3 6 ...)

> (True, False).roll; # -> True
> Bool.roll;          # -> True

> (True, True, False, False, False,).roll; # -> True

> srand(1234567890); say rand; say rand;
0.9168008342654074
0.297372052451493

> srand(1234567890); say rand; say rand;
0.9168008342654074
0.297372052451493

> srand(112); (1 .. 6).pick.fmt("%d ").print for ^10; say "";
6 1 4 6 6 4 5 4 6 3

> srand(112); (1 .. 6).pick.fmt("%d ").print for ^10; say "";
6 1 4 6 6 4 5 4 6 3

> srand(1); (1..10).pick; # -> 4
> srand(1); (1..10).pick; # -> 4
> srand(1); (1..10).pick; # -> 4

> Pair(1 => 2).WHAT
(Pair)

> (1 => 2).WHAT # The same, but shorter
(Pair)

> Pair.new(1, 2).WHAT # Without the "fat arrow"
(Pair)

> my $a = (pi => pi);
pi => 3.141592653589793

> my $age = 14;
> my $p = :$age;
> say $p; # -> age => 10

> my $a = (1 => 2); # -> 1 => 2
> $a.key;           # -> 1

> $a.value; # -> 2

> ("a" => "r").antipair; # -> r => a