Raku 官方文档

%sets{$p1} += $r1;
%sets{$p2} += $r2;

if $r1 > $r2 {
    %matches{$p1}++;
} else {
    %matches{$p2}++;
}

my $names = 'things';
say 'Do not call me $names'; # OUTPUT: «Do not call me $names␤»
say "Do not call me $names"; # OUTPUT: «Do not call me things␤»

say "Math: { 1 + 2 }";
# OUTPUT: «Math: 3␤»

my @people = <Luke Matthew Mark>;
say "The synoptics are: {@people}";
# OUTPUT: «The synoptics are: Luke Matthew Mark␤»

say "{%sets}␤";
# OUTPUT (From the table tennis tournament):

# Charlie 4
# Dave    6
# Ana     8
# Beth    4

    =head2 My Definition

    Some paragraphs, followed by some code:

    =begin code
    my Code $examples = "amazing";
    =end code

    Mind === blown.

    =head3 Minor details about My Definition

    It's fantastic.

    =head2 And now, for something completely different

    …

=item X<C<How to use the þ infix> | infix,þ> (This a special case, which
is always considered a definition)

=item C<The þ Infix>

=item B<The C<þ> Infix>

=item C<Infix þ>

=item B<Infix C<þ>>

=item C<trait is cached> (A special case for the L<trait|/language/functions#Traits> documentables)

=item X<B<foo>|foo> a fancy subroutine

sort { $^a cmp $^z }, 1, 5, 6, 4, 2, 3;
# OUTPUT: «(1 2 3 4 5 6)␤»
sort { $^g cmp $^a }, 1, 5, 6, 4, 2, 3;
# OUTPUT: «(6 5 4 3 2 1)␤»
for 1..9 { say $^c, $^a, $^b; last }
# OUTPUT: «312␤»

# Print out a list of compunit repositories
.say for $*REPO.repo-chain;

use Test;
use MyModule;
say flat $*REPO.repo-chain.map(*.loaded); #-> (MyModule Test)

for $*KERNEL, $*DISTRO, $*VM -> $what {
    say $what.^name;
    say 'version '  ~ $what.version
        ~ ' named ' ~ $what.name
        ~ ' by '    ~ $what.auth;
}

# Kernel
# version 4.10.0.42.generic named linux by unknown
# Distro
# version 17.04.Zesty.Zapus named ubuntu by https://www.ubuntu.com/
# VM
# version 2017.11 named moar by The MoarVM Team

$SIG{"INT"} = sub { say "bye"; exit }

signal(SIGINT).tap: { say "bye"; exit }; loop {}

signal(SIGINT).tap: -> $signal { say "bye with $signal"; exit }; loop {}

react {
    whenever signal(SIGINT) {
        say "goodbye";
        done
    }
}

try {
    fail "Boooh";
    CATCH {
        # within the catch block
        # the exception is placed into $_
        say 'within the catch:';
        say $_.^name ~ ' : ' ~ $_.message;
        $_.resume; # do not abort
    }
}

# outside the catch block the exception is placed
# into $!
say 'outside the catch:';
say $!.^name ~ ' : ' ~ $!.message;

within the catch:
X::AdHoc : Boooh
outside the catch:
X::AdHoc : Boooh

console.log('Hello, world!');

say('Hello, world!');
say 'Hello, world!';

let name = 'Joe';
console.log('What\'s up,' + name + '?');
console.log(`What's up, {name}?`);
console.log("What's up, ", name, "?");

my $name = 'Joe';
say 'What\'s up, ' ~ $name ~ '?';
say "What's up, $name?";
say "What's up, ", $name, "?";

var foo = 1;    // Lexically scoped with functions and modules
let foo = 1;    // Lexically scoped with blocks
const foo = 1;  // Lexically scoped with blocks; constant

global.foo = 1; // Dynamically scoped; global
foo = 1;        // Ditto, but implicit; forbidden in strict mode

my $foo = 1;      # Lexically scoped with blocks
our $foo = 1;     # Lexically scoped with blocks and modules
constant foo = 1; # Lexically scoped with blocks and modules; constant

my $*foo = 1;       # Dynamically scoped with blocks
OUR::<$foo> = 1;    # Dynamically scoped with blocks and modules
GLOBAL::<$foo> = 1; # Dynamically scoped; global

let foo = 1;
function logDupe() {
    let foo = 2;
    console.log(foo);
}

logDupe(2);       // 2
console.log(foo); // 1

my $foo = 1;
sub log-dupe {
    my $foo = 2;
    say $foo;
}

log-dupe; # 2
say $foo; # 1

my IO::Socket::INET $server .= new:
    :localhost<localhost>,
    :localport<8000>,
    :listen;

my IO::Socket::INET $client .= new: :host<localhost>, :port<8000>;
$client.print: 'Hello, world!';

my IO::Socket::INET $conn = $server.accept;
my Str $msg               = $conn.recv;
say $msg; # OUTPUT: Hello, world!
$conn.print($msg);

say $client.recv; # OUTPUT: Hello, world!
$conn.close;
$client.close;
$server.close;

my $supply = IO::Socket::Async.listen('localhost', 8000);
my $server = $supply.tap(-> $conn {
    $conn.Supply.tap(-> $data {
        say $data; # OUTPUT: Hello, world!
        await $conn.print: $data;
        $conn.close;
    })
});

my $client = await IO::Socket::Async.connect('localhost', 8000);
$client.Supply.tap(-> $data {
    say $data; # OUTPUT: Hello, world!
    $client.close;
    $server.close;
});

await $client.print: 'Hello, world!';

const net = require('net');

const server = net.createServer(conn => {
    conn.setEncoding('utf8');
    conn.on('data', data => {
        console.log(data); # OUTPUT: Hello, world!
        conn.write(data);
        conn.end();
    });
}).listen(8000, 'localhost');

const client = net.createConnection(8000, 'localhost', () => {
    client.setEncoding('utf8');
    client.on('data', data => {
        console.log(data); # OUTPUT: Hello, world!
        client.end();
        server.close();
    });
    client.write("Hello, world!");
});

foo +     # 在 Ruby  中结尾的运算符意味着解析会继续
  bar +
  baz

if 5 < $x < 10 {
    say "Yep!";
    $x = 17     # 在闭合花括号 } 之前不需要分号 ;
}               # 因为换行, 在闭合花括号 } 之后不需要分号 ;
say "Done!";    # 如果后面什么也没有, 那么这儿的分号也不需要

# 不符合习惯但是在 Ruby 中是合法的
puts"Hello "+
(people [ i]
    . name
    ) . upcase+"!"if$greeted[i]<1

foo (3, 4, 1); # 在 Ruby 或 Raku 中都不正确 ( 在 Raku 中这会
               # 尝试为 foo 传递一个 List 类型的单个参数)
foo(3, 4, 1);  # Ruby 和 Raku 中都可以
foo 3, 4, 1;   # Ruby 和 Raku 中都可以 - 圆括号是可供选择的-less style

if(a < 0); ...; end         # OK in Ruby
if ($a < 0) { ... }         # Raku
if $a < 0   { ... }         # Raku, 更地道

while(x > 5); ...; end      # OK in Ruby
while ($x > 5) { ... }      # Raku
while $x > 5   { ... }      # Raku, 更地道

seen [ :fish ] = 1    # Ruby, 不地道, 但是允许这样写
%seen< fish > = 1;    # Raku, 'seen' 后面不允许出现空格

n<1     # Ruby (in Raku this would conflict with postcircumfix < >)
$n < 1; # Raku

person.name    # Ruby
$person.name   # Raku

object.send(methodname, args);  # Ruby
$object."$methodname"(@args);   # Raku

say "match!" if $foo ~~ /bar/;      # Regex match
say "match!" if $foo ~~ "bar";      # String match
say "match!" if $foo ~~ :(Int, Str) # Signature match (destructure)

# Infix ops (two arguments; one on each side of the op)
+&  +|  +^  And Or Xor: Numeric
~&  ~|  ~^  And Or Xor: String
?&  ?|  ?^  And Or Xor: Boolean

# Prefix ops (one argument, after the op)
+^  Not: Numeric
~^  Not: String
?^  Not: Boolean (same as the ! op)

puts 42 << 3  # Ruby
say  42 +< 3; # Raku

hash = { "AAA" => 1, "BBB" => 2 }  # Ruby, though symbol keys are more common
my %hash = ( AAA => 1, BBB => 2 ); # Raku, uses ()'s though {} usually work

result     = (  score > 60 )  ? 'Pass'  : 'Fail'; # Ruby
my $result = ( $score > 60 ) ?? 'Pass' !! 'Fail'; # Raku

$food = 'grape' + 'fruit'  # Ruby
$food = 'grape' ~ 'fruit'; # Raku

# Ruby
name = "Bob"
puts "Hello! My name is #{name}!"

# Raku
my $name = "Bob"
say "Hello! My name is $name!"

next if line   =~ /static/   # Ruby
next if $line  ~~ /static/;  # Raku

next if line  !~  /dynamic/ ; # Ruby
next if $line !~~ /dynamic/ ; # Raku

next if line.match(/static/)    # Ruby
next if $line.match(/static/);  # Raku

fixed = line.sub(/foo/, 'bar')        # Ruby, non-mutating
my $fixed = $line.subst(/foo/, 'bar') # Raku, non-mutating

line.sub!(/foo/, 'bar')   # Ruby, mutating
$line ~~ s/foo/bar/;      # Raku, mutating

next if $line =~    /static/i # Ruby
next if $line ~~ m:i/static/; # Raku

/this is a test/ # Ruby, boring string
/this.*/         # Ruby, possibly interesting string

/ this " " is " " a " " test / # Raku, each space is quoted
/ "this is a test" / # Raku, quoting the whole string
/ this .* /          # Raku, possibly interesting string

lines = File.readlines("file")   # Ruby
my @lines = "file".IO.lines;     # Raku, create an IO object from a string

# Ruby
File.foreach("file") do |line|
    puts line
end

# Raku
for "file".IO.lines -> $line {
    say $line
}

# Ruby
class Foo
    def greet(name)
        puts "Hi #{name}!"
    end
end

# Raku
class Foo {
    method greet($name) {
        say "Hi $name!"
    }
}

# Ruby
class Person
    attr_accessor :age    # Declare .age as an accessor method for @age
    def initialize
        @name = 'default' # Assign default value to private instance var
    end
end

# Raku
class Person {
    has $.age;              # Declare $!age and accessor methods
    has $!name = 'default'; # Assign default value to private instance var
}

# Ruby
class Person
    attr_accessor :name, :age
    def initialize(attrs)
        @name = attrs[:name] || 'Jill'
        @age  = attrs[:age] || 42
        @birth_year = Time.now.year - @age
    end
end
p = Person.new( name: 'Jack', age: 23 )

# Raku
class Person
    has $.name = 'Jill';
    has $.age  = 42;
    has $!birth_year;
    method BUILD {
        $!birth_year = now.Date.year - $.age;
    }
}
p = Person.new( name => 'Jack', age => 23 )

# Ruby
class Foo
    def visible
        puts "I can be seen!"
        hidden
    end

    private
    def hidden
        puts "I cannot easily be called!"
    end
end

# Raku
class Foo {
    method visible {
        say "I can be seen!"
        self!hidden
    }

    method !hidden {
        say "I cannot easily be called!"
    }
}

person = Person.new       # Ruby, create a new person
my $person = Person.new   # Raku, create a new person

person.class              # Ruby, returns Person (class)
$person.WHAT              # Raku, returns Person (class)

person.methods            # Ruby
$person.^methods          # Raku, using .^ syntax to access meta-methods

person.instance_variables # Ruby
$person.^attributes       # Raku

5.send(:+, 3)    # => 8, Ruby
&link:5, 3[+]       # => 8, Raku, reference to infix addition operator

&[+].^candidates # Raku, lists all signatures for the + operator

$ RUBYLIB="/some/module/lib" ruby program.rb

$ PERL6LIB="/some/module/lib" raku program.p6

# Ruby and Raku
use lib '/some/module/lib';

unit module Bar; # remainder of the file is in module Bar { ... }

sub foo($a) is export { say "foo $a" }
sub bar($b) is export { say "bar $b" }
sub baz($z) { say "baz $z" }

use Bar;
foo(1);    #=> "foo 1"
bar(2);    #=> "bar 2"

use Bar <foo>; # Import only foo
foo(1);        #=> "foo 1"
bar(2);        # Error!

plusTwo :: Integer -> Integer   -- Types
plusTwo x = x + 2               -- Values

plusTwo 2          -- This is valid
plusTwo Integer    -- This is not valid

sub plus-two(Int $x --> Int) { $x + 2 }

plus-two(2);   # This is valid
plus-two(Int); # This is valid

multi sub is-string(Str $ --> True)  {}
multi sub is-string(Any $ --> False) {}

is-string('hello');    #True
is-string(4);          #False

parseInt :: String -> Maybe Integer

case parseInt myString of
  Just x  -> x
  Nothing -> 0

my @foo = 1,2,3,4,5;   # no parentheses needed
.say for 1,2,3,4,5;    # also no parentheses

my $scalar = (1);      # *not* a list, as there is no comma
my $list   = (1,);     # a List in a scalar container

(1..^5).list;  # (1 2 3 4)
(1^..5).list;  # (2 3 4 5)
(1^..^5).list; # (2 3 4)
(^5).list;     # (0 1 2 3 4)

$x = $ok  ? $yes  : $no;  # Perl 5
$x = $ok ?? $yes !! $no;  # Raku

class LongClassName {
    has $.frobnicate;
}
my LongClassName $bar .= new( frobnicate => 42 ); # no need to repeat class name

my @a = <1 2 3>;
say qq/@a[] example@example.com/;

my %a = 1 => 2, 3 => 4;
say "%a{}";

my $a = 42;
say qqw/$a b c/;

$x.trans(
    ['a'..'c'] => ['A'..'C'],
    ['d'..'q'] => ['D'..'Q'],
    ['r'..'z'] => ['R'..'Z']
    );

for 'huge-csv'.IO.lines -> $line {
    # Do something with $line
}

my $x = "filename".IO.slurp;
=== ... or ...
my $fh = open "filename", :r;
my $x = $fh.slurp;

print "Hello, world!"

print("Hello, world!")

put "Hello, world!"

my $hello = "Hello, world!";
say $hello;  # also prints "Hello, world!"
             # same as: put $hello.gist

my $planet = 'earth';
say "Hello, $planet";   # Hello, earth
say 'Hello, $planet';   # Hello, $planet
say "Hello, planet number { 1 + 2 }"; # Hello, planet number 3

print 1 + 2 + \
    3 + 4
print ( 1 +
    2 )

say 1 + 2 +
    3 + 4;
say 1 +
    2;

if 1 == 2:
    print "Wait, what?"
else:
    print "1 is not 2."

if 1 == 2 {
    say "Wait, what?"
} else {
    say "1 is not 2."
}

foo = 12
bar = 19

my $foo;       # declare
$foo = 12;     # initialize
my $bar = 19;  # both at once

s = 10
l = [1, 2, 3]
d = { a : 12, b : 99 }

print s
print l[2]
print d['a']
# 10, 2, 12

my $s = 10;
my @l = 1, 2, 3;
my %d = a => 12, b => 99;
my \x = 99;

say $s;
say @l[1];
say %d<a>;  # or %d{'a'}
say x;
# 10, 2, 12, 99

if True:
    x = 10
print x
# x is now 10

if True {
    my $x = 10
}
say $x
# error, $x is not declared in this scope

my $x;
if True {
    $x = 10
}
say $x
# ok, $x is 10

x = 10
for x in 1, 2, 3:
   pass
print x
# x is 3

my \x = 10;
for 1, 2, 3 -> \x {
    # do nothing
    }
say x;
# x is 10

l = lambda i: i + 12

my $l = -> $i { $i + 12 }

my $l = * + 12    # same as above

squares = []
for x in range(5):
    squares.append(lambda: x ** 2)
print squareslink:[2]
print squareslink:[4]
# both 16 since there is only one x

my \squares = [];
for ^5 -> \x {
    squares.append({ x² });
}
say squareslink:[2];
say squareslink:[4];
# 4, 16 since each loop iteration has a lexically scoped x,

for i in 1, 2:
    print i
j = 1
while j < 3:
    print j
    j += 1

# 1,2,1,2

for 1, 2 -> $i {
    say $i
}
my $j = 1;
while $j < 3 {
    say $j;
    $j += 1
}

for i in range(10):
    if i == 3:
        continue
    if i == 5:
        break
    print i

for ^10 -> $i {
    next if $i == 3;
    last if $i == 5;
    say $i;
}

def count():
    for i in 1, 2, 3:
        yield i

for c in count():
    print c

sub count {
    gather {
        for 1, 2, 3 -> $i {
            take $i
        }
    }
}

for count() -> $c {
    say $c;
}

def add(a, b):
    return a + b

sub add(\a, \b) {
    return a + b
}

sub add(\a, \b) {
    a + b
}

# using variables with sigils
sub add($a, $b) {
    $a + $b
}

def speak(word, times):
    for i in range(times):
        print word
speak('hi', 2)
speak(word='hi', times=2)

sub speak($word, $times) {
  say $word for ^$times
}
speak('hi', 2);

sub speak(:$word, :$times) {
  say $word for ^$times
}
speak(word => 'hi', times => 2);
speak(:word<hi>, :times<2>);      # Alternative, more idiomatic

multi sub speak($word, $times) {
  say $word for ^$times
}
multi sub speak(:$word, :$times) {
    speak($word, $times);
}
speak('hi', 2);
speak(:word<hi>, :times<2>);

sub hello {...};
# all the same
hello(name => 'world'); # fat arrow syntax
hello(:name('world'));  # pair constructor
hello :name<world>;     # <> quotes words and makes a list
my $name = 'world';
hello(:$name);          # lexical var with the same name

square = lambda x: x ** 2

my $square = sub ($x) { $x ** 2 };  # anonymous sub
my $square = -> $x { $x ** 2 };     # pointy block
my $square = { $^x ** 2 };          # placeholder variable
my $square = { $_ ** 2 };           # topic variable

my $power = { $^x ** $^y };
my $power = -> $x, $y { $x ** $y };

print [ i * 2 for i in 3, 9 ]                      # OUTPUT: «[6, 18]␤»

say ( $_ * 2 for 3, 9 );                           # OUTPUT: «(6 18)␤»
say ( { $^i * 2 } for 3, 9 );                      # OUTPUT: «(6 18)␤»
say ( -> \i { i * 2 } for 3, 9 );                  # OUTPUT: «(6 18)␤»

print [ x * 2 for x in 1, 2, 3 if x > 1 ]          # OUTPUT: «[4, 6]␤»

say ( $_ * 2 if $_ > 1 for 1, 2, 3 );              # OUTPUT: «(4 6)␤»

print [ i + j for i in 3,9 for j in 2,10 ]         # OUTPUT: «[5, 13, 11, 19]␤»

say ( { $_[0] + $_[1] } for (3,9) X (2,10) );      # OUTPUT: «(5 13 11 19)␤»
say ( -> (\i, \j) { i + j } for (3,9) X (2,10) );  # OUTPUT: «(5 13 11 19)␤»

class Dog:
    def __init__(self, name):
        self.name = name

class Dog {
    has $.name;
}

d = Dog('Fido')
e = Dog('Buddy')
print d.name
print e.name

my $d = Dog.new(:name<Fido>); # or: Dog.new(name => 'Fido')
my $e = Dog.new(:name<Buddy>);
say $d.name;
say $e.name;

class Dog:
    kind = 'canine'                # class attribute
    def __init__(self, name):
        self.name = name           # instance attribute
d = Dog('Fido')
e = Dog('Buddy')
print d.kind
print e.kind
print d.name
print e.name

class Dog {
    my $kind = 'canine';           # class attribute
    method kind { $kind }
    has $.name;                    # instance attribute
}

my $d = Dog.new(:name<Fido>);
my $e = Dog.new(:name<Buddy>);
say $d.kind;
say $e.kind;
say $d.name;
say $e.name;

class Dog:
    def __init__(self, name):
        self.name = name
d = Dog()
d.name = 'rover'

class Dog {
    has $.name is rw;
}
my $d = Dog.new;
$d.name = 'rover';

class Animal:
    def jump(self):
        print ("I am jumping")

class Dog(Animal):
    pass

d = Dog()
d.jump()

class Animal {
    method jump {
        say "I am jumping"
    }
}

class Dog is Animal {
}

my $d = Dog.new;
$d.jump;

class Dog(Animal, Friend, Pet):
    pass

class Animal {}; class Friend {}; class Pet {};
...;
class Dog is Animal is Friend is Pet {};

class Animal {}; class Friend {}; class Pet {};
...;
class Dog is Animal {
    also is Friend;
    also is Pet;
    ...
}

def greeter(f):
    def new():
        print 'hello'
        f()
    return new

@greeter
def world():
    print 'world'

world();

sub world {
    say 'world'
}

&world.wrap(sub () {
    say 'hello';
    callsame;
});

world;

# declare the trait 'greeter'
multi sub trait_mod:<is>(Routine $r, :$greeter) {
    $r.wrap(sub {
        say 'hello';
        callsame;
    })
}

sub world is greeter {
    say 'world';
}

world;

class hello:
    def __exit__(self, type, value, traceback):
        print 'bye'
    def __enter__(self):
        print 'hello'

with hello():
    print 'world'

sub hello(Block $b) {
    say 'hello';
    $b();
    say 'bye';
}

hello {
    say 'world';
}

{
    LEAVE say 'bye';
    ENTER say 'hello';
    say 'world';
}

user_input = input("Say hi → ")
print(user_input)

my $user_input = prompt("Say hi → ");
say $user_input; # OUTPUT: whatever you entered.

sub test-doesn't-hang { ... }
my $ความสงบ = 42;
my \Δ = 72; say 72 - Δ;

$person->name  # Perl 5

$person.name   # Raku

$object->$methodname(@args);  # Perl 5

$object."$methodname"(@args); # Raku

my $sub = \&foo; # Perl 5

my $sub = &foo;  # Raku

callback => sub { say @_ }  # Perl 5 - can't pass built-in sub directly

callback => &say            # Raku - & gives "noun" form of any sub

# Perl 5:
first_index { $_ > 5 } @values;
&first_index($coderef, @values); # (disabling the prototype that parses a
                                     # literal block as the first argument)

# Raku:
first { $_ > 5 }, @values, :k;   # the :k makes first return an index
first $coderef, @values, :k;

sub foo { say "before"; &bar;     say "after" } # Perl 5

sub foo { say "before"; bar(|@_); say "after" } # Raku - have to be explicit

sub foo { say "before"; goto &bar } # Perl 5

proto foo (|) {*};
multi foo ( Any $n ) {
    say "Any"; say $n;
};
multi foo ( Int $n ) {
    say "Int"; callsame;
};
foo(3); # /language/functions#index-entry-dispatch_callsame

# Perl 5 - ancient method
sub read_2 {
    local (*H) = @_;
    return scalar(<H>), scalar(<H>);
}
open FILE, '<', $path or die;
my ($line1, $line2) = read_2(*FILE);

# Perl 5 - modern use of lexical filehandles
sub read_2 {
    my ($fh) = @_;
    return scalar(<$fh>), scalar(<$fh>);
}
open my $in_file, '<', $path or die;
my ($line1, $line2) = read_2($in_file);

# Raku
sub read-n($fh, $n) {
    return $fh.get xx $n;
}
my $in-file = open $path or die;
my ($line1, $line2) = read-n($in-file, 2);

# Infix ops (two arguments; one on each side of the op)
+&  +|  +^  And Or Xor: Numeric
~&  ~|  ~^  And Or Xor: String
?&  ?|  ?^  And Or Xor: Boolean

# Prefix ops (one argument, after the op)
+^  Not: Numeric
~^  Not: String
?^  Not: Boolean (same as the ! op)

say 42 << 3; # Perl 5

say 42 +< 3; # Raku

sub get_the_loot { ... }; # Raku stub
# Works in Perl 5 and Raku
my %hash = ( AAA => 1, BBB => 2 );
get_the_loot( 'diamonds', { quiet_level => 'very', quantity => 9 }); # Note the curly braces

# Perl 5
sub get_the_loot {
    my $loot = shift;
    my %options = @_;
    # ...
}
# Note: no curly braces in this sub call
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 );

# Raku, original API
sub get_the_loot( $loot, *%options ) { # The * means to slurp everything
    ...
}
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 ); # Note: no curly braces in this API

# Raku, API changed to specify valid options
# The colon before the sigils means to expect a named variable,
# with the key having the same name as the variable.
sub get_the_loot( $loot, :$quiet_level?, :$quantity = 1 ) {
    # This version will check for unexpected arguments!
    ...
}
get_the_loot( 'diamonds', quietlevel => 'very' ); # Throws error for misspelled parameter name

my $result = $score > 60 ?  'Pass' :  'Fail'; # Perl 5

my $result = $score > 60 ?? 'Pass' !! 'Fail'; # Raku

$food = 'grape' . 'fruit'; # Perl 5

$food = 'grape' ~ 'fruit'; # Raku

# Perl 5
    print '-' x 80;             # Print row of dashes
    @ones = (1) x 80;           # A list of 80 1's
    @ones = (5) x @ones;        # Set all elements to 5

# Raku
    print '-' x 80;             # Unchanged
    @ones = 1 xx 80;            # Parentheses no longer needed
    @ones = 5 xx @ones;         # Parentheses no longer needed

while (my $x = dostuff()) {...}  # Perl 5

while dostuff() -> $x {...}      # Raku

while (<IN_FH>)  { } # Perl 5

for $IN_FH.lines { } # Raku

# Perl 5
do {
    ...
} while $x < 10;

do {
    ...
} until $x >= 10;

# Raku
repeat {
    ...
} while $x < 10;

repeat {
    ...
} until $x >= 10;

for  ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 5

loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Raku

for my $car (@cars)  {...} # Perl 5; read-write

for @cars  -> $car   {...} # Raku; read-only
for @cars <-> $car   {...} # Raku; read-write

for (@cars)      {...} # Perl 5; $_ is read-write

for @cars        {...} # Raku; $_ is read-write
for @cars <-> $_ {...} # Raku; $_ is also read-write

my @array = 1..10;
for @array -> $first, $second {
    say "First is $first, second is $second";
}

while (my ($i, $v) = each(@array)) { ... } # Perl 5

for @array.kv -> $i, $v { ... } # Raku

while (my ($k, $v) = each(%hash)) { ... } # Perl 5

for %hash.kv -> $k, $v { ... } # Raku

my @results = grep { $_ eq "bars" } @foo; # Perl 5

my @results = grep { $_ eq "bars" }, @foo; # Raku

my $deleted_value = delete $hash{$key};  # Perl 5

my $deleted_value = %hash{$key}:delete;  # Raku - use :delete adverb

my $deleted_value = delete $array[$i];  # Perl 5

my $deleted_value = @array[$i]:delete;  # Raku - use :delete adverb

say "element exists" if exists $hash{$key};  # Perl 5

say "element exists" if %hash{$key}:exists;  # Raku - use :exists adverb

say "element exists" if exists $array[$i];  # Perl 5

say "element exists" if @array[$i]:exists;  # Raku - use :exists adverb

next if $line  =~ /static/  ; # Perl 5

next if $line  ~~ /static/  ; # Raku

next if $line  !~ /dynamic/ ; # Perl 5

next if $line !~~ /dynamic/ ; # Raku

$line =~ s/abc/123/;          # Perl 5

$line ~~ s/abc/123/;          # Raku

/(.+)/ and print $1; # Perl 5

/(.+)/ and print $0; # Raku

next if $line =~    /static/i ; # Perl 5

next if $line ~~ m:i/static/  ; # Raku

next if $line =~    m/[aeiou]/   ; # Perl 5

next if $line ~~ m:P5/[aeiou]/   ; # Raku, using P5 modifier
next if $line ~~ m/  <[aeiou]> / ; # Raku, native new syntax

use v5.22;
"þor is mighty" =~ /is (?<iswhat>\w+)/n;
say $+{iswhat};

"þor is mighty" ~~ /is \s+ $<iswhat>=(\w+)/;
say $<iswhat>;

/ word #`(match lexical "word") /

my $foo;             # Perl 5
BEGIN { $foo = 42 }

BEGIN my $foo = 42;  # Raku

# Perl 5
open my $i_fh, '<', $input_path;  # Fails silently on error
use autodie;
open my $o_fh, '>', $output_path; # Throws exception on error

# Raku
my $i_fh = open $input_path,  :r; # Returns Failure on error
my $o_fh = open $output_path, :w; # Returns Failure on error

# Raku
if open($input_path,:r) -> $handle {
    .say for $handle.lines;
}
else {
    # gracefully handle the fact that the open() failed
}

# Perl 5
package Cat;
use base qw(Animal);

# Raku
class Cat is Animal {}

use constant DEBUG => 0; # Perl 5

constant DEBUG = 0;      # Raku

use constant pi => 4 * atan2(1, 1); # Perl 5

tau, pi, e, i; # built-in constants in Raku
τ, π, 𝑒        # and their unicode equivalents

my int $foo = 42;
my int $bar = 666;
say $foo * $bar;    # uses native integer multiplication

say Animal.^mro;    # .^ indicates calling a meta-method on the object

open my $fh, "<", "file" or die "$!";
my @lines = <$fh>;                # lines are NOT chomped
close $fh;

my @lines = "file".IO.lines;  # auto-chomped

# initialize the file to read
spurt "test-file", q:to/END/;
first line
second line
third line
END
# read the file
my @lines = "test-file".IO.slurp.split(/\n/);
say @lines.elems;    #-> 4

my @lines = "test-file".IO.slurp.lines;  # also auto-chomps

my $fh = open('./bad/path/to/file', :w) or die $fh;

my $fh = open('./bad/path/to/file', :w) orelse .die;

my $fh = open('./bad/path/to/file', :w).self;

my $arg = 'Hello';
my $captured = `echo \Q$arg\E`;
my $captured = qx(echo \Q$arg\E);

my $arg = shell_quote 'Hello';
my $captured = `echo $arg`;
my $captured = qx(echo $arg);

my $arg = 'Hello';
my $captured = run('echo', $arg, :out).out.slurp;
my $captured = run(«echo "$arg"», :out).out.slurp;

my $arg = 'Hello';
my $captured = shell("echo $arg", :out).out.slurp;
my $captured = qqx{echo $arg};

$ PERL5LIB="/some/module/lib" perl program.pl

$ PERL6LIB="/some/module/lib" raku program.p6

$ export PERL5LIB=/module/dir1:/module/dir2;

$ export PERL6LIB=/module/dir1,/module/dir2;

use lib '/some/module/lib'

... if defined $x and length $x; # or just length() in modern perls

... if $x;

use ModuleName qw{foo bar baz};

unit module Bar;

sub foo($a) is export { say "foo $a" }
sub bar($b) is export { say "bar $b" }
sub baz($z) { say "baz $z" }

use Bar;
foo(1);    #=> "foo 1"
bar(2);    #=> "bar 2"

sub EXPORT(*@import-list) {
    my %exportable-subs =
        '&foo' => &foo,
        '&bar' => &bar,
        ;
    my %subs-to-export;
    for @import-list -> $import {
        if grep $sub-name, %exportable-subs.keys {
            %subs-to-export{$sub-name} = %exportable-subs{$sub-name};
        }
    }
    return %subs-to-export;
}

sub foo($a, $b, $c) { say "foo, $a, $b, $c" }
sub bar($a) { say "bar, $a" }
sub baz($z) { say "baz, $z" }

use Bar <foo>;
foo(1);       #=> "foo 1"

use Bar <foo>;
foo(1);
bar(5);       #!> "Undeclared routine: bar used at line 3"

use Bar <foo bar>;
foo(1);       #=> "foo 1"
bar(5);       #=> "bar 5"

use Bar <foo bar baz>;
baz(3);       #!> "Undeclared routine: baz used at line 2"

unit module Bar;
sub foo() is export { }                   # added by default to :DEFAULT
sub bar() is export(:FNORBL) { }          # added to the FNORBL export group
sub baz() is export(:DEFAULT:FNORBL) { }  # added to both

use Bar;                     # imports foo / baz
use Bar :FNORBL;             # imports bar / baz
use Bar :ALL;                # imports foo / bar / baz

# Given:
    my @array_of_hashes = (
        { NAME => 'apple',   type => 'fruit' },
        { NAME => 'cabbage', type => 'no, please no' },
    );
# Perl 5
    use Data::Dumper;
    $Data::Dumper::Useqq = 1;
    print Dumper \@array_of_hashes; # Note the backslash.

# Raku
say @array_of_hashes.perl; # .perl on the array, not on its reference.

# Given:
    my ( $foo, $bar ) = ( 42, 44 );
    my @baz = ( 16, 32, 64, 'Hike!' );
# Perl 5
    use Data::Dumper;
    print Data::Dumper->Dump(
        [     $foo, $bar, \@baz   ],
        [ qw(  foo   bar   *baz ) ],
    );
# Output
#    $foo = 42;
#    $bar = 44;
#    @baz = (
#             16,
#             32,
#             64,
#             'Hike!'
#           );

# Raku
say [ :$foo, :$bar, :@baz ].perl;
# OUTPUT: «["foo" => 42, "bar" => 44, "baz" => [16, 32, 64, "Hike!"]]»

# Raku
dd $foo, $bar, @baz;
# OUTPUT: «Int $foo = 42
# Int $bar = 44
# Array @baz = [16, 32, 64, "Hike!"]
# »

# Perl 5
    use 5.010;
    use Getopt::Long;
    GetOptions(
        'length=i' => \( my $length = 24       ), # numeric
        'file=s'   => \( my $data = 'file.dat' ), # string
        'verbose'  => \( my $verbose           ), # flag
    ) or die;
    say $length;
    say $data;
    say 'Verbosity ', ($verbose ? 'on' : 'off') if defined $verbose;
perl example.pl
    24
    file.dat
perl example.pl --file=foo --length=42 --verbose
    42
    foo
    Verbosity on

perl example.pl --length=abc
    Value "abc" invalid for option length (number expected)
    Died at c.pl line 3.

# Raku
    sub MAIN( Int :$length = 24, :file($data) = 'file.dat', Bool :$verbose ) {
        say $length if $length.defined;
        say $data   if $data.defined;
        say 'Verbosity ', ($verbose ?? 'on' !! 'off');
    }

raku example.p6
    24
    file.dat
    Verbosity off
raku example.p6 --file=foo --length=42 --verbose
    42
    foo
    Verbosity on
raku example.p6 --length=abc
    Usage:
      c.p6 [--length=<Int>] [--file=<Any>] [--verbose]

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

# Perl 5
my $str = '';
for (1..5) {
    next if $_ % 2 == 1;
    $str .= $_;
}
continue {
    $str .= ':'
}

# Raku
my $str = '';
for 1..5 {
    next if $_ % 2 == 1;
    $str ~= $_;
    NEXT {
        $str ~= ':'
    }
}

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    default { ... }
}

FOO:                         # Labels end with colons, like in Perl 5
for ^10 {
    say "outer for before";
    for ^10 {
        say "inner for";
        last FOO;
    }
    say "outer for after";   # Will not show because of the "last"
}
=== outer for before
=== inner for

my $p1 = Promise.new;
say $p1.status;       # OUTPUT: «Planned␤»
$p1.keep('Result');
say $p1.status;       # OUTPUT: «Kept␤»
say $p1.result;       # OUTPUT: «Result␤»
                      # (since it has been kept, a result is available!)

my $p2 = Promise.new;
$p2.break('oh no');
say $p2.status;       # Broken
say $p2.result;       # dies, because the promise has been broken

CATCH { default { say .^name, ': ', .Str } };
# OUTPUT: «X::AdHoc+{X::Promise::Broken}: oh no␤»

my $promise1 = Promise.new();
my $promise2 = $promise1.then(
    -> $v { say $v.result; "Second Result"}
);
$promise1.keep("First Result");
say $promise2.result;   # First Result \n Second Result

my $promise1 = Promise.new();
my $promise2 = $promise1.then(-> $v { say "Handled but : "; say $v.result});
$promise1.break("First Result");
try $promise2.result;
say $promise2.cause;        # Handled but : \n First Result

my $promise1 = Promise.in(5);
my $promise2 = $promise1.then(-> $v { say $v.status; 'Second Result' });
say $promise2.result; # 5 秒后打印出: Kept\n Second Result

my $promise = Promise.start(
    { my $i = 0; for 1 .. 10 { $i += $_ }; $i}
);
say $promise.status;    # Kept
say $promise.result;    # 55

my $promise = Promise.start({ die "Broken Promise" });
try $promise.result; # Nil
say $promise.cause;  # Broken Promise
                     #  in block <unit> at <unknown file> line 1

my $promise = start {
    my $i = 0;
    for 1 .. 10 {
        $i += $_
    }
    $i
}
my $result = await $promise;
say $result;

my $p1 = start {
    my $i = 0;
    for 1 .. 10 {
        $i += $_
    }
    $i
};
my $p2 = start {
    my $i = 0;
    for 1 .. 10 {
        $i -= $_
    }
    $i
};
my @result = await $p1, $p2;
say @result;            # [55 -55]

my $promise = Promise.allof(
    Promise.in(2),
    Promise.in(3)
);

await $promise;
say "All done"; # Should be not much more than three seconds later

my $promise = Promise.anyof(
    Promise.in(3),
    Promise.in(8600)
);

await $promise;
say "All done"; # Should be about 3 seconds later

my @promises;
for 1..5 -> $t {
    push @promises, start {
        sleep $t;
        Bool.pick;
    };
}
say await Promise.allof(@promises).then({ so all(@promises>>.result) });

sub get_promise {
    my $promise = Promise.new;
    my $vow = $promise.vow;
    Promise.in(10).then({$vow.keep});
    $promise;
}

my $promise = get_promise();

# Will throw an exception
# "Access denied to keep/break this Promise; already vowed"
$promise.keep;

my $supplier = Supplier.new;
my $supply   = $supplier.Supply;

$supply.tap( -> $v { say $v });

for 1 .. 10 {
    $supplier.emit($_); # 1\n2\n3\n4\n5\n6\n7\n8\n9\n10
}

my $supply = supply {
    for 1 .. 10 {
        emit($_);
    }
}
$supply.tap( -> $v { say $v });
# 1\n2\n3\n4\n5\n6\n7\n8\n9\n10

my $supply = supply {
    for 1 .. 10 {
        emit($_);
    }
}
$supply.tap( -> $v { say "First : $v" });
$supply.tap( -> $v { say "Second : $v" });

my $supplier = Supplier.new;
my $supply   = $supplier.Supply;

my $tap = $supply.tap( -> $v { say $v });

$supplier.emit("OK");
$tap.close;
$supplier.emit("Won't trigger the tap");

my $supply = Supply.interval(2);
$supply.tap(-> $v { say $v });
sleep 10;

react {
    whenever Supply.interval(2) -> $v {
        say $v;
        done() if $v == 4;
    }
}

my $supply = Supply.interval(2);
$supply.tap(-> $v { say "First $v" });
sleep 6;
$supply.tap(-> $v { say "Second $v"});
sleep 10;

react {
    whenever Supply.from-list(1..10) -> $v {
        say $v;
    }
}

my $supplier = Supplier.new;
my $supply = $supplier.Supply;
$supply.tap(-> $v { say "Original : $v" });
my $odd_supply = $supply.grep({ $_ % 2 });
$odd_supply.tap(-> $v { say "Odd : $v" });
my $even_supply = $supply.grep({ not $_ % 2 });
$even_supply.tap(-> $v { say "Even : $v" });
for 0 .. 10 {
    $supplier.emit($_);
}

my $supplier = Supplier.new;
my $supply = $supplier.Supply;
$supply.tap(-> $v { say "Original : $v" });
my $half_supply = $supply.map({ $_ / 2 });
$half_supply.tap(-> $v { say "Half : $v" });
for 0 .. 10 {
    $supplier.emit($_);
}

$supply.tap: { ... },
    done => { say 'Job is done.' },
    quit => {
        when X::MyApp::Error { say "App Error: ", $_.message }
    };

react {
    whenever $supply {
        ...; # your usual supply tap code here
        LAST { say 'Job is done.' }
        QUIT { when X::MyApp::Error { say "App Error: ", $_.message } }
    }
}

my $channel = Channel.new;
$channel.send('Channel One');
say $channel.receive;  # 'Channel One'

my $channel = Channel.new;
await (^10).map: -> $r {
    start {
        sleep $r;
        $channel.send($r);
    }
}
$channel.close;
for $channel.list -> $r {
    say $r;
}

my $c = Channel.new;

# Start three Promises that sleep for 1..3 seconds, and then
# send a value to our Channel
^3 .map: -> $v {
    start {
        sleep 3 - $v;
        $c.send: "$v from thread {$*THREAD.id}";
    }
}

# Wait 3 seconds before closing the channel
Promise.in(3).then: { $c.close }

# Continuously loop and poll the channel, until it's closed
my $is-closed = $c.closed;
loop {
    if $c.poll -> $item {
        say "$item received after {now - INIT now} seconds";
    }
    elsif $is-closed {
        last;
    }

    say 'Doing some unrelated things...';
    sleep .6;
}

# Doing some unrelated things...
# Doing some unrelated things...
# 2 from thread 5 received after 1.2063182 seconds
# Doing some unrelated things...
# Doing some unrelated things...
# 1 from thread 4 received after 2.41117376 seconds
# Doing some unrelated things...
# 0 from thread 3 received after 3.01364461 seconds
# Doing some unrelated things...

sub get-value {
    return $c.poll // do { start replenish-cache; $c.receive };
}

sub replenish-cache {
    for ^20 {
        $c.send: $_ for slowly-fetch-a-thing();
    }
}

my $channel = Channel.new;
my $p = start {
    react {
        whenever $channel {
            say $_;
        }
    }
}

await (^10).map: -> $r {
    start {
        sleep $r;
        $channel.send($r);
    }
}

$channel.close;
await $p;

my $supplier = Supplier.new;
my $supply   = $supplier.Supply;
my $channel = $supply.Channel;

my $p = start {
    react  {
        whenever $channel -> $item {
            say "via Channel: $item";
        }
    }
}

await (^10).map: -> $r {
    start {
        sleep $r;
        $supplier.emit($r);
    }
}

$supplier.done;
await $p;

my $proc = Proc::Async.new('echo', 'foo', 'bar');

$proc.stdout.tap(-> $v { print "Output: $v" });
$proc.stderr.tap(-> $v { print "Error:  $v" });

say "Starting...";
my $promise = $proc.start;

await $promise;
say "Done.";

# Output:
# Starting...
# Output: foo bar
# Done.

my $proc = Proc::Async.new(:w, 'grep', 'foo');

$proc.stdout.tap(-> $v { print "Output: $v" });

say "Starting...";
my $promise = $proc.start;

$proc.say("this line has foo");
$proc.say("this one doesn't");

$proc.close-stdin;
await $promise;
say "Done.";

# Output:
# Starting...
# Output: this line has foo
# Done.

my $thread = Thread.new(code => { for  1 .. 10  -> $v { say $v }});
# ...
$thread.run;

my $thread = Thread.start({ for  1 .. 10  -> $v { say $v }});

$thread.finish;

method cue(:&code, Instant :$at, :$in, :$every, :$times = 1; :&catch)

my $i = 0;
my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );
sleep 20;

my $i = 0;
my $cancellation = $*SCHEDULER.cue({ say $i++}, every => 2 );
sleep 10;
$cancellation.cancel;
sleep 10;

my $lock = Lock.new;

my $a = 0;

await (^10).map: {
    start {
            $lock.protect({
                my $r = rand;
                sleep $r;
                $a++;
            });
    }
}

say $a; # 10

grammar My::Gram { ..methods 'n stuff... }

my $matchObject = My::Gram.parse($what-a-big-string-you-have);

grammar My::Gram {
  token TOP { <thingy> .* }
  token thingy { 'clever_text_keyword' }
}

grammar REST {
    token TOP     { '/' <subject> '/' <command> [ '/' <data> ]? }
    token subject { \w+ }
    token command { \w+ }
    token data    { .* }
}

my $m = REST.parse('/product/create');
say $m<subject>, $m<command>;

# OUTPUT: «｢product｣｢create｣␤»

grammar REST {
    token TOP     { <slash><subject><slash><command>[<slash><data>]? }
    token subject { \w+ }
    token command { \w+ }
    token data    { .* }

    token slash   { \s* '/' \s* }
}

my $m = REST.parse('/ product / update /7 /notify');
say $m;

# OUTPUT: «｢/ product / update /7 /notify｣␤
#          slash => ｢/ ｣
#          subject => ｢product｣
#          slash => ｢ / ｣
#          command => ｢update｣
#          slash => ｢ /｣
#          data => ｢7 /notify｣»

token command { \w+ }

# ...becomes...

token command { 'create'|'retrieve'|'update'|'delete' }

proto token command {*}
token command:sym<create>   { <sym> }
token command:sym<retrieve> { <sym> }
token command:sym<update>   { <sym> }
token command:sym<delete>   { <sym> }

grammar REST
{
    token TOP { <slash><subject><slash><command>[<slash><data>]? }

    proto token command {*}
    token command:sym<create>   { <sym> }
    token command:sym<retrieve> { <sym> }
    token command:sym<update>   { <sym> }
    token command:sym<delete>   { <sym> }

    token subject { \w+ }
    token data    { .* }
    token slash   { \s* '/' \s* }
}

my @uris = ['/product/update/7/notify',
            '/product/create',
            '/item/delete/4'];

for @uris -> $uri {
    my $m = REST.parse($uri);
    say "Sub: $m<subject> Cmd: $m<command> Dat: $m<data>";
}

# OUTPUT: «Sub: product Cmd: update Dat: 7/notify␤
#          Sub: product Cmd: create Dat:
#          Sub: item Cmd: delete Dat: 4»

class REST-actions
{
    method data($/) { make $/.split('/') }
}

my $uri = '/product/update/7/notify';

my $match = REST.parse($uri, actions => REST-actions.new);

say $match<data>.made[0];  # OUTPUT: «7␤»
say $match<command>.Str;   # OUTPUT: «update␤»

class REST-actions
{
    method TOP ($/) {
        make { subject => $<subject>.Str,
               command => $<command>.Str,
               data    => $<data>.made }
    }

    method data($/) { make $/.split('/') }
}

my $uri = '/product/update/7/notify';

my $match = REST.parse($uri, actions => REST-actions.new);

my $rest = $match.made;
say $rest<data>[0];   # OUTPUT: «7␤»
say $rest<command>;   # OUTPUT: «update␤»
say $rest<subject>;   # OUTPUT: «product␤»

my $uri = '/product/update/7/notify';

my $rest = REST.parse($uri, actions => REST-actions.new).made;

say $rest<data>[0];   # OUTPUT: «7␤»
say $rest<command>;   # OUTPUT: «update␤»
say $rest<subject>;   # OUTPUT: «product␤»

class REST-actions
{
    method TOP ($/) {
        make { subject    => $<subject>.Str,
               command    => $<command>.Str,
               data       => $<data>.made,
               subject-id => $<data>.made[0] }
    }

    method data($/) { make $/.split('/') }
}

my $uri = '/product/update/7/notify';

my $rest = REST.parse($uri, actions => REST-actions.new).made;

say $rest<command>;    # OUTPUT: «update␤»
say $rest<subject>;    # OUTPUT: «product␤»
say $rest<subject-id>; # OUTPUT: «7␤»

grammar REST
{
    token TOP { <slash><subject><slash><command>[<slash><data>]? }

    proto token command {*}
    token command:sym<create>   { <sym> }
    token command:sym<retrieve> { <sym> }
    token command:sym<update>   { <sym> }
    token command:sym<delete>   { <sym> }

    token subject { \w+ }
    token data    { .* }
    token slash   { \s* '/' \s* }
}


class REST-actions
{
    method TOP ($/) {
        make { subject    => $<subject>.Str,
               command    => $<command>.Str,
               data       => $<data>.made,
               subject-id => $<data>.made[0] }
    }

    method data($/) { make $/.split('/') }
}

grammar G {
  rule TOP { <function-define> }
  rule function-define {
    'sub' <identifier>
    {
      say "func " ~ $<identifier>.made;
      make $<identifier>.made;
    }
    '(' <parameter> ')' '{' '}'
    { say "end " ~ $/.made; }
  }
  token identifier { \w+ { make ~$/; } }
  token parameter { \w+ { say "param " ~ $/; } }
}

G.parse('sub f ( a ) { }');
# OUTPUT: «func f␤param a␤end f␤»

module M {
  sub greeting ($name = 'Camelia') { "Greetings, $name!" }
  our sub loud-greeting (--> Str)  { greeting().uc       }
  sub friendly-greeting is export  { greeting('friend')  }
}

import M;               # import the module
say M::loud-greeting;   # OUTPUT: «GREETINGS, CAMELIA!»
say friendly-greeting;  # OUTPUT: «Greetings, friend!»

module Foo {
  sub greeting ($name = 'Camelia') { "Greetings, $name!" }
  our sub loud-greeting (--> Str)  { greeting().uc       }
  sub friendly-greeting is export  { greeting('friend')  }
}

use Foo;
say Foo::loud-greeting;  # OUTPUT: «GREETINGS, CAMELIA!»
say friendly-greeting;   # OUTPUT: «Greetings, friend!»

sub greeting ($name = 'Camelia') { "Greetings from Bar, $name!" }
our sub loud-greeting (--> Str)  { greeting().uc                }
sub friendly-greeting is export  { greeting('friend')           }

use Foo;
say Foo::loud-greeting;  # OUTPUT: «GREETINGS, CAMELIA!»
say friendly-greeting;   # OUTPUT: «Greetings, friend!»

use Bar;
say loud-greeting;       # OUTPUT: «GREETINGS FROM BAR, CAMELIA!»
say friendly-greeting;   # OUTPUT: «Greetings from Bar, friend!»

class Cook is Employee {
    has @.utensils  is rw;
    has @.cookbooks is rw;

    method cook( $food ) {
        say "Cooking $food";
    }

    method clean_utensils {
        say "Cleaning $_" for @.utensils;
    }
}

class Baker is Cook {
    method cook( $confection ) {
        say "Baking a tasty $confection";
    }
}

my $cook = Cook.new(
    utensils => <spoon ladle knife pan>,
    cookbooks => 'The Joy of Cooking',
    salary => 40000);

$cook.cook( 'pizza' );       # OUTPUT: «Cooking pizza␤»
say $cook.utensils.perl;     # OUTPUT: «["spoon", "ladle", "knife", "pan"]␤»
say $cook.cookbooks.perl;    # OUTPUT: «["The Joy of Cooking"]␤»
say $cook.salary;            # OUTPUT: «40000␤»

my $baker = Baker.new(
    utensils => 'self cleaning oven',
    cookbooks => "The Baker's Apprentice",
    salary => 50000);

$baker.cook('brioche');      # OUTPUT: «Baking a tasty brioche␤»
say $baker.utensils.perl;    # OUTPUT: «["self cleaning oven"]␤»
say $baker.cookbooks.perl;   # OUTPUT: «["The Baker's Apprentice"]␤»
say $baker.salary;           # OUTPUT: «50000␤»

unit module MyModule;
our $var is export = 3;
sub foo is export { ... };
constant $FOO is export = "foobar";
enum FooBar is export <one two three>;

# Packages like classes can be exported too
class MyClass is export {};

# If a subpackage is in the namespace of the current package
# it doesn't need to be explicitly exported
class MyModule::MyClass {};

sub foo (Str $string) is export {...}

# lib/MyModule.pm
unit module MyModule;
sub bag        is export              { ... }
sub pants      is export(:MANDATORY)  { ... }
sub sunglasses is export(:day)        { ... }
sub torch      is export(:night)      { ... }
sub underpants is export(:ALL)        { ... }

# main.pl
use lib 'lib';
use MyModule;           #bag, pants
use MyModule :DEFAULT;  #the same
use MyModule :day;      #pants, sunglasses
use MyModule :night;    #pants, torch
use MyModule :ALL;      #bag, pants, sunglasses, torch, underpants

unit module MyModule;

sub foo is export         { ... }
sub bar is export(:other) { ... }

unit module MyModule;

my package EXPORT::DEFAULT {
  our sub foo { ... }
}

my package EXPORT::other {
  our sub bar { ... }
}

# lib/MyModule.pm
unit module MuModule;

my package EXPORT::DEFAULT {
  for <zero one two three four>.kv -> $number, $name {
      for <sqrt log> -> $func {
          OUR::{'&' ~ $func ~ '-of-' ~ $name } := sub { $number."$func()" };
      }
  }
}

# main.pl
use MyModule;
say sqrt-of-four; #-> 2
say log-of-zero;  #-> -Inf

class MyModule::Class { ... }

sub EXPORT {
  {
      '$var'      => 'one',
      '@array'    => <one two three>,
      '%hash'     => { one => 'two', three => 'four'},
      '&doit'     => sub { ... },
      'ShortName' => MyModule::class
  }
}

# main.pl
use lib 'lib';
use MyModule;
say $var;
say @array;
say %hash;
doit();
say ShortName.new;  #-> MyModule::Class.new

# lib/MyModule

class MyModule::Class {}

sub EXPORT($short_name?) {
    {
      do $short_name => MyModule::Class if $short_name
    }
}

sub always is export(:MANDATORY) { say "works" }

#import with :ALL or :DEFAULT to get
sub shy is export { say "you found me!" }

# main.pl
use lib 'lib';
use MyModule 'foo';
say foo.new(); #MyModule::Class.new
always();      #OK   - is imported
shy();         #FAIL - won't be imported