learnxinyminutes-docs/raku.md

---
category: language
language: Raku
filename: learnraku.raku
contributors:
    - ["vendethiel", "http://github.com/vendethiel"]
    - ["Samantha McVey", "https://cry.nu"]
---

Raku (formerly Perl 6) is a highly capable, feature-rich programming language
made for at least the next hundred years.

The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on
the JVM and the [MoarVM](http://moarvm.com).

Meta-note:

* Although the pound sign (`#`) is used for sentences and notes, Pod-styled
  comments (more below about them) are used whenever it's convenient.
* `# OUTPUT:` is used to represent the output of a command to any standard
   stream. If the output has a newline, it's represented by the `␤` symbol.
   The output is always enclosed by angle brackets (`«` and `»`).
* `#=>` represents the value of an expression, return value of a sub, etc.
   In some cases, the value is accompanied by a comment.
* Backticks are used to distinguish and highlight the language constructs
  from the text.

```perl6
####################################################
# 0. Comments
####################################################

# Single line comments start with a pound sign.

#`( Multiline comments use #` and a quoting construct.
  (), [], {}, 「」, etc, will work.
)

=for comment
Use the same syntax for multiline comments to embed comments.
for #`(each element in) @array {
    put #`(or print element) $_ #`(with newline);
}

# You can also use Pod-styled comments. For example:

=comment This is a comment that extends until an empty
newline is found.

=comment
The comment doesn't need to start in the same line as the directive.

=begin comment
This comment is multiline.

Empty newlines can exist here too!
=end comment

####################################################
# 1. Variables
####################################################

# In Raku, you declare a lexical variable using the `my` keyword:
my $variable;

# Raku has 3 basic types of variables: scalars, arrays, and hashes.

#
# 1.1 Scalars
#

# Scalars represent a single value. They start with the `$` sigil:
my $str = 'String';

# Double quotes allow for interpolation (which we'll see later):
my $str2 = "$str";

# Variable names can contain but not end with simple quotes and dashes,
# and can contain (and end with) underscores:
my $person's-belongings = 'towel'; # this works!

my $bool = True;             # `True` and `False` are Raku's boolean values.
my $inverse = !$bool;        # Invert a bool with the prefix `!` operator.
my $forced-bool = so $str;   # And you can use the prefix `so` operator
$forced-bool = ?$str;        # to turn its operand into a Bool. Or use `?`.

#
# 1.2 Arrays and Lists
#

# Arrays represent multiple values. An array variable starts with the `@`
# sigil. Unlike lists, from which arrays inherit, arrays are mutable.

my @array = 'a', 'b', 'c';
# equivalent to:
my @letters = <a b c>;
# In the previous statement, we use the quote-words (`<>`) term for array
# of words, delimited by space. Similar to perl's qw, or Ruby's %w.

@array = 1, 2, 4;

# Array indices start at 0. Here the third element is being accessed.
say @array[2]; # OUTPUT: «4␤»

say "Interpolate an array using []: @array[]";
# OUTPUT: «Interpolate an array using []: 1 2 3␤»

@array[0]    = -1;     # Assigning a new value to an array index
@array[0, 1] = 5, 6;   # Assigning multiple values

my @keys = 0, 2;
@array[@keys] = @letters; # Assignment using an array containing index values
say @array;               # OUTPUT: «a 6 b␤»

#
# 1.3 Hashes, or key-value Pairs.
#

# Hashes are pairs of keys and values. You can construct a `Pair` object
# using the syntax `key => value`. Hash tables are very fast for lookup,
# and are stored unordered. Keep in mind that keys get "flattened" in hash
# context, and any duplicated keys are deduplicated.
my %hash = 'a' => 1, 'b' => 2;

# Keys get auto-quoted when the fat comma (`=>`) is used. Trailing commas are
# okay.
%hash = a => 1, b => 2, ;

# Even though hashes are internally stored differently than arrays,
# Raku allows you to easily create a hash from an even numbered array:
%hash = <key1 value1 key2 value2>;          # Or:
%hash = "key1", "value1", "key2", "value2";

%hash = key1 => 'value1', key2 => 'value2'; # same result as above

# You can also use the "colon pair" syntax. This syntax is especially
# handy for named parameters that you'll see later.
%hash = :n(2),    # equivalent to `n => 2`
        :is-even, # equivalent to `:is-even(True)` or `is-even => True`
        :!is-odd, # equivalent to `:is-odd(False)` or `is-odd => False`
;
# The `:` (as in `:is-even`) and `:!` (as `:!is-odd`) constructs are known
# as the `True` and `False` shortcuts respectively.

# As demonstrated in the example below, you can use {} to get the value from a key.
# If it's a string without spaces, you can actually use the quote-words operator
# (`<>`). Since Raku doesn't have barewords, as Perl does, `{key1}` doesn't work
# though.
say %hash{'n'};     # OUTPUT: «2␤», gets value associated to key 'n'
say %hash<is-even>; # OUTPUT: «True␤», gets value associated to key 'is-even'

####################################################
# 2. Subroutines
####################################################

# Subroutines, or functions as most other languages call them, are
# created with the `sub` keyword.
sub say-hello { say "Hello, world" }

# You can provide (typed) arguments. If specified, the type will be checked
# at compile-time if possible, otherwise at runtime.
sub say-hello-to( Str $name ) {
    say "Hello, $name !";
}

# A sub returns the last value of the block. Similarly, the semicolon in
# the last expression can be omitted.
sub return-value { 5 }
say return-value;      # OUTPUT: «5␤»

sub return-empty { }
say return-empty;      # OUTPUT: «Nil␤»

# Some control flow structures produce a value, for instance `if`:
sub return-if {
	if True { "Truthy" }
}
say return-if;         # OUTPUT: «Truthy␤»

# Some don't, like `for`:
sub return-for {
    for 1, 2, 3 { 'Hi' }
}
say return-for;        # OUTPUT: «Nil␤»

# Positional arguments are required by default. To make them optional, use
# the `?` after the parameters' names.

# In the following example, the sub `with-optional` returns `(Any)` (Perl's
# null-like value) if no argument is passed. Otherwise, it returns its argument.
sub with-optional( $arg? ) {
    $arg;
}
with-optional;     # returns Any
with-optional();   # returns Any
with-optional(1);  # returns 1

# You can also give provide a default value when they're not passed. Doing
# this make said parameter optional. Required parameters must come before
# optional ones.

# In the sub `greeting`, the parameter `$type` is optional.
sub greeting( $name, $type = "Hello" ) {
  say "$type, $name!";
}

greeting("Althea");                 # OUTPUT: «Hello, Althea!␤»
greeting("Arthur", "Good morning"); # OUTPUT: «Good morning, Arthur!␤»

# You can also, by using a syntax akin to the one of hashes (yay unified syntax!),
# declared named parameters and thus pass named arguments to a subroutine.
# By default, named parameter are optional and will default to `Any`.
sub with-named( $normal-arg, :$named ) {
	say $normal-arg + $named;
}
with-named(1, named => 6); # OUTPUT: «7␤»

# There's one gotcha to be aware of, here: If you quote your key, Raku
# won't be able to see it at compile time, and you'll have a single `Pair`
# object as a positional parameter, which means the function subroutine
# `with-named(1, 'named' => 6);` fails.
with-named(2, :named(5));  # OUTPUT: «7␤»

# Similar to positional parameters, you can provide your named arguments with
# default values.
sub named-def( :$def = 5 ) {
    say $def;
}
named-def;            # OUTPUT: «5»
named-def(def => 15); # OUTPUT: «15»

# In order to make a named parameter mandatory, you can append `!` to the
# parameter. This is the inverse of `?`, which makes a required parameter
# optional.

sub with-mandatory-named( :$str! )  {
    say "$str!";
}
with-mandatory-named(str => "My String"); # OUTPUT: «My String!␤»
# with-mandatory-named;   # runtime error: "Required named parameter not passed"
# with-mandatory-named(3);# runtime error: "Too many positional parameters passed"

# If a sub takes a named boolean argument, you can use the same "short boolean"
# hash syntax we discussed earlier.
sub takes-a-bool( $name, :$bool ) {
    say "$name takes $bool";
}
takes-a-bool('config', :bool);  # OUTPUT: «config takes True␤»
takes-a-bool('config', :!bool); # OUTPUT: «config takes False␤»

# Since parenthesis can be omitted when calling a subroutine, you need to use
# `&` in order to distinguish between a call to a sub with no arguments and
# the code object.

# For instance, in this example we must use `&` to store the sub `say-hello`
# (i.e., the sub's code object) in a variable, not a subroutine call.
my &s = &say-hello;
my &other-s = sub { say "Anonymous function!" }

# A sub can have a "slurpy" parameter, or what one'd call a
# "doesn't-matter-how-many" parameter. This is Raku's way of supporting variadic
# functions. For this, you must use `*@` (slurpy) which will "take everything
# else". You can have as many parameters *before* a slurpy one, but not *after*.
sub as-many($head, *@rest) {
    @rest.join(' / ') ~ " !";
}
say as-many('Happy', 'Happy', 'Birthday');          # OUTPUT: «Happy / Birthday !␤»
say as-many('Happy', ['Happy', 'Birthday'], 'Day'); # OUTPUT: «Happy / Birthday / Day !␤»

# Note that the splat (the *) did not consume the parameter before it.

# There are other two variations of slurpy parameters in Raku. The previous one
# (namely, `*@`), known as flattened slurpy, flattens passed arguments. The other
# two are `**@` and `+@` known as unflattened slurpy and "single argument rule"
# slurpy respectively. The unflattened slurpy doesn't flatten its listy
# arguments (or Iterable ones).
sub b(**@arr) { @arr.perl.say };
b(['a', 'b', 'c']);             # OUTPUT: «[["a", "b", "c"],]»
b(1, $('d', 'e', 'f'), [2, 3]); # OUTPUT: «[1, ("d", "e", "f"), [2, 3]]»
b(1, [1, 2], ([3, 4], 5));      # OUTPUT: «[1, [1, 2], ([3, 4], 5)]␤»

# On the other hand, the "single argument rule" slurpy follows the "single argument
# rule" which dictates how to handle the slurpy argument based upon context and
# roughly states that if only a single argument is passed and that argument is
# Iterable, that argument is used to fill the slurpy parameter array. In any
# other case, `+@` works like `**@`.
sub c(+@arr) { @arr.perl.say };
c(['a', 'b', 'c']);             # OUTPUT: «["a", "b", "c"]␤»
c(1, $('d', 'e', 'f'), [2, 3]); # OUTPUT: «[1, ("d", "e", "f"), [2, 3]]␤»
c(1, [1, 2], ([3, 4], 5));      # OUTPUT: «[1, [1, 2], ([3, 4], 5)]␤»

# You can call a function with an array using the "argument list flattening"
# operator `|` (it's not actually the only role of this operator,
# but it's one of them).
sub concat3($a, $b, $c) {
    say "$a, $b, $c";
}
concat3(|@array); # OUTPUT: «a, b, c␤»
                  # `@array` got "flattened" as a part of the argument list

####################################################
# 3. Containers
####################################################

# In Raku, values are actually stored in "containers". The assignment
# operator asks the container on the left to store the value on its right.
# When passed around, containers are marked as immutable which means that,
# in a function, you'll get an error if you try to mutate one of your
# arguments. If you really need to, you can ask for a mutable container by
# using the `is rw` trait.
sub mutate( $n is rw ) {
    $n++; # postfix ++ operator increments its argument but returns its old value
}
my $m = 42;
mutate $m; #=> 42, the value is incremented but the old value is returned
say $m;    # OUTPUT: «43␤»

# This works because we are passing the container $m to the `mutate` sub.
# If we try to just pass a number instead of passing a variable, it won't work
# because there is no container being passed and integers are immutable by
# themselves:

# mutate 42; # Parameter '$n' expected a writable container, but got Int value

# Similar error would be obtained, if a bound variable is passed to
# to the subroutine. In Raku, you bind a value to a variable using the binding
# operator `:=`.
my $v := 50; # binding 50 to the variable $v
# mutate $v;   # Parameter '$n' expected a writable container, but got Int value

# If what you want is a copy instead, use the `is copy` trait which will
# cause the argument to be copied and allow you to modify the argument
# inside the routine without modifying the passed argument.

# A sub itself returns a container, which means it can be marked as `rw`.
# Alternatively, you can explicitly mark the returned container as mutable
# by using `return-rw` instead of `return`.
my $x = 42;
my $y = 45;
sub x-store is rw { $x }
sub y-store       { return-rw $y }

# In this case, the parentheses are mandatory or else Raku thinks that
# `x-store` and `y-store` are identifiers.
x-store() = 52;
y-store() *= 2;

say $x; # OUTPUT: «52␤»
say $y; # OUTPUT: «90␤»

####################################################
# 4.Control Flow Structures
####################################################

#
# 4.1 if/if-else/if-elsif-else/unless
#

# Before talking about `if`, we need to know which values are "truthy"
# (represent `True`), and which are "falsey" (represent `False`). Only these
# values are falsey: 0, (), {}, "", Nil, a type (like `Str`, `Int`, etc.) and
# of course, `False` itself. Any other value is truthy.
my $number = 5;
if $number < 5 {
    say "Number is less than 5"
}
elsif $number == 5 {
    say "Number is equal to 5"
}
else {
    say "Number is greater than 5"
}

unless False {
    say "It's not false!";
}

# `unless` is the equivalent of `if not (X)` which inverts the sense of a
# conditional statement. However, you cannot use `else` or `elsif` with it.

# As you can see, you don't need parentheses around conditions. However, you
# do need the curly braces around the "body" block. For example,
# `if (True) say 'It's true';` doesn't work.

# You can also use their statement modifier (postfix) versions:
say "Quite truthy" if True;      # OUTPUT: «Quite truthy␤»
say "Quite falsey" unless False; # OUTPUT: «Quite falsey␤»

# The ternary operator (`??..!!`) is structured as follows `condition ??
# expression1 !! expression2` and it returns expression1 if the condition is
# true. Otherwise, it returns expression2.
my $age = 30;
say $age > 18 ?? "You are an adult" !! "You are under 18";
# OUTPUT: «You are an adult␤»

#
# 4.2 with/with-else/with-orwith-else/without
#

# The `with` statement is like `if`, but it tests for definedness rather than
# truth, and it topicalizes on the condition, much like `given` which will
# be discussed later.
my $s = "raku";
with   $s.index("r") { say "Found a at $_"      }
orwith $s.index("k") { say "Found c at $_"      }
else                 { say "Didn't find r or k" }

# Similar to `unless` that checks un-truthiness, you can use `without` to
# check for undefined-ness.
my $input01;
without $input01 {
    say "No input given."
}
# OUTPUT: «No input given.␤»

# There are also statement modifier versions for both `with` and `without`.
my $input02 = 'Hello';
say $input02 with $input02;               # OUTPUT: «Hello␤»
say "No input given." without $input02;

#
# 4.3 given/when, or Raku's switch construct
#

=begin comment
`given...when` looks like other languages' `switch`, but is much more
powerful thanks to smart matching and Raku's "topic variable", `$_`.

The topic variable `$_ `contains the default argument of a block, a loop's
current iteration (unless explicitly named), etc.

`given` simply puts its argument into `$_` (like a block would do),
 and `when` compares it using the "smart matching" (`~~`) operator.

Since other Raku constructs use this variable (as said before, like `for`,
blocks, `with` statement etc), this means the powerful `when` is not only
applicable along with a `given`, but instead anywhere a `$_` exists.

=end comment

given "foo bar" {
    say $_;            # OUTPUT: «foo bar␤»

    # Don't worry about smart matching yet. Just know `when` uses it. This is
    # equivalent to `if $_ ~~ /foo/`.
    when /foo/ {
        say "Yay !";
    }

    # smart matching anything with `True` is `True`, i.e. (`$a ~~ True`)
    # so you can also put "normal" conditionals. For example, this `when` is
    # equivalent to this `if`: `if $_ ~~ ($_.chars > 50) {...}`
    # which means: `if $_.chars > 50 {...}`
    when $_.chars > 50 {
        say "Quite a long string !";
    }

    # same as `when *` (using the Whatever Star)
    default {
        say "Something else"
    }
}

#
# 4.4 Looping constructs
#

# The `loop` construct is an infinite loop if you don't pass it arguments, but
# can also be a C-style `for` loop:
loop {
    say "This is an infinite loop !";
    last;
}
# In the previous example, `last` breaks out of the loop very much
# like the `break` keyword in other languages.

# The `next` keyword skips to the next iteration, like `continue` in other
# languages. Note that you can also use postfix conditionals, loops, etc.
loop (my $i = 0; $i < 5; $i++) {
    next if $i == 3;
    say "This is a C-style for loop!";
}

# The `for` constructs iterates over a list of elements.
my @odd-array = 1, 3, 5, 7, 9;

# Accessing the array's elements with the topic variable $_.
for @odd-array {
    say "I've got $_ !";
}

# Accessing the array's elements with a "pointy block", `->`.
# Here each element is read-only.
for @odd-array -> $variable {
    say "I've got $variable !";
}

# Accessing the array's elements with a "doubly pointy block", `<->`.
# Here each element is read-write so mutating `$variable` mutates
# that element in the array.
for @odd-array <-> $variable {
    say "I've got $variable !";
}

# As we saw with `given`, a `for` loop's default "current iteration" variable
# is `$_`. That means you can use `when` in a `for`loop just like you were
# able to in a `given`.
for @odd-array {
    say "I've got $_";

    # This is also allowed. A dot call with no "topic" (receiver) is sent to
    # `$_` (topic variable) by default.
    .say;

    # This is equivalent to the above statement.
    $_.say;
}

for @odd-array {
    # You can...
    next if $_ == 3; # Skip to the next iteration (`continue` in C-like lang.)
    redo if $_ == 4; # Re-do iteration, keeping the same topic variable (`$_`)
    last if $_ == 5; # Or break out of loop (like `break` in C-like lang.)
}

# The "pointy block" syntax isn't specific to the `for` loop. It's just a way
# to express a block in Raku.
sub long-computation { "Finding factors of large primes" }
if long-computation() -> $result {
    say "The result is $result.";
}

####################################################
# 5. Operators
####################################################

=begin comment
Since Perl languages are very much operator-based languages, Raku
operators are actually just funny-looking subroutines, in syntactic
categories, like infix:<+> (addition) or prefix:<!> (bool not).

The categories are:
    - "prefix": before (like `!` in `!True`).
    - "postfix": after (like `++` in `$a++`).
    - "infix": in between (like `*` in `4 * 3`).
    - "circumfix": around (like `[`-`]` in `[1, 2]`).
    - "post-circumfix": around, after another term (like `{`-`}` in
                   `%hash{'key'}`)

The associativity and precedence list are explained below.

Alright, you're set to go!

=end comment

#
# 5.1 Equality Checking
#

# `==` is numeric comparison
say 3 == 4; # OUTPUT: «False␤»
say 3 != 4; # OUTPUT: «True␤»

# `eq` is string comparison
say 'a' eq 'b';  # OUTPUT: «False␤»
say 'a' ne 'b';  # OUTPUT: «True␤», not equal
say 'a' !eq 'b'; # OUTPUT: «True␤», same as above

# `eqv` is canonical equivalence (or "deep equality")
say (1, 2) eqv (1, 3); # OUTPUT: «False␤»
say (1, 2) eqv (1, 2); # OUTPUT: «True␤»
say Int === Int;       # OUTPUT: «True␤»

# `~~` is the smart match operator which aliases the left hand side to $_ and
# then evaluates the right hand side.
# Here are some common comparison semantics:

# String or numeric equality
say 'Foo' ~~ 'Foo'; # OUTPUT: «True␤», if strings are equal.
say 12.5 ~~ 12.50;  # OUTPUT: «True␤», if numbers are equal.

# Regex - For matching a regular expression against the left side.
# Returns a `Match` object, which evaluates as True if regexp matches.
my $obj = 'abc' ~~ /a/;
say $obj;       # OUTPUT: «｢a｣␤»
say $obj.WHAT;  # OUTPUT: «(Match)␤»

# Hashes
say 'key' ~~ %hash; # OUTPUT: «True␤», if key exists in hash.

# Type - Checks if left side "is of type" (can check superclasses and roles).
say 1 ~~ Int;       # OUTPUT: «True␤»

# Smart-matching against a boolean always returns that boolean (and will warn).
say 1 ~~ True;        # OUTPUT: «True␤», smartmatch against True always matches
say False.so ~~ True; # OUTPUT: «True␤», use .so for truthiness

# General syntax is `$arg ~~ &bool-returning-function;`. For a complete list
# of combinations, refer to the table at:
# https://docs.raku.org/language/operators#index-entry-smartmatch_operator

# Of course, you also use `<`, `<=`, `>`, `>=` for numeric comparison.
# Their string equivalent are also available: `lt`, `le`, `gt`, `ge`.
say 3 > 4;       # OUTPUT: «False␤»
say 3 >= 4;      # OUTPUT: «False␤»
say 3 < 4;       # OUTPUT: «True␤»
say 3 <= 4;      # OUTPUT: «True␤»
say 'a' gt 'b';  # OUTPUT: «False␤»
say 'a' ge 'b';  # OUTPUT: «False␤»
say 'a' lt 'b';  # OUTPUT: «True␤»
say 'a' le 'b';  # OUTPUT: «True␤»

#
# 5.2 Range constructor
#

say 3 .. 7;          # OUTPUT: «3..7␤»,   both included.
say 3 ..^ 7;         # OUTPUT: «3..^7␤»,  exclude right endpoint.
say 3 ^.. 7;         # OUTPUT: «3^..7␤»,  exclude left endpoint.
say 3 ^..^ 7;        # OUTPUT: «3^..^7␤», exclude both endpoints.

# The range 3 ^.. 7 is similar like 4 .. 7 when we only consider integers.
# But when we consider decimals:

say 3.5 ~~ 4 .. 7;	 # OUTPUT: «False␤»
say 3.5 ~~ 3 ^.. 7;	 # OUTPUT: «True␤»,

# This is because the range `3 ^.. 7` only excludes anything strictly
# equal to 3. Hence, it contains decimals greater than 3. This could
# mathematically be described as 3.5 ∈ (3,7] or in set notation,
# 3.5 ∈ { x | 3 < x ≤ 7 }.

say 3 ^.. 7 ~~ 4 .. 7; # OUTPUT: «False␤»

# This also works as a shortcut for `0..^N`:
say ^10;             # OUTPUT: «^10␤», which means 0..^10

# This also allows us to demonstrate that Raku has lazy/infinite arrays,
# using the Whatever Star:
my @natural = 1..*; # 1 to Infinite! Equivalent to `1..Inf`.

# You can pass ranges as subscripts and it'll return an array of results.
say @natural[^10]; # OUTPUT: «1 2 3 4 5 6 7 8 9 10␤», doesn't run out of memory!

# NOTE: when reading an infinite list, Raku will "reify" the elements
# it needs, then keep them in memory. They won't be calculated more than once.
# It also will never calculate more elements than that are needed.

# An array subscript can also be a closure. It'll be called with the array's
# length as the argument. The following two examples are equivalent:
say join(' ', @array[15..*]);            # OUTPUT: «15 16 17 18 19␤»
say join(' ', @array[-> $n { 15..$n }]); # OUTPUT: «15 16 17 18 19␤»

# NOTE: if you try to do either of those with an infinite array, you'll
# trigger an infinite loop (your program won't finish).

# You can use that in most places you'd expect, even when assigning to an array:
my @numbers = ^20;

# Here the numbers increase by 6, like an arithmetic sequence; more on the
# sequence (`...`) operator later.
my @seq =  3, 9 ... * > 95;  # 3 9 15 21 27 [...] 81 87 93 99;

# In this example, even though the sequence is infinite, only the 15
# needed values will be calculated.
@numbers[5..*] = 3, 9 ... *;
say @numbers; # OUTPUT: «0 1 2 3 4 3 9 15 21 [...] 81 87␤», only 20 values

#
# 5.3 and (&&), or (||)
#

# Here `and` calls `.Bool` on both 3 and 4 and gets `True` so it returns
# 4 since both are `True`.
say (3 and 4);     # OUTPUT: «4␤», which is truthy.
say (3 and 0);     # OUTPUT: «0␤»
say (0 and 4);     # OUTPUT: «0␤»

# Here `or` calls `.Bool` on `0` and `False` which are both `False`
# so it returns `False` since both are `False`.
say (0 or False); # OUTPUT: «False␤».

# Both `and` and `or` have tighter versions which also shortcut circuits.
# They're `&&` and `||` respectively.

# `&&` returns the first operand that evaluates to `False`. Otherwise,
# it returns the last operand.
my ($a, $b, $c, $d, $e) = 1, 0, False, True, 'pi';
say $a && $b && $c; # OUTPUT: «0␤», the first falsey value
say $a && $b && $c; # OUTPUT: «False␤», the first falsey value
say $a && $d && $e; # OUTPUT: «pi␤», last operand since everything before is truthy

# `||` returns the first argument that evaluates to `True`.
say $b || $a || $d; # OUTPUT: «1␤»
say $e || $d || $a; # OUTPUT: «pi␤»

# And because you're going to want them, you also have compound assignment
# operators:
$a *= 2;        # multiply and assignment. Equivalent to $a = $a * 2;
$b %%= 5;       # divisible by and assignment. Equivalent to $b = $b %% 2;
$c div= 3;      # return divisor and assignment. Equivalent to $c = $c div 3;
$d mod= 4;      # return remainder and assignment. Equivalent to $d = $d mod 4;
@array .= sort; # calls the `sort` method and assigns the result back

####################################################
# 6. More on subs!
####################################################

# As we said before, Raku has *really* powerful subs. We're going
# to see a few more key concepts that make them better than in any
# other language :-).

#
# 6.1 Unpacking!
#

# Unpacking is the ability to "extract" arrays and keys
# (AKA "destructuring"). It'll work in `my`s and in parameter lists.
my ($f, $g) = 1, 2;
say $f;                  # OUTPUT: «1␤»
my ($, $, $h) = 1, 2, 3; # keep the non-interesting values anonymous (`$`)
say $h;                  # OUTPUT: «3␤»

my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs"
my (*@small) = 1;

sub unpack_array( @array [$fst, $snd] ) {
  say "My first is $fst, my second is $snd! All in all, I'm @array[].";
  # (^ remember the `[]` to interpolate the array)
}
unpack_array(@tail);
# OUTPUT: «My first is 2, my second is 3! All in all, I'm 2 3.␤»

# If you're not using the array itself, you can also keep it anonymous,
# much like a scalar:
sub first-of-array( @ [$fst] ) { $fst }
first-of-array(@small); #=> 1

# However calling `first-of-array(@tail);` will throw an error ("Too many
# positional parameters passed"), which means the `@tail` has too many
# elements.

# You can also use a slurpy parameter. You could keep `*@rest` anonymous
# Here, `@rest` is `(3,)`, since `$fst` holds the `2`. This results
# since the length (.elems) of `@rest` is 1.
sub slurp-in-array(@ [$fst, *@rest]) {
    say $fst + @rest.elems;
}
slurp-in-array(@tail); # OUTPUT: «3␤»

# You could even extract on a slurpy (but it's pretty useless ;-).)
sub fst(*@ [$fst]) { # or simply: `sub fst($fst) { ... }`
    say $fst;
}
fst(1);    # OUTPUT: «1␤»

# Calling `fst(1, 2);` will throw an error ("Too many positional parameters
# passed") though. After all, the `fst` sub declares only a single positional
# parameter.

# You can also destructure hashes (and classes, which you'll learn about later).
# The syntax is basically the same as
# `%hash-name (:key($variable-to-store-value-in))`.
# The hash can stay anonymous if you only need the values you extracted.

# In order to call the function, you must supply a hash wither created with
# curly braces or with `%()` (recommended). Alternatively, you can pass
# a variable that contains a hash.

sub key-of( % (:value($val), :qua($qua)) ) {
 	say "Got value $val, $qua time" ~~
        $qua == 1 ?? '' !! 's';
}

my %foo-once = %(value => 'foo', qua => 1);
key-of({value => 'foo', qua => 2});  # OUTPUT: «Got val foo, 2 times.␤»
key-of(%(value => 'foo', qua => 0)); # OUTPUT: «Got val foo, 0 times.␤»
key-of(%foo-once);                   # OUTPUT: «Got val foo, 1 time.␤»

# The last expression of a sub is returned automatically (though you may
# indicate explicitly by using the `return` keyword, of course):
sub next-index( $n ) {
 	$n + 1;
}
my $new-n = next-index(3); # $new-n is now 4

# This is true for everything, except for the looping constructs (due to
# performance reasons): there's no reason to build a list if we're just going to
# discard all the results. If you still want to build one, you can use the
# `do` statement prefix or the `gather` prefix, which we'll see later:

sub list-of( $n ) {
 	do for ^$n { $_ }
}
my @list3 = list-of(3); #=> (0, 1, 2)

#
# 6.2 Lambdas (or anonymous subroutines)
#

# You can create a lambda by using a pointy block (`-> {}`), a
# block (`{}`) or creating a `sub` without a name.

my &lambda1 = -> $argument {
	"The argument passed to this lambda is $argument"
}

my &lambda2 = {
	"The argument passed to this lambda is $_"
}

my &lambda3 = sub ($argument) {
	"The argument passed to this lambda is $argument"
}

# Both pointy blocks and blocks are pretty much the same thing, except that
# the former can take arguments, and that the latter can be mistaken as
# a hash by the parser. That being said, blocks can declare what's known
# as placeholders parameters through the twigils `$^` (for positional
# parameters) and `$:` (for named parameters). More on them later on.

my &mult = { $^numbers * $:times }
say mult 4, :times(6); #=> «24␤»

# Both pointy blocks and blocks are quite versatile when working with functions
# that accepts other functions such as `map`, `grep`, etc. For example,
# we add 3 to each value of an array using the `map` function with a lambda:
my @nums = 1..4;
my @res1 = map -> $v { $v + 3 }, @nums; # pointy block, explicit parameter
my @res2 = map { $_ + 3 },       @nums; # block using an implicit parameter
my @res3 = map { $^val + 3 },    @nums; # block with placeholder parameter

# A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
# A block doesn't have a "function context" (though it can have arguments),
# which means that if you return from it, you're going to return from the
# parent function.

# Compare:
sub is-in( @array, $elem ) {
   say map({ return True if $_ == $elem }, @array);
   say 'Hi';
}

# with:
sub truthy-array( @array ) {
    say map sub ($i) { $i ?? return True !! return False }, @array;
    say 'Hi';
}

# In the `is-in` sub, the block will `return` out of the `is-in` sub once the
# condition evaluates to `True`, the loop won't be run anymore and the
# following statement won't be executed. The last statement is only executed
# if the block never returns.

# On the contrary, the `truthy-array` sub will produce an array of `True` and
# `False`, which will printed, and always execute the last execute statement.
# Thus, the `return` only returns from the anonymous `sub`

# The `anon` declarator can be used to create an anonymous sub from a
# regular subroutine. The regular sub knows its name but its symbol is
# prevented from getting installed in the lexical scope, the method table
# and everywhere else.
my $anon-sum = anon sub summation(*@a) { [+] @a }
say $anon-sum.name;     # OUTPUT: «summation␤»
say $anon-sum(2, 3, 5); # OUTPUT: «10␤»
#say summation;         # Error: Undeclared routine: ...

# You can also use the Whatever Star to create an anonymous subroutine.
# (it'll stop at the furthest operator in the current expression).
# The following is the same as `{$_ + 3 }`, `-> { $a + 3 }`,
# `sub ($a) { $a + 3 }`, or even `{$^a + 3}` (more on this later).
my @arrayplus3v0 = map * + 3, @nums;

# The following is the same as `-> $a, $b { $a + $b + 3 }`,
# `sub ($a, $b) { $a + $b + 3 }`, or `{ $^a + $^b + 3 }` (more on this later).
my @arrayplus3v1 = map * + * + 3, @nums;

say (*/2)(4); # OUTPUT: «2␤», immediately execute the Whatever function created.
say ((*+3)/5)(5); # OUTPUT: «1.6␤», it works even in parens!

# But if you need to have more than one argument (`$_`) in a block (without
# wanting to resort to `-> {}`), you can also either `$^` and `$:` which
# declared placeholder parameters or self-declared positional/named parameters.
say map { $^a + $^b + 3 }, @nums;

# which is equivalent to the following which uses a `sub`:
map sub ($a, $b) { $a + $b + 3 }, @nums;

# Placeholder parameters are sorted lexicographically so the following two
# statements are equivalent:
say sort           { $^b <=> $^a }, @nums;
say sort -> $a, $b { $b  <=> $a  }, @nums;

#
# 6.3 Multiple Dispatch
#

# Raku can decide which variant of a `sub` to call based on the type of the
# arguments, or on arbitrary preconditions, like with a type or `where`:

# with types:
multi sub sayit( Int $n ) { # note the `multi` keyword here
    say "Number: $n";
}
multi sayit( Str $s ) {     # a multi is a `sub` by default
    say "String: $s";
}
sayit "foo"; # OUTPUT: «String: foo␤»
sayit 25;    # OUTPUT: «Number: 25␤»
sayit True;  # fails at *compile time* with "calling 'sayit' will never
             # work with arguments of types ..."

# with arbitrary preconditions (remember subsets?):
multi is-big(Int $n where * > 50) { "Yes!" }    # using a closure
multi is-big(Int $n where {$_ > 50}) { "Yes!" } # similar to above
multi is-big(Int $ where 10..50)  { "Quite." }  # Using smart-matching
multi is-big(Int $) { "No" }

subset Even of Int where * %% 2;
multi odd-or-even(Even) { "Even" } # Using the type. We don't name the argument.
multi odd-or-even($) { "Odd" }     # "everything else" hence the $ variable

# You can even dispatch based on the presence of positional and named arguments:
multi with-or-without-you($with) {
    say "I wish I could but I can't";
}
multi with-or-without-you(:$with) {
    say "I can live! Actually, I can't.";
}
multi with-or-without-you {
    say "Definitely can't live.";
}

# This is very, very useful for many purposes, like `MAIN` subs (covered
# later), and even the language itself uses it in several places.

# For example, the `is` trait is actually a `multi sub` named `trait_mod:<is>`,
# and it works off that. Thus, `is rw`, is simply a dispatch to a function with
# this signature `sub trait_mod:<is>(Routine $r, :$rw!) {}`

####################################################
# 7. About types...
####################################################

# Raku is gradually typed. This means you can specify the type of your
# variables/arguments/return types, or you can omit the type annotations in
# in which case they'll default to `Any`. Obviously you get access to a few
# base types, like `Int` and `Str`. The constructs for declaring types are
# `subset`, `class`, `role`, etc. which you'll see later.

# For now, let us examine `subset` which is a "sub-type" with additional
# checks. For example, "a very big integer is an `Int` that's greater than 500".
# You can specify the type you're subtyping (by default, `Any`), and add
# additional checks with the `where` clause.
subset VeryBigInteger of Int where * > 500;

# Or the set of the whole numbers:
subset WholeNumber of Int where * >= 0;
my WholeNumber $whole-six    = 6;  # OK
#my WholeNumber $nonwhole-one = -1; # Error: type check failed...

# Or the set of Positive Even Numbers whose Mod 5 is 1. Notice we're
# using the previously defined WholeNumber subset.
subset PENFO of WholeNumber where { $_ %% 2 and $_ mod 5 == 1 };
my PENFO $yes-penfo = 36;  # OK
#my PENFO $no-penfo  = 2;  # Error: type check failed...

####################################################
# 8. Scoping
####################################################

# In Raku, unlike many scripting languages, (such as Python, Ruby, PHP),
# you must declare your variables before using them. The `my` declarator
# we've used so far uses "lexical scoping". There are a few other declarators,
# (`our`, `state`, ..., ) which we'll see later. This is called
# "lexical scoping", where in inner blocks, you can access variables from
# outer blocks.

my $file_scoped = 'Foo';
sub outer {
    my $outer_scoped = 'Bar';
    sub inner {
        say "$file_scoped $outer_scoped";
    }
    &inner; # return the function
}
outer()();  # OUTPUT: «Foo Bar␤»

# As you can see, `$file_scoped` and `$outer_scoped` were captured.
# But if we were to try and use `$outer_scoped` outside the `outer` sub,
# the variable would be undefined (and you'd get a compile time error).

####################################################
# 9. Twigils
####################################################

# There are many special `twigils` (composed sigils) in Raku. Twigils
# define a variable's scope.
# The `*` and `?` twigils work on standard variables:
#     * for dynamic variables
#     ? for compile-time variables
#
# The `!` and the `.` twigils are used with Raku's objects:
#     ! for attributes (instance attribute)
#     . for methods (not really a variable)

#
# `*` twigil: Dynamic Scope
#

# These variables use the `*` twigil to mark dynamically-scoped variables.
# Dynamically-scoped variables are looked up through the caller, not through
# the outer scope.

my $*dyn_scoped_1 = 1;
my $*dyn_scoped_2 = 10;

sub say_dyn {
    say "$*dyn_scoped_1 $*dyn_scoped_2";
}

sub call_say_dyn {
    # Defines $*dyn_scoped_1 only for this sub.
    my $*dyn_scoped_1 = 25;

    # Will change the value of the file scoped variable.
    $*dyn_scoped_2 = 100;

    # $*dyn_scoped 1 and 2 will be looked for in the call.
    say_dyn();  # OUTPUT: «25 100␤»

    # The call to `say_dyn` uses the value of $*dyn_scoped_1 from inside
    # this sub's lexical scope even though the blocks aren't nested (they're
    # call-nested).
}
say_dyn();      # OUTPUT: «1 10␤»

# Uses $*dyn_scoped_1 as defined in `call_say_dyn` even though we are calling it
# from outside.
call_say_dyn(); # OUTPUT: «25 100␤»

# We changed the value of $*dyn_scoped_2 in `call_say_dyn` so now its
# value has changed.
say_dyn();      # OUTPUT: «1 100␤»

# TODO: Add information about remaining twigils

####################################################
# 10. Object Model
####################################################

# To call a method on an object, add a dot followed by the method name:
# `$object.method`

# Classes are declared with the `class` keyword. Attributes are declared
# with the `has` keyword, and methods declared with the `method` keyword.

# Every attribute that is private uses the `!` twigil. For example: `$!attr`.
# Immutable public attributes use the `.` twigil which creates a read-only
# method named after the attribute. In fact, declaring an attribute with `.`
# is equivalent to declaring the same attribute with `!` and then creating
# a read-only method with the attribute's name. However, this is done for us
# by Raku automatically. The easiest way to remember the `$.` twigil is
# by comparing it to how methods are called.

# Raku's object model ("SixModel") is very flexible, and allows you to
# dynamically add methods, change semantics, etc... Unfortunately, these will
# not all be covered here, and you should refer to:
# https://docs.raku.org/language/objects.html.

class Human {
    has Str $.name;           # `$.name` is immutable but with an accessor method.
    has Str $.bcountry;       # Use `$!bcountry` to modify it inside the class.
	has Str $.ccountry is rw; # This attribute can be modified from outside.
	has Int $!age = 0;        # A private attribute with default value.

	method birthday {
		$!age += 1; # Add a year to human's age
	}

	method get-age {
		return $!age;
	}

	# This method is private to the class. Note the `!` before the
	# method's name.
	method !do-decoration {
    	return "$!name born in $!bcountry and now lives in $!ccountry."
  	}

  	# This method is public, just like `birthday` and `get-age`.
  	method get-info {
        # Invoking a method on `self` inside the class.
        # Use `self!priv-method` for private method.
  		say self!do-decoration;

  		# Use `self.public-method` for public method.
  		say "Age: ", self.get-age;
  	}
};

# Create a new instance of Human class.
# NOTE: Only attributes declared with the `.` twigil can be set via the
# default constructor (more later on). This constructor only accepts named
# arguments.
my $person1 = Human.new(
	name     => "Jord",
	bcountry => "Togo",
	ccountry => "Togo"
);

# Make human 10 years old.
$person1.birthday for 1..10;

say $person1.name;     # OUTPUT: «Jord␤»
say $person1.bcountry; # OUTPUT: «Togo␤»
say $person1.ccountry; # OUTPUT: «Togo␤»
say $person1.get-age;  # OUTPUT: «10␤»

# This fails, because the `has $.bcountry`is immutable. Jord can't change
# his birthplace.
# $person1.bcountry = "Mali";

# This works because the `$.ccountry` is mutable (`is rw`). Now Jord's
# current country is France.
$person1.ccountry = "France";

# Calling methods on the instance objects.
$person1.birthday;      #=> 1
$person1.get-info;      #=> Jord born in Togo and now lives in France. Age: 10
# $person1.do-decoration; # This fails since the method `do-decoration` is private.

#
# 10.1 Object Inheritance
#

# Raku also has inheritance (along with multiple inheritance). While
# methods are inherited, submethods are not. Submethods are useful for
# object construction and destruction tasks, such as `BUILD`, or methods that
# must be overridden by subtypes. We will learn about `BUILD` later on.

class Parent {
  	has $.age;
 	has $.name;

  	# This submethod won't be inherited by the Child class.
  	submethod favorite-color {
    	say "My favorite color is Blue";
  	}

  	# This method is inherited
  	method talk { say "Hi, my name is $!name" }
}

# Inheritance uses the `is` keyword
class Child is Parent {
  	method talk { say "Goo goo ga ga" }
  	# This shadows Parent's `talk` method.
  	# This child hasn't learned to speak yet!
}

my Parent $Richard .= new(age => 40, name => 'Richard');
$Richard.favorite-color;  # OUTPUT: «My favorite color is Blue␤»
$Richard.talk;            # OUTPUT: «Hi, my name is Richard␤»
# $Richard is able to access the submethod and he knows how to say his name.

my Child $Madison .= new(age => 1, name => 'Madison');
$Madison.talk;            # OUTPUT: «Goo goo ga ga␤», due to the overridden method.
# $Madison.favorite-color # does not work since it is not inherited.

# When you use `my T $var`, `$var` starts off with `T` itself in it, so you can
# call `new` on it. (`.=` is just the dot-call and the assignment operator).
# Thus, `$a .= b` is the same as `$a = $a.b`. Also note that `BUILD` (the method
# called inside `new`) will set parent's properties too, so you can pass `val =>
# 5`.

#
# 10.2 Roles, or Mixins
#

# Roles are supported too (which are called Mixins in other languages)
role PrintableVal {
  	has $!counter = 0;
  	method print {
    	say $.val;
  	}
}

# you "apply" a role (or mixin) with the `does` keyword:
class Item does PrintableVal {
  	has $.val;

    =begin comment
    When `does`-ed, a `role` literally "mixes in" the class:
    the methods and attributes are put together, which means a class
    can access the private attributes/methods of its roles (but
    not the inverse!):
    =end comment
  	method access {
  		say $!counter++;
  	}

    =begin comment
    However, this: method print {} is ONLY valid when `print` isn't a `multi`
    with the same dispatch. This means a parent class can shadow a child class's
    `multi print() {}`, but it's an error if a role does)

    NOTE: You can use a role as a class (with `is ROLE`). In this case,
    methods will be shadowed, since the compiler will consider `ROLE`
    to be a class.
    =end comment
}

####################################################
# 11. Exceptions
####################################################

# Exceptions are built on top of classes, in the package `X` (like `X::IO`).
# In Raku, exceptions are automatically 'thrown':

# open 'foo';   # OUTPUT: «Failed to open file foo: no such file or directory␤»

# It will also print out what line the error was thrown at
# and other error info.

# You can throw an exception using `die`. Here it's been commented out to
# avoid stopping the program's execution:
# die 'Error!'; # OUTPUT: «Error!␤»

# Or more explicitly (commented out too):
# X::AdHoc.new(payload => 'Error!').throw; # OUTPUT: «Error!␤»

# In Raku, `orelse` is similar to the `or` operator, except it only matches
# undefined variables instead of anything evaluating as `False`.
# Undefined values include: `Nil`, `Mu` and `Failure` as well as `Int`, `Str`
# and other types that have not been initialized to any value yet.
# You can check if something is defined or not using the defined method:
my $uninitialized;
say $uninitialized.defined; # OUTPUT: «False␤»

# When using `orelse` it will disarm the exception and alias $_ to that
# failure. This will prevent it to being automatically handled and printing
# lots of scary error messages to the screen. We can use the `exception`
# method on the `$_` variable to access the exception
open 'foo' orelse say "Something happened {.exception}";

# This also works:
open 'foo' orelse say "Something happened $_";
# OUTPUT: «Something happened Failed to open file foo: no such file or directory␤»

# Both of those above work but in case we get an object from the left side
# that is not a failure we will probably get a warning. We see below how we
# can use try` and `CATCH` to be more specific with the exceptions we catch.

#
# 11.1 Using `try` and `CATCH`
#

# By using `try` and `CATCH` you can contain and handle exceptions without
# disrupting the rest of the program. The `try` block will set the last
# exception to the special variable `$!` (known as the error variable).
# NOTE: This has no relation to $!variables seen inside class definitions.

try open 'foo';
say "Well, I tried! $!" if defined $!;
# OUTPUT: «Well, I tried! Failed to open file foo: no such file or directory␤»

# Now, what if we want more control over handling the exception?
# Unlike many other languages, in Raku, you put the `CATCH` block *within*
# the block to `try`. Similar to how the `$_` variable was set when we
# 'disarmed' the exception with `orelse`, we also use `$_` in the CATCH block.
# NOTE: The `$!` variable is only set *after* the `try` block has caught an
# exception. By default, a `try` block has a `CATCH` block of its own that
# catches any exception (`CATCH { default {} }`).

try {
    my $a = (0 %% 0);
    CATCH {
        default { say "Something happened: $_" }
    }
}
# OUTPUT: «Something happened: Attempt to divide by zero using infix:<%%>␤»

# You can redefine it using `when`s (and `default`) to handle the exceptions
# you want to catch explicitly:

try {
  open 'foo';
    CATCH {
        # In the `CATCH` block, the exception is set to the $_ variable.
        when X::AdHoc {
            say "Error: $_"
        }
        when X::Numeric::DivideByZero {
            say "Error: $_";
        }

        =begin comment
        Any other exceptions will be re-raised, since we don't have a `default`.
        Basically, if a `when` matches (or there's a `default`), the
	    exception is marked as "handled" so as to prevent its re-throw
        from the `CATCH` block. You still can re-throw the exception
        (see below) by hand.
        =end comment
        default {
            say "Any other error: $_"
        }
  }
}
# OUTPUT: «Failed to open file /dir/foo: no such file or directory␤»

# There are also some subtleties to exceptions. Some Raku subs return a
# `Failure`, which is a wrapper around an `Exception` object which is
# "unthrown". They're not thrown until you try to use the variables containing
# them unless you call `.Bool`/`.defined` on them - then they're handled.
# (the `.handled` method is `rw`, so you can mark it as `False` back yourself)
# You can throw a `Failure` using `fail`. Note that if the pragma `use fatal`
# is on, `fail` will throw an exception (like `die`).

my $value = 0/0; # We're not trying to access the value, so no problem.
try {
    say 'Value: ', $value; # Trying to use the value
    CATCH {
        default {
            say "It threw because we tried to get the fail's value!"
        }
  }
}

# There is also another kind of exception: Control exceptions. Those are "good"
# exceptions, which happen when you change your program's flow, using operators
# like `return`, `next` or `last`. You can "catch" those with `CONTROL` (not 100%
# working in Rakudo yet).

####################################################
# 12. Packages
####################################################

# Packages are a way to reuse code. Packages are like "namespaces", and any
# element of the six model (`module`, `role`, `class`, `grammar`, `subset` and
# `enum`) are actually packages. (Packages are the lowest common denominator)
# Packages are important - especially as Perl is well-known for CPAN,
# the Comprehensive Perl Archive Network.

# You can use a module (bring its declarations into scope) with `use`:
use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
say from-json('[1]').perl; # OUTPUT: «[1]␤»

# You should not declare packages using the `package` keyword (unlike Perl).
# Instead, use `class Package::Name::Here;` to declare a class, or if you only
# want to export variables/subs, you can use `module` instead.

# If `Hello` doesn't exist yet, it'll just be a "stub", that can be redeclared
# as something else later.
module Hello::World { # bracketed form
    # declarations here
}

# The file-scoped form which extends until the end of the file. For
# instance, `unit module Parse::Text;` will extend until of the file.

# A grammar is a package, which you could `use`. You will learn more about
# grammars in the regex section.
grammar Parse::Text::Grammar {
}

# As said before, any part of the six model is also a package.
# Since `JSON::Tiny` uses its own `JSON::Tiny::Actions` class, you can use it:
my $actions = JSON::Tiny::Actions.new;

# We'll see how to export variables and subs in the next part.

####################################################
# 13. Declarators
####################################################

# In Raku, you get different behaviors based on how you declare a variable.
# You've already seen `my` and `has`, we'll now explore the others.

# `our` - these declarations happen at `INIT` time -- (see "Phasers" below).
# It's like `my`, but it also creates a package variable. All packagish
# things such as `class`, `role`, etc. are `our` by default.

module Var::Increment {
    # NOTE: `our`-declared variables cannot be typed.
    our $our-var = 1;
    my $my-var = 22;

    our sub Inc {
        our sub available { # If you try to make inner `sub`s `our`...
                            # ... Better know what you're doing (Don't !).
            say "Don't do that. Seriously. You'll get burned.";
        }

        my sub unavailable { # `sub`s are `my`-declared by default
            say "Can't access me from outside, I'm 'my'!";
        }
        say ++$our-var; # Increment the package variable and output its value
  }

}

say $Var::Increment::our-var; # OUTPUT: «1␤», this works!
say $Var::Increment::my-var;  # OUTPUT: «(Any)␤», this will not work!

say Var::Increment::Inc;  # OUTPUT: «2␤»
say Var::Increment::Inc;  # OUTPUT: «3␤», notice how the value of $our-var was retained.

# Var::Increment::unavailable;  # OUTPUT: «Could not find symbol '&unavailable'␤»

# `constant` - these declarations happen at `BEGIN` time. You can use
# the `constant` keyword to declare a compile-time variable/symbol:
constant Pi = 3.14;
constant $var = 1;

# And if you're wondering, yes, it can also contain infinite lists.
constant why-not = 5, 15 ... *;
say why-not[^5]; # OUTPUT: «5 15 25 35 45␤»

# `state` - these declarations happen at run time, but only once. State
# variables are only initialized one time. In other languages such as C
# they exist as `static` variables.
sub fixed-rand {
    state $val = rand;
    say $val;
}
fixed-rand for ^10; # will print the same number 10 times

# Note, however, that they exist separately in different enclosing contexts.
# If you declare a function with a `state` within a loop, it'll re-create the
# variable for each iteration of the loop. See:
for ^5 -> $a {
    sub foo {
        # This will be a different value for every value of `$a`
        state $val = rand;
    }
    for ^5 -> $b {
        # This will print the same value 5 times, but only 5. Next iteration
        # will re-run `rand`.
        say foo;
    }
}

####################################################
# 14. Phasers
####################################################

# Phasers in Raku are blocks that happen at determined points of time in
# your program. They are called phasers because they mark a change in the
# phase of a program.  For example, when the program is compiled, a for loop
# runs, you leave a block, or an exception gets thrown (The `CATCH` block is
# actually a phaser!). Some of them can be used for their return values,
# some of them can't (those that can have a "[*]" in the beginning of their
# explanation text). Let's have a look!

#
# 14.1 Compile-time phasers
#
BEGIN { say "[*] Runs at compile time, as soon as possible, only once" }
CHECK { say "[*] Runs at compile time, as late as possible, only once" }

#
# 14.2 Run-time phasers
#
INIT { say "[*] Runs at run time, as soon as possible, only once" }
END  { say "Runs at run time, as late as possible, only once" }

#
# 14.3 Block phasers
#
ENTER { say "[*] Runs every time you enter a block, repeats on loop blocks" }
LEAVE {
    say "Runs every time you leave a block, even when an exception
    happened. Repeats on loop blocks."
}

PRE {
    say "Asserts a precondition at every block entry,
        before ENTER (especially useful for loops)";
    say "If this block doesn't return a truthy value,
        an exception of type X::Phaser::PrePost is thrown.";
}

# Example (commented out):
for 0..2 {
    # PRE { $_ > 1 } # OUTPUT: «Precondition '{ $_ > 1 }' failed
}

POST {
    say "Asserts a postcondition at every block exit,
        after LEAVE (especially useful for loops)";
    say "If this block doesn't return a truthy value,
        an exception of type X::Phaser::PrePost is thrown, like PRE.";
}

# Example (commented out):
for 0..2 {
    # POST { $_ < 1 } # OUTPUT: «Postcondition '{ $_ < 1 }' failed
}

#
# 14.4 Block/exceptions phasers
#
{
    KEEP { say "Runs when you exit a block successfully
                (without throwing an exception)" }
    UNDO { say "Runs when you exit a block unsuccessfully
                (by throwing an exception)" }
}

#
# 14.5 Loop phasers
#
for ^5 {
  FIRST { say "[*] The first time the loop is run, before ENTER" }
  NEXT  { say "At loop continuation time, before LEAVE" }
  LAST  { say "At loop termination time, after LEAVE" }
}

#
# 14.6 Role/class phasers
#
COMPOSE {
    say "When a role is composed into a class. /!\ NOT YET IMPLEMENTED"
}

# They allow for cute tricks or clever code...:
say "This code took " ~ (time - CHECK time) ~ "s to compile";

# ... or clever organization:
class DB {
    method start-transaction { say "Starting transaction!" }
    method commit            { say "Committing transaction..." }
    method rollback          { say "Something went wrong. Rolling back!" }
}

sub do-db-stuff {
    my DB $db .= new;
  	$db.start-transaction; # start a new transaction
  	KEEP $db.commit;       # commit the transaction if all went well
  	UNDO $db.rollback;     # or rollback if all hell broke loose
}

do-db-stuff();

####################################################
# 15. Statement prefixes
####################################################

# Those act a bit like phasers: they affect the behavior of the following
# code. Though, they run in-line with the executable code, so they're in
# lowercase. (`try` and `start` are theoretically in that list, but explained
# elsewhere) NOTE: all of these (except start) don't need explicit curly
# braces `{` and `}`.

#
# 15.1 `do` - It runs a block or a statement as a term.
#

# Normally you cannot use a statement as a value (or "term"). `do` helps
# us do it. With `do`, an `if`, for example, becomes a term returning a value.
=for comment :reason<this fails since `if` is a statement>
my $value = if True { 1 }

# this works!
my $get-five = do if True { 5 }

#
# 15.1 `once` - makes sure a piece of code only runs once.
#
for ^5 {
	once say 1
};
# OUTPUT: «1␤», only prints ... once

# Similar to `state`, they're cloned per-scope.
for ^5 {
	sub { once say 1 }()
};
# OUTPUT: «1 1 1 1 1␤», prints once per lexical scope.

#
# 15.2 `gather` - co-routine thread.
#

# The `gather` constructs allows us to `take` several values from an array/list,
# much like `do`.
say gather for ^5 {
    take $_ * 3 - 1;
    take $_ * 3 + 1;
}
# OUTPUT: «-1 1 2 4 5 7 8 10 11 13␤»

say join ',', gather if False {
    take 1;
    take 2;
    take 3;
}
# Doesn't print anything.

#
# 15.3 `eager` - evaluates a statement eagerly (forces eager context).

# Don't try this at home. This will probably hang for a while (and might crash)
# so commented out.
# eager 1..*;

# But consider, this version which doesn't print anything
constant thricev0 = gather for ^3 { say take $_ };
# to:
constant thricev1 = eager gather for ^3 { say take $_ }; # OUTPUT: «0 1 2␤»

####################################################
# 16. Iterables
####################################################

# Iterables are objects that can be iterated over for things such as
# the `for` construct.

#
# 16.1 `flat` - flattens iterables.
#
say (1, 10, (20, 10) );      # OUTPUT: «(1 10 (20 10))␤»,  notice how nested
                             # lists are preserved
say (1, 10, (20, 10) ).flat; # OUTPUT: «(1 10 20 10)␤», now the iterable is flat

#
# 16.2 `lazy` - defers actual evaluation until value is fetched by forcing lazy context.
#
my @lazy-array = (1..100).lazy;
say @lazy-array.is-lazy; # OUTPUT: «True␤», check for laziness with the `is-lazy` method.

say @lazy-array;         # OUTPUT: «[...]␤», List has not been iterated on!

# This works and will only do as much work as is needed.
for @lazy-array { .print };

# (**TODO** explain that gather/take and map are all lazy)

#
# 16.3 `sink` - an `eager` that discards the results by forcing sink context.
#
constant nilthingie = sink for ^3 { .say } #=> 0 1 2
say nilthingie.perl;                       # OUTPUT: «Nil␤»

#
# 16.4 `quietly` - suppresses warnings in blocks.
#
quietly { warn 'This is a warning!' }; # No output

####################################################
# 17. More operators thingies!
####################################################

# Everybody loves operators! Let's get more of them.

# The precedence list can be found here:
# https://docs.raku.org/language/operators#Operator_Precedence
# But first, we need a little explanation about associativity:

#
# 17.1 Binary operators
#

my ($p, $q, $r) = (1, 2, 3);

# Given some binary operator § (not a Raku-supported operator), then:

# $p § $q § $r; # with a left-associative  §, this is ($p § $q) § $r
# $p § $q § $r; # with a right-associative §, this is $p § ($q § $r)
# $p § $q § $r; # with a non-associative   §, this is illegal
# $p § $q § $r; # with a chain-associative §, this is ($p § $q) and ($q § $r)§
# $p § $q § $r; # with a list-associative  §, this is `infix:<>`

#
# 17.2 Unary operators
#

# Given some unary operator § (not a Raku-supported operator), then:
# §$p§ # with left-associative  §, this is (§$p)§
# §$p§ # with right-associative §, this is §($p§)
# §$p§ # with non-associative   §, this is illegal

#
# 17.3 Create your own operators!
#

# Okay, you've been reading all of that, so you might want to try something
# more exciting?! I'll tell you a little secret (or not-so-secret):
# In Raku, all operators are actually just funny-looking subroutines.

# You can declare an operator just like you declare a sub. In the following
# example, `prefix` refers to the operator categories (prefix, infix, postfix,
# circumfix, and post-circumfix).
sub prefix:<win>( $winner ) {
	say "$winner Won!";
}
win "The King"; # OUTPUT: «The King Won!␤»

# you can still call the sub with its "full name":
say prefix:<!>(True);      # OUTPUT: «False␤»
prefix:<win>("The Queen"); # OUTPUT: «The Queen Won!␤»

sub postfix:<!>( Int $n ) {
    [*] 2..$n; # using the reduce meta-operator... See below ;-)!
}
say 5!; # OUTPUT: «120␤»

# Postfix operators ('after') have to come *directly* after the term.
# No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!`

sub infix:<times>( Int $n, Block $r ) { # infix ('between')
    for ^$n {
        # You need the explicit parentheses to call the function in `$r`,
        # else you'd be referring at the code object itself, like with `&r`.
        $r();
    }
}
3 times -> { say "hello" }; # OUTPUT: «hello␤hello␤hello␤»

# It's recommended to put spaces around your infix operator calls.

# For circumfix and post-circumfix ones
multi circumfix:<[ ]>( Int $n ) {
    $n ** $n
}
say [5]; # OUTPUT: «3125␤»

# Circumfix means 'around'. Again, no whitespace.

multi postcircumfix:<{ }>( Str $s, Int $idx ) {
    $s.substr($idx, 1);
}
say "abc"{1}; # OUTPUT: «b␤», after the term `"abc"`, and around the index (1)

# Post-circumfix is 'after a term, around something'

# This really means a lot -- because everything in Raku uses this.
# For example, to delete a key from a hash, you use the `:delete` adverb
# (a simple named argument underneath). For instance, the following statements
# are equivalent.
my %person-stans =
    'Giorno Giovanna'  => 'Gold Experience',
    'Bruno Bucciarati' => 'Sticky Fingers';
my $key = 'Bruno Bucciarati';
%person-stans{$key}:delete;
postcircumfix:<{ }>( %person-stans, 'Giorno Giovanna', :delete );
# (you can call operators like this)

# It's *all* using the same building blocks! Syntactic categories
# (prefix infix ...), named arguments (adverbs), ..., etc. used to build
# the language - are available to you. Obviously, you're advised against
# making an operator out of *everything* -- with great power comes great
# responsibility.

#
# 17.4 Meta operators!
#

# Oh boy, get ready!. Get ready, because we're delving deep into the rabbit's
# hole, and you probably won't want to go back to other languages after
# reading this. (I'm guessing you don't want to go back at this point but
# let's continue, for the journey is long and enjoyable!).

# Meta-operators, as their name suggests, are *composed* operators. Basically,
# they're operators that act on another operators.

# The reduce meta-operator is a prefix meta-operator that takes a binary
# function and one or many lists. If it doesn't get passed any argument,
# it either returns a "default value" for this operator (a meaningless value)
# or `Any` if there's none (examples below). Otherwise, it pops an element
# from the list(s) one at a time, and applies the binary function to the last
# result (or the first element of a list) and the popped element.

# To sum a list, you could use the reduce meta-operator with `+`, i.e.:
say [+] 1, 2, 3; # OUTPUT: «6␤», equivalent to (1+2)+3.

# To multiply a list
say [*] 1..5; # OUTPUT: «120␤», equivalent to ((((1*2)*3)*4)*5).

# You can reduce with any operator, not just with mathematical ones.
# For example, you could reduce with `//` to get first defined element
# of a list:
say [//] Nil, Any, False, 1, 5;  # OUTPUT: «False␤»
                                 # (Falsey, but still defined)
# Or with relational operators, i.e., `>` to check elements of a list
# are ordered accordingly:
say [>] 234, 156, 6, 3, -20; # OUTPUT: «True␤»

# Default value examples:
say [*] (); # OUTPUT: «1␤», empty product
say [+] (); # OUTPUT: «0␤», empty sum
say [//];   # OUTPUT: «(Any)␤»
            # There's no "default value" for `//`.

# You can also use it with a function you made up,
# You can also surround  using double brackets:
sub add($a, $b) { $a + $b }
say [[&add]] 1, 2, 3; # OUTPUT: «6␤»

# The zip meta-operator is an infix meta-operator that also can be used as a
# "normal" operator. It takes an optional binary function (by default, it
# just creates a pair), and will pop one value off of each array and call
# its binary function on these until it runs out of elements. It returns an
# array with all of these new elements.
say (1, 2) Z (3, 4); # OUTPUT: «((1, 3), (2, 4))␤»
say 1..3 Z+ 4..6;    # OUTPUT: «(5, 7, 9)␤»

# Since `Z` is list-associative (see the list above), you can use it on more
# than one list.
(True, False) Z|| (False, False) Z|| (False, False); # (True, False)

# And, as it turns out, you can also use the reduce meta-operator with it:
[Z||] (True, False), (False, False), (False, False); # (True, False)

# And to end the operator list:

# The sequence operator (`...`) is one of Raku's most powerful features:
# It's composed by the list (which might include a closure) you want Raku to
# deduce from on the left and a value (or either a predicate or a Whatever Star
# for a lazy infinite list) on the right that states when to stop.

# Basic arithmetic sequence
my @listv0 = 1, 2, 3...10;

# This dies because Raku can't figure out the end
# my @list = 1, 3, 6...10;

# As with ranges, you can exclude the last element (the iteration ends when
# the predicate matches).
my @listv1 = 1, 2, 3...^10;

# You can use a predicate (with the Whatever Star).
my @listv2 = 1, 3, 9...* > 30;

# Equivalent to the example above but using a block here.
my @listv3 = 1, 3, 9 ... { $_ > 30 };

# Lazy infinite list of fibonacci sequence, computed using a closure!
my @fibv0 = 1, 1, *+* ... *;

# Equivalent to the above example but using a pointy block.
my @fibv1 = 1, 1, -> $a, $b { $a + $b } ... *;

# Equivalent to the above example but using a block with placeholder parameters.
my @fibv2 = 1, 1, { $^a + $^b } ... *;

# In the examples with explicit parameters (i.e., $a and $b), $a and $b
# will always take the previous values, meaning that for the Fibonacci sequence,
# they'll start with $a = 1 and $b = 1 (values we set by hand), then $a = 1
# and $b = 2 (result from previous $a + $b), and so on.

# In the example we use a range as an index to access the sequence. However,
# it's worth noting that for ranges, once reified, elements aren't re-calculated.
# That's why, for instance, `@primes[^100]` will take a long time the first
# time you print it but then it will be instantaneous.
say @fibv0[^10]; # OUTPUT: «1 1 2 3 5 8 13 21 34 55␤»

####################################################
# 18. Regular Expressions
####################################################

# I'm sure a lot of you have been waiting for this one. Well, now that you know
# a good deal of Raku already, we can get started. First off, you'll have to
# forget about "PCRE regexps" (perl-compatible regexps).

# IMPORTANT: Don't skip them because you know PCRE. They're different. Some
# things are the same (like `?`, `+`, and `*`), but sometimes the semantics
# change (`|`). Make sure you read carefully, because you might trip over a
# new behavior.

# Raku has many features related to RegExps. After all, Rakudo parses itself.
# We're first going to look at the syntax itself, then talk about grammars
# (PEG-like), differences between `token`, `regex` and `rule` declarators,
# and some more. Side note: you still have access to PCRE regexps using the
# `:P5` modifier which we won't be discussing this in this tutorial, though.

# In essence, Raku natively implements PEG ("Parsing Expression Grammars").
# The pecking order for ambiguous parses is determined by a multi-level
# tie-breaking test:
#  - Longest token matching: `foo\s+` beats `foo` (by 2 or more positions)
#  - Longest literal prefix: `food\w*` beats `foo\w*` (by 1)
#  - Declaration from most-derived to less derived grammars
#    (grammars are actually classes)
#  - Earliest declaration wins
say so 'a' ~~ /a/;   # OUTPUT: «True␤»
say so 'a' ~~ / a /; # OUTPUT: «True␤», more readable with some spaces!

# In all our examples, we're going to use the smart-matching operator against
# a regexp. We're converting the result using `so` to a Boolean value because,
# in fact, it's returning a `Match` object. They know how to respond to list
# indexing, hash indexing, and return the matched string. The results of the
# match are available in the `$/` variable (implicitly lexically-scoped). You
# can also use the capture variables which start at 0: `$0`, `$1', `$2`...

# You can also note that `~~` does not perform start/end checking, meaning
# the regexp can be matched with just one character of the string. We'll
# explain later how you can do it.

# In Raku, you can have any alphanumeric as a literal, everything else has
# to be escaped by using a backslash or quotes.
say so 'a|b' ~~ / a '|' b /; # OUTPUT: «True␤», it wouldn't mean the same
                             # thing if `|` wasn't escaped.
say so 'a|b' ~~ / a \| b /;  # OUTPUT: «True␤», another way to escape it.

# The whitespace in a regex is actually not significant, unless you use the
# `:s` (`:sigspace`, significant space) adverb.
say so 'a b c' ~~ / a  b  c /; #=> `False`, space is not significant here!
say so 'a b c' ~~ /:s a b c /; #=> `True`, we added the modifier `:s` here.

# If we use only one space between strings in a regex, Raku will warn us
# about space being not signicant in the regex:
say so 'a b c' ~~ / a b c /;   # OUTPUT: «False␤»
say so 'a b c' ~~ / a  b  c /; # OUTPUT: «False»

# NOTE: Please use quotes or `:s` (`:sigspace`) modifier (or, to suppress this
# warning, omit the space, or otherwise change the spacing). To fix this and make
# the spaces less ambiguous, either use at least two spaces between strings
# or use the `:s` adverb.

# As we saw before, we can embed the `:s` inside the slash delimiters, but we
# can also put it outside of them if we specify `m` for 'match':
say so 'a b c' ~~ m:s/a  b  c/; # OUTPUT: «True␤»

# By using `m` to specify 'match', we can also use other delimiters:
say so 'abc' ~~ m{a  b  c};     # OUTPUT: «True␤»
say so 'abc' ~~ m[a  b  c];     # OUTPUT: «True␤»

# `m/.../` is equivalent to `/.../`:
say 'raku' ~~ m/raku/; # OUTPUT: «True␤»
say 'raku' ~~ /raku/;  # OUTPUT: «True␤»

# Use the `:i` adverb to specify case insensitivity:
say so 'ABC' ~~ m:i{a  b  c};   # OUTPUT: «True␤»

# However, whitespace is important as for how modifiers are applied
# (which you'll see just below) ...

#
# 18.1 Quantifiers - `?`, `+`, `*` and `**`.
#

# `?` - zero or one match
say so 'ac' ~~ / a  b  c /;   # OUTPUT: «False␤»
say so 'ac' ~~ / a  b?  c /;  # OUTPUT: «True␤», the "b" matched 0 times.
say so 'abc' ~~ / a  b?  c /; # OUTPUT: «True␤», the "b" matched 1 time.

# ... As you read before, whitespace is important because it determines which
# part of the regex is the target of the modifier:
say so 'def' ~~ / a  b  c? /; # OUTPUT: «False␤», only the "c" is optional
say so 'def' ~~ / a  b?  c /; # OUTPUT: «False␤», whitespace is not significant
say so 'def' ~~ / 'abc'? /;   # OUTPUT: «True␤»,  the whole "abc" group is optional

# Here (and below) the quantifier applies only to the "b"

# `+` - one or more matches
say so 'ac' ~~ / a  b+  c /;     # OUTPUT: «False␤», `+` wants at least one 'b'
say so 'abc' ~~ / a  b+  c /;    # OUTPUT: «True␤», one is enough
say so 'abbbbc' ~~ / a  b+  c /; # OUTPUT: «True␤», matched 4 "b"s

# `*` - zero or more matches
say so 'ac' ~~ / a  b*  c /;     # OUTPUT: «True␤», they're all optional
say so 'abc' ~~ / a  b*  c /;    # OUTPUT: «True␤»
say so 'abbbbc' ~~ / a  b*  c /; # OUTPUT: «True␤»
say so 'aec' ~~ / a  b*  c /;    # OUTPUT: «False␤», "b"(s) are optional, not replaceable.

# `**` - (Unbound) Quantifier
# If you squint hard enough, you might understand why exponentiation is used
# for quantity.
say so 'abc' ~~ / a  b**1  c /;         # OUTPUT: «True␤», exactly one time
say so 'abc' ~~ / a  b**1..3  c /;      # OUTPUT: «True␤», one to three times
say so 'abbbc' ~~ / a  b**1..3  c /;    # OUTPUT: «True␤»
say so 'abbbbbbc' ~~ / a  b**1..3  c /; # OUTPUT: «Fals␤», too much
say so 'abbbbbbc' ~~ / a  b**3..*  c /; # OUTPUT: «True␤», infinite ranges are ok

#
# 18.2 `<[]>` - Character classes
#

# Character classes are the equivalent of PCRE's `[]` classes, but they use a
# more raku-ish syntax:
say 'fooa' ~~ / f <[ o a ]>+ /;  # OUTPUT: «fooa␤»

# You can use ranges (`..`):
say 'aeiou' ~~ / a <[ e..w ]> /; # OUTPUT: «ae␤»

# Just like in normal regexes, if you want to use a special character, escape
# it (the last one is escaping a space which would be equivalent to using
# ' '):
say 'he-he !' ~~ / 'he-' <[ a..z \! \  ]> + /; # OUTPUT: «he-he !␤»

# You'll get a warning if you put duplicate names (which has the nice effect
# of catching the raw quoting):
'he he' ~~ / <[ h e ' ' ]> /;
# Warns "Repeated character (') unexpectedly found in character class"

# You can also negate character classes... (`<-[]>` equivalent to `[^]` in PCRE)
say so 'foo' ~~ / <-[ f o ]> + /; # OUTPUT: «False␤»

# ... and compose them:
# any letter except "f" and "o"
say so 'foo' ~~ / <[ a..z ] - [ f o ]> + /;   # OUTPUT: «False␤»

# no letter except "f" and "o"
say so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /;  # OUTPUT: «True␤»

# the + doesn't replace the left part
say so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # OUTPUT: «True␤»

#
# 18.3 Grouping and capturing
#

# Group: you can group parts of your regexp with `[]`. Unlike PCRE's `(?:)`,
# these groups are *not* captured.
say so 'abc' ~~ / a [ b ] c /;  # OUTPUT: «True␤», the grouping does nothing
say so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /; # OUTPUT: «True␤»

# The previous line returns `True`. The regex matches "012" one or more time
# (achieved by the the `+` applied to the group).

# But this does not go far enough, because we can't actually get back what
# we matched.

# Capture: The results of a regexp can be *captured* by using parentheses.
say so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # OUTPUT: «True␤»
# (using `so` here, see `$/` below)

# So, starting with the grouping explanations. As we said before, our `Match`
# object is stored inside the `$/` variable:
say $/;    # Will either print the matched object or `Nil` if nothing matched.

# As we also said before, it has array indexing:
say $/[0]; # OUTPUT: «｢ABC｣ ｢ABC｣␤»,

# The corner brackets (｢..｣) represent (and are) `Match` objects. In the
# previous example, we have an array of them.

say $0;    # The same as above.

# Our capture is `$0` because it's the first and only one capture in the
# regexp. You might be wondering why it's an array, and the answer is simple:
# Some captures (indexed using `$0`, `$/[0]` or a named one) will be an array
# if and only if they can have more than one element. Thus any capture with
# `*`, `+` and `**` (whatever the operands), but not with `?`.
# Let's use examples to see that:

# NOTE: We quoted A B C to demonstrate that the whitespace between them isn't
# significant. If we want the whitespace to *be* significant there, we can use the
# `:sigspace` modifier.
say so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # OUTPUT: «True␤»
say $/[0];   # OUTPUT: «｢ABC｣␤»
say $0.WHAT; # OUTPUT: «(Match)␤»
             # There can't be more than one, so it's only a single match object.

say so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /;    # OUTPUT: «True␤»
say $0.WHAT; # OUTPUT: «(Any)␤», this capture did not match, so it's empty.

say so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; #=> OUTPUT: «True␤»
say $0.WHAT; # OUTPUT: «(Array)␤», A specific quantifier will always capture
             # an Array, be a range or a specific value (even 1).

# The captures are indexed per nesting. This means a group in a group will be
# nested under its parent group: `$/[0][0]`, for this code:
'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /;
say $/[0].Str;    # OUTPUT: «hello~␤»
say $/[0][0].Str; # OUTPUT: «~␤»

# This stems from a very simple fact: `$/` does not contain strings, integers
# or arrays, it only contains `Match` objects. These contain the `.list`, `.hash`
# and `.Str` methods but you can also just use `match<key>` for hash access
# and `match[idx]` for array access.

# In the following example, we can see `$_` is a list of `Match` objects.
# Each of them contain a wealth of information: where the match started/ended,
# the "ast" (see actions later), etc. You'll see named capture below with
# grammars.
say $/[0].list.perl; # OUTPUT: «(Match.new(...),).list␤»

# Alternation - the `or` of regexes
# WARNING: They are DIFFERENT from PCRE regexps.
say so 'abc' ~~ / a [ b | y ] c /; # OUTPUT: «True␤», Either "b" or "y".
say so 'ayc' ~~ / a [ b | y ] c /; # OUTPUT: «True␤», Obviously enough...

# The difference between this `|` and the one you're used to is
# LTM ("Longest Token Matching") strategy. This means that the engine will
# always try to match as much as possible in the string.
say 'foo' ~~ / fo | foo /; # OUTPUT: «foo», instead of `fo`, because it's longer.

# To decide which part is the "longest", it first splits the regex in two parts:
#
#     * The "declarative prefix" (the part that can be statically analyzed)
#     which includes alternations (`|`), conjunctions (`&`), sub-rule calls (not
#     yet introduced), literals, characters classes and quantifiers.
#
#     * The "procedural part" includes everything else: back-references,
#     code assertions, and other things that can't traditionally be represented
#     by normal regexps.

# Then, all the alternatives are tried at once, and the longest wins.

# Examples:
# DECLARATIVE | PROCEDURAL
/ 'foo' \d+     [ <subrule1> || <subrule2> ] /;

# DECLARATIVE (nested groups are not a problem)
/ \s* [ \w & b ] [ c | d ] /;

# However, closures and recursion (of named regexes) are procedural.
# There are also more complicated rules, like specificity (literals win
# over character classes).

# NOTE: The alternation in which all the branches are tried in order
# until the first one matches still exists, but is now spelled `||`.
say 'foo' ~~ / fo || foo /; # OUTPUT: «fo␤», in this case.

####################################################
# 19. Extra: the MAIN subroutine
####################################################

# The `MAIN` subroutine is called when you run a Raku file directly. It's
# very powerful, because Raku actually parses the arguments and pass them
# as such to the sub. It also handles named argument (`--foo`) and will even
# go as far as to autogenerate a `--help` flag.

sub MAIN($name) {
    say "Hello, $name!";
}
# Supposing the code above is in file named cli.raku, then running in the command
# line (e.g., $ raku cli.raku) produces:
# Usage:
# cli.raku <name>

# And since MAIN is a regular Raku sub, you can have multi-dispatch:
# (using a `Bool` for the named argument so that we can do `--replace`
# instead of `--replace=1`. The presence of `--replace` indicates truthness
# while its absence falseness). For example:

    # convert to IO object to check the file exists
    =begin comment
    subset File of Str where *.IO.d;

    multi MAIN('add', $key, $value, Bool :$replace) { ... }
    multi MAIN('remove', $key) { ... }
    multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
    =end comment

# Thus $ raku cli.raku produces:
# Usage:
#   cli.raku [--replace] add <key> <value>
#   cli.raku remove <key>
#   cli.raku [--as=<Str>] import <File>

# As you can see, this is *very* powerful. It even went as far as to show inline
# the constants (the type is only displayed if the argument is `$`/is named).

####################################################
# 20. APPENDIX A:
####################################################

# It's assumed by now you know the Raku basics. This section is just here to
# list some common operations, but which are not in the "main part" of the
# tutorial to avoid bloating it up.

#
# 20.1 Operators
#

# Sort comparison - they return one value of the `Order` enum: `Less`, `Same`
# and `More` (which numerify to -1, 0 or +1 respectively).
say 1 <=> 4;     # OUTPUT: «More␤»,   sort comparison for numerics
say 'a' leg 'b'; # OUTPUT: «Lessre␤», sort comparison for string
say 1 eqv 1;     # OUTPUT: «Truere␤», sort comparison using eqv semantics
say 1 eqv 1.0;   # OUTPUT: «False␤»

# Generic ordering
say 3 before 4;    # OUTPUT: «True␤»
say 'b' after 'a'; # OUTPUT: «True␤»

# Short-circuit default operator - similar to `or` and `||`, but instead
# returns the first *defined* value:
say Any // Nil // 0 // 5;        # OUTPUT: «0␤»

# Short-circuit exclusive or (XOR) - returns `True` if one (and only one) of
# its arguments is true
say True ^^ False;               # OUTPUT: «True␤»

# Flip flops. These operators (`ff` and `fff`, equivalent to P5's `..`
# and `...`) are operators that take two predicates to test: They are `False`
# until their left side returns `True`, then are `True` until their right
# side returns `True`. Similar to ranges, you can exclude the iteration when
# it become `True`/`False` by using `^` on either side. Let's start with an
# example :

for <well met young hero we shall meet later> {
    # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
    if 'met' ^ff 'meet' { # Won't enter the if for "met"
        .say              # (explained in details below).
    }

    if rand == 0 ff rand == 1 { # compare variables other than `$_`
        say "This ... probably will never run ...";
    }
}

# This will print "young hero we shall meet" (excluding "met"): the flip-flop
# will start returning `True` when it first encounters "met" (but will still
# return `False` for "met" itself, due to the leading `^` on `ff`), until it
# sees "meet", which is when it'll start returning `False`.

# The difference between `ff` (awk-style) and `fff` (sed-style) is that `ff`
# will test its right side right when its left side changes to `True`, and can
# get back to `False` right away (*except* it'll be `True` for the iteration
# that matched) while `fff` will wait for the next iteration to try its right
# side, once its left side changed:

# The output is due to the right-hand-side being tested directly (and returning
# `True`). "B"s are printed since it matched that time (it just went back to
# `False` right away).
.say if 'B' ff 'B' for <A B C B A>; # OUTPUT: «B B␤»,

# In this case the right-hand-side wasn't tested until `$_` became "C"
# (and thus did not match instantly).
.say if 'B' fff 'B' for <A B C B A>; #=> «B C B␤»,

# A flip-flop can change state as many times as needed:
for <test start print it stop not printing start print again stop not anymore> {
    # exclude both "start" and "stop",
    .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # OUTPUT: «print it print again␤»
}

# You might also use a Whatever Star, which is equivalent to `True` for the
# left side or `False` for the right, as shown in this example.
# NOTE: the parenthesis are superfluous here (sometimes called "superstitious
# parentheses"). Once the flip-flop reaches a number greater than 50, it'll
# never go back to `False`.
for (1, 3, 60, 3, 40, 60) {
    .say if $_ > 50 ff *;  # OUTPUT: «60␤3␤40␤60␤»
}

# You can also use this property to create an `if` that'll not go through the
# first time. In this case, the flip-flop is `True` and never goes back to
# `False`, but the `^` makes it *not run* on the first iteration
for <a b c> { .say if * ^ff *; }  # OUTPUT: «b␤c␤»

# The `===` operator, which uses `.WHICH` on the objects to be compared, is
# the value identity operator whereas the `=:=` operator, which uses `VAR()` on
# the objects to compare them, is the container identity operator.
```

If you want to go further and learn more about Raku, you can:

- Read the [Raku Docs](https://docs.raku.org/). This is a great
resource on Raku. If you are looking for something, use the search bar.
This will give you a dropdown menu of all the pages referencing your search
term (Much better than using Google to find Raku documents!).

- Read the [Raku Advent Calendar](https://rakuadventcalendar.wordpress.com/). This
is a great source of Raku snippets and explanations. If the docs don't
describe something well enough, you may find more detailed information here.
This information may be a bit older but there are many great examples and
explanations.

- Come along on `#raku` at [`irc.libera.chat`](https://web.libera.chat/?channel=#raku). The folks here are
always helpful.

- Check the [source of Raku's functions and
classes](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo is
mainly written in Raku (with a lot of NQP, "Not Quite Perl", a Raku subset
easier to implement and optimize).

- Read [the language design documents](https://design.raku.org/). They explain
Raku from an implementor point-of-view, but it's still very interesting.