infix:<+>(1, 2);                # same as 1 + 2 
circumfix:«[ ]»(<a b c>);       # same as [<a b c>]

my $str = 'old string';
$str ~~ s/o .+ d/new/;
say $str; # OUTPUT: «new string␤»

my $str = 'foo muCKed into the lEn';
 
# replace second 'o' with 'x' 
$str ~~ s:2nd/o/x/;
 
# replace 'M' or 'L' followed by non-whitespace stuff with 'd' 
# and lower-cased version of that stuff: 
$str ~~ s :g :i/<[ML]> (\S+)/d{lc $0}/;
 
say $str; # OUTPUT: «fox ducked into the den␤»

my $str = 'foober';
$str ~~ s!foo!fox!;
$str ~~ s{b(.)r} = " d$0n";
say $str; # OUTPUT: «fox den␤»

say S/o .+ d/new/ with 'old string';      # OUTPUT: «new string␤» 
S:g/« (.)/$0.uc()/.say for <foo bar ber>; # OUTPUT: «Foo␤Bar␤Ber␤»

my $str = 'old string';
$str ~~ tr/dol/wne/;
say $str; # OUTPUT: «new string␤»

my $str = 'old string';
$str ~~ tr:c:d/dol st//;
say $str; # OUTPUT: «old st␤»

with 'old string' {
    say TR/dol/wne/; # OUTPUT: «new string␤» 
}

say TR:d/dol // with 'old string'; # OUTPUT: «string␤»

my $x = 1;        # item assignment; $x = 1 
my @x = 1,2,3;    # list assignment; @x = [1,2,3]

my $a = 32;
$a += 10;         # $a = 42 
$a -= 2;          # $a = 40 
 
$a = 3;
$a min= 5;        # $a = 3 
$a min= 2;        # $a = 2 
 
my $s = 'a';
$s ~= 'b';        # $s = 'ab' 
 
# And an example of a custom operator: 
sub infix:<space-concat> ($a, $b) { $a ~ " " ~ $b };
my $a = 'word1';
$a space-concat= 'word2';                 # OUTPUT: «'word1 word2'␤»

my sub fac (Int $n) { [*] 1..$n };        # sub for calculating factorial 
my @x = ( my $y = fac(100), $y*101 );     # @x = [100!, 101!] 
 
my $i = 0;
repeat { say $i } while ($i += 1) < 10;   # OUTPUT: «0,1,2,...9␤»

expression1 += expression2;                     # compound assignment
expression1  = expression1 + expression2;       # simple assignment

my @arr = [10, 20, 30];
my $i = 0;
 
if rand < 1/2 {
    @arr[++$i] += 1;                # @arr = [10,21,30] 
} else {
    @arr[++$i] = @arr[++$i] + 1;    # @arr = [10,31,30] (or [10,20,21]?) 
}                                   # the result may be implementation-specific 
say @arr;

my @str = "Cleanliness is next to godliness".comb;
my ($len, $str);
for @str -> $c {
  $len += 1;
  $str ~= $c;
}
say "The string '$str' has $len characters.";

my $a = 3.14;
$a .= round;      # $a = $a.round; OUTPUT: «3»

my $a = True;
say so $a != True;    # OUTPUT: «False␤» 
my $i = 10;
 
my $release = Date.new(:2015year, :12month, :24day);
my $today = Date.today;
say so $release !before $today;     # OUTPUT: «False␤»

say 4 R/ 12;               # OUTPUT: «3␤» 
say [R/] 2, 4, 16;         # OUTPUT: «2␤» 
say [RZ~] <1 2 3>,<4 5 6>  # OUTPUT: «(41 52 63)␤»

say (1, 2, 3) »*» 2;          # OUTPUT: «(2 4 6)␤» 
say (1, 2, 3, 4) »~» <a b>;   # OUTPUT: «(1a 2b 3a 4b)␤» 
say (1, 2, 3) »+« (4, 5, 6);  # OUTPUT: «(5 7 9)␤» 
say (&sin, &cos, &sqrt)».(0.5);
# OUTPUT: «(0.479425538604203 0.877582561890373 0.707106781186548)␤»

my @a = <1 2 3>;
my @b = <4 5 6>;
say (@a,@b)»[1]; # OUTPUT: «(2 5)␤»

my @a = 1, 2, 3;
say @a »+=» 1;    # OUTPUT: «[2 3 4]␤» 
my ($a, $b, $c);
(($a, $b), $c) «=» ((1, 2), 3);
say "$a, $c";       #  OUTPUT: «1, 3␤»

my @wisdom = True, False, True;
say !« @wisdom;     # OUTPUT: «[False True False]␤» 
 
my @a = 1, 2, 3;
@a»++;
say @a;             # OUTPUT: «[2 3 4]␤»

say -« [[1, 2], 3]; # OUTPUT: «[[-1 -2] -3]␤»

class CarefulClass { method take-care {} }
my CarefulClass @objs;
my @results = @objs».take-care();
 
my @slops;        # May Contain Nuts 
@slops».?this-method-may-not-exist();

my %outer = 1, 2, 3 Z=> <a b c>;
my %inner = 1, 2 Z=> <x z>;
say %outer «~» %inner;          # OUTPUT: «{"1" => "ax", "2" => "bz"}␤»

sub pretty-file-size (Int $size --> Str) {
    # rounding version of infix:</>(Int, Int) 
    sub infix:<r/>(Int \i1, Int \i2) {
        round(i1 / i2, 0.1)
    }
 
    # we build a vector of fractions of $size and zip that with the fitting prefix 
    for $size «[r/]« (2**60, 2**50, 2**40, 2**30, 2**20, 2**10)
              Z      <EB     PB     TB     GB     MB     KB> -> [\v,\suffix] {
        # starting with the biggest suffix, 
        # we take the first that is 0.5 of that suffix or bigger 
        return v ~ ' ' ~ suffix if v > 0.4
    }
    # this be smaller or equal then 0.4 KB 
    return $size.Str;
}
 
for 60, 50, 40, 30, 20, 10 -> $test {
    my &a = { (2 ** $test) * (1/4, 1/2, 1, 10, 100).pick * (1..10).pick };
    print pretty-file-size(a.Int) xx 2, ' ';
}
 
# OUTPUT: «10 EB 4 EB 2 PB 5 PB 0.5 PB 4 TB 300 GB 4.5 GB 50 MB 200 MB 9 KB 0.6 MB␤»

say (<a b>, <c d e>)».elems;        # OUTPUT: «(2 3)␤» 
say (<a b>, <c d e>)».&{ .elems };  # OUTPUT: «((1 1) (1 1 1))␤»

my $neighbors = ((-1, 0), (0, -1), (0, 1), (1, 0));
my $p = (2, 3);
say $neighbors »>>+<<» ($p, *);   # OUTPUT: «((1 3) (2 2) (2 4) (3 3))␤»

# These two are equivalent: 
say [+] 1, 2, 3;                # OUTPUT: «6␤» 
say reduce &infix:<+>, 1, 2, 3; # OUTPUT: «6␤»

sub plus { $^a + $^b };
say [[&plus]] 1, 2, 3;          # OUTPUT: «6␤»

say [X~] (1, 2), <a b>;         # OUTPUT: «(1a 1b 2a 2b)␤»

my @n = [\~] 1..*;
say @n[^5];         # OUTPUT: «(1 12 123 1234 12345)␤»

1..3 X~ <a b> # OUTPUT: «<1a, 1b, 2a, 2b, 3a, 3b>␤»

my @l = <a b c> Z~ 1, 2, 3;     # OUTPUT: «[a1 b2 c3]␤»

my @l = <a b c d> Z~ ':' xx *;  # OUTPUT: «<a: b: c: d:>» 
   @l = <a b c d> Z~ 1, 2, *;   # OUTPUT: «<a1 b2 c2 d2>»

my @l = 1 Z 2;  # OUTPUT: «[(1 2)]»

say so 1 S& 2 S& 3;  # OUTPUT: «True␤»

my @a = 1, 2, 3;
my @b = 5, 6, 7;
@a X[+=] @b;
say @a;         # OUTPUT: «[19 20 21]␤»

say <a b c>[1];   # OUTPUT: «b␤»

multi p(:$a!) { say 'named'      }
multi p($a)   { say 'positional' }
p a => 1;           # OUTPUT: «named␤» 
p (a => 1);         # OUTPUT: «positional␤»

{}.^name.say;        # OUTPUT: «Hash␤» 
{;}.^name.say;       # OUTPUT: «Block␤» 
 
{:$_}.^name.say;     # OUTPUT: «Block␤» 
%(:$_).^name.say;    # OUTPUT: «Hash␤» 
hash(:$_).^name.say; # OUTPUT: «Hash␤»

say .raku for [3,2,[1,0]]; # OUTPUT: «3␤2␤$[1, 0]␤»

sub postcircumfix:<[ ]>(@container, **@index,
                        :$k, :$v, :$kv, :$p, :$exists, :$delete)

my @alphabet = 'a' .. 'z';
say @alphabet[0];                   # OUTPUT: «a␤» 
say @alphabet[1];                   # OUTPUT: «b␤» 
say @alphabet[*-1];                 # OUTPUT: «z␤» 
say @alphabet[100]:exists;          # OUTPUT: «False␤» 
say @alphabet[17, 0, 10, 20].join;  # OUTPUT: «raku␤» 
say @alphabet[23 .. *].raku;        # OUTPUT: «("x", "y", "z")␤» 
 
@alphabet[1, 2] = "B", "C";
say @alphabet[0..3].raku;           # OUTPUT: «("a", "B", "C", "d")␤»

sub postcircumfix:<{ }>(%container, **@key,
                        :$k, :$v, :$kv, :$p, :$exists, :$delete)

my %color = kiwi => "green", banana => "yellow", cherry => "red";
say %color{"banana"};                 # OUTPUT: «yellow␤» 
say %color{"cherry", "kiwi"}.raku;    # OUTPUT: «("red", "green")␤» 
say %color{"strawberry"}:exists;      # OUTPUT: «False␤» 
 
%color{"banana", "lime"} = "yellowish", "green";
%color{"cherry"}:delete; # note that value is always returned but removal only happens when delete is true. 
say %color;             # OUTPUT: «banana => yellowish, kiwi => green, lime => green␤»

use JSON::Tiny;
 
my $config = from-json('{ "files": 3, "path": "/home/some-user/raku.rakudoc" }');
say $config.raku;      # OUTPUT: «${:files(3), :path("/home/some-user/raku.rakudoc")}␤» 
my %config-hash = $config<>;
say %config-hash.raku; # OUTPUT: «{:files(3), :path("/home/some-user/raku.rakudoc")}␤» 

my %color = kiwi => "green", banana => "yellow", cherry => "red";
say %color<banana>;               # OUTPUT: «yellow␤» 
say %color<cherry kiwi>.raku;     # OUTPUT: «("red", "green")␤» 
say %color<strawberry>:exists;    # OUTPUT: «False␤»

my %color = kiwi => "green", banana => "yellow", cherry => "red";
my $fruit = "kiwi";
say %color«cherry "$fruit"».raku;   # OUTPUT: «("red", "green")␤»

my sub f($invocant){ "The arg has a value of $invocant" }
42.&f;
# OUTPUT: «The arg has a value of 42␤» 
 
42.&(-> $invocant { "The arg has a value of $invocant" });
# OUTPUT: «The arg has a value of 42␤»

class Foo {
    has $.a = 3;
    method bar {
        return $.^name
    }
};
say Foo.new.bar; # OUTPUT: «Foo␤» 

class A {
  method foo { say "from A"; }
}
class B is A {
  multi method foo { say "from B"; }
  multi method foo(Str) { say "from B (Str)"; }
}
class C is B is A {
  multi method foo { say "from C"; }
  multi method foo(Str) { say "from C (Str)"; }
}
 
say C.+foo; # OUTPUT: «from C␤from B␤from A␤(True True True)␤»

my @a = <a b c>;
my @b = @a».ord;                  # OUTPUT: «[97, 98, 99]␤» 
# The first parameter of a method is the invocant. 
sub foo(Str:D $c){ $c.ord * 2 };
# So we can pretend to have a method call with a sub that got a good 
# first positional argument. 
say @a».&foo;
# Blocks have an implicit positional arguments that lands in $_. The latter can 
# be omitted for method calls. 
say @a».&{ .ord};

@a».say;  # WRONG! Could produce a␤b␤c␤ or c␤b␤a␤ or any other order 

my @a;
@a[1, 2, 3];
@a.[1, 2, 3]; # Same

class Operation {
    has $.symbol;
    has &.function;
}
my $addition = Operation.new(:symbol<+>, :function{ $^a + $^b });
say $addition.function()(1, 2);   # OUTPUT: «3␤» 
# OR 
say $addition.function.(1, 2);    # OUTPUT: «3␤»

1.i # No such method 'i' for invocant of type 'Int' 

my $a = 1;
say ++$a;       # OUTPUT: «2␤» 
say $a.:<++>;   # OUTPUT: «3␤»

class Bar {
    method baz { 42 }
}
class Foo is Bar {
    method baz { "nope" }
}
say Foo.Bar::baz;       # OUTPUT: «42␤»

my %a = :11a, :22b;
%a ,= :33x;
say %a # OUTPUT: «{a => 11, b => 22, x => 33}␤»

multi prefix:<++>($x is rw) is assoc<non>

my $x = 3;
say ++$x;   # OUTPUT: «4␤» 
say $x;     # OUTPUT: «4␤»

multi prefix:<-->($x is rw) is assoc<non>

my $x = 3;
say --$x;   # OUTPUT: «2␤» 
say $x;     # OUTPUT: «2␤»

multi postfix:<++>($x is rw) is assoc<non>

my $x = 3;
say $x++;   # OUTPUT: «3␤» 
say $x;     # OUTPUT: «4␤»

my $x;
$x++;
say $x;     # OUTPUT: «1␤»

my $x;
say $x++;   # OUTPUT: «0␤» 
say $x;     # OUTPUT: «1␤»

my $filename = "somefile-001.txt";
say $filename++ for 1..3;
# OUTPUT: «somefile-001.txt␤somefile-002.txt␤somefile-003.txt␤»

my $was٧ = "ثمانية٧";
$was٧++;
say $was٧; # OUTPUT: «ثمانية٨␤» 

my $เลขไทย="๙๙";
$เลขไทย++;
say $เลขไทย; # OUTPUT: «๑๐๐␤» 

multi postfix:<-->($x is rw) is assoc<non>

my $x = 3;
say $x--;   # OUTPUT: «3␤» 
say $x;     # OUTPUT: «2␤»

my $x;
say $x--;   # OUTPUT: «0␤» 
say $x;     # OUTPUT: «-1␤»

my $filename = "somefile-003.txt";
say $filename-- for 1..3;
# OUTPUT: «somefile-003.txt␤somefile-002.txt␤somefile-001.txt␤»

multi infix:<**>(Any, Any --> Numeric:D) is assoc<right>

sub squared( Int $num ) { $num² };
say squared($_) for ^5; # OUTPUT: «0␤1␤4␤9␤16␤»

sub twenty-second-power( Int $num ) { $num²² };
say twenty-second-power($_) for ^5; # OUTPUT: «0␤1␤4194304␤31381059609␤17592186044416␤»

multi prefix:<?>(Mu --> Bool:D)

multi prefix:<!>(Mu --> Bool:D)