if True {
    say "Hello";
}

    if True {
say "Hello"; # Bad indentation intended 
        }

if True { say "Hello" }

if True {say "Hello"}

sub alignment(+@l) { +@l };
sub long-name-alignment(+@l) { +@l };
alignment\         (1,2,3,4).say;
long-name-alignment(3,5)\   .say;
say Inf+Inf\i;

say "Hello";
say "world";

say "Hello";
say "world"

if True {
    say "Hello"
}
say "world"

if True { say "Hello" }
say "world";

if True { say "Hello" }; say "world";
#                     ^^^ this ; is required 

my @names = <Foo Bar Baz>;
my @upper-case-names = @names.map: { .uc }    # OUTPUT: [FOO BAR BAZ] 

if True { say "Hello" } else { say "Goodbye" }; say "world";
#                                            ^^^ this ; is required 

if True { say "Hello" } else { say "Goodbye" } # <- implied statement separator 
say "world";

if True { say "Hello" }   # still in the middle of an if/else statement 
else    { say "Goodbye" } # <- no semicolon required because it ends in a block 
                          #    without trailing statements in the same line 
say "world";

if $age > 250 {     # catch obvious outliers 
    # this is another comment! 
    die "That doesn't look right"
}

if #`( why would I ever write an inline comment here? ) True {
    say "something stupid";
}

#`[
And this is how a multi would work.
That says why we do what we do below.
]
say "No more";

say "this is code";
 
=begin comment
 
Here are several
lines
of comment
 
=end comment
 
say 'code again';

constant c = 299792458;     # identifier "c" names an Int 
my $a = 123;                # identifier "a" in the name "$a" of a Scalar 
sub hello { say "Hello!" }; # identifier "hello" names a Sub

# valid ordinary identifiers: 
x
_snake_oil
something-longer
with-numbers1234
don't-do-that
piece_of_π
駱駝道              # "Rakuda-dō", Japanese for "Way of the camel" 

# invalid ordinary identifiers: 
42                 # identifier does not start with alphabetic character 
with-numbers1234-5 # embedded hyphen not followed by alphabetic character 
is-prime?          # question mark is not alphanumeric 
x²                 # superscript 2 is not alphanumeric (explained above) 

Dog:auth<Somebody>:ver<1.0>  # long module names including author and version 
Dog:auth<Somebody>:ver<2.0>
 
use Dog:auth<Somebody>:ver<2.0>;
# Selection of second module causes its full name to be aliased to the 
# short name for the rest of # the lexical scope, allowing a declaration 
# like this. 
my Dog $spot .= new("woof");

infix:<+>                 # the official name of the operator in $a + $b 
infix:<*>                 # the official name of the operator in $a * $b 
infix:«<=»                # the official name of the operator in $a <= $b 

# exemplary valid extended identifiers: 
postfix:<²>               # the official long name of the operator in $x² 
WOW:That'sAwesome
WOW:That's<<🆒>>
party:sweet<16>
 
# exemplary invalid extended identifiers: 
party:16<sweet>           # 16 is not an ordinary identifier 
party:16sweet
party:!a                  # ...and neither is !a 
party:$a                  # ...nor $a 

infix:<+>
infix:<<+>>
infix:«+»
infix:['+']
infix:('+')

my $foo:bar<baz> = 'quux';
say $foo:bar«baz»;                               # OUTPUT: «quux␤» 
my $take-me:<home> = 'Where the glory has no end';
say $take-me:['home'];                           # OUTPUT: «Where [...]␤» 
my $foo:bar<2> = 5;
say $foo:bar(1+1);                               # OUTPUT: «5␤» 

my $a:b<c>:d<e> = 100;
my $a:d<e>:b<c> = 200;
say $a:b<c>:d<e>;               # OUTPUT: «100␤», NOT: «200␤» 

use ThatModule:auth<Somebody>:ver<2.7.18.28.18>
use ThatModule:ver<2.7.18.28.18>:auth<Somebody>

constant $c = 42;  # Constant binds to Int; $-sigil enables interpolation 
my $a:foo<42> = "answer";
say $a:foo«$c»;    # OUTPUT: «answer␤» 

constant $what = 'are';
my @we:<are>= <the champions>;
say @we:«$what»;     # OUTPUT: «[the champions]␤» 
say @we:<$what>;
# Compilation error: Variable '@we:<$what>' is not declared 

module MyModule {               # declare a module package 
    our $var = "Hello";         # declare package-scoped variable 
}
say $MyModule::var              # OUTPUT: «Hello␤»

my $foo::bar = 1;
say OUR::.keys;           # OUTPUT: «(foo)␤» 
say OUR::foo.HOW          # OUTPUT: «Perl6::Metamodel::PackageHOW.new␤» 

my $buz = "quux";
my $bur::quux = 7;
say $bur::($buz);               # OUTPUT: «7␤»

use Test; plan 1; constant &term:<👍> = &ok.assuming(True);
👍
# OUTPUT: «1..1␤ok 1 - ␤»

sub term:<dice> { (1..6).pick };
say dice + dice;

sub dice() {(1...6).pick }

my $x = if True { 42 };     # Syntax error! 

my $x = do if True { 42 };

# declaration: 
my $number = 21;
# usage: 
say $number * 2;

say Int;                # OUTPUT: «(Int)␤» 
#   ^^^ type name (built in) 
 
constant answer = 42;
say answer;
#   ^^^^^^ constant 
 
class Foo {
    method type-name {
        self.^name;
      # ^^^^ built-in term 'self' 
    }
}
say Foo.type-name;     # OUTPUT: «Foo␤» 
#   ^^^ type name

$foo                # simple identifiers 
$Foo::Bar::baz      # compound identifiers separated by :: 
$Foo::($bar)::baz   # compound identifiers that perform interpolations 
Foo::Bar::bob(23)   # function invocation given qualified name 

say 'a string literal';
say "a string literal\nthat interprets escape sequences";

say "🔔\a";  # OUTPUT: «🔔␇␤»

1000000
1_000_000
10_00000
100_00_00

# not a single literal, but unary - operator applied to numeric literal 2 
-2
12345
0xBEEF      # base 16 
0o755       # base 8 
:3<1201>    # arbitrary base, here base 3 

1.          # Error: A number must have at least one digit after the radix point 
1.0
3.14159
-2.5        # Not actually a literal, but still a Rat 
:3<21.0012> # Base 3 rational 
⅔
2/3         # Not actually a literal, but still a Rat 

1.e0        # error: A number must have at least one digit after the radix point 
1e0
6.022e23
1e-9
-2e48
2e2.5       # error 

1.+2i       # error: A number must have at least one digit after the radix point 
1+2.i       # error: A number must have at least one digit after the radix point 
1+2i
6.123e5i    # note that this is 6.123e5 * i, not 6.123 * 10 ** (5i) 

like-an-identifier-ain't-it => 42
"key" => 42
('a' ~ 'b') => 1

my $thing = 42;
:$thing                 # same as  thing => $thing 
:thing                  # same as  thing => True 
:!thing                 # same as  thing => False 

:42thing            # same as  thing => 42 
:٤٢thing            # same as  thing => 42

:٤٢ث              # same as   ث => ٤٢

:thing($value)              # same as  thing => $value 
:thing<quoted list>         # same as  thing => <quoted list> 
:thing['some', 'values']    # same as  thing => ['some', 'values'] 
:thing{a => 'b'}            # same as  thing => { a => 'b' } 

say ['a', 'b', 42].join(' ');   # OUTPUT: «a b 42␤» 
#   ^^^^^^^^^^^^^^ Array constructor

my @a = 1, 2;
say [@a].raku;  # OUTPUT: «[1, 2]␤» 
say [@a,].raku; # OUTPUT: «[[1, 2],]␤»

my @a = 1, 2;
say [@a, 3, 4].raku;  # OUTPUT: «[[1, 2], 3, 4]␤» 
say [|@a, 3, 4].raku; # OUTPUT: «[1, 2, 3, 4]␤»

my @a is List = 1, 2; # a List, not an Array 
# wrong: creates an Array of Lists 
my List @a;

say %( a => 3, b => 23, :foo, :dog<cat>, "french", "fries" );
# OUTPUT: «a => 3, b => 23, dog => cat, foo => True, french => fries␤» 
 
say %(a => 73, foo => "fish").keys.join(" ");   # OUTPUT: «a foo␤» 
#   ^^^^^^^^^^^^^^^^^^^^^^^^^ Hash constructor

my %ages = fred => 23, jean => 87, ann => 4;

my $when = :{ (now) => "Instant", (DateTime.now) => "DateTime" };

say :{ -1 => 41, 0 => 42, 1 => 43 }<0>;  # OUTPUT: «(Any)␤» 
say :{ -1 => 41, 0 => 42, 1 => 43 }{0};  # OUTPUT: «42␤»

my %hash;                    # Hash 
my %hash is Hash;            # explicit Hash 
my %map is Map;              # Map 
my %stash is Stash;          # Stash 
 
my %quant-hash is QuantHash; # QuantHash 
 
my %setty is Setty;          # Setty 
my %set is Set;              # Set 
my %set-hash is SetHash;     # SetHash 
 
my %baggy is Baggy;          # Baggy 
my %bag is Bag;              # Bag 
my %bag-hash is BagHash;     # BagHash 
 
my %mixy is Mixy;            # Mixy 
my %mix is Mix;              # Mix 
my %mix-hash is MixHash;     # MixHash

# This is wrong: creates a Hash of Mixes, not Mix: 
my Mix %mix;
# Works with $ sigil: 
my Mix $mix;
# Can be typed: 
my Mix[Int] $mix-of-ints;

/foo/          # Short version 
rx/foo/        # Longer version 
Q :regex /foo/ # Even longer version
 
my $r = /foo/; # Regexes can be assigned to variables

say "match!" if 5, "fish" ~~ :(Int, Str); # OUTPUT: «match!␤» 
 
my $sig = :(Int $a, Str);
say "match!" if (5, "fish") ~~ $sig; # OUTPUT: «match!␤» 
 
given "foo", 42 {
  when :(Str, Str) { "This won't match" }
  when :(Str, Int $n where $n > 20) { "This will!" }
}

my $x;                          # simple lexical variable 
my $x = 7;                      # initialize the variable 
my Int $x = 7;                  # declare the type 
my Int:D $x = 7;                # specify that the value must be defined (not undef) 
my Int $x where { $_ > 3 } = 7; # constrain the value based on a function 
my Int $x where * > 3 = 7;      # same constraint, but using Whatever shorthand

sub {}
# The minimal legal subroutine declaration 
 
sub say-hello1 { say "Hello!" }
# A subroutine with a name 
 
sub say-hello2(Str $to-whom) { say "Hello $to-whom!" }
# A subroutine with a name and a signature

my &greet0 = sub { say "Hello!" }            # Unnamed sub assigned to &greet0 
my &greet1 = sub say-hello1 { say "Hello!" } # Named sub assigned to &greet1

multi greet { say "Hello!" }
#     ^^^ optional 
multi greet($name) { say "Hello $name!" }

proto at-least1($, |) {*}
multi at-least1($first)          { note $first }
multi at-least1($first, $second) { note "got two" }
multi at-least1($first, :$named) { note "got named" }
 
# The following is legal to *declare* but can never be called 
multi at-least1 { note "Got none"}

my &greet0 = { say "Hello!" }     # Block stored in &greet0 
my &greet1 = { say "Hello $_!" }  # Block with default signature 
my &greet2 = -> $to-whom { say "Hello $to-whom!" }  # Block with explicit signature 
my &greet3 = { say "Hello $^to-whom!" }             # Block with implicit positional 
my &greet4 = { say "Hello $:to-whom!" }             # Block with implicit named 
 
my &add1-in-place = <-> $a { ++$a }                 # Block with rw signature

my $greet = { say "Hello!" }

my &m = method ($invocant: $arg1, $arg2) { note }

class Greeter {
   method greet($to-whom)           { say "Hello $to-whom!" }
   method defined-greet(Greeter:D:) { say "Hello!" }
}

class Greeter {
      multi method greet           { say "Hello!" }
      multi method greet($to-whom) { say "Hello $to-whom!" }
 
      proto method at-least1($, |)   {*}
      multi method at-least1($first) { note $first }
      # The following is legal to *declare* but can never be called 
      multi method at-least1         { note "Got none"}
}

package P { }
 
module M { }
 
class C { }
 
role R { }
 
grammar G { }

unit module M;
# ... stuff goes here instead of in {}'s 

foo;
foo();
&foo();
&foo.();

my $foo = sub { note }
$foo();
$foo.();

class Person {
    has $.age = 0;
    has Str $.name = "Anon";
 
    multi method greet        { say "Hello, $.name()!" }
    multi method greet($name) { say "Hello, $name!" }
};
my $person = Person.new(:name<Jane>, :age(98));
 
$person.greet;   # Calls greet method with 0 args 
$person.greet(); # Calls greet method with 0 args 
$person.greet('Nushi'); # Calls greet method with 1 arg 
$person.greet: 'Nushi'; # Calls greet method with 1 arg 

    my $band = 'Foo Fighters';
    say $band.substr( 0, 3 ).uc; # OUTPUT: «FOO␤» 
    say $band.substr: 0, 3  .uc; # OUTPUT: «Foo␤» 
 

given 'Foo Fighters' {
   say .substr: 0, 3;  # OUTPUT: «Foo␤» 
}

sub greet($name, :$excited = True) {
    say "Hello $name" ~ ($excited ?? '!' !! '.')
}
greet "Maria";    # OUTPUT: «Hello Maria!␤» 
"Maria".&greet;   # OUTPUT: «Hello Maria!␤» 
"Maria".&greet(); # OUTPUT: «Hello Maria!␤» 
given "Maria" { .&greet } # OUTPUT: «Hello Maria!␤» 
 
"Maria".&greet(:!excited); # OUTPUT: «Hello Maria.␤» 
"Maria".&greet: :!excited; # OUTPUT: «Hello Maria.␤»

class Person {
    has Str $.name;
 
    multi method greet        { say "Hello, $.name()!" }
    multi method greet($name) { say "Hello, $name!" }
};
my $person = Person.new(:name<Ruòxī>, :age(11));
 
greet $person:;         # same as $person.greet; 
greet Person: 'Yasmin'; # same as Person.greet('Yasmin');

say 42;  # Subroutine call 
42.&say; # Still a subroutine call 
42.say;  # Method call 
say 42:; # Also a method call

my @list = 1..9;
sub add1($a) { $a + 1 }
 
map &add1, @list; # Sub call; expects list last 
map @list: &add1; # Method call; expects function last 
 
@list.map(&add1);  # Method call; expects function last 
&add1.&map(@list); # Sub call; expects list last

++$x           # prefix, operator comes before single input 
5 + 3          # infix, operator is between two inputs 
$x++           # postfix, operator is after single input 
<the blue sky> # circumfix, operator surrounds single input 
%foo<bar>      # postcircumfix, operator comes after first input and surrounds second 

$x += 5     # Adds 5 to $x, same as $x = $x + 5 
$x min= 3   # Sets $x to the smaller of $x and 3, same as $x = $x min 3 
$x .= child # Equivalent to $x = $x.child 

say [+] <1 2 3 4 5>;    # OUTPUT: «15␤» 
(((1 + 2) + 3) + 4) + 5 # equivalent expanded version

say <1 2 3> «+» <4 5 6> # OUTPUT: «(5 7 9)␤»