# WRONG (most likely): 
unit module Something::Or::Other;
constant $config-file = "config.txt".IO.slurp;

# Good; file gets updated from 'config.txt' file on each script run: 
unit module Something::Or::Other;
my $config-file := "config.txt".IO.slurp;

my @a = 4, 8, 15, 16;
@a[2] = Nil;
say @a; # OUTPUT: «[4 8 (Any) 16]␤» 

my %h is default(Nil) = a => Nil;
say %h; # OUTPUT: «Hash %h = {:a(Nil)}␤» 

@a[3] := Nil;
say @a; # OUTPUT: «[4 8 (Any) Nil]␤» 

my $result2 = 'abcdef' ~~ / dex /;
say "Result2 is { $result2.^name }"; # OUTPUT: «Result2 is Any␤» 

sub count-it { say "Count is {$++}" }
count-it;
count-it;
 
# OUTPUT: 
# Count is 0 
# Count is 0 

sub count-it {
    for ^3 {
        state $count = 0;
        say "Count is $count";
        $count++;
    }
}
 
count-it;
say "…and again…";
count-it;
 
 
# OUTPUT: 
# Count is 0 
# Count is 1 
# Count is 2 
# …and again… 
# Count is 0 
# Count is 1 
# Count is 2 

sub count-it { say "Count is $($++)" }
count-it;
count-it;
 
# OUTPUT: 
# Count is 0 
# Count is 1 

sub count-it { say "Count is " ~ $++ }

enum Foo «a b»;
say Foo.enums ∋ 'a';
 
# OUTPUT: 
# False 

enum Foo «a b»;
say Foo.enums<a>:exists;
 
# OUTPUT: 
# True 

$ = {say 42;} # Block 
$ = {;}       # Block 
$ = {…}       # Block 
$ = { }       # Hash 

my &does-nothing = {;};
say does-nothing(33); # OUTPUT: «Nil␤»

class Point {
    has $.x;
    has $.y;
    method double {
        $.x *= 2;   # WRONG 
        $.y *= 2;   # WRONG 
        self;
    }
}
 
say Point.new(x => 1, y => -2).double.x
# OUTPUT: «Cannot assign to an immutable value␤» 

method double {
    $!x *= 2;
    $!y *= 2;
    self;
}

class A {
    has $.x;
    has $.y;
    submethod BUILD {
        $!y = 18;
    }
}
 
say A.new(x => 42).x;       # OUTPUT: «Any␤» 

submethod BUILD(:$x) {
    $!y = 18;
    $!x := $x;
}

submethod BUILD(:$!x) {
    $!y = 18;
}

say 'a b' ~~ /a b/; # OUTPUT: «False␤» 

# WRONG; trying to hash-slice a Bool: 
while ($++ > 5){ .say }

# RIGHT: 
while ($++ > 5) { .say }
 
# EVEN BETTER; Raku does not require parentheses there: 
while $++ > 5 { .say }

# WRONG; ambiguity with `[<]` metaop: 
my @a = [[<foo>],];

# RIGHT; reductions cannot have spaces in them, so put one in: 
my @a = [[ <foo>],];
 
# No ambiguity here, natural spaces between items suffice to resolve it: 
my @a = [[<foo bar ber>],];

# WRONG; trying to index 3 associatively: 
say 3<5>4

# RIGHT; prefer some extra whitespace around infix operators: 
say 3 < 5 > 4

my $a = 2; say join ",", ($a, ++$a);  # OUTPUT: «3,3␤» 

my $a = 2; say join ",", (+$a, ++$a); # OUTPUT: «2,3␤» 

my $a = 2; say  "$a, {++$a}"; # OUTPUT: «2, 3␤» 

my @arr;
my ($a, $b) = (1,1);
for ^5 {
    ($a,$b) = ($b, $a+$b);
    @arr.push: ($a, $b);
    say @arr
};

my @arr;
my ($a, $b) = (1,1);
for ^5 {
    ($a,$b) = ($b, $a+$b);
    @arr.push: ($a.item, $b.item);
    say @arr
};

my @a = <a b c d>;
say @a.index(‘a’);    # OUTPUT: «0␤» 
say @a.index('c');    # OUTPUT: «4␤» -- not 2! 
say @a.index('b c');  # OUTPUT: «2␤» -- not undefined! 
say @a.index(<a b>);  # OUTPUT: «0␤» -- not undefined! 

my @menu = <hamburger fries milkshake>;
say @menu.contains('hamburger');            # OUTPUT: «True␤» 
say @menu.contains('hot dog');              # OUTPUT: «False␤» 
say @menu.contains('milk');                 # OUTPUT: «True␤»! 
say @menu.contains('er fr');                # OUTPUT: «True␤»! 
say @menu.contains(<es mi>);                # OUTPUT: «True␤»! 

my @menu = <hamburger fries milkshake>;
say @menu (cont) 'fries';                   # OUTPUT: «True␤» 
say @menu (cont) 'milk';                    # OUTPUT: «False␤» 
say @menu (>) <hamburger fries>;            # OUTPUT: «True␤» 
say @menu (>) <milkshake fries>;            # OUTPUT: «True␤» (! NB: order doesn't matter) 

say 0xff.contains(55);      # OUTPUT: «True␤» 
say 0xff.contains(0xf);     # OUTPUT: «False␤» 
say 12_345.contains("23");  # OUTPUT: «True␤» 
say 12_345.contains("2_");  # OUTPUT: «False␤» 

my @colors = <red orange yellow green blue indigo violet>;
say @colors.rand;       # OUTPUT: «2.21921955680514␤» 
say @colors.pick;       # OUTPUT: «orange␤» 
say @colors.roll;       # OUTPUT: «blue␤» 
say @colors.pick(2);    # OUTPUT: «(yellow violet)␤»  (cannot repeat) 
say @colors.roll(3);    # OUTPUT: «(red green red)␤»  (can repeat) 

say 42 %% <11 33 88 55 111 20325>; # OUTPUT: «True␤»

say 42 %% <11 33 88 55 111 20325>.any;
# OUTPUT: «any(False, False, False, False, False, False)␤» 

my @array = qw{victor alice bob charlie eve};
say @array[-1];    # OUTPUT: «eve␤»

my @array = qw{victor alice bob charlie eve};
say @array[*-1];   # OUTPUT: «eve␤» 

my @array = qw{victor alice bob charlie eve};
say @array.tail;      # OUTPUT: «eve␤» 
say @array.tail(2);   # OUTPUT: «(charlie eve)␤» 

sub foo(Array @a) { ... }

sub foo(@a where Array) { ... }

sub bar(Int @a) { 42.say };
bar([1, 2, 3]);             # expected Positional[Int] but got Array 

my Int @b = 1, 2, 3;
bar(@b);                    # OUTPUT: «42␤» 
bar(Array[Int].new(1, 2, 3));

my $x = ‘hello’;
my $y = ‘foo bar’;
 
my %h = $x => 42, $y => 99;
say %h«$x»;   # ← WRONG; assumption that $x has no whitespace 
say %h«$y»;   # ← WRONG; splits ‘foo bar’ by whitespace 
say %h«"$y"»; # ← KINDA OK; it works but there is no good reason to do that 
say %h{$y};   # ← RIGHT; this is what should be used 
 
run «touch $x»;        # ← WRONG; assumption that only one file will be created 
run «touch $y»;        # ← WRONG; will touch file ‘foo’ and ‘bar’ 
run «touch "$y"»;      # ← WRONG; better, but has a different issue if $y starts with - 
run «touch -- "$y"»;   # ← KINDA OK; it works but there is no good enough reason to do that 
run ‘touch’, ‘--’, $y; # ← RIGHT; explicit and *always* correct 
run <touch -->, $y;    # ← RIGHT; < > are OK, this is short and correct 

# "HTML tags" interpreted as associative indexing: 
"$foo<html></html>" eq
"$foo{'html'}{'/html'}"

# Parentheses interpreted as call with argument: 
"$foo(" ~ @args ~ ")" eq
"$foo(' ~ @args ~ ')"

my $a = 1;
say '\qq[$a]()$b()';
# OUTPUT: «1()$b()␤» 

my $a = 1;
say Q:c«{$a}()$b()»;
# OUTPUT: «1()$b()␤» 

my $world = "there\";rm -rf /path/to/dir\"";
say qqx{echo "hello $world"};
# OUTPUT: «hello there␤» 

say "cba".sort;              # OUTPUT: «(cba)␤» 
say "cba".comb.sort.join;    # OUTPUT: «abc␤» 

say "\c[LATIN SMALL LETTER J WITH CARON, COMBINING DOT BELOW]"; # OUTPUT: «ǰ̣␤» 
say 'ǰ̣'.codes;        # OUTPUT: «2␤» 
say 'ǰ̣'.chars;        # OUTPUT: «1␤» 
say 'ǰ̣'.encode.bytes; # OUTPUT: «4␤»

say so   <0>; # OUTPUT: «False␤» 
say so <0e0>; # OUTPUT: «False␤» 
say so <0.0>; # OUTPUT: «False␤»

say so      ~<0>;     # OUTPUT: «True␤» 
say so       <0>.Str; # OUTPUT: «True␤» 
say so chars <0>;     # OUTPUT: «True␤»

say ‘groß’.lc eq ‘GROSS’.lc; # ← WRONG; False 
say ‘groß’.uc eq ‘GROSS’.uc; # ← WRONG; True, but that's just luck 
say ‘groß’.fc eq ‘GROSS’.fc; # ← RIGHT; True 

enum Animals <Dog Cat>;
my %h := :{ Dog => 42 };
say %h{Dog}; # OUTPUT: «(Any)␤» 

my $v = 'value A';
my $pair = Pair.new( 'a', $v );
$pair.say;  # OUTPUT: a => value A 
 
$v = 'value B';
$pair.say; # OUTPUT: a => value B 

my $set = <a b c>.Set;
.say for $set.list; # OUTPUT: «a => True␤c => True␤b => True␤» 
# OUTPUT: «a => True␤c => True␤b => True␤» 
# OUTPUT: «c => True␤b => True␤a => True␤» 

my $set = <a b c>.Set;
.say for $set.list.sort;  # OUTPUT: «a => True␤b => True␤c => True␤»

say 1... ^5; # OUTPUT: «(1 0 1 2 3 4)␤» 
say 1...^5;  # OUTPUT: «(1 2 3 4)␤»

say join ", ", "az".."bc";
# OUTPUT: «az, ba, bb, bc␤» 

say join ", ", "az".."bc";
#`{ OUTPUT: «
    az, ay, ax, aw, av, au, at, as, ar, aq, ap, ao, an, am, al, ak, aj, ai, ah,
    ag, af, ae, ad, ac, bz, by, bx, bw, bv, bu, bt, bs, br, bq, bp, bo, bn, bm,
    bl, bk, bj, bi, bh, bg, bf, be, bd, bc
␤»}

say join ", ", "r2".."t3";
# OUTPUT: «r2, r3, s2, s3, t2, t3␤» 

say join ", ", ("az", *.succ ... "bc");
# OUTPUT: «az, ba, bb, bc␤» 

my &method = { note $_; $_ };
$_ = 'object';
say .&method;
# OUTPUT: «object␤object␤» 
say 'topic' ~~ .&method;
# OUTPUT: «topic␤True␤» 

my &method = { note $_; $_ };
$_ = 'object';
say .&method;
# OUTPUT: «object␤object␤» 
say .&method ~~ 'topic';
# OUTPUT: «object␤False␤» 

constant V = 'x';
my %h = V => 'oi‽', ::V => 42;
say %h.raku
# OUTPUT: «{:V("oi‽"), :x(42)}␤» 

my $x = 10;
$x += 20;
say $x;     # OUTPUT: «30␤»

my @a = 1, 2, 3;
@a += 10;
say @a;  # OUTPUT: «[13]␤»

my @a = 1, 2, 3;
@a = @a + 10;
say @a;  # OUTPUT: «[13]␤»

my @a = 1, 2, 3;
@a »+=» 10;
say @a;  # OUTPUT: «[11 12 13]␤»

my $s = "abcd";
say $s .= uc.lc; # OUTPUT: abcd 
say $s;          # OUTPUT: ABCD

my $s = "abcd";
say $s .= uc .= lc; # OUTPUT: abcd 
say $s;             # OUTPUT: abcd

my $variable = 'camelia';
say ‘I ♥ camelia’ ~~ /  $variable  /;   # OUTPUT: ｢camelia｣ 
say ‘I ♥ camelia’ ~~ / <$variable> /;   # OUTPUT: ｢camelia｣

my $variable = '#camelia';
say ‘I ♥ #camelia’ ~~ /  $variable  /;   # OUTPUT: «｢#camelia｣␤» 
say ‘I ♥ #camelia’ ~~ / <$variable> /;   # !! Error: malformed regex

my $variable = 'ailemac';
say ‘I ♥ camelia’ ~~ / $($variable.flip)   /;   # OUTPUT: «｢camelia｣␤» 
say ‘I ♥ camelia’ ~~ / <{$variable.flip}>  /;   # OUTPUT: «｢camelia｣␤»

my $variable = 'ailema.';
say ‘I ♥ camelia’ ~~ / $($variable.flip)   /;   # OUTPUT: Nil 
say ‘I ♥ camelia’ ~~ / <{$variable.flip}>  /;   # OUTPUT: «｢camelia｣␤»

say 42 ~~ / [  0 || 42 ] | 4/; # OUTPUT: «｢4｣␤» 
say 42 ~~ / [ 42 ||  0 ] | 4/; # OUTPUT: «｢42｣␤» 

say 'foo' ~~ /< foo >/;  # OUTPUT: «｢foo｣␤» 
say 'foo' ~~ /< foo>/;   # OUTPUT: «｢foo｣␤»

say 'foo' ~~ /<foo>/;
# OUTPUT: «No such method 'foo' for invocant of type 'Match'␤ in block <unit> at <unknown file> line 1␤» 

if  'x' ~~ /./ { say 'yes' }  # OUTPUT: «yes␤» 
for 'x' ~~ /./ { say 'yes' }  # NO OUTPUT

say ('x' ~~ /./).list  # OUTPUT: «()␤»

for 'x' ~~ m:g/./ { say 'yes' }  # OUTPUT: «yes␤» 
for 'x' ~~ /(.)/  { say 'yes' }  # OUTPUT: «yes␤» 
for ('x' ~~ /./,) { say 'yes' }  # OUTPUT: «yes␤»

my %x = a => 42;
say !%x<b>:exists;            # dies with X::AdHoc 
say %x<b>:!exists;            # this works 
say !(%x<b>:exists);          # works too 
say not %x<b>:exists;         # works as well 
say True unless %x<b>:exists; # avoid negation altogether 

1..3.say;    # OUTPUT: «3␤» (and warns about useless use of "..") 
(1..3).say;  # OUTPUT: «1..3␤» 

sub f {
    return True and False;
    # this is actually 
    # (return True) and False; 
}
say f; # OUTPUT: «True␤» 

say -1²;   # OUTPUT: «-1␤» 
say -1**2; # OUTPUT: «-1␤» 

say (-1)²;   # OUTPUT: «1␤» 
say (-1)**2; # OUTPUT: «1␤» 

say  -1.abs;  # OUTPUT: «-1␤» 
say (-1).abs; # OUTPUT: «1␤» 

foo(...); # function call form, where ... represent the required arguments 
foo ...;  # list op form, where ... represent the required arguments 

sub foo() { say 'no arg' }
sub bar($a) { say "one arg: $a" }

foo();    # okay: no arg 
foo ();   # FAIL: Too many positionals passed; expected 0 arguments but got 1 
bar($a);  # okay: one arg: 1 
bar ($a); # okay: one arg: 1 

sub foo($a, $b) { say "two args: $a, $b" }

foo($a, $b);  # okay: two args: 1, 2 
foo ($a, $b); # FAIL: Too few positionals passed; expected 2 arguments but got 1 

sub foo($a, :$b) { ... }
foo(1, 'b' => 2); # FAIL: Too many positionals passed; expected 1 argument but got 2 

foo(1, b => 2); # okay 
foo(1, :b(2));  # okay 
foo(1, :b<it>); # okay 
 
my $b = 2;
foo(1, :b($b)); # okay, but redundant 
foo(1, :$b);    # okay 
 
# Or even... 
my %arg = 'b' => 2;
foo(1, |%arg);  # okay too 

my $list = ('b' => 2),; # this is a List containing a single Pair 
foo(|$list, :$b);       # okay: we passed the pair 'b' => 2 to the first argument 
foo(1, |$list);         # FAIL: Too many positionals passed; expected 1 argument but got 2 
foo(1, |$list.Capture); # OK: .Capture call converts all Pair objects to named args in a Capture