Raku Advent Calendar

say True but False ?? 'Tis true' !! 'Tis false';
# OUTPUT: «Tis false␤»

my  $n = 42 but 'forty two';
say $n;     # OUTPUT: «forty two␤»
say $n + 7; # OUTPUT: «49␤»

my $n = 42 but role Evener {
    method is-even { self %% 2 }
}
say $n.is-even; # OUTPUT: «True␤»
say $n.^name;   # OUTPUT: «Int+{Evener}␤»

put True but 'some boolean'; # OUTPUT: «some boolean␤»

put True but role {
    method ::(BEGIN 'some boolean'.^name) {
        'some boolean'
    }
} # OUTPUT: «some boolean␤»

say 'some boolean'.^name;  # OUTPUT: «Str␤»

role Perl5Str {
    method Bool {
        nextsame unless self eq '0';
        False
    }
}
sub perlify { $^v but Perl5Str };

say so perlify 'meows'; # OUTPUT: «True␤»
say so perlify '0';     # OUTPUT: «False␤»
say so perlify '';      # OUTPUT: «False␤»

my $o = class { method stuff { 'original' } }.new;
say $o.stuff;  # OUTPUT: «original␤»

$o does role { method stuff { 'modded' } };
say $o.stuff; # OUTPUT: «modded␤»

$*IN does role { method get { "🎄 {callsame} 🎄" } }

my $name = prompt "Enter your name: ";
say "You entered your name as: $name";

# OUTPUT
# Enter your name: (typed by user:) Zoffix Znet
# You entered your name as: 🎄 Zoffix Znet 🎄

True does False;
say 42 ?? "tis true" !! "tis false";
# OUTPUT: «tis true␤»

True does False;
say 42.Bool ?? "tis true" !! "tis false";
# OUTPUT: «tis false␤»

BEGIN 42 does role { method Bridge { 12e0 } }
say 42 + 15;   # OUTPUT: «57␤»
say 42 + 15e0; # OUTPUT: «27␤»

use soft;
sub foo { say 'in foo' }
&foo.wrap: -> | {
    say 'in the wrap';
    callsame;
    say 'back in the wrap';
}
foo;

# OUTPUT:
# in the wrap
# in foo
# back in the wrap

IO::Handle.^lookup('print').wrap: my method (|c) {
    my &wrapee = nextcallee;
    wrapee self, "🎄 Ho-ho-ho! 🎄\n";
    wrapee self, |c
};

print "Hello, World!\n";

# OUTPUT:
# 🎄 Ho-ho-ho! 🎄
# Hello, World!

[⁠] U+2060 WORD JOINER [Cf]
[⁡] U+2061 FUNCTION APPLICATION [Cf]
[⁢] U+2062 INVISIBLE TIMES [Cf]
[⁣] U+2063 INVISIBLE SEPARATOR [Cf]

sub infix:<¯\(°_o)/¯> {
    ($^a, $^b).pick
}

say 'Coke' ¯\(°_o)/¯ 'Pepsi';
# OUTPUT: «Pepsi␤»

sub term:«\c[family: woman woman boy boy]» {
    '♫ We— are— ♪ faaaamillyyy ♬'
}
say 👩‍👩‍👦‍👦;
# OUTPUT: «♫ We— are— ♪ faaaamillyyy ♬»

sub infix:«\c[INVISIBLE TIMES]» { $^a × $^b }
my \r = 42;

say "Area of the circle is " ~ π⁢r²;
# OUTPUT: «Area of the circle is 5541.76944093239␤»

unit module Jolly;

sub   term:«\c[INVISIBLE TIMES]» is export { 42 }
sub  infix:«\c[INVISIBLE TIMES]» is export {
    $^a × $^b
}
sub prefix:«\c[INVISIBLE SEPARATOR]» (|)
    is looser(&[,]) is export
{
    say "Ho-ho-ho!";
}

⁣say 42⁢⁢;

# OUTPUT:
# 1764
# Ho-ho-ho!

.say for '⁣say 42⁢⁢;'.uninames;

# OUTPUT:
# INVISIBLE SEPARATOR
# LATIN SMALL LETTER S
# LATIN SMALL LETTER A
# LATIN SMALL LETTER Y
# SPACE
# DIGIT FOUR
# DIGIT TWO
# INVISIBLE TIMES
# INVISIBLE TIMES
# SEMICOLON

BEGIN $*LANG.refine_slang: 'MAIN',
    role SomeExtraGrammar {
        token term:sym<meow> {
            'This is not a syntax error'
        }
    },
    role SomeExtraActions {
        method EXPR (Mu $/) {
            say "Parsed expression: " ~ $/;
            nextsame
        }
    }

This is not a syntax error;
say 'hehe'

# OUTPUT:
# Parsed expression: This is not a syntax error
# Parsed expression: 'hehe'
# Parsed expression: say 'hehe'
# hehe

BEGIN $*LANG.refine_slang: 'MAIN', role {
    token comment:sym<todo> {
        '#' \s* 'TODO' ':'? \s+ <( \N*
        { die "Ho-ho-ho! I think you were"
            ~ " meant to finish " ~ $/ }
    }
}

sub business-stuff {
    # TODO: business stuff
}

# OUTPUT:
# ===SORRY!===
# Ho-ho-ho! I think you were meant to finish business stuff

# File: ./Jolly.pm6
sub EXPORT {
    $*LANG.refine_slang: 'MAIN', role {
        token comment:sym<todo> {
            '#' \s* 'TODO' ':'? \s+ <( \N*
            { die "Ho-ho-ho! I think you were"
                ~ " meant to finish " ~ $/ }
        }
    }

    Map.new
}

# File: ./script.p6
use lib <.>;
use Jolly;

sub business-stuff {
    # TODO: business stuff
}

# OUTPUT:
# ===SORRY!===
# Ho-ho-ho! I think you were meant to finish business stuff

my $foo := 42;
say "The value is $foo"; # OUTPUT: «The value is 42␤»

my $ordered-things := <foo bar ber>;
my $named-things   := %(:42foo, :bar<ber>);

say "$named-things<foo> bottles of $ordered-things[2] on the wall";
# OUTPUT: «42 bottles of ber on the wall␤»

.say for $ordered-things;  # OUTPUT: «foo␤bar␤ber␤»
.say for $named-things;    # OUTPUT: «bar => ber␤foo => 42␤»

my $list := (1, 2, 3);
$list[0] := 100;
# OUTPUT: «Cannot use bind operator with this left-hand side […] »

1 := 100;
# OUTPUT: «Cannot use bind operator with this left-hand side […] »

my $list := (my $, my $, my $);
$list[0] := 100;
say $list; # OUTPUT: «(100 (Any) (Any))␤»

my $list := (my $, my $, my $);
$list[0] := 100;
$list[0] := 200;
# OUTPUT: «Cannot use bind operator with this left-hand side […] »

my $list := (my $ = 1, my $ = 2, my $ = 3);
$list[0] = 100;
$list[0] = 200;
say $list;
# OUTPUT: «(200 2 3)␤»

my $list := (my Int $ = 1, my Str $ = '2', my Rat $ = 3.0);
$list[0] = 100; # OK!
$list[1] = 42;  # Typecheck failure!

# OUTPUT: «Type check failed in assignment;
#    expected Str but got Int (42) […] »

my Positional $list := (my $ = 1, my $ = '2', my $ = 3.0);

my @list := 42;
# OUTPUT: «Type check failed in binding;
#   expected Positional but got Int (42) […] »

my @list := [1, '2', 3.0];
@list[0] = 100;
@list[0] = 200;
say @list;
# OUTPUT: «[200 2 3]␤»

my @list = 1, '2', 3.0;

my  %hash = :42foo, :bar<ber>;
say %hash;  # OUTPUT: «{bar => ber, foo => 42}␤»

my &reversay = sub { $^text.flip.say }
reversay '6 lreP ♥ I'; # OUTPUT: «I ♥ Raku␤»

# store a different Callable in the same variable
&reversay = *.uc.say;  # a WhateverCode object
reversay 'I ♥ Raku'; # OUTPUT: «I ♥ PERL 6␤»

my  $listish = (1, 2, 3);
say $listish; # OUTPUT: «(1 2 3)␤»

# Binding:
my  $list := (1, 2, 3);
say $list.perl;
say "Item: $_" for $list;

# OUTPUT:
# (1, 2, 3)
# Item: 1
# Item: 2
# Item: 3


# Assignment:
my $listish = (1, 2, 3);
say $listish.perl;
say "Item: $_" for $listish;

# OUTPUT:
# $(1, 2, 3)
# Item: 1 2 3

my @stuff = (1, 2, 3), %(:42foo, :70bar);
say "List Item: $_" for @stuff[0];
say "Hash Item: $_" for @stuff[1];

# OUTPUT:
# List Item: 1 2 3
# Hash Item: bar  70
# foo 42

my @stuff = (1, 2, 3), %(:42foo, :70bar);
say flat @stuff;
# OUTPUT: «((1 2 3) {bar => 70, foo => 42})␤»

-> *@args { @args.say }(@stuff)
# OUTPUT: «[(1 2 3) {bar => 70, foo => 42}]␤»

my @stuff = (1, 2, 3), %(:42foo, :70bar);
say "Item: $_" for @stuff[0]<>;
say "Item: $_" for @stuff[1]<>;

# OUTPUT:
# Item: 1
# Item: 2
# Item: 3
# Item: bar   70
# Item: foo   42

my @stuff = (1, 2, 3), %(:42foo, :70bar);
say flat @stuff»<>;
# OUTPUT: «(1 2 3 bar => 70 foo => 42)␤»

-> *@args { @args.say }(@stuff»<>)
# OUTPUT: «[1 2 3 bar => 70 foo => 42]␤»

my @stuff := (1, 2, 3), %(:42foo, :70bar);
say flat @stuff;
# OUTPUT: «(1 2 3 bar => 70 foo => 42)␤»

-> *@args { @args.say }(@stuff)
# OUTPUT: «[1 2 3 bar => 70 foo => 42]␤»

my @stuff = (1, 2, 3), (4, 5);
say "Item: $_" for |@stuff[0];

# OUTPUT:
# Item: 1
# Item: 2
# Item: 3

my $primes = ^∞ .grep: *.is-prime;
say "$_ is a prime number" for |$primes;

# CAREFUL! Don't consume all of your resources!
my $primes = ^∞ .map: *.self;
Nil for |$primes;

my $primes = ^∞ .map: *.self;
Nil for $primes<>;

my $primes := ^∞ .map: *.self;
Nil for $primes;

my \Δ = 42;
say Δ²; # OUTPUT: «1764␤»

my \Δ = my $ = 42;
Δ = 11;
say Δ²; # OUTPUT: «121␤»

sub sigiled ($x is raw, +@y) {
    $x = 100;
    say flat @y
}

sub sigil-less (\x, +y) {
    x = 200;
    say flat y
}

my $x = 42;
sigiled    $x, (1, 2), (3, 4); # OUTPUT: «((1 2) (3 4))␤»
say $x;                        # OUTPUT: «100␤»

sigil-less $x, (1, 2), (3, 4); # OUTPUT: «(1 2 3 4)␤»
say $x;                        # OUTPUT: «200␤»

my $x is default(42);
say $x;   # OUTPUT: «42␤»

$x = 10;
say $x;   # OUTPUT: «10␤»

$x = Nil;
say $x;   # OUTPUT: «42␤»

my @a is default<meow> = 1, 2, 3;
say @a[0, 2, 42]; # OUTPUT: «(1 3 meow)␤»

@a[0]:delete;
say @a[0];        # OUTPUT: «meow␤»

my %h is default(Nil) = :bar<ber>;
say %h<bar foos>; # OUTPUT: «(ber Nil)␤»

%h<bar>:delete;
say %h<bar>       # OUTPUT: «Nil␤»

say my Int $y; # OUTPUT: «(Int)␤»
say my Mu  $z; # OUTPUT: «(Mu)␤»

say my Int $i where *.is-prime; # OUTPUT: «(<anon>)␤»
$i.new; # OUTPUT: (exception) «You cannot create […]»

say my $x;    # OUTPUT: «(Any)␤»
say $x = Nil; # OUTPUT: «(Any)␤»

my $collector := do {
    my @stuff;
    Proxy.new: :STORE{ @stuff.push: @_[1] },
               :FETCH{ @stuff.join: "|"   }
}

$collector = 42;
$collector = 'meows';
say $collector; # OUTPUT: «42|meows␤»

$collector = 'foos';
say $collector; # OUTPUT: «42|meows|foos␤»

class Foo {
    has $!foo;
    method foo {
        Proxy.new: :STORE(-> $, Int() $!foo { $!foo }),
                   :FETCH{ $!foo }
    }
}

my $o = Foo.new;
$o.foo = ' 42.1e0 ';
say $o.foo; # OUTPUT: «42␤»

sub test { say "$^implied @:parameters[]" }
test 'meow', :parameters<says the cat>;
# OUTPUT: «meow says the cat␤»

with class Foo {
    has $!foo = 42;
    has @.bar = 100;
    method what's-foo { $!foo }
}.new {
    say .bar;       # OUTPUT: «[100]␤»
    say .what's-foo # OUTPUT: «42␤»
}

Dear Santa: I have been a good boy so I want you to bring me a collection of scythes and an ocean liner with a captain and a purser and a time travel machine and instructions to operate it and I know I haven't been so good at times but that is why I'm asking the time machine so that I can make it good and well and also find out what happened on July 13th which I completely forgot.

[ "Dear Santa: I have been a good boy so I want you to bring me a collection of scythes", "an ocean liner with a captain", "a purser", "a time travel machine", "instructions to operate it", "I know I haven't been so good at times but that is why I'm asking the time machine so that I can make it good", "well", "also find out what happened on July 13th which I completely forgot.\n" ]

zef install Text::Markdown

# Dear Santa

I have been a good boy so I want you to bring me a collection of
scythes and an ocean liner with a captain and a purser and a time
travel machine and instructions to operate it and I know I haven't
been so good at times but that is why I'm asking the time machine so
that I can make it good and well and also find out what happened on
July 13th which I completely forgot.

# Dude

=== Welll...

I have been a naughty person


=== Requests

Well...

# Dear Santa

=== Behavior

I have been a good boy


=== Requests

And this is what I want

 - scythes
 - an ocean liner with a captain and a purser
 - a time travel machine and instructions to operate it

 - Morning sickness
 - Scythe
 - Mug

grammar MathExpression {
    token TOP    { <sum> }
    rule sum     { <product>+ %  '+' }
    rule product { <term>+ % '*' }
    rule term    { <number> | <group> }
    rule group   { '(' <sum> ')' }
    token number { \d+ }
}

say MathExpression.parse('2 + 4 * 5 * (1 + 3)');

⌜2 + 4 * 5 * (1 + 3)⌟
 sum => ⌜2 + 4 * 5 * (1 + 3)⌟
  product => ⌜2 ⌟
   term => ⌜2 ⌟
    number => ⌜2⌟
  product => ⌜4 * 5 * (1 + 3)⌟
   term => ⌜4 ⌟
    number => ⌜4⌟
   term => ⌜5 ⌟
    number => ⌜5⌟
   term => ⌜(1 + 3)⌟
    group => ⌜(1 + 3)⌟
     sum => ⌜1 + 3⌟
      product => ⌜1 ⌟
       term => ⌜1 ⌟
        number => ⌜1⌟
      product => ⌜3⌟
       term => ⌜3⌟
        number => ⌜3⌟

    token number {
        (\d+)
        { die "how did I get here?" if $0 eq '1' }
    }

how did I get here?
  in regex number at bt.p6 line 9
  in regex term at bt.p6 line 5
  in regex product at bt.p6 line 4
  in regex sum at bt.p6 line 3
  in regex group at bt.p6 line 6
  in regex term at bt.p6 line 5
  in regex product at bt.p6 line 4
  in regex sum at bt.p6 line 3
  in regex TOP at bt.p6 line 2
  in block <unit> at bt.p6 line 13

rule sum { <product>+ %  '+' }
rule product { <term>+ % '*' }

rule  expression { <operator>+ % <term> }
token operator   {  '*' | '+' }

token a { <a>? 'a' }

VAR1=value
VAR2=

    token assignment {
        <variable> '=' <string>?
    }

grammar MathExpression {
    token number { \d+ }
}

grammar MathExpression {
    token number { \d+ }
}

multi sub MAIN(Bool :$test!) {
    use Test;
    plan 2;
    ok MathExpression.parse('1234', :rule<number>),
        '<number> parses 1234';
    nok MathExpression.parse('1+4', :rule<number>),
        '<number> does not parse 1+4';
}

grammar MathExpression {
    token number { \d+ }
    rule product { <number>+ % '*' }
}

multi sub MAIN(Bool :$test!) {
    use Test;
    plan 5;
    ok MathExpression.parse('1234', :rule<number>),
        '<number> parses 1234';
    nok MathExpression.parse('1+4', :rule<number>),
        '<number> does not parse 1+4';

    ok MathExpression.parse('1234', :rule<product>),
        '<product> can parse a simple number';
    ok MathExpression.parse('1*3*4', :rule<product>),
        '<product> can parse three terms';
    ok MathExpression.parse('1 * 3', :rule<product>),
        '<product> and whitespace';
}

zef install Grammar::Debugger

grammar INI {
    token TOP {
        ^ <.eol>* <toplevel>?  <sections>* <.eol>* $
            }
    token toplevel { <keyval>* }
    token sections { <header> <keyval>* }
    token header   { ^^ \h* '[' ~ ']' $<text>=<-[ \] \n ]>+
                     \h* <.eol>+ }
    token keyval   { ^^ \h* <key> \h* '=' \h* <value>? \h*
                     <.eol>+ }
    regex key      { <![#\[]> <-[;=]>+ }
    regex value    { [ <![#;]> \N ]+ }
    token eol      { [ <[#;]> \N* ]? \n }
}

a = b
[foo]
c: d

use Grammar::Tracer;

INI.parse(q:to/EOF/);
a = b
[foo]
c: d
EOF

TOP
|  eol
|  * FAIL
|  toplevel
|  |  keyval
|  |  |  key
|  |  |  * MATCH "a "
|  |  |  value
|  |  |  * MATCH "b"
|  |  |  eol
|  |  |  * MATCH "\n"
|  |  |  eol
|  |  |  * FAIL
|  |  * MATCH "a = b\n"
|  |  keyval
|  |  |  key
|  |  |  * FAIL
|  |  * FAIL
|  * MATCH "a = b\n"

|  sections
|  |  header
|  |  |  eol
|  |  |  * MATCH "\n"
|  |  |  eol
|  |  |  * FAIL
|  |  * MATCH "[foo]\n"
|  |  keyval
|  |  |  key
|  |  |  * MATCH "c: d\n"
|  |  * FAIL
|  * MATCH "[foo]\n"

|  sections
|  |  header
|  |  * FAIL
|  * FAIL
|  eol
|  * FAIL
* FAIL

grammar INIFile {
    token TOP { <section>* }
    token section {
        <header>
        <keyvalue>*
    }
    rule header {
        '['  <-[ \] \n ]>+ ']' <.eol>
    }
    rule keyvalue {
        ^^
        $<key>=[\w+]
        <[:=]>
        $<value>=[<-[\n;#]>*]
        <.eol>
    }
    token ws { <!ww> \h* }
    token eol {
        \n [\h*\n]*
    }
}

[db]
driver: mysql
host: db01.example.com
port: 122
username: us123
password: s3kr1t

# comment parsing for SQL:
token ws { <!ww> \s* [ '--' \N* \n ]* }

# comment parsing for INI files:
token eol { [ [ <[#;]> \N* ]? \n ]+ }

int x = 42;

int x = 42;
x y = 23;

a = 1
b = 2
c = a, 5, b

grammar VariableLists {
    token TOP        { <statement>* }
    rule  statement  { <identifier> '=' <termlist> \n }
    rule  termlist   { <term> * % ',' }
    token term       { <identifier> | <number> }
    token number     { \d+ }
    token identifier { <:alpha> \w* }
    token ws         { <!ww> \h* }
}

a = 1
c = a, 5, b
b = 2

grammar VariableLists {
    token TOP {
        :my %*SYMBOLS;
        <statement>*
    }
    token ws { <!ww> \h* }
    rule statement {
        <identifier>
        { %*SYMBOLS{ $<identifier> } = True }
        '=' <termlist>
        \n
    }
    rule termlist { <term> * % ',' }
    token term { <variable> | <number> }
    token variable {
        <identifier>
        <?{ %*SYMBOLS{ $<identifier> } }>
    }
    token number { \d+ }
    token identifier { <:alpha> \w* }
}

    rule statement {
        <identifier>
        { %*SYMBOLS{ $<identifier> } = True }
        '=' <termlist>
        \n
    }

    token term { <variable> | <number> }
    token variable {
        <identifier>
        <?{ %*SYMBOLS{ $<identifier> } }>
    }

VariableLists.parse('abc', rule => 'variable');

Dynamic variable %*SYMBOLS not found

a = 1
b = 2
{
    c = a, 5, b
}

a = 1
{
    b = 2
}
c = a, 5, b

grammar VariableLists {
    token TOP {
        :my %*SYMBOLS;
        <statement>*
    }
    token ws { <!ww> \h* }
    token statement {
        | <declaration>
        |  <block>
    }
    rule declaration {
        <identifier>
        { %*SYMBOLS{ $<identifier> } = True; }
        '=' <termlist>
        \n
    }
    rule block {
        :my %*SYMBOLS = CALLERS::<%*SYMBOLS>;
        '{' \n*
            <statement>*
        '}' \n*
    }
    rule termlist { <term> * % ',' }
    token term { <variable> | <number> }
    token variable {
        <identifier>
        <?{ %*SYMBOLS{ $<identifier> } }>
    }
    token number { \d+ }
    token identifier { <:alpha> \w* }
}

a = 1
b = 2
{
    c = a, 5, b
}

class SymbolTable {
    has @!scopes = {}, ;
    method enter-scope() {
        @!scopes.push({})
    }
    method leave-scope() {
        @!scopes.pop();
    }
    method declare($variable) {
        @!scopes[*-1]{$variable} = True
    }
    method check-declared($variable) {
        for @!scopes.reverse -> %scope {
            return True if %scope{$variable};
        }
        return False;
    }
}

grammar VariableLists {
    token TOP {
        :my $*ST = SymbolTable.new();
        <statement>*
    }
    token ws { <!ww> \h* }
    token statement {
        | <declaration>
        |  <block>
    }
    rule declaration {
        <identifier>
        { $*ST.declare( $<identifier> ) }
        '=' <termlist>
        \n
    }
    rule block {
        '{' \n*
            { $*ST.enter-scope() }
            <statement>*
            { $*ST.leave-scope() }
        '}' \n*
    }
    rule termlist { <term> * % ',' }
    token term { <variable> | <number> }
    token variable {
        <identifier>
        <?{ $*ST.check-declared($<identifier>) }>
    }
    token number { \d+ }
    token identifier { <:alpha> \w* }
}

    method block {
        $*ST.enter-scope();
        LEAVE $*ST.leave-scope();
        self.block_wrapped();
    }
    rule block_wrapped {
        '{' \n*
            <statement>*
        '}' \n*
    }

use JSON::Fast;
my $item = from-json(q:to/END/);
    {
        "book" : {
            "title"  : "A Christmas Carol",
            "author" : "Charles Dickens"
        },
        "count" : 12,
        "tags" : [ "christmas", "santa"]
    }
    END

sub myfunc(% (:%book (Str:D :$title, Str:D :$author), Int :$count,
              :@tags ($first-tag, *@other-tags)) )
{...}

for @itemlist -> % (:%book (Str:D :$title, Str:D :$author), Int :$count,
                    :@tags ($first-tag, *@other-tags))
{
    say "$title, $author, $count, @tags[], $first-tag, @other-tags[]"
}

class Book {
    has $.title;
    has $.author;
    has $.count;
    has @.tags;
}

my @booklist =
    Book.new(title => 'A Christmas Carol',
             author => 'Charles Dickens',
             count => 12,
             tags => <ghost christmas>),

    Book.new(title => 'A Visit from St. Nicholas',
             author => 'Clement Clarke Moore',
             count => 4,
             tags => <santa christmas>);

for @booklist -> Book $b (:$title,:$author, :$count, :@tags) {
    say "$title, $author, $count, @tags[]";
}

is 1 + 1, 2, 'prop. 54.43, Principia Mathematica';

ok 1 + 1 == 2, 'prop. 54.43, Principia Mathematica';

ok 'Lake Char­gogg­a­gogg­man­chaugg­a­gogg­chau­bun­a­gung­a­maugg' ~~ 'manchau', 'my side';

like 'Lake Char­gogg­a­gogg­man­chaugg­a­gogg­chau­bun­a­gung­a­maugg',
     /manchau/, 'my side';

is sprintf( "%s", '1' ), '1', "%s formats numbers";
is sprintf( "%s", '⅑' ), '⅑', "%s formats fractions";
is sprintf( "%s", 'Ⅷ' ), 'Ⅷ', "%s formats graphemes";
is sprintf( "%s", '三' ), '三', "%s formats CJKV";

is sprintf( "%s", '1' ), '1', "%s formats numbers';
# ...

is sprintf( "%d, '1' ), '1', "%d formats numbers';
# ...

subtest '%s', {
    is sprintf( "%s", '1' ), '1', "formats numbers";
    is sprintf( "%s", '⅑' ), '⅑', "formats fractions";
    is sprintf( "%s", 'Ⅷ' ), 'Ⅷ', "formats graphemes";
    is sprintf( "%s", '三' ), '三', "formats CJKV";
};

=begin table
-r0c0  r0c1
=end table

"===SORRY!=== Cannot iterate object with P6opaque representation"

say("Hello, world!");

$ nqp hello.nqp
Hello, world!

configuration information
a header line with N cells
M content lines, each with N cells

got fork https://github.com/rakudo/rakudo.git
got fork https://github.com/raku/roast.git

$ git remote -v
origin  git@github.com:tbrowder/rakudo.git (fetch)
origin  git@github.com:tbrowder/rakudo.git (push)
upstream    https://github.com/rakudo/rakudo.git (fetch)
upstream    https://github.com/rakudo/rakudo.git (push)

git clone https://github.com/ugexe/zef
export PATH=`pwd`/install/bin:$PATH
cd zef; raku -Ilib bin/zef install .
cd ..
export PATH=`pwd`/install/share/raku/site/bin:$PATH
zef install Inline::Perl5

zef install Debugger::UI::CommandLine
zef install Grammar::Debugger

make
make install

use Cro;
use Cro::HTTP::Request;
use Cro::HTTP::Response;

class MuskoxApp does Cro::Transform {
    method consumes() { Cro::HTTP::Request }
    method produces() { Cro::HTTP::Response }
    method transformer(Supply $pipeline --> Supply) {
        supply whenever $pipeline -> $request {
            given Cro::HTTP::Response.new(:$request, :200status) {
                .append-header: "Content-type", "text/html";
                .set-body: "Muskox Rocks!\n".encode('ascii');
                .emit;
            }
        }
    }
}

use Cro::TCP;
use Cro::HTTP::RequestParser;
use Cro::HTTP::ResponseSerializer;

my $server = Cro.compose:
    Cro::TCP::Listener.new(:port(4242)),
    Cro::HTTP::RequestParser.new,
    MuskoxApp,
    Cro::HTTP::ResponseSerializer;

$server.start;
react whenever signal(SIGINT) {
    $server.stop;
    exit;
}

$ curl http://localhost:4242/
Muskox Rocks!

use Cro::TLS;

my $server = Cro.compose:
    Cro::TLS::Listener.new(
        :port(4242),
        :certificate-file('certs-and-keys/server-crt.pem'),
        :private-key-file('certs-and-keys/server-key.pem')
    ),
    Cro::HTTP::RequestParser.new,
    MuskoxApp,
    Cro::HTTP::ResponseSerializer;

$ curl -k https://localhost:4242/
Muskox Rocks!

use Cro;
use Cro::HTTP::Server;

class MuskoxApp does Cro::Transform {
    method consumes() { Cro::HTTP::Request }
    method produces() { Cro::HTTP::Response }
    method transformer(Supply $pipeline --> Supply) {
        supply whenever $pipeline -> $request {
            given Cro::HTTP::Response.new(:$request, :200status) {
                .append-header: "Content-type", "text/html";
                .set-body: "Muskox Rocks!\n".encode('ascii');
                .emit;
            }
        }
    }
}

my $server = Cro::HTTP::Server.new: :port(4242), :application(MuskoxApp);
$server.start;
react whenever signal(SIGINT) {
    $server.stop;
    exit;
}

my %tls =
    :certificate-file('certs-and-keys/server-crt.pem'),
    :private-key-file('certs-and-keys/server-key.pem');
my $server = Cro::HTTP::Server.new: :port(4242), :application(MuskoxApp),
    :%tls, :http<1.1 2>;

use Cro::HTTP::Router;
use Cro::HTTP::Server;

my $application = route {
    get -> {
        content 'text/html', 'Do you like dugongs?';
    }
}

my $server = Cro::HTTP::Server.new: :port(4242), :$application;
$server.start;
react whenever signal(SIGINT) {
    $server.stop;
    exit;
}

get -> {
    content 'text/html', 'Do you like dugongs?';
}

get -> 'product', $id {
    content 'application/json', {
        id => $id,
        name => 'Arctic fox photo on canvas'
    }
}

$ curl http://localhost:4242/product/42
{"name": "Arctic fox photo on canvas","id": "42"}

get -> 'css', *@path {
    static 'assets/css', @path;
}

get -> 'product', Int $id {
    content 'application/json', {
        id => $id,
        name => 'Arctic fox photo on canvas'
    }
}

get -> 'search', :$query {
    content 'text/plain', "You searched for $query";
}

$ curl http://localhost:4242/search?query=llama
You searched for llama

get -> 'product', 'index' { ... }
get -> 'product', $what { ... }

get -> 'product', $what { ... }
get -> 'product', 'index' { ... }

my $application = route {
    after {
        header 'Strict-transport-security', 'max-age=31536000; includeSubDomains';
    }
    # Routes here...
}

my $application = route {
    before {
        unless .has-header('Authorization') {
            forbidden 'text/plain', 'Missing authorization';
        }
    }
    # Routes here...
}

$ curl http://localhost:4242/
Missing authorization
$ curl -H"Authorization: Token 123" http://localhost:4242/
<strong>Do you like dugongs?</strong>

my $chat = Supplier.new;
get -> 'chat' {
    # For each request for a web socket...
    web-socket -> $incoming {
        # We start this bit of reactive logic...
        supply {
            # Whenever we get a message on the socket, we emit it into the
            # $chat Supplier
            whenever $incoming -> $message {
                $chat.emit(await $message.body-text);
            }
            # Whatever is emitted on the $chat Supplier (shared between all)
            # web sockets), we send on this web socket.
            whenever $chat -> $text {
                emit $text;
            }
        }
    }
}

say 20 * 18; # 360

say pi ** e; # 22.4591577183611

my $weather = '*****';
my $snow = $weather ~~ / ('*'*) /;
say 'Snow level is ' ~ $snow.chars; # Snow level is 5

my $operator = '..';
say "'$operator' is a valid Raku operator"
    if $operator ~~ /^ '.' ** 1..3 $/;

my $phrase = 'I love you......';
say 'You are so uncertain...'
    if $phrase ~~ / '.' ** 4..* /;

list-gifts('chocolade', 'ipad', 'camelia', 'raku');

sub list-gifts(*@items) {
    say 'Look at my gifts this year:';
    .say for @items;
}

dump(alpha => 'a', beta => 'b'); # Prints:
                                 # alpha = a
                                 # beta = b

sub dump(*%data) {
    for %data.kv {say "$^a = $^b"}
}

Too few positionals passed; expected 1 argument but got 0

my @a = < chocolade ipad >;
my @b = < camelia raku >;

all-together(@a, @b);
all-together(['chocolade', 'ipad'], ['camelia', 'raku']);
all-together(< chocolade ipad >, < camelia raku >);

sub all-together(*@items) {
    .say for @items;
}

chocolade
ipad
camelia
raku
chocolade
ipad
camelia
raku
chocolade
ipad
camelia
raku

keep-groupped(@a, @b);
keep-groupped(['chocolade', 'ipad'], ['camelia', 'raku']);
keep-groupped(< chocolade ipad >, < camelia raku >);

sub keep-groupped(**@items) {
    .say for @items;
}

[chocolade ipad]
[camelia raku]

(chocolade ipad)
(camelia raku)

sub happy-new-year() {
    "Happy new $*year year!"
}

my $*year = 2018;
say happy-new-year(); # 输出 Happy new 2018 year!

Variable '$year' is not declared

sub happy-new-year() {
    "Happy new $*year year!"
}

my $*year = 2018;
say happy-new-year();

{
    $*year = 2019;        # New value
    say happy-new-year(); # 2019
}

{
    my $*year = 2020;     # New variable
    say happy-new-year(); # 2020
}

say $*PERL;      # Raku (6.c)
say @*ARGS;      # Prints command-line arguments
say %*ENV<HOME>; # Prints home directory

6.*perl.*say; # (6 Int.new)

pi.perl.say; # 3.14159265358979e0 (notice the scientific
             # format, unlike pi.say)

class Present {
    method giver() {
        'parents'
    }
}

class ChristmasPresent is Present {
    method giver() {
        'Santa Claus'
    }
}

my ChristmasPresent $present;

$present.giver.say;             # Santa Claus
$present.*giver.join(', ').say; # Santa Claus, parents

.say for 1 .. *;

multi method new(Whatever \min,Whatever \max,:$excludes-min,:$excludes-max){
    nqp::create(self)!SET-SELF(-Inf,Inf,$excludes-min,$excludes-max,1);
}
multi method new(Whatever \min, \max, :$excludes-min, :$excludes-max) {
    nqp::create(self)!SET-SELF(-Inf,max,$excludes-min,$excludes-max,1);
}
multi method new(\min, Whatever \max, :$excludes-min, :$excludes-max) {
    nqp::create(self)!SET-SELF(min,Inf,$excludes-min,$excludes-max,1);
}

class N {
    multi method display(Int $n) {
        say $n;
    }

    multi method display(Whatever) {
        say 2000 + 100.rand.Int;
    }
}

my $n = N.new;
$n.display(2018);
$n.display(*);

sub echo($x) {
    say $x;
}

echo(2018); # 2018
echo(*);    # *

Unsupported use of a negative -1 subscript
to index from the end; in Raku please
use a function such as *-1

say (*-1).WHAT; # (WhateverCode)

my @a = < one two three four five six >;
say @a[3..*]; # (four five six)

say (3..*).WHAT; # (Range)

say @a[3 .. *-2]; # (four five)

say (3 .. *-2).WHAT; # (WhateverCode)

class N {
    multi method display(Int $n) {
        say $n;
    }

    multi method display(Whatever) {
        say 2000 + 100.rand.Int;
    }

    multi method display(WhateverCode $code) {
        say $code(2000 + 100.rand.Int);
    }
}

N.display(2018);     # display(Int $n)

N.display(*);        # display(Whatever)

N.display(* / 2);    # display(WhateverCode $code)
N.display(* - 1000); # display(WhateverCode $code)

multi method display(WhateverCode $code)

say $code(2000 + 100.rand.Int);

multi method display(WhateverCode $code
                     where {$code.arity == 2}) {
    say $code(2000, 100.rand.Int);
}

N.display( * + * );
N.display( * - * );

N.display( * * * );
N.display( * ** * );

2000 * 100.rand.Int

2000 ** 100.rand.Int

my @n =
    ((0, 1, * + * ... *).grep: *.is-prime).map: * * * * *;
.say for @n[^5];

((0, 1, * + * ... Inf).grep: *.is-prime).map: * * * * *

((0, 1, -> $x, $y {$x + $y} ... Inf).grep:
    *.is-prime).map: * * * * *

(0, 1, -> $x, $y {$x + $y} ... Inf).grep({
    $_.is-prime
}).map: * * * * *

my @n = (0, 1, -> $x, $y {$x + $y} ... Inf).grep({
        $_.is-prime
    }).map({
        $^a * $^b * $^c
    });
.say for @n[^5];

class-definition :
[ encapsulated ] class-prefixes
class-specifier

rule class_definition {
  [<|w>'encapsulated'<|w>]?
  <class_prefixes>
  <class_specifier>
}

lib
----Grammar
--------Modelica
------------LexicalConventions.pm6
------------ClassDefinition.pm6
------------Extends.pm6
------------ComponentClause.pm6
------------Modification.pm6
------------Equations.pm6
------------Expressions.pm6
--------Modelica.pm6

rule expression {
  [
  <|w>'if'<|w> <expression> <|w>'then'<|w> <expression> [
  <|w>'elseif'<|w> <expression> <|w>'then'<|w> <expression>
  ]*
  <|w>'else'<|w> <expression>
  ]
  ||
  <simple_expression>
}

grammar TestExpression is Grammar::Modelica {
    rule TOP {^ <expression> $}
    rule simple_expression { 'simple_expression' }
}
ok TestExpression.parse('simple_expression');
...

rule type_prefix {
  [<|w>[ 'flow' || 'stream' ]<|w>]?
  [<|w>[ 'discrete' || 'parameter' || 'constant' ]<|w>]?
  [<|w>[ 'input' || 'output' ]<|w>]?
}

$ raku web-spider.p6 [–domain=http://example.com]

use HTML::Parser::XML;
use XML::Document;
use HTTP::UserAgent;

sub MAIN(:$domain="http://www.perlmonks.org") {

    my $ua =  HTTP::UserAgent.new;
    my %url_seen;
    my @urls=($domain);

    loop {
        my @promises;
        while ( @urls ) {
            my $url = @urls.shift;
            my $p = Promise.start({crawl($ua, $domain, $url)});
            @promises.push($p);
        }
        await Promise.allof(@promises);
        for @promises.kv -> $index, $p {
            if $p.status ~~ Kept {
                my @results =  $p.result;
                for @results {
                    unless %url_seen{$_} {
                        @urls.push($_);
                        %url_seen{$_}++;
                    }
                }
            }
        }
        # Terminate if no more URLs to crawl
        if @urls.elems == 0 {
            last;
        }
    }
    say %url_seen.keys;
}

# Get page and identify urls linked to in it. Return urls.
sub crawl($ua, $domain, $url) {
    my $page = $ua.get($url);
    my $p = HTML::Parser::XML.new;
    my XML::Document $doc = $p.parse($page.content);
    # URLs to crawl
    my %todo;
    my @anchors = $doc.elements(:TAG<a>, :RECURSE);
    for @anchors -> $anchor {
        next unless $anchor.defined;
        my $href =  $anchor.attribs<href>;

        # Convert relative to absolute urls
        if $href.starts-with('/') or $href.starts-with('?') {
            $href = $domain ~ $href;
        }

        # Get unique urls from page
        if $href.starts-with($domain) {
              %todo{$href}++;
        }
    }
    my @urls = %todo.keys;

    return @urls;
}

zef install Net::AMQP

my $n = Net::AMQP.new(
  host => 'localhost',
  port => 5672,
  login => 'guest',
  password => 'guest',
  vhost => '/'
);

use Net::AMQP;

my $n = Net::AMQP.new;

await $n.connect;
my $channel = $n.open-channel(1).result;
my $exchange = $channel.exchange.result;
$exchange.publish(routing-key => "hello", body => "Hello, World".encode);
await $n.close("", "");

use Net::AMQP;

my $n = Net::AMQP.new;

my $connection = $n.connect.result;

react {
    whenever $n.open-channel(1) -> $channel {
        whenever $channel.declare-queue("hello") -> $queue {
            $queue.consume;
            whenever $queue.message-supply.map( -> $v { $v.body.decode }) -> $message {
                say $message;
                $n.close("", "");
                done();
            }
        }
    }
}

$n.close("", "");
done();

whenever signal(SIGINT) {
    $n.close("", "");
    done();
}

use Net::AMQP;

my $supply = Supply.from-list("Hello, World", "Bonjour le monde", "Hola Mundo");
my $n = Net::AMQP.new;

react {
    whenever $n.connect {
        whenever $n.open-channel(1) -> $channel {
            whenever $channel.exchange -> $exchange {
                whenever $supply.map(-> $v { $v.encode }) -> $body {
                    $exchange.publish(routing-key => "hello", :$body );
                    LAST {
                        $n.close("", "");
                        done();
                    }
                }
            }
        }
    }
}

use Net::AMQP;

my $n = Net::AMQP.new;
my $con =  await $n.connect;
my $channel = $n.open-channel(1).result;
my $exchange = $channel.declare-exchange('logs', 'fanout').result;
$exchange.publish(body => 'Hello, World'.encode);
await $n.close("", "");

use Net::AMQP;

my $n = Net::AMQP.new;

my $connection = $n.connect.result;

react {
    whenever $n.open-channel(1) -> $channel {
        whenever $channel.declare-exchange('logs', 'fanout') -> $exchange {
            whenever $channel.declare-queue() -> $queue {
                whenever $queue.bind('logs') {
                    $queue.consume;
                    whenever $queue.message-supply.map( -> $v { $v.body.decode }) -> $message {
                        say $*PID ~ " : " ~ $message;
                    }
                }
                whenever signal(SIGINT) {
                    say $*PID ~ " exiting";
                    $n.close("", "");
                    done();
                }

            }
        }
    }
}

use Net::AMQP;

multi sub MAIN(Str $message = 'Hello, World', Str $level = 'application.info') {
	my $n = Net::AMQP.new;
	my $con =  await $n.connect;
	my $channel = $n.open-channel(1).result;
	my $exchange = $channel.declare-exchange('topic-logs', 'topic').result;
	$exchange.publish(routing-key => $level, body => $message.encode);
	await $n.close("", "");
}

use Net::AMQP;

multi sub MAIN(*@topics ) {
    my $n = Net::AMQP.new(:debug);
    unless @topics.elems {
        say "will be displaying all the messages";
        @topics.push: '#';
    }
    my $connection = $n.connect.result;
    react {
        whenever $n.open-channel(1) -> $channel {
            whenever $channel.declare-exchange('topic-logs', 'topic') -> $exchange {
                whenever $channel.declare-queue() -> $queue {
                    for @topics -> $topic {
                        await $queue.bind('topic-logs', $topic);
                    }
                    $queue.consume;
                    my $body-supply = $queue.message-supply.map( -> $v { [ $v.routing-key, $v.body.decode ] }).share;
                    whenever $body-supply -> ( $topic , $message ) {
                            say $*PID ~ " : [$topic]  $message";
                    }
                }
            }
        }
    }
}

use EventSource::Server;
use Net::AMQP;
use Cro::HTTP::Router;
use Cro::HTTP::Server;

my $supply = supply {
	my $n = Net::AMQP.new;
	my $connection = $n.connect.result;
	whenever $n.open-channel(1) -> $channel {
		whenever $channel.declare-queue("hello") -> $queue {
			$queue.consume;
			whenever $queue.message-supply.map( -> $v { $v.body.decode }) -> $data {
				emit EventSource::Server::Event.new(type => 'hello', :$data);
			}
		}
	}
};

my $es = EventSource::Server.new(:$supply);

my $application = route {
	get -> 'greet', $name {
		content 'text/event-stream; charset=utf-8', $es.out-supply;
	}
}
my Cro::Service $hello = Cro::HTTP::Server.new:
	:host, :port, :$application;
$hello.start;

react whenever signal(SIGINT) { $hello.stop; exit; }

	var EventSource = require('eventsource');

	var event = process.argv[2] || 'message';

	console.info(event);
	var v = new EventSource(' http://127.0.0.1:10000');

	v.addEventListener(event, function(e) {
		console.info(e);

	}, false);

zef install LIVR

use LIVR;

# Automatically trim all values before validation
LIVR::Validator.default-auto-trim(True);

my $validator = LIVR::Validator.new(livr-rules => {
    name      => 'required',
    email     => [ 'required', 'email' ],
    gender    => { one_of => ['male', 'female'] },
    phone     => { max_length => 10 },
    password  => [ 'required', {min_length => 10} ],
    password2 => { equal_to_field => 'password' }
});

my $user-data = {
    name      => 'Viktor',
    email     => 'viktor@mail.com',
    gender    => 'male',
    password  => 'mypassword123',
    password2 => 'mypassword123'
}


if my $valid-data = $validator.validate($user-data) {
    # $valid-data is clean and does contain only fields
    # which have validation and have passed it
    $valid-data.say;
} else {
    my $errors = $validator.errors();
    $errors.say;
}

{
    name  => { required => [] },
    phone => { max_length => [10] }
}

{
    phone => { max_length => 10 }
}

{
    name => 'required'
}

{
    name => [ 'required', { max_length => 10 } ]
}

use LIVR;

my $validator = LIVR::Validator.new(livr-rules => {
    name  => 'required',
    phone => {max_length => 10},
    address => {'nested_object' => {
        city => 'required',
        zip  => ['required', 'positive_integer']
    }}
});

my $user-data = {
    name  => "Michael",
    phone => "0441234567",
    address => {
        city => "Kiev",
        zip  => "30552"
    }
}

if my $valid-data = $validator.validate($user-data) {
    # $valid-data is clean and does contain only fields
    # which have validation and have passed it
    $valid-data.say;
} else {
    my $errors = $validator.errors();
    $errors.say;
}

my @game = [
    [4,0,0,0,0,0,0,0,0],
    [0,9,0,3,4,6,0,5,0],
    [5,8,0,0,9,0,0,0,6],
    [0,4,0,8,1,3,0,0,9],
    [0,0,0,5,0,4,0,0,0],
    [8,0,0,6,2,9,0,4,0],
    [3,0,0,0,5,0,0,6,2],
    [0,5,0,9,3,2,0,8,0],
    [0,0,0,0,0,0,0,0,1]
];

if ( 5 < 1|10 < 2 ) { say "Spooky" } else { say "Boo" }
Spooky

my $full-test = none( (^9 X ^9).map(-> ($x,$y) {
    @game[$y][$x];
} ) );
say so $full-test == 0;
False

subset Index of Int where 0 <= * <= 8;
sub row( Index $y ) {
    return (^9).map( { ( $_, $y ) } );
}
sub col( Index $x ) {
     return (^9).map( { ( $x, $_ ) } );
}
multi sub square( Index $sq ) {
    my $x = $sq % 3 * 3;
    my $y = $sq div 3 * 3;
    return self.square( $x, $y );
}
multi sub square( Index $x, Index $y ) {
     my $tx = $x div 3 * 3;
     my $ty = $y div 3 * 3;
     return ( (0,1,2) X (0,1,2) ).map( -> ( $dx, $dy ) {
        ( $tx + $dx, $ty + $dy )
    } );
}

my $complete-all = all(
     (^9).map(
        {
            |(
                one( row( $_ ).map( -> ( $x, $y ) {
                    @game[$y][$x]
                } ) ),
                one( col( $_ ).map( -> ( $x, $y ) {
                    @game[$y][$x]
                } ) ),
                one( square( $_ ).map( -> ( $x, $y ) {
                    @game[$y][$x]
                } ) )
            )
        }
    )
);

say [&&] (1..9).map( so $complete-all == * );
False

$valid-all = all(
    (^9).map(
        {
            |(
                one(
                    none( row( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) ),
                    one( row( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) )
                ),
                one(
                    none( col( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) ),
                    one( col( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) )
                ),
                one(
                    none( square( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) ),
                    one( square( $_ ).map( -> ( $x, $y ) {
                        @game[$y][$x]
                    } ) )
                )
            )
        }
    )
);

say [&&] (1..9).map( so $valid-all == * );
True

sub possible( Index $x, Index $y, @game ) {
    return () if @game[$y][$x] > 0;

    (
        (1..9)
            (-)
        set(
            ( row($y).map( -> ( $x, $y ) {
                @game[$y][$x]
            } ).grep( * > 0 ) ),
            ( col($x).map( -> ( $x, $y ) {
                @game[$y][$x]
            } ).grep( * > 0 ) ),
            ( square($x,$y).map( -> ( $x, $y ) {
                @game[$y][$x]
            } ).grep( * > 0 ) )
        )
    ).keys.sort;
 }

my @updates;
repeat {
    @updates = (^9 X ^9).map( -> ($x,$y) {
        ($x,$y) => possible($x,$y,@game)
    } ).grep( *.value.elems == 1 );
    for @updates -> $pair {
        my ( $x, $y ) = $pair.key;
        @game[$y][$x] = $pair.value[0];
    }
} while ( @updates.elems > 0 &&
          ! [&&] (1..9).map( so $complete-all == * ) );

(1,2,3),(2,3,4),(),(),(4,5),(),(),(2,3,4),()

say (1,2,3) (^) (2,3,4) (^) () (^) () (^) (4,5) (^) () (^) () (^) (2,3,4) (^) ()
set(1 5)

say [(^)] (1,2,3),(2,3,4),(),(),(4,5),(),(),(2,3,4),()
set(1 5)

my @updates;
for ^9 -> $idx {
    my $only = [(^)] row($idx).map( -> ( $x,$y ) {
        possible($x,$y,@game)
    } );
    for $only.keys -> $val {
        for row($idx) -> ($x,$y) {
            if $val (elem) possible($x,$y,@game) {
                @updates.push( ($x,$y) => $val );
            }
        }
    }
}

say set(1,5){1}
True

zef install Game::Sudoku

class A {
    has $.value = 42;
    method TWEAK(:$value = 0) { # default prevents warning
        # change the attribute if the default value is specified
        $!value = 666 if $value == $!value;
    }
}
# no value specified, it gets the default attribute value
dd A.new;              # A.new(value => 42)

# value specified, but it is not the default
dd A.new(value => 77); # A.new(value => 77)

# value specified, and it is the default
dd A.new(value => 42); # A.new(value => 666)

my int $a;
    await (^5).map: {
        start { ++$a for ^100000 }
    }
    say $a; # something like 419318

   my int $a;
    my $l = Lock.new;
    await (^5).map: {
       start {
           for ^100000 {
               $l.protect( { ++$a } )
           }
       }
    }
    say $a; # 500000

   my atomicint $a;
    await (^5).map: {
        start { ++⚛$a for ^100000 }
    }
    say $a; # 500000

say "BUTTERFLY".parse-names; # 🦋

my $t = "THUMBS UP SIGN, EMOJI MODIFIER FITZPATRICK TYPE";
print "$t-$_".parse-names for 3..6; # 👍🏼👍🏽👍🏾👍🏿

# sort by codepoint value
say <ä a o ö>.sort; # (a o ä ö)
# sort using Unicode Collation Algorithm
say <ä a o ö>.collate; # (a ä o ö)

say "a" cmp "Z"; # More
say "a" unicmp "Z"; # Less

say (^Inf).grep(*.is-prime)[999]; # 7919

say (^Inf).grep(*.is-prime).skip(999).head; # 7919

my $b = Buf.new(100..105);
$b.subbuf-rw(2,3) = Blob.new(^5);
say $b.perl; # Buf.new(100,101,0,1,2,3,4,105)

my $b = Buf.allocate(10,(1,2,3));
say $b.perl; # Buf.new(1,2,3,1,2,3,1,2,3,1)
$b.reallocate(5);
say $b.perl; # Buf.new(1,2,3,1,2)

use Telemetry;
say T<wallclock cpu max-rss>; # (138771 280670 82360)

use Telemetry;
snap;
Nil for ^10000000;  # something that takes a bit of time

Telemetry Report of Process #60076
Number of Snapshots: 2
Initial/Final Size: 82596 / 83832 Kbytes
Total Time:           0.55 seconds
Total CPU Usage:      0.56 seconds
No supervisor thread has been running

wallclock  util%  max-rss
   549639  12.72     1236
--------- ------ --------
   549639  12.72     1236

Legend:
wallclock  Number of microseconds elapsed
    util%  Percentage of CPU utilization (0..100%)
  max-rss  Maximum resident set size (in Kbytes)

use Telemetry;
snapper;
Nil for ^10000000;  # something that takes a bit of time

Telemetry Report of Process #60722
Number of Snapshots: 7
Initial/Final Size: 87324 / 87484 Kbytes
Total Time:           0.56 seconds
Total CPU Usage:      0.57 seconds
No supervisor thread has been running

wallclock  util%  max-rss
   103969  13.21      152
   101175  12.48
   101155  12.48
   104097  12.51
   105242  12.51
    44225  12.51        8
--------- ------ --------
   559863  12.63      160

Legend:
wallclock  Number of microseconds elapsed
    util%  Percentage of CPU utilization (0..100%)
  max-rss  Maximum resident set size (in Kbytes)

$ RAKUDO_EXCEPTIONS_HANDLER=JSON raku -e '42 = 666'
{
  "X::Assignment::RO" : {
    "value" : 42,
    "message" : "Cannot modify an immutable Int (42)"
  }
}

1 3 3 1

0 1 3 3 1

1 3 3 1
+ + + +
0 1 3 3 1
=
1 4 6 4 1

for ^16 { put (+combinations($^row,$_) for 0..$row) }

.put for 1, { |$_,0 Z+ 0,|$_ } ... 16

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1
1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1

.base(2).comb(~1) %% 2 && .say for ^50

‘a’..‘z’ ⊆ .lc.comb && .say for @*ARGS

-0.5 0.00625 0.025 0.0375 0.05 0.0625 0.083333 0.1
0.111111 0.125 0.142857 0.15 0.166667 0.1875 0.2
0.25 0.333333 0.375 0.4 0.416667 0.5 0.583333 0.6
0.625 0.666667 0.75 0.8 0.833333 0.875 0.916667 1
1.5 2 2.5 3 3.5 4 4.5 5 5.5 6 6.5 7 7.5 8 8.5 9 10
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
45 46 47 48 49 50 60 70 80 90 100 200 300 400 500
600 700 800 900 1000 2000 3000 4000 5000 6000 7000
8000 9000 10000 20000 30000 40000 50000 60000 70000
80000 90000 100000 200000 216000 300000 400000
432000 500000 600000 700000 800000 900000 1000000
100000000 10000000000 1000000000000

say 5max3  # ERROR

say ⑤max③  # OUTPUT: «5␤»

puts 10<30?1:2   # ruby

say 10 <30??1!!2 # perl 6

say 5>3>say(42)

say ‘yes!’ if 5==3|5

say (‘♔’…‘♙’)».uniname».words»[2]
#   KING QUEEN ROOK BISHOP KNIGHT PAWN

say ‘1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144381497587012203408058879544547492461856953648644492410443207713449470495658467885098743394422125448770664780915884607499887124007652170575179788341662562494075890697040002812104276217711177780531531714101170466659914669798731761356006708748071013179523689427521948435305678300228785699782977834784587822891109762500302696156170025046433824377648610283831268330372429267526311653392473167111211588186385133162038400522216579128667529465490681131715993432359734949850904094762132229810172610705961164562990981629055520852479035240602017279974717534277759277862561943208275051312181562855122248093947123414517022373580577278616008688382952304592647878017889921990270776903895321968198615143780314997411069260886742962267575605231727775203536139362’

my @digits-in-base37 = 9123607.polymod(37 xx *); # Base conversion

☠☠☠⚠⚠⚠ WARNING! WARNING! WARNING! ⚠⚠⚠☠☠☠
THIS WILL MAKE YOUR COMPUTER IMPLODE!
UNICODE STRINGS ARE SUBJECT TO NORMALIZATION SO YOUR
DATA WILL NOT BE PRESERVED. HIDE YOUR KIDS, HIDE YOUR
WIFE. HIDE YOUR KIDS, HIDE YOUR WIFE. HIDE YOUR KIDS,
HIDE YOUR WIFE. AND HIDE YOUR HUSBAND.
☠☠☠⚠⚠⚠ WARNING! WARNING! WARNING! ⚠⚠⚠☠☠☠

󻁾񤍠򷒋󜹕󘶸񙦅񨚑򙯬񗈼𢍟𪱷򡀋𢕍򌠐񘦵𔇆򅳒򑠒󌋩򯫞򶝠򚘣򣥨񫵗𿞸􋻩񱷳󟝐󮃞󵹱񿢖𛒕𺬛󊹛󲝂򺗝𭙪񰕺𝧒򊕆𘝞뎛􆃂򊥍񲽤򩻛󂛕磪󡯮끝򰯬󢽈󼿶󘓥򮀓񽑖򗔝󃢖񶡁􁇘󶪼񌍌񛕄񻊺򔴩寡񿜾񿸶򌰘񡇈򦬽𥵑󧨑򕩃򳴪񾖾򌯎󿥐񱛦𱫞𵪶򁇐󑓮򄨠򾎹𛰑𗋨䨀򡒶𰌡򶟫񦲋𧮁􍰍񲍚񰃦𦅂󎓜󸾧󉦩󣲦򄉼񿒣𸖉񿡥󬯞嗟𧽘񿷦򠍍🼟򇋹񖾷𖏕񟡥󜋝􋯱񤄓򭀢򌝓𱀉𫍡󬥝򈘏򞏡񄙍𪏸࿹𺐅񢻳򘮇𐂇񘚡ந򾩴󜆵𰑕򰏷񛉿򢑬򭕴𨬎󴈂􋵔򆀍񖨸􂳚󽡂󎖪񡉽񕧣񎗎򝤉򡔙񆔈󖾩󅾜񋩟򝼤񯓦󐚉񟯶򄠔𦔏򲔐o

say ‘1.’,:1114110[‘o򲔐𦔏򄠔񟯶󐚉񯓦򝼤񋩟󅾜󖾩񆔈򡔙򝤉񎗎񕧣񡉽󎖪󽡂􂳚񖨸򆀍􋵔󴈂𨬎򭕴򢑬񛉿򰏷𰑕󜆵򾩴ந񘚡𐂇򘮇񢻳𺐅࿹𪏸񄙍򞏡򈘏󬥝𫍡𱀉򌝓򭀢񤄓􋯱󜋝񟡥𖏕񖾷򇋹🼟򠍍񿷦𧽘嗟󬯞񿡥𸖉񿒣򄉼󣲦󉦩󸾧󎓜𦅂񰃦񲍚􍰍𧮁񦲋򶟫𰌡򡒶䨀𗋨𛰑򾎹򄨠󑓮򁇐𵪶𱫞񱛦󿥐򌯎񾖾򳴪򕩃󧨑𥵑򦬽񡇈򌰘񿸶񿜾寡򔴩񻊺񛕄񌍌󶪼􁇘񶡁󃢖򗔝񽑖򮀓󘓥󼿶󢽈򰯬끝󡯮磪󂛕򩻛񲽤򊥍􆃂뎛𘝞򊕆𝧒񰕺𭙪򺗝󲝂󊹛𺬛𛒕񿢖󵹱󮃞󟝐񱷳􋻩𿞸񫵗򣥨򚘣򶝠򯫞󌋩򑠒򅳒𔇆񘦵򌠐𢕍򡀋𪱷𢍟񗈼򙯬񨚑񙦅󘶸󜹕򷒋񤍠󻁾’.ords]

enum Side «:Up('U') :Down('D') :Front('F') :Back('B') :Left('L') :Right('R')»;
enum Colors «:Red('R') :Green('G') :Blue('B') :Yellow('Y') :White('W') :Orange('O')»;

class Cube::Three {
    has %!Sides;
    ...
    submethod BUILD() {
        %!Sides{Up}    = [White  xx 9];
        %!Sides{Front} = [Red    xx 9];
        ...
    }
}

         W0 W1 W2
         W3 W4 W5
         W6 W7 W8
G2 G5 G8 R2 R5 R8 B2 B5 B8 O2 O5 O8
G1 G4 G7 R1 R4 R7 B1 B4 B7 O1 O4 O7
G0 G3 G6 R0 R3 R6 B0 B3 B6 B0 B3 B6
         Y0 Y1 Y2
         Y3 Y4 Y5
         Y6 Y7 Y8

method F {
    self!rotate-clockwise(Front);
    self!fixup-sides([
        Pair.new(Up,    [6,7,8]),
        Pair.new(Right, [2,1,0]),
        Pair.new(Down,  [2,1,0]),
        Pair.new(Left,  [6,7,8]),
    ]);
    self;
}

# 0 1 2    6 3 0
# 3 4 5 -> 7 4 1
# 6 7 8    8 5 2
method !rotate-clockwise(Side \side) {
    %!Sides{side}[0,1,2,3,5,6,7,8] = %!Sides{side}[6,3,0,7,1,8,5,2];
}

method F2 { self.F.F; }
method Fʼ { self.F.F.F; }

say Cube::Three.new.U2.D2.F2.B2.R2.L2;

      W Y W
      Y W Y
      W Y W
G B G R O R B G B O R O
B G B O R O G B G R O R
G B G R O R B G B O R O
      Y W Y
      W Y W
      Y W Y

method gist {
    my $result;
    $result = %!Sides{Up}.rotor(3).join("\n").indent(6);
    $result ~= "\n";

    for 2,1,0 -> $row {
        for (Left, Front, Right, Back) -> $side {
            my @slice = (0,3,6) >>+>> $row;
            $result ~= ~%!Sides{$side}[@slice].join(' ') ~ ' ';
        }
        $result ~= "\n";
    }
    $result ~= %!Sides{Down}.rotor(3).join("\n").indent(6);
    $result;
}

method dump {
    gather for (Up, Front, Right, Back, Left, Down) -> $side {
        take %!Sides{$side}.join('');
    }.join('|');
}

use Test; use Cube::Three;
my $a = Cube::Three.new();
is $a.R.U2.Rʼ.Uʼ.R.Uʼ.Rʼ.Lʼ.U2.L.U.Lʼ.U.L.dump,
    'WWBWWWWWB|RRRRRRRRW|BBRBBBBBO|OOWOOOOOO|GGGGGGGGG|YYYYYYYYY',
    'corners rotation';

method rotate-F-U {
     self!rotate-clockwise(Right);
     self!rotate-counter-clockwise(Left);

     # In addition to moving the side data, have to
     # re-orient the indices to match the new side.
     my $temp = %!Sides{Up};
     %!Sides{Up}    = %!Sides{Front};
     self!rotate-counter-clockwise(Up);
     %!Sides{Front} = %!Sides{Down};
     self!rotate-clockwise(Front);
     %!Sides{Down}  = %!Sides{Back};
     self!rotate-clockwise(Down);
     %!Sides{Back}  = $temp;
     self!rotate-counter-clockwise(Back);
     self;
}

method solved {
    for (Up, Down, Left, Right, Back, Front) -> $side {
        return False unless
            %!Sides{$side}.all eq %!Sides{$side}[4];
    }
    return True;
}

method scramble {
    my @random = <U D F R B L>.roll(100).squish[^10];
    for @random -> $method {
        my $actual = $method ~ ("", "2", "ʼ").pick(1);
        self."$actual"();
    }
}

method solve {
    self.solve-top-cross;
}

method solve-top-cross {
    sub completed {
        %!Sides{Up}[1,3,5,7].all eq 'W' &&
        %!Sides{Front}[5] eq 'R' &&
        %!Sides{Right}[5] eq 'B' &&
        %!Sides{Back}[5]  eq 'O' &&
        %!Sides{Left}[5]  eq 'G';
    }
    ...
    MAIN:
    while !completed() {
        # Move white-edged pieces in second row up to top

        # Move incorrectly placed pieces in the top row to the middle

        # Move pieces from the bottom to the top
    }
}

my @middle-edges =
    [Front, Right],
    [Right, Back],
    [Back,  Left],
    [Left,  Front],
;

for @middle-edges -> $edge {
    my $side7 = $edge[0];
    my $side1 = $edge[1];
    my $color7 = %!Sides{$side7}[7];
    my $color1 = %!Sides{$side1}[1];
    if $color7 eq 'W' {
        # find number of times we need to rotate the top:
        my $turns = (
            @ordered-sides.first($side1, :k) -
            @ordered-sides.first(%expected-sides{~$color1}, :k)
        ) % 4;
        self.U for 1..$turns;
        self."$side1"();
        self.Uʼ for 1..$turns;
        next MAIN;
    } elsif $color1 eq 'W' {
        my $turns = (
            @ordered-sides.first($side7, :k) -
            @ordered-sides.first(%expected-sides{~$color7}, :k)
        ) % 4;
        self.Uʼ for 1..$turns;
        self."$side1"();
        self.U for 1..$turns;
        next MAIN;
    }
}

use Cube::Three;
my $cube = Cube::Three.new();
$cube.scramble;
say $cube;
say '';
$cube.solve;
say $cube;

    W G G
      Y W W
      Y Y Y
O O B R R R G B O Y Y B
R G O B R R G B G W O B
Y B B R O W G G G W W O
      W W O
      Y Y O
      B R R

      Y W W
      W W W
      G W R
O G W O R Y B B G R O G
Y G G R R B R B Y R O G
O O R Y O W O O R W Y B
      G G B
      B Y Y
      Y B B

my %webservices =
  '/ws1' => ( &ws1, 'html' ),
  '/ws2' => ( &ws2, 'json' )
;

wap(:$server-ip, :$server-port, :$default-html, :%webservices);

react {
  whenever IO::Socket::Async.listen($server-ip,$server-port) -> $conn {
    whenever $conn.Supply(:bin) -> $buf {
      my $response = response(:$buf, :$current-dir, :$default-html, :%webservices);
      $conn.write: $response.encode('UTF-8');
      $conn.close;
    }
  }
}

given $path {
  when %webservices{"$_"}:exists {
    my ( &ws, $direct-type ) = %webservices{"$_"};
    my $type = content-type(:$direct-type);
    return response-headers(200, $type) ~ &ws(:$get-params, :$body);
  }
  ..
}

sub ws1 ( :$get-params, :$body ) is export {
  if $get-params { return 'From ws1: ' ~ $get-params; }
  if $body { return 'From ws1: ' ~ $body; }
}

given $path {
..
  default {
    my $filepath = "$current-dir/public/$path";
    my $type = content-type(:$filepath);
    return response-headers(200, $type) ~ slurp "$current-dir/public/$path";
  }
}

#!/usr/bin/perl -CSDA

use strict;
use warnings;
use utf8;
use Encode qw/encode_utf8 decode_utf8/;
use Getopt::Long;
use Digest::MD5;
use Term::ANSIColor;
use Term::ProgressBar;
use File::Find;
use File::Basename;
use Data::Dumper;

use Digest::MD5;
use Terminal::ANSIColor;
use Terminal::Spinners;

# Define our command-line arguments.
my %opts = ( 'blocksize' => 16384 );
GetOptions(\%opts, "verify=s", "create=s", "update=s", "files", "blocksize=s", "help!");

multi MAIN (Str :$create, *@files where { so @files }) { ... }
multi MAIN (Str :$update, *@files) { ... }
multi MAIN (Str :$verify, *@files) { ... }
multi MAIN (*@files where { so @files }) { ... }

#| Verify the MD5 sums in a file that conforms to md5sum output:
#|
multi MAIN (Str :$verify, *@files) { ... }

sub load_md5sum_file
{
	my ($filename) = @_;
	my @plan;

	open(my $fh, '<:utf8', $filename) or die "Couldn't open '$filename' : $!\n";
	my $linenum = 0;
	while (my $line = <$fh>) {
		chomp $line;
		$linenum++;
		if ($line =~ /^(?\p{ASCII_Hex_Digit}{32})  (?.*)$/) {
			# Checksum and filename compatible with md5sum output.
			push @plan, create_plan_for_filename($+{filename}, $+{md5});

		} elsif ($line =~ /^(?\p{ASCII_Hex_Digit}{32})  (?.*)$/) {
			# Checksum and filename compatible with md5sum's manpage but not valid for the actual program.
			# We'll use it, but complain.
			print STDERR colored("Warning: ", 'bold red'), colored("md5sum entry '", 'red'), $line, colored("' on line $linenum of file $filename is using only one space, not two - this doesn't match the output of the actual md5sum program!.", 'red'), "\n";
			push @plan, create_plan_for_filename($+{filename}, $+{md5});

		} elsif ($line =~ /^\s*$/) {
			# Blank line, ignore.

		} else {
			# No idea. Best not to keep quiet, it could be a malformed checksum line and we don't want to just quietly skip the file if so.
			print STDERR colored("Warning: ", 'bold red'), colored("Unrecognised md5sum entry '", 'red'), $line, colored("' on line $linenum of file $filename.", 'red'), "\n";
			push @plan, { error => "Unrecognised md5sum entry" };
		}
	}
	close($fh) or die "Couldn't close '$filename' : $!\n";

	return @plan;
}

grammar MD5SUM {
	token TOP        { <md5> <spacer> <filehandle> }
	token md5        { <xdigit> ** 32 }
	token spacer     { \s+ }
	token filehandle { .* }
}

sub load-md5sum-file (Str $filehandle where { $filehandle.IO.f }) {
	my MD5Plan @plans;

	PARSE: for $filehandle.IO.lines(:close) -> $line {
		next PARSE if !$line; # We don't get worked up over blank lines.

		my $match = MD5SUM.parse($line);

		if (!$match) {
			say $*ERR: colored("Couldn't parse $line", $ERROR_COLOUR);
			next PARSE;
		}

		if (!$match<filehandle>.IO.f) {
			say $*ERR: colored("{ $match<filehandle> } isn't an existing file.", $ERROR_COLOUR);
			next PARSE;
		}

		if ($match<spacer>.chars == 2) {
			@plans.push(MD5Plan.new($match<filehandle>.Str, $match<md5>.Str));
		}
		else {
			say $*ERR: colored("'$line' does not match the output of md5sum: wrong number of spaces.", $WARNING_COLOUR);
			@plans.push(MD5Plan.new($match<filehandle>.Str, $match<md5>.Str));
		}
	}

	 return @plans;
}

sub save_md5sum_file
{
	my ($filename, @plan) = @_;

	my $fh;
	unless (open($fh, '>:utf8', $filename)) {
		...
	}
	foreach my $plan_entry (@plan) {
		next unless $plan_entry->{correct_md5} && $plan_entry->{filename};
		print $fh "$plan_entry->{correct_md5}  $plan_entry->{filename}\n";
	}
	close($fh) or die "Couldn't close '$filename' : $!\n";
}

sub save-md5sum-file (Str $filehandle, @plans) {
	my $io = $filehandle.IO.open: :w;

	WRITE: for @plans -> $plan {
		next WRITE unless $plan.computed-md5 && $plan.filehandle;

		$io.say("{ $plan.computed-md5 }  { $plan.filehandle }");
	}

	$io.close;
}

sub run_md5_file
{
	my ($plan_entry, $progress_fn) = @_;

	# We use the OO interface to Digest::MD5 so we can feed it data a chunk at a time.
	my $md5 = Digest::MD5->new();
	my $current_bytes_read = 0;
	my $buffer;
	$plan_entry->{start_time} = time();
	$plan_entry->{elapsed_time} = 0;
	$plan_entry->{elapsed_bytes} = 0;

	# 3 argument form of open() allows us to specify 'raw' directly instead of using binmode and is a bit more modern.
	open(my $fh, '<:raw', $plan_entry->{filename}) or die "Couldn't open file $plan_entry->{filename}, $!\n";

	# Read the file in chunks and feed into md5.
	while ($current_bytes_read = read($fh, $buffer, $opts{blocksize})) {
		$md5->add($buffer);
		$plan_entry->{elapsed_bytes} += $current_bytes_read;
		$plan_entry->{elapsed_time} = time() - $plan_entry->{start_time};
		&$progress_fn($plan_entry->{elapsed_bytes});
	}
	# The loop will exit as soon as read() returns 0 or undef. 0 is normal EOF, undef indicates an error.
	die "Error while reading $plan_entry->{filename}, $!\n" if ( ! defined $current_bytes_read);

	close($fh) or die "Couldn't close file $plan_entry->{filename}, $!\n";

	# We made it out of the file alive. Store the md5 we computed. Note that this resets the Digest::MD5 object.
	$plan_entry->{computed_md5} = $md5->hexdigest();
}

sub calc-md5-sum (MD5Plan $plan) {
    my $md5 = Digest::MD5.new;

    print "Calculating MD5 sum for { $plan.filehandle }       "; # We need some space for the spinner to take up.
	                                                             # I like 'bounce', so I need 6 spaces for the spinner
	                                                             # + an extra one to separate it from the filehandle.

	my Buf $buffer = $plan.filehandle.IO.slurp(:close, :bin);

	my $decoded = $buffer.decode('iso-8859-1');

	my $spinner = Spinner.new(type => 'bounce');

	my $promise = Promise.start({
		$md5.md5_hex($decoded)
	});

	until $promise.status {
		$spinner.next;
	}

	say ''; # Add a new line after the spinner.

	$plan.computed-md5 = $promise.result;
}

#| This reads a letter file
sub MAIN ( Str $file = "letter.txt" ) {
    my $letter =$file.IO.slurp;
    my $parsed = Santa-Letter.parse($letter);
    say $parsed<signature>.trim;
}

./get-signed.p6 --help

Usage:
  ./get-signed.p6 [] -- This reads a letter file

#|{ This reads a letter file in text format.
With no arguments, it will read the C<letter.txt> file.
}
sub MAIN ( Str $file = "letter.txt" ) {
    my $letter =$file.IO.slurp;
    my $parsed = Santa-Letter.parse($letter);
    say $parsed<signature>.trim;
    say $=pod[0].perl;
}

raku --doc get-signed.p6

sub MAIN(
	Str $file = "letter.txt",
)
This reads a letter file in text format. With no arguments, it will read the C file.

Pod::Block::Declarator.new(WHEREFORE => sub MAIN (Str $file = "letter.txt") { #`(Sub|81308800) ... }, config => {}, contents => [])

=begin pod

=head1 NAME

Santa-Letter - A grammar for letters to Santa for the L<Raku Advent Calendar|https://rakuadvent.wordpress.com>

=head1 SYNOPSIS

Parses letters formatted nicely and written by all good kids in the world.

=end pod

NAME

Santa-Letter - A grammar for letters to Santa for the Raku Advent
Calendar

SYNOPSIS

Parses letters formatted nicely and written by all good kids in the
world.

raku --doc=HTML Santa-Letter.pm6

raku --doc=Pager Santa-Letter.pm6

=begin code

use Santa-Letter;

say Santa-Letter.parse("Dear Santa\nAll I want for Christmas\nIs you\n Mariah");

=end code

our $pod = $=pod[0];

say $Santa-Letter::pod.perl;

say Dump( $Santa-Letter::pod, :indent(4), :3max-recursion );

=head1 SYNOPSIS

Parses letters formatted nicely and written by all good kids in the world.

=begin code

use Santa-Letter;

say Santa-Letter.parse("Dear Santa\nAll I want for Christmas\nIs you\n Mariah");

=end code

You can also access particular elements in the letter, as long as they are included on the grammar

    my $letter="Dear Santa,\nI have not been that good.\nJust a paper clip will do\n Donald"
    say Santa-Letter.parse($letter)<signature>

Also

=for code :notest :reason("Variable defined above")
say "The letter signed by ", Santa-Letter.parse($letter),
    " has ", Santa-Letter.parse($letter).elems, " paragraphs";

=end pod

for $Santa-Letter::pod.contents -> $block {
    next if $block !~~ Pod::Block::Code;
    if $block.config<notest> {
        say "→ Block\n\t"~ $block.contents
            ~ "\n\t❈ Not tested since \'" ~ $block.config<reason> ~ "\'";
    } else {
        my $code = $block.contents.join("");
        say "→ Block\n\t"~ $block.contents;
        try {
            EVAL $code;
        }
        if ( $! ) {
            say "\n\t✘ Produces error \"$!\"", "\n" xx 2;
        } else {
            say "✔ is OK\n";
        }
    }
}

→ Block
	my $letter="Dear Santa,\nI have not been that good.\nJust a paper clip will do\n Donald"
say Santa-Letter.parse($letter)

	✘ Produces error "Two terms in a row across lines (missing semicolon or comma?)"(

)

my $x = "Christmas";

say("Merry " ~ $x);       # reading
$x = "Easter";            # writing

# Before
my $veggie = "potato";
say "$veggie, and that's all I have to say about that!";

# After
(-> $veggie {
    say "$veggie, and that's all I have to say about that!";
})("potato");

my $lexical = "mainline";
my $*dynamic = "mainline";

sub foo() {
    my $lexical = "foo";
    my $*dynamic = "foo";
    bar();
}

sub bar() {
    say $lexical;       # "mainline"
    say $*dynamic;      # "foo"
}

foo();

use experimental :macros;

macro moo {
    my $counter = 0;
    quasi {
        say ++$counter;
    }
}

for ^10 {
    moo;
}

use Object::Delayed;
my $dbh = slack { DBIish.connect(...) }

use Object::Delayed;
my $dbh = slack { DBIish.connect(...) }
my $sth = slack { $dbh.prepare(...) }

use Object::Delayed;
my $dbh = slack { DBIish.connect(...) }
my $sth = slack { $dbh.prepare(...) }
# lotsa program
if $needed {
    $sth.execute;  # opens database handle + prepares query
}

LEAVE .disconnect with $dbh;

use Object::Delayed;
my $foo = catchup { sleep 5; "Merry" }      # sleep is just
my $bar = catchup { sleep 9; "Christmas" }  # another word
my $baz = catchup { sleep 8; "everyone" }   # for baking
say "$foo $bar, $baz!";
say "Took { now - INIT now } seconds";
# Merry Christmas, everybody!
# Took 9.008 seconds

constant number-of-states = 3;
constant field-width = 60;

my int8 @field;

sub init-field {
    @field = (^number-of-states).roll(field-width);
}

sub output-a-row {

    for @field {
        # Using the unicode characters "Light shade", "Medium shade", and "Dark shade"
        # and printing each field twice so they look square rather than slim and tall.
        print ["\x2591", "\x2592", "\x2593"][$_] x 2
    }

    say "";
}

init-field;
output-a-row;

sub simulate-step {
    my int8 @output;

    for ^field-width -> $x {
        # do some calculations here
    }

    @field = @output;
}

sub simulate-step {
    my int8 @output;

    for ^field-width -> $x {
        my $left   = $x - 1 < 0 ?? 0 !! @field[$x - 1];
        my $middle = @field[$x];
        my $right  = $x + 1 >= field-width ?? 0 !! @field[$x + 1];

        # do some calculation with $left, $middle, and $right
        # then push the result into @output
    }

    @field = @output;
}

000  001  002
010  011  012
020  021  022
100  101  102
110  111  112
120  121  122
200  201  202
210  211  212
220  221  222

my int8 @lookup-table = (^number-of-states).roll(3³);

sub simulate-step {
    my int8 @output;

    for ^field-width -> $x {
        my $left   = $x - 1 < 0 ?? 0 !! @field[$x - 1];
        my $middle = @field[$x];
        my $right  = $x + 1 >= field-width ?? 0 !! @field[$x + 1];

        my $index = $left * 9 + $middle * 3 + $right;

        @output.push(@lookup-table[$index]);
    }

    @field = @output;
}

constant number-of-states = 3;
constant field-width = 60;

my int8 @field;

sub init-field {
    @field = (^number-of-states).roll(field-width);
}
init-field;

sub output-a-row {

    for @field {
        # Using the unicode characters "Light shade", "Medium shade", and "Dark shade"
        # and printing each field twice so they look square rather than slim and tall.
        print ["\x2591", "\x2592", "\x2593"][$_] x 2
    }

    say "";
}

my int8 @lookup-table = (^number-of-states).roll(3³);

sub simulate-step {
    my int8 @output;

    for ^field-width -> $x {
        my $left   = $x - 1 < 0 ?? 0 !! @field[$x - 1];
        my $middle = @field[$x];
        my $right  = $x + 1 >= field-width ?? 0 !! @field[$x + 1];

        my $index = $left * 9 + $middle * 3 + $right;

        @output.push(@lookup-table[$index]);
    }

    @field = @output;
}

for ^100 {
    simulate-step;
    output-a-row;
}

my int8 @lookup-table = <0 0 2 0 0 0 1 2 0 0 1 1 2 1 1 2 1 1 1 0 1 2 2 0 2 1 1>;

constant number-of-states = 4;

# the size of the lookup table should be based on the number of states
my int8 @lookup-table = (^number-of-states).roll(number-of-states³);

sub output-a-row {

    for @field {
        # add unicode character "Full block" for the fourth state
        print ["\x2591", "\x2592", "\x2593", "\x2588"][$_] x 2
    }

    say "";
}

my $index = $left * number-of-states * number-of-states
            + $middle * number-of-states
            + $right;

# three states, but four neighbors
constant number-of-states = 3;
constant number-of-neighbors = 4;

# ...

# exponentiate number-of-states with number-of-neighbors, like
# you would to get a number-of-neighbors number in base number-of-states.
my int8 @lookup-table = (^number-of-states).roll(number-of-states ** number-of-neighbors);

sub simulate-step {
   my int8 @output;

   for ^field-width -> $x {
       my $leftleft   = $x <= 1 ?? 0 !! @field[$x - 2];
       my $left       = $x == 0 ?? 0 !! @field[$x - 1];

       my $right      = $x == field-width - 1 ?? 0 !! @field[$x + 1];
       my $rightright = $x >= field-width - 2 ?? 0 !! @field[$x + 2];

       # many multiplications later ...
       my $index = $leftleft * number-of-states * number-of-states * number-of-states
                   + $left   * number-of-states * number-of-states
                   + $right  * number-of-states
                   + $rightright;

       @output.push(@lookup-table[$index]);
   }

   @field = @output;
}

for (0, |@field, 0).rotor(3 => -2) -> ($left, $middle, $right) {
    my $index = :3[$right, $middle, $left];
}

my $left   = 0;
my $middle = @field[0];
my $right  = @field[1];

for ^field-width -> $x {
    my $index = $left * number-of-states * number-of-states
            + $middle * number-of-states
            + $right;

    @output.push: @lookup-table[$index];
    $left = $middle;
    $middle = $right;
    $right = $x + 1 >= field-width ?? 0 !! @field[$x + 1];
}

my $left   = 0;
my $middle = @field[0] * 3;
my $right  = @field[1];

for ^field-width -> $x {
    my $index = $left + $middle + $right;

    @output.push: @lookup-table[$index];
    $left = $middle * 3;
    $middle = $right * 3;
    $right = $x + 1 >= field-width ?? 0 !! @field[$x + 1];
}

constant probability = 0.75e0;

my $left   = 0;
my $middle = @field[0] * 3;
my $right  = @field[1];

for ^field-width -> $x {
    if rand < probability {
        my $index = $left + $middle + $right;

        @output.push: @lookup-table[$index];
    }
    else {
        @output.push: $middle;
    }
    $left = $middle * 3;
    $middle = $right * 3;
    $right = $x + 1 >= field-width ?? 0 !! @field[$x + 1];
}

my $s; my @a;

grammar G {
    rule TOP {
        <variable-declaration>* %% ';'
    }

    rule variable-declaration {
        | <scalar-declaration>
        | <array-declaration>
    }

    rule scalar-declaration {
        'my' '$' <variable-name>
    }

    rule array-declaration {
        'my' '@' <variable-name>
    }

    token variable-name {
        \w+
    }
}

class A {
    has %!var;

    method TOP($/) {
        dd %!var;
    }

    method variable-declaration($/) {
        if $<scalar-declaration> {
            %!var{$<scalar-declaration><variable-name>} = 0;
        }
        elsif $<array-declaration> {
            %!var{$<array-declaration><variable-name>} = [];
        }
    }
}

G.parse('my $s; my @a;', :actions(A.new));

method scalar-declaration($/) {
    %!var{$<variable-name>} = 0;
}

method array-declaration($/) {
    %!var{$<variable-name>} = [];
}

rule variable-declaration {
    'my' [
        | <scalar-declaration>
        | <array-declaration>
    ]
}

rule scalar-declaration {
    '$' <variable-name>
}

rule array-declaration {
    '@' <variable-name>
}

my $s; my @a; $s = 3; $a[1] = 4;

grammar G {
    rule TOP {
        [
            | <variable-declaration>
            | <assignment>
        ]
        * %% ';'
    }

    # . . .

    rule assignment {
        '$' <variable-name> <index>? '=' <value>
    }

    rule index {
        '[' <value> ']'
    }

    token value {
        \d+
    }
}

method assignment($/) {
    if $<index> {
        %!var{$<variable-name>}[$<index><value>] = +$<value>;
    }
    else {
        %!var{$<variable-name>} = +$<value>;
    }
}

multi method assignment($/ where !$<index>) {
    %!var{$<variable-name>} = +$<value>;
}

multi method assignment($/ where $<index>) {
    %!var{$<variable-name>}[$<index><value>] = +$<value>;
}

my $a; my $b; $a = 3; $b = -3.14;

token value {
    | '-'? \d+
    | '-'? \d+ '.' \d+
}

Hash %!var = {:a(3), :b(-3.14)}

multi method assignment($/ where !$<index>) {
    %!var{$<variable-name>} = +$<value>;
}

token numish {
    [
    | 'NaN' >>
    | <integer>
    | <dec_number>
    | <rad_number>
    | <rat_number>
    | <complex_number>
    | 'Inf' >>
    | $<uinf>='∞'
    | <unum=:No+:Nl>
    ]
}

my $a; $a = 6 + 5 * (4 - 3);

grammar G {
    # . . .

    rule assignment {
        '$' <variable-name> <index>? '=' <expression>
    }

    multi token op(1) {
        '+' | '-'
    }

    multi token op(2) {
        '*' | '/'
    }

    rule expression {
        <expr(1)>
    }

    multi rule expr($n) {
        <expr($n + 1)>+ %% <op($n)>
    }

    multi rule expr(3) {
        | <value>
        | '(' <expression> ')'
    }

    # . . .
}

multi method assignment($/ where !$<index>) {
    use MONKEY-SEE-NO-EVAL;
    %!var{$<variable-name>} = EVAL($<expression>);
}

constant $tau = pi * 2;

my constant SPEED_LIGHT is export = 2.99792458e8;

my constant @months = ;
...
@months[9] = 'Hacktober';   # changing a name
push @months, 'Hogmannay';  # we'd all like more time after Christmas

Cannot modify and immutable Str (D)       # error for the assignment
# or
Cannot call 'push' on an immutable 'List' # error for the push

use v6;
unit class Astro::Constants:ver<0.0.1>:auth;

my constant SPEED_LIGHT is export = 2.99792458e8;
...

method ver { v0.0.1 }

=begin pod

=head1 DESCRIPTION

A set of constants used in Physics, Chemistry and Math

=end pod

use v6;
use lib ;
use Astro::Constants;

say "speed of light =\t", SPEED_LIGHT;

import GRAVITATIONAL as G;
...
$F_between_two_bodies = G * $mass1 * $mass2 / $distance**2;

mkdir ~/rakudo-packages && cd $_
wget https://github.com/nxadm/rakudo-pkg/releases/download/v2018.10-02/rakudo-pkg-Debian9_2018.10-02_amd64.deb
dpkg -i rakudo-pkg-Debian9_2018.10-02_amd64.deb

PATH=$PATH:/opt/rakudo-pkg/bin

source /etc/profile

raku -v
This is Rakudo version 2018.10 built on MoarVM version 2018.10
implementing Raku.c.

apt-get install git libssl-dev build-essential

git config --global url."https://".insteadOf git://

zef install cro

zef install --/test cro

use Cro::HTTP::Router;
use Cro::HTTP::Server;

my $application = route {
  get -> 'greet', $name {
  content 'text/plain', "Hello, $name!";
  }
}

my Cro::Service $hello = Cro::HTTP::Server.new(:host<0.0.0.0>, :port<10000>, :$application);

$hello.start;

react whenever signal(SIGINT) { $hello.stop; exit; }

raku server.p6

http://192.168.1.48:10000/greet/Ramiro

World-Schema DEFINITIONS AUTOMATIC TAGS ::=
BEGIN
  Rocket ::= SEQUENCE
  {
     name      UTF8String (SIZE(1..16)),
     message   UTF8String DEFAULT "Hello World" ,
     fuel      ENUMERATED {solid, liquid, gas},
     speed     CHOICE
     {
        mph    INTEGER,
        kmph   INTEGER
     }  OPTIONAL,
     payload   SEQUENCE OF UTF8String
  }
END

World-Schema DEFINITIONS IMPLICIT TAGS ::=
BEGIN
  Rocket ::= SEQUENCE
  {
     name      UTF8String (SIZE(1..16)),
     message   UTF8String DEFAULT "Hello World" ,
     fuel      ENUMERATED {solid, liquid, gas},
     speed     CHOICE
     {
        mph   [0] INTEGER,
        kmph  [1] INTEGER
     }  OPTIONAL,
     payload   SEQUENCE OF UTF8String
  }
END

class  Rocket {}

class Rocket {
    has $.name;
    has $.message is default("Hello World");
    has $.fuel;
    has $.speed;
    has @.payload;
}

enum Fuel <Solid Liquid Gas>;

class Rocket {
    has Str $.name;
    has Str $.message is default("Hello World");
    has Fuel $.fuel;
    has $.speed;
    has Str @.payload;
}

role ASNSequence { #`[ Elves Special Magic Truly Happens Here ] }

role ASNChoice { #`[ And even here ]  }

class SpeedChoice does ASNChoice {
    method ASN-choice() {
        # Description of: names, tags, types specificed by this CHOICE
        { mph => (0 => Int), kmph => (1 => Int) }
    }
}

class Rocket does ASNSequence {
    has Str $.name is UTF8String;
    has Str $.message is default-value("Hello World") is UTF8String;
    has Fuel $.fuel;
    has SpeedChoice $.speed is optional;
    has Str @.payload is UTF8String;

    method ASN-order { <$!name $!message $!fuel $!speed @!payload> }
}

my $rocket = Rocket.new(
    name => 'Falcon',
    fuel => Solid,
    speed => SpeedChoice.new((mph => 18000)),
    payload => [ "Car", "GPS" ]);

enum Fuel <Solid Liquid Gas>;

class SpeedChoice does ASNChoice {
    method ASN-choice { { mph => (1 => Int), kmph => (0 => Int) } }
}

class Rocket does ASNSequence {
    has Str $.name is UTF8String;
    has Str $.message is default-value("Hello World") is UTF8String;
    has Fuel $.fuel;
    has SpeedChoice $.speed is optional;
    has Str @.payload is UTF8String;

    method ASN-order { <$!name $!message $!fuel $!speed @!payload> }
}

my $rocket = Rocket.new(
    name => 'Falcon',
    fuel => Solid,
    speed => SpeedChoice.new((mph => 18000)),
    payload => [ "Car", "GPS" ]);

my $rocket-bytes = ASN::Serializer.serialize($rocket, :mode(Implicit));

#`[ Result:
      Blob.new(
          0x30, 0x1B, # Outermost SEQUENCE
          0x0C, 0x06, 0x46, 0x61, 0x6C, 0x63, 0x6F, 0x6E, # NAME, MESSAGE is missing
          0x0A, 0x01, 0x00, # ENUMERATED
          0x81, 0x02, 0x46, 0x50, # CHOICE
          0x30, 0x0A, # SEQUENCE OF UTF8String
              0x0C, 0x03, 0x43, 0x61, 0x72,  # UTF8String
              0x0C, 0x03, 0x47, 0x50, 0x53); # UTF8String
]

say ASN::Parser.new(:type(Rocket)).parse($rocket-bytes) eqv $rocket; # Certainly true!

# 1
role ASNSequence {
    # every descendant has to fulfill this important vow!
    method ASN-order {...}
}

# 2
role ASNChoice {
    has $.choice-value;

    # if you have to choose, choose wisely!
    method ASN-choice() {...}
    method ASN-value() { $!choice-value }

    method new($choice-value) { $?CLASS.bless(:$choice-value) }
}

# 3
role ASN::StringWrapper {
    has Str $.value;

    # Don't do this at home. :]
    method new(Str $value) { self.bless(:$value) }
}

# UTF8String wrapper
role ASN::Types::UTF8String does ASN::StringWrapper {}

# Yes, it is _this_ short
multi trait_mod:(Attribute $attr, :$UTF8String) is export { $attr does ASN::Types::UTF8String }

class ASN::Serializer {
    ...

    # like this:
    multi method serialize(ASNSequence $sequence, Int $index = 48, :$debug, :$mode = Implicit) { ... }

    # or this:
    multi method serialize(Int $int is copy where $int.HOW ~~ Metamodel::ClassHOW, Int $index = 2, :$debug, :$mode) { ... }
    multi method serialize($enum-value where $enum-value.HOW ~~ Metamodel::EnumHOW, Int $index = 10, :$debug, :$mode) { ... }

    # or even this:
    multi method serialize(Positional $sequence, Int $index is copy = 16, :$debug, :$mode) { ... }

    ...

my $parser = ASN::Parser.new(type => Rocket);
say $parser.parse($rocket-ber); # Yes, here goes our rocket!

multi method parse(Blob $input, ...) {
    ...
    self.parse($input, $!type, ...);
}

# Details and basic indentation are omitted for clarity

...

multi method parse(Buf $input is rw, ASNSequence $type, :$debug, :$mode) {
    # `$type` here is, really, not a value, but a Type Object. As `ASN-order` is defined on
    # type, there are no problems with gathering necessary info:
    my @params = do gather {
        for $type.ASN-order.kv -> $i, $field {
            # Here be dragons! Or, rather, MOP is used here!
        }
    }
    # A-a-and a ready object of a type our parser has no clue about is returned.
    # Yes, it is kind of neat. :)
    $type.bless(|Map.new(@params));
}

multi method parse(Buf $input is rw, $enum-type where $enum-type.HOW ~~ Metamodel::EnumHOW, :$debug, :$mode) {
    say "Parsing `$input[0]` out of $input.perl()" if $debug;
    $enum-type($input[0]);
}

class ASN::Parser::Async {
    has Supplier::Preserving $!out = Supplier::Preserving.new;
    has Supply $!values = $!out.Supply;
    has Buf $!buffer = Buf.new;
    has ASN::Parser $!parser = ASN::Parser.new(type => $!type);
    has $.type;

    method values(--> Supply) {
        $!values;
    }

    method process(Buf $chunk) {
        $!buffer.append: $chunk;
        loop {
            # Minimal message length
            last if $!buffer.elems < 2;
            # Message is incomplete, good luck another time
            last unless $!parser.is-complete($!buffer);
            # Cut off tag, we know what it is already in this specific case
            $!parser.get-tag($!buffer);
            my $length = $!parser.get-length($!buffer);
            # Tag and length are already cut down here, take only value
            my $item-octets = $!buffer.subbuf(0, $length);
            $!out.emit: $!parser.parse($item-octets, :!to-chop); # `!to-chop`, because "prefix" is already cut
            $!buffer .= subbuf($length);
        }
    }

    method close() {
        $!out.done;
    }
}

my $parser = ASN::Parser::Async.new(type => Rocket);

$parser.values.tap({ say "I get a nice thing!"; });

react {
    whenever $socket.data-arrived -> $chunk {
        $parser.process($chunk);
        LAST { $parser.close; }
    }
}

use v6.d;

say "Nice List restored!!!";

say 'Started initializing nice lister.';
sub MAIN() { say "Nice List restored!!!" }
say 'Finished initializing nice lister.';

sub MAIN (
    :$list-of-all-kids,
    :$naughty-list
) { ... }

$ nice-list
Usage:
  nicelist [--list-of-all-kids=<Any>] [--naughty-list=<Any>]

Stub code executed
  in sub MAIN at foo line 1
  in block <unit> at foo line 1

#| Rebuild the Nice List
sub MAIN (
    :$all,    #= path to file containing the list of all children
    :$naughty #= path to file containing the Naughty List
) { ... }

Usage:
  nicelist [--all=<Any>] [--naughty=<Any>] -- Rebuild the Nice List

    --all=<Any>        path to file containing the list of all children
    --naughty=<Any>    path to file containing the Naughty List

subset FilePath of Str:D where *.IO.f;

#| Rebuild the Nice List
sub MAIN (
    FilePath :$all,    #= path to file containing the list of all children
    FilePath :$naughty #= path to file containing the Naughty List
) { ... }

subset FileNotFound of Str:D where !*.IO.f();

multi sub MAIN (
    FilePath :$all,    #= path to file containing the list of all children
    FilePath :$naughty #= path to file containing the Naughty List
) { ... }

multi sub MAIN (
    FileNotFound :$all,
    *%otherStuff
) {
    die "List of all children file does not exist";
}

multi sub MAIN (
    FileNotFound :$naughty,
    *%otherStuff
) {
    die "Naughty List file does not exist";
}

multi sub MAIN (
    FileNotFound :$all,
    *%otherStuff
) is hidden-from-USAGE {
    die "List of all children file does not exist";
}

#| Rebuild the Nice List
multi sub MAIN (
    'build',
    FilePath :$all,    #= path to file containing the list of all children
    FilePath :$naughty #= path to file containing the Naughty List
) { ... }

#| Compare all the lists for correctness
multi sub MAIN (
    'audit',
    FilePath :$all,     #= path to file containing the list of all children
    FilePath :$naughty, #= path to file containing the Naughty List
    FilePath :$nice,    #= path to file containing the Nice List
) { ... }

my %*SUB-MAIN-OPTS =
    :named-anywhere,    # allow named variables at any location
;

for 0..9 -> int $d {
    for 0..9 -> int $e {
        next if $e == $d;

        my int $y = ($d + $e) % 10;
        my int $_c1 = ($d + $e) div 10;

        for 0..9 -> int $n {
            next if $n == $d;
            next if $n == $e;
            next if $n == $y;

            for 0..9 -> int $r {
                next if $r == $d;
                next if $r == $e;
                next if $r == $y;
                next if $r == $n;

                next unless ($_c1 + $n + $r) % 10 == $e;
                my int $_c2 = ($_c1 + $n + $r) div 10;

                for 0..9 -> int $o {
                    next if $o == $d;
                    next if $o == $e;
                    next if $o == $y;
                    next if $o == $n;
                    next if $o == $r;

                    next unless ($_c2 + $e + $o) % 10 == $n;
                    my int $_c3 = ($_c2 + $e + $o) div 10;

                    for 1..9 -> int $s {
                        next if $s == $d;
                        next if $s == $e;
                        next if $s == $y;
                        next if $s == $n;
                        next if $s == $r;
                        next if $s == $o;

                        for 1..9 -> int $m {
                            next if $m == $d;
                            next if $m == $e;
                            next if $m == $y;
                            next if $m == $n;
                            next if $m == $r;
                            next if $m == $o;
                            next if $m == $s;

                            next unless ($_c3 + $s + $m) % 10 == $o;
                            my int $_c4 = ($_c3 + $s + $m) div 10;

                            next unless $_c4 % 10 == $m;

                            say "$s$e$n$d + $m$o$r$e == $m$o$n$e$y";
                        }
                    }
                }
            }
        }
    }
}

my $d <- 0..9;
my $e <- 0..9;
guard $e != any($d);
my $y = ($d + $e) % 10;
my $_c1 = ($d + $e) div 10;

my $n <- 0..9;
guard $n != any($d, $e, $y);
my $r <- 0..9;
guard $r != any($d, $e, $y, $n);
guard ($_c1 + $n + $r) % 10 == $e;
my $_c2 = ($_c1 + $n + $r) div 10;

my $o <- 0..9;
guard $o != any($d, $e, $y, $n, $r);
guard ($_c2 + $e + $o) % 10 == $n;
my $_c3 = ($_c2 + $e + $o) div 10;

my $s <- 1..9;
guard $s != any($d, $e, $y, $n, $r, $o);
my $m <- 1..9;
guard $m != any($d, $e, $y, $n, $r, $o, $s);
guard ($_c3 + $s + $m) % 10 == $o;
my $_c4 = ($_c3 + $s + $m) div 10;

guard $_c4 % 10 == $m;

say "$s$e$n$d + $m$o$r$e == $m$o$n$e$y";

my $indent = 0;
constant SPACE = chr(0x20);
sub indent { SPACE x 4 * $indent }

for lines() {
    when /^ my \h+ ('$' \w) \h* '<-' \h* (\d+ \h* '..' \h* \d+) ';' $/ {
        say indent, "for $1 -> int $0 \{";
        $indent++;
    }

    when /^ guard \h+ ('$' \w) \h* '!=' \h* 'any(' ('$' \w)+ % [\h* ',' \h*] ')' \h* ';' $/ {
        say indent, "next if $0 == $_;"
            for $1;
        say "";
    }

    when /^ guard \h+ ([<!before '=='> .]+ '==' <-[;]>+) ';' $/ {
        say indent, "next unless $0;";
    }

    when /^ my \h+ ('$' \w+) \h* '=' \h* (<-[;]>+) ';' $/ {
        say indent, "my int $0 = $1;";
    }

    when /^ \h* $/ {
        say "";
    }

    when /^ say \h+ (<-[;]>+) ';' $/ {
        say indent, $_;
    }

    default {
        die "Couldn't match $_";
    }
}

while $indent-- {
    say indent, "\}";
}

ALL_DISTINCT

$d in 0..9
$e in 0..9
$n in 0..9
$r in 0..9
$o in 0..9
$s in 1..9
$m in 1..9

$y = ($d + $e) % 10
$_c1 = ($d + $e) div 10

($_c1 + $n + $r) % 10 == $e
$_c2 = ($_c1 + $n + $r) div 10

($_c2 + $e + $o) % 10 == $n
$_c3 = ($_c2 + $e + $o) div 10

($_c3 + $s + $m) % 10 == $o
$_c4 = ($_c3 + $s + $m) div 10

$_c4 % 10 == $m

    S E N D
+   M O R E
-----------
  M O N E Y

<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:svg="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     width="100"
     height="100">
	<g>
		<rect x="5" y="5" width="90" height="90" stroke="black" fill="green" />
	</g>
</svg>

use SVG;

say SVG.serialize(
    svg => [
        width => 100, height => 100,
        :g[:rect[:x<5>, :y<5>, :width<90>, :height<90>, :stroke<black>, :file<green>]],
    ],
);

use SVG;

class SVG::Drawing {
    role Element {
        method serialize() {
            ...
        }
    }

    has Element @.elements;

    has Int $.width;
    has Int $.height;

    class Group does Element {
        has Element @.elements;
        method serialize( --> Pair ) {
            g => @!elements.map( -> $e { $e.serialize }).list;
        }
    }

    class Rectangle does Element {
        has Int $.x;
        has Int $.y;
        has Int $.width;
        has Int $.height;
        has Str $.stroke;
        has Str $.fill;

        method serialize( --> Pair) {
            rect => [x =>  $!x, y => $!y, width => $!width, height => $!height, stroke => $!stroke, fill => $!fill ];
        }
    }

    method serialize( --> Str ) {
        SVG.serialize(svg => @!elements.map(-> $e { $e.serialize }).list);
    }
}

use SVG::Drawing;

my SVG::Drawing $drawing = SVG::Drawing.new(elements => [
    SVG::Drawing::Group.new(elements => [
        SVG::Drawing::Rectangle.new(x => 5, y => 5, width => 100, height => 100, stroke => "black", fill => "green" )
    ]);
]);

say $drawing.serialize;

use SVG;

class SVG::Drawing {
    role Element {
        method serialize() {
            ...
        }
    }

    has Element @.elements;

    has Int $.width;
    has Int $.height;

    class Group does Element {
        has Element @.elements;
        method serialize( --> Pair ) {
            g => @!elements.map( -> $e { $e.serialize }).list;
        }
    }

    class Rectangle does Element {
        has Int $.x;
        has Int $.y;
        has Int $.width;
        has Int $.height;
        has Str $.stroke;
        has Str $.fill;

        method serialize( --> Pair) {
            rect => [x =>  $!x, y => $!y, width => $!width, height => $!height, stroke => $!stroke, fill => $!fill ];
        }
    }

    class Point {
        has Int $.x;
        has Int $.y;

        method Str( --> Str ) {
            ($!x, $!y).join: ',';
        }
    }

    class Polygon does Element {
        has Str $.stroke;
        has Str $.fill;

        has Point @.points;

        method serialize( --> Pair ) {
            polygon => [ points => @!points.join(' '), fill => $!fill, stroke => $!stroke ];
        }

    }

    method serialize( --> Str ) {
        SVG.serialize(svg => @!elements.map(-> $e { $e.serialize }).list);
    }
}

use SVG::Drawing;

my SVG::Drawing $drawing = SVG::Drawing.new(elements => [
    SVG::Drawing::Group.new(elements => [
        SVG::Drawing::Polygon.new(stroke => "black", fill => "green", points => [
            SVG::Drawing::Point.new(x => 5, y => 5),
            SVG::Drawing::Point.new(x => 105, y => 5),
            SVG::Drawing::Point.new(x => 105, y => 105),
            SVG::Drawing::Point.new(x => 5, y => 105)
        ])
    ]);
]);

say $drawing.serialize;

<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:svg="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
	<g>
		<polygon points="5,5 105,5 105,105 5,105" fill="green" stroke="black" />
	</g>
</svg>

use SVG;

class SVG::Drawing {
    role Element {
        method serialize() {
            ...
        }
    }

    role Styled {
        has Str $.stroke;
        has Str $.fill;

        method styles() {
            ( stroke => $!stroke, fill => $!fill ).grep( { .value.defined } );
        }

    }

    has Element @.elements;

    has Int $.width;
    has Int $.height;

    class Group does Element {
        has Element @.elements;
        method serialize( --> Pair ) {
            g => @!elements.map( -> $e { $e.serialize }).list;
        }
    }

    class Rectangle does Element does Styled {
        has Int $.x;
        has Int $.y;
        has Int $.width;
        has Int $.height;

        method serialize( --> Pair) {
            rect => [x =>  $!x, y => $!y, width => $!width, height => $!height, |self.styles ];
        }
    }

    class Point {
        has Int $.x;
        has Int $.y;

        method Str( --> Str ) {
            ($!x, $!y).join: ',';
        }
    }

    class Polygon does Element does Styled {

        has Point @.points;

        method serialize( --> Pair ) {
            polygon => [ points => @!points.join(' '), |self.styles ];
        }

    }

    method serialize( --> Str ) {
        SVG.serialize(svg => @!elements.map(-> $e { $e.serialize }).list);
    }
}

use SVG;

class SVG::Drawing {
    role Element {
        method serialize() {
            ...
        }
    }

    role Styled {
        has Str $.stroke;
        has Str $.fill;

        method styles() {
            ( stroke => $!stroke, fill => $!fill ).grep( { .value.defined } );
        }

    }

    has Element @.elements;

    has Int $.width;
    has Int $.height;

    class Group does Element {
        has Element @.elements;
        method serialize( --> Pair ) {
            g => @!elements.map( -> $e { $e.serialize }).list;
        }
    }

    class Rectangle does Element does Styled {
        has Int $.x;
        has Int $.y;
        has Int $.width;
        has Int $.height;

        method serialize( --> Pair) {
            rect => [x =>  $!x, y => $!y, width => $!width, height => $!height, |self.styles ];
        }
    }

    class Point {
        has Numeric $.x;
        has Numeric $.y;

        method Str( --> Str ) {
            ($!x, $!y).join: ',';
        }
    }

    class Polygon does Element does Styled {

        has Point @.points;

        method serialize( --> Pair ) {
            polygon => [ points => @.points.join(' '), |self.styles ];
        }

    }

    class Triangle is Polygon {
        has Point $.apex is required;
        has Int   $.side is required;

        method points() {
            ($!apex, |self.base-points);
        }

        method base-points() {
            my $y = $!apex.y + self.get-height;

            (Point.new(:$y, x => $!apex.x - ( $!side / 2 )), Point.new(:$y, x => $!apex.x + ( $!side / 2 )));
        }

        method get-height(--> Num ) {
            sqrt($!side**2 - ($!side/2)**2)
        }

    }

    method dimensions() {
        ( height => $!height, width => $!width ).grep( { .value.defined } );

    }

    method serialize( --> Str ) {
        SVG.serialize(svg =>  [ |self.dimensions, |@!elements.map(-> $e { $e.serialize })]);
    }
}

use SVG::Drawing;

my SVG::Drawing $drawing = SVG::Drawing.new(
    elements => [
        SVG::Drawing::Group.new(elements => [
            SVG::Drawing::Triangle.new(stroke => "black", fill => "green",
                apex => SVG::Drawing::Point.new(x => 100, y => 50),
                side => 50,
            )
        ])
    ],
    height  => 300,
    width   => 200
);

say $drawing.serialize;

use SVG::Drawing;

my SVG::Drawing $drawing = SVG::Drawing.new(
    elements => [
        SVG::Drawing::Group.new(elements => [
            SVG::Drawing::Triangle.new(stroke => "green", fill => "green",
                apex => SVG::Drawing::Point.new(x => 100, y => 50),
                side => 50,
            ),
            SVG::Drawing::Triangle.new(stroke => "green", fill => "green",
                apex => SVG::Drawing::Point.new(x => 100, y => 75),
                side => 75,
            ),
            SVG::Drawing::Triangle.new(stroke => "green", fill => "green",
                apex => SVG::Drawing::Point.new(x => 100, y => 100),
                side => 100,
            ),
            SVG::Drawing::Rectangle.new(stroke  => "brown",
                                        fill    => "brown",
                                        x       =>  90,
                                        y       => 185,
                                        width   => 20,
                                        height  => 40),
        ])
    ],
    height  => 300,
    width   => 200
);

say $drawing.serialize;

<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:svg="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     height="300"
     width="200">
	<g>
		<polygon points="100,50 75,93.30127018922192 125,93.30127018922192" stroke="green" fill="green" />
		<polygon points="100,75 62.5,139.9519052838329 137.5,139.9519052838329" stroke="green" fill="green" />
		<polygon points="100,100 50,186.60254037844385 150,186.60254037844385" stroke="green" fill="green" />
		<rect x="90" y="185" width="20" height="40" stroke="brown" fill="brown" />
	</g>
</svg>

sub infix: ( UInt $count, UInt $size ) { (1..$size).roll($count) }
sub prefix: ( UInt $size ) { 1 d $size }

# Get the GTK::Simple libraries
use GTK::Simple;
use GTK::Simple::App;

# Create the main app
my $app = GTK::Simple::App.new( title => "Dice Roller" );

# Start the app running
$app.run;

# Get the GTK::Simple libraries
use GTK::Simple;
use GTK::Simple::App;

# Create the main app
my $app = GTK::Simple::App.new( title => "Grid" );

$app.set-content(
    GTK::Simple::Grid.new(
        # Grid key is [x,y,height,width]
        [0,0,1,1] => GTK::Simple::Button.new( label => "a" ),
        # A Button is a simple push button with a label
        [0,1,1,1] => GTK::Simple::Button.new( label => "b" ),
        [0,2,1,1] => GTK::Simple::Button.new( label => "c" ),
        [1,0,1,3] => GTK::Simple::Button.new( label => "d" ),
    )
);

$app.border-width = 10;
# Start the app
$app.run;

# Get the GTK::Simple libraries
use GTK::Simple;
use GTK::Simple::App;

# Create the main app
my $app = GTK::Simple::App.new( title => "Grid" );

$app.set-content(
    GTK::Simple::Grid.new(
        # As we want to refer to our buttons later we assign them
        # to variables
        [0,0,1,1] => my $b1 = GTK::Simple::Button.new( label => "Push Me" ),
        [1,1,1,1] => my $b2 = GTK::Simple::Button.new( label => "---" ),
        [2,2,1,1] => my $b3 = GTK::Simple::Button.new( label => "---" ),
        [3,3,1,1] => my $b4 = GTK::Simple::Button.new( label => "---" ),
    )
);

# The sensitive flag controls whether you can click on the button
$b2.sensitive = False;
$b3.sensitive = False;
$b4.sensitive = False;

# In the
$b1.clicked.tap( {
    # $_ is the clicked button. Turn it off
    .sensitive = False;
    # Change the label on the next button
    $b2.label = "Now Me!";
    # Make it clickable
    $b2.sensitive = True
} );

# Leaving on one line to cut down on space
$b2.clicked.tap( { .sensitive = False; $b3.label = "Me Next"; $b3.sensitive = True } );
$b3.clicked.tap( { .sensitive = False; $b4.label = "Me! Me!"; $b4.sensitive = True } );
# App.exit closes the app.
$b4.clicked.tap( { $app.exit } );

$app.border-width = 10;
# Start the app
$app.run;

# Get the GTK::Simple libraries
use GTK::Simple;
use GTK::Simple::App;

# Define our `d` operator
sub infix: ( UInt $count, UInt $size ) { (1..$size).roll($count) }

# Create the main app
my $app = GTK::Simple::App.new( title => "Dice Roller" );

# Output Box : Define here so the buttons can access it.
my $output = GTK::Simple::Label.new( text => 'Roll : ');

# Ouput box updater.
sub roll( $label, $count, $size ) {
    my @roll = $count d $size;
    $label.text = "Roll : {@roll.join(" + ")} = {@roll.sum}";
}

# Create a grid and put the output box at the bottom filling the width
my @grid = ( [0,6,7,1] => $output );

# Track our depth in tthe grid
my $y = 0;

# Loop through counts
for (1..6) -> $count {

    # Track our postion along the grid
    my $x = 0;

    # Loop through standard dice sizes
    for (4,6,8,10,12,20,100) -> $size {

	# Standard labelling
	my $label = $count > 1 ?? "{$count}d{$size}" !! "d{$size}";

	# Create our button
	my $button = GTK::Simple::Button.new(label => $label);

	# Buttons get a supply which emit when they are clicked
	# Assign our roll function with the current count and size to it
	# Note we do it in a block so it's not called right now but when
	# the button is clicked
	$button.clicked.tap(
	    { roll( $output, $count, $size ) }
	);

	# Put the button in the valid place in the grid taking up one space
	@grid.push( [$x,$y,1,1] => $button );

	$x++;
    }
    $y++
}

# Create a grid object and assign it to the app.
$app.set-content(
    GTK::Simple::Grid.new( |@grid )
);

$app.border-width = 10;

# Start the app running
$app.run;

#|« A square on the n-cube with wrapping.
In the n-cube there are 3*(n choose 2)*2**(n-2) WrapSquare variables,
one for every square and every kind of value that can be assigned to it.
»
class WrapSquare is Cube::Face does Propositional::Variable {
    has $.kind is required;

    method WHICH {
        ValueObjAt.new: "WrapSquare|$!kind|{callsame}"
    }

    # ...
}

multi prefix: (Str $s) {
    WrapSquare.new: :kind<□>,
        Cube::Face.from-word($s)
}

multi prefix: (Str $s) {
    WrapSquare.new: :kind<■>,
        Cube::Face.from-word($s)
}

multi prefix: (Str $s) {
    WrapSquare.new: :kind<🎀>,
        Cube::Face.from-word($s)
}

method NNF {
    self.rewrite(
        (  ^:p ⇔ ^:q ) => { ($:p ⇒  $:q) ∧ ($:q ⇒ $:p) },
        (  ^:p ⇒ ^:q ) => { ¬$:p ∨  $:q },
        (¬(^:p ∨ ^:q)) => { ¬$:p ∧ ¬$:q },
        (¬(^:p ∧ ^:q)) => { ¬$:p ∨ ¬$:q },
        (¬¬^:p)        => {  $:p        },
    )
    andthen .squish
}

method CNF {
    self.NNF.rewrite(
        (^:p ∨ (^:q ∧ ^:r)) => { ($:p ∨ $:q) ∧ ($:p ∨ $:r) },
        ((^:q ∧ ^:r) ∨ ^:p) => { ($:p ∨ $:q) ∧ ($:p ∨ $:r) },
    )
    andthen .squish
}

multi axioms ($n = 3) {
    my \φ = .CNF with [∧] gather {
        take □<**0> ∨ ■<**0> ∨ 🎀<**0>;
        take □<**0> ⇒ ¬(■<**0> ∨ 🎀<**0>);
        take ■<**0> ⇒ ¬(□<**0> ∨ 🎀<**0>);
        take 🎀<**0> ⇒ ¬(□<**0> ∨ ■<**0>);

        take ■<**0> ⇒ (■<**1> ∨ 🎀<**1>);
        take (■<**0> ∧ ■<**1>) ⇒ (■<*0*> ∨ 🎀<*0*> ∨ ■<0**> ∨ 🎀<0**>);
        take (🎀<**0> ∧ ■<**1>) ⇒ (■<*0*> ∨ ■<0**>);
        take (🎀<**0> ∧ (■<*0*> ∨ ■<0**>)) ⇒ ■<**1>;
        take 🎀<**0> ⇒ ¬(🎀<**1> ∨ 🎀<*0*> ∨ 🎀<*1*> ∨ 🎀<0**> ∨ 🎀<1**>);
    }

    my \ψ = φ.rewrite(:1ce,
        (^:s(WrapSquare)) => { $:s° }
    );
    return [∧] gather for (1,2,3).permutations -> \π {
        take (φ ∧ ψ).rewrite(:1ce,
            (^:s(WrapSquare)) => { $:s ⤩ π }
        );

        LAST take ¬(■<**0> ∧ ■<**1> ∧ ■<*0*> ∧ ■<*1*> ∧ ■<0**> ∧ ■<1**>);
    }
}

multi axioms ($n where * > 3) {
    my \Φ = axioms;
    [∧] gather for Faces($n, 3) -> \Δ {
        take Φ.rewrite(:1ce,
            (^:s(WrapSquare)) => { $:s ↗ Δ }
        )
    }
}

say count-sat Giftoid::axioms(3), :now
#= OUTPUT: 28
say count-sat(Giftoid::axioms(3), :now)
#= OUTPUT: 1848
say  count-sat(Giftoid::axioms(3), :now)
#= OUTPUT: 58213276

.put for all-sat(Giftoid::axioms).map({ Giftoid.new: n => 3, deco => $_ })
#=« OUTPUT:
■■■🎀■■
□□■🎀■■
■■■■🎀■
■■■■■🎀
■■🎀■■■
■🎀■■■■
□□■■🎀■
□□🎀■■■
□□■■■🎀
□□■■■■
■■□□■🎀
■■□□🎀■
...
»

sub mean-bows ($n) {
    my ($sum, $count);
    all-sat(Giftoid::axioms($n)).map({
        $sum += +.keys.grep(*.kind eq <🎀>);
        $count++;
    });
    $sum / $count;
}

say mean-bows(3);
#= OUTPUT: 0.857143
say mean-bows(4);
#= OUTPUT: 2.766234