The document outlines the history and features of Perl 6, including notable instances like Pugs and Rakudo. It discusses variable types, custom types, object-oriented programming aspects, and function parameters. Additionally, it covers the language's syntactic features such as method signatures, pattern matching, and lambda functions.

1. Perl 6
An Apocalypse
The Camelia image is copyright 2009 and trademarked by Larry Wall Matt Follett matt.follett@gmail.com

2. Instance of Perl 6
• Pugs - Perl 6 on Haskell
• Niecza - Perl 6 on the CLR
• Sprixel - Perl 6 in JavaScript
• Elf, Mildew
• Perlito (MiniPerl6) - JVM, Go, Perl 5, JS, Lisp
• YAPSI - Perl 6 in Perl 6
• Rakudo - Perl 6 on Parrot
Matt Follett matt.follett@gmail.com

3. Instance of Perl 6
• Pugs - Perl 6 on Haskell
• Niecza - Perl 6 on the CLR
• Sprixel - Perl 6 in JavaScript
• Elf, Mildew
• Perlito (MiniPerl6) - JVM, Go, Perl 5, JS, Lisp
• YAPSI - Perl 6 in Perl 6
• Rakudo - Perl 6 on Parrot
Matt Follett matt.follett@gmail.com

4. Modules
Matt Follett matt.follett@gmail.com

5. The Backstory
• Perl 6 announced at Perl Conference in 2000
• Immediate RFCs
• First apocalypse on April 2, 2001
• Twelfth apocalypse April 13, 2004
Matt Follett matt.follett@gmail.com
http://www.perlfoundation.org/perl6/index.cgi?timeline

6. More Backstory
• Parrot April Fool’s Joke 2001
• First commit to Parrot on August 29, 2001
• Audrey Tang publicly releases Pugs in February of 2005
Matt Follett matt.follett@gmail.com

7. Recent History
• Parrot starts monthly releases in January 2007
• Parrot starts major releases on a yearly cycle in 2010
• Rakudo * monthly releases start in July 2010
Matt Follett matt.follett@gmail.com

8. Recent History
• Parrot starts monthly releases in January 2007
• Parrot starts major releases on a yearly cycle in 2010
• Rakudo * monthly releases start in July 2010
Matt Follett matt.follett@gmail.com

9. Rakudo *
• a useful, usable, "early adopter" distribution of Perl
6
 nota 1.0
 compile yourself
• Includes modules for XML, JSON, YAML, database
interfaces, etc
• includes neutro
• Helps get feedback to the Rakudo team
Matt Follett matt.follett@gmail.com

10. Feedback = Improvements
Matt Follett matt.follett@gmail.com
http://gil.di.uminho.pt/users/smash/rakudo-bench.html

11. The Basics
• Variables are prepended with a sigil to indicate
their basic type (scalar, array, hash)
• These sigils are invariant
• Variables declared with ‘my’ are lexically scoped
• Perl 6 autoboxes
Matt Follett matt.follett@gmail.com

12. my @array = 1,2,3;
say(@array[0])
my ($fruit, $jp) = 'apples', JSON.new();
$jp.parse($something_from_somewhere);
my %dictionary = apples => 2, pears => 3;
say("I have %dictionary{$fruit} $fruit");
Matt Follett matt.follett@gmail.com

13. my @array = 1,2,3;
say(@array[0])
my ($fruit, $jp) = 'apples', JSON.new();
$jp.parse($something_from_somewhere);
my %dictionary = apples => 2, pears => 3;
say("I have %dictionary{$fruit} $fruit");
Matt Follett matt.follett@gmail.com

14. my @array = 1,2,3;
say(@array[0])
my ($fruit, $jp) = 'apples', JSON.new();
$jp.parse($something_from_somewhere);
my %dictionary = apples => 2, pears => 3;
say("I have %dictionary{$fruit} $fruit");
Matt Follett matt.follett@gmail.com

15. my @array = 1,2,3;
say(@array[0])
my ($fruit, $jp) = 'apples', JSON.new();
$jp.parse($something_from_somewhere);
my %dictionary = apples => 2, pears => 3;
say("I have %dictionary{$fruit} $fruit");
Matt Follett matt.follett@gmail.com

16. Optional Typing
• All variables in Perl 6 have a type, declared like:
my Str $name = 'Matt Follett';
$name = 'Matthew Follett';
$name = 4; # asplode
• If a type isn’t declared the type is Any
my $foo = 11;
say('$foo is an '~ $foo.WHAT); # Any
Matt Follett matt.follett@gmail.com

17. Types
Matt Follett matt.follett@gmail.com

18. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

19. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

20. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

21. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

22. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

23. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

24. Custom Type & Enums
subset Odd of Int where * % 2;
my Odd $number = 41;
enum Color <red green blue>;
my Color $color = red;
say $color == red; # true (1)
say $color; # 0
say $color.key; # 'red'
Matt Follett matt.follett@gmail.com

25. Classes
• declare:
 attributes
 accessors/mutators
 delegation
• inherit from multiple classes
• define methods
• consume roles
Matt Follett matt.follett@gmail.com

26. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

27. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

28. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

29. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

30. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

31. class Employee {
has Str $.name is rw
= <Alice Bob Charles Dorothy>.pick;
has Rat $!salary;
has Rat $!money = 0;
method work_on( $project ) {
say "$.name is working on $project."
}
method pay() { $!money += $!salary }
}
Matt Follett matt.follett@gmail.com

32. class Manager is Employee
{
has @.employees is rw;
has Employee $.assistant
is ro handles 'work_on';
}
Matt Follett matt.follett@gmail.com

33. class Manager is Employee
{
has @.employees is rw;
has Employee $.assistant
is ro handles 'work_on';
}
Matt Follett matt.follett@gmail.com

34. class Manager is Employee
{
has @.employees is rw;
has Employee $.assistant
is ro handles 'work_on';
}
Matt Follett matt.follett@gmail.com

35. Roles
• Classes consume roles
• Roles provide:
 new methods for a set of tasks (like mix-ins)
 modifications for existing methods
• Roles can be consumed at compile time or run time
Matt Follett matt.follett@gmail.com

36. role Ergonaut
{
method evaluate {
say 'This ' ~ <chair desk>.pick
~ ' ' ~ <is isn't>.pick
~ ' ergonomic';
}
}
Matt Follett matt.follett@gmail.com

37. • Compile Time
class EmployeeErgonaut
is Employee does Ergonaut
{}
• Mixin Style
my Employee $e1 = Employee.new(
name => 'Matt',
title => 'software developer',
salary => 1_000_000
);
$e1 does Ergonaut;
Matt Follett matt.follett@gmail.com

38. Sub Signatures
• positional and named parameters
• Constrain method invocation on:
 number of variables
 types
 where clauses
 pattern
• or, don’t constrain at all
Matt Follett matt.follett@gmail.com

39. Plain old Positional
sub exp($base, $exponent) {
return $base ** $exponent
}
exp( 2, 5) # 32
Matt Follett matt.follett@gmail.com

40. Named Parameters
sub exp($base, $exponent) {
return $base ** $exponent
}
exp(
exponent => 5,
base => 2
)
Matt Follett matt.follett@gmail.com

41. Strictly Named Parameters
sub draw_circle( $canvas, :$x, :$y,
:$radius, :$color )
draw_circle( $canvas2, 3, 2, 3, 442266 );
Matt Follett matt.follett@gmail.com

42. Strictly Named Parameters
sub draw_circle( $canvas, :$x, :$y,
:$radius, :$color )
draw_circle( $canvas2, 3, 2, 3, 442266 );
Matt Follett matt.follett@gmail.com

43. Strictly Named Parameters
sub draw_circle( $canvas, :$x, :$y,
:$radius, :$color )
draw_circle( $canvas2,
x => 3,
y => 2,
radius => 3,
color => ”#442266” );
Matt Follett matt.follett@gmail.com

44. Constraining Inputs
sub is_prime( $input )
Matt Follett matt.follett@gmail.com

45. Constraining Inputs
sub is_prime( Int $input )
Matt Follett matt.follett@gmail.com

46. Constraining Inputs
sub is_prime( Int $input
where * % 2)
Matt Follett matt.follett@gmail.com

47. Methods as Objects
Matt Follett matt.follett@gmail.com

48. Methods as Objects
• Curry methods
sub multiply_numbers(Num $x, Num $y) {
$x * $y;
}
my $mult_by_four =
&multiply_numbers.assuming(4);
Matt Follett matt.follett@gmail.com

49. Methods as Objects
• Curry methods
• Wrap around methods
sub multiply_numbers(Num $x, Num $y) {
$x * $y;
}
my $mult_and_add =
&multiply_numbers.wrap({$^x+$^y
+callwith($^x, $^y)});
Matt Follett matt.follett@gmail.com

50. Methods as Objects
• Curry methods
• Wrap around methods
sub multiply_numbers(Num $x, Num $y) {
$x * $y;
}
my $mult_and_add =
&multiply_numbers.wrap({$^x+$^y
+callwith($^x, $^y)});
Matt Follett matt.follett@gmail.com

51. Methods as Objects
• Curry methods
• Wrap around methods
• Determine method arity
sub multiply_numbers(Num $x, Num $y) {
$x * $y;
}
my $arity = &multiply_numbers.arity()
Matt Follett matt.follett@gmail.com

52. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

53. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

54. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

55. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

56. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

57. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

58. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

59. Functional Style Pattern Matching
• Perl subs and methods can do pattern matching in their
parameter list
• Example:
multi divide($num, 0) {
die 'floating point exception';
}
multi divide($num, $denom) {
return $num/$denom
}
divide(11, 0); # dies! (would return Inf)
divide(12, 2); # 6
Matt Follett matt.follett@gmail.com

60. λ Functions
• Just as powerful as named functions
• Multiple ways to create
• A building block of the language
Matt Follett matt.follett@gmail.com

61. Basic Form
my $add_two_nums =
sub (Real $x, Real $y) {$x+$y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

62. Basic Form
my $add_two_nums =
sub (Real $x, Real $y) {$x+$y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

63. With Twigils
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

64. With Twigils
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

65. With Twigils
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
my $add_two_nums=sub($x,$y){$x+$y}
Matt Follett matt.follett@gmail.com

66. λs are Everywhere
• All blocks are λs
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

67. λs are Everywhere
• All blocks are λs
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

68. λs are Everywhere
• All blocks are λs
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
my $add_two_nums = ->$x,$y{$x+$y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

69. λs are Everywhere
• All blocks are λs
my $add_two_nums = sub {$^x+$^y};
$add_two_nums(11,12);
my $add_two_nums = ->$x,$y{$x+$y};
$add_two_nums(11,12);
Matt Follett matt.follett@gmail.com

70. λs are Everywhere
• All blocks are λs
• All blocks benefit
for 1..10 -> $x
{ say $x }
Matt Follett matt.follett@gmail.com

71. λs are Everywhere
• All blocks are λs
• All blocks benefit
for 1..10
{ say $^x }
Matt Follett matt.follett@gmail.com

72. λs are Everywhere
• All blocks are λs
• All blocks benefit
for 1..10 -> $x, $y
{ say "$x, $y" }
Matt Follett matt.follett@gmail.com

73. λs are Everywhere
• All blocks are λs
• All blocks benefit
for 1..11 -> $x, $y=''
{ say "$x, $y" }
Matt Follett matt.follett@gmail.com

74. Simplest Form
• Uses the Whatever term
• Included in a unary or binary operation
• Statement returns a λ
• Examples:
my $add_two = * + 2;
$add_two(3); # 5
my $invoke_method = *.sort;
$invoke_method(@some_array);
Matt Follett matt.follett@gmail.com

75. Operators
Matt Follett matt.follett@gmail.com

76. Operators
• New Operators
• Better range operator
• Chaining Binary Operators
• New Types of Operators
 Meta Operators
 Junctive Operators
• More powerful custom operators
Matt Follett matt.follett@gmail.com

77. Range Operator
Matt Follett matt.follett@gmail.com

78. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
Matt Follett matt.follett@gmail.com

79. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
Matt Follett matt.follett@gmail.com

80. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
Matt Follett matt.follett@gmail.com

81. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
Matt Follett matt.follett@gmail.com

82. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
Matt Follett matt.follett@gmail.com

83. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
Matt Follett matt.follett@gmail.com

84. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
Matt Follett matt.follett@gmail.com

85. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
• Advanced form takes λs for iterator and ending condition:
my @fib := 0,1,*+*...*
my @double_letters := 'a'...* eq 'zz'
Matt Follett matt.follett@gmail.com

86. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
• Advanced form takes λs for iterator and ending condition:
my @fib := 0,1,*+*...*
my @double_letters := 'a'...* eq 'zz'
Matt Follett matt.follett@gmail.com

87. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
• Advanced form takes λs for iterator and ending condition:
my @fib := 0,1,*+*...*
my @double_letters := 'a'...* eq 'zz'
Matt Follett matt.follett@gmail.com

88. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
• Advanced form takes λs for iterator and ending condition:
my @fib := 0,1,*+*...*
my @double_letters := 'a'...* eq 'zz'
Matt Follett matt.follett@gmail.com

89. Range Operator
• Creates lazily evaluated lists:
my @N := 0...*
• Basic form is very smart, versatile:
my @negatives := -1,-2...*
my @multiples_of_two := 0,2,4...*
my @powers_of_two := 0,2,4,8...*
my @letters = 'a'...'z'
• Advanced form takes λs for iterator and ending condition:
my @fib := 0,1,*+*...*
my @double_letters := 'a'...* eq 'zz'
Matt Follett matt.follett@gmail.com

90. Meta Operators
• Meta operators are operators who’s operand is another
operator
• Simplify writing operators
• Provide new strengths
 meta reduction operator
 cross meta operator
 hyperoperator
Matt Follett matt.follett@gmail.com

91. Meta Operators Simplifying Operators
• Assignment operators
A op= B
 example:
@names .= sort
• Negated relational operators
 infix
relational operators can all be negated by prepending ‘!’
 example:
$foo !< 11
Matt Follett matt.follett@gmail.com

92. Reduction Meta Operator
• Written as []
• Takes a list and reduces it to a scalar value
• uses a specified infix operator
• like foldl, foldr but respects associativity
• Examples:
[*] 1..$x
[**] 1..$x # 1 ** ( 2 ** ( 3 **…$x ) )
[<] @list or [>] @list
Matt Follett matt.follett@gmail.com

93. Reduction Meta Operator
• Written as []
• Takes a list and reduces it to a scalar value
• uses a specified infix operator
• like foldl, foldr but respects associativity
• Examples:
[*] 1..$x
[**] 1..$x # 1 ** ( 2 ** ( 3 **…$x ) )
[<] @list or [>] @list
Matt Follett matt.follett@gmail.com

94. Reduction Meta Operator
• Written as []
• Takes a list and reduces it to a scalar value
• uses a specified infix operator
• like foldl, foldr but respects associativity
• Examples:
[*] 1..$x
[**] 1..$x # 1 ** ( 2 ** ( 3 **…$x ) )
[<] @list or [>] @list
Matt Follett matt.follett@gmail.com

95. Reduction Meta Operator
• Written as []
• Takes a list and reduces it to a scalar value
• uses a specified infix operator
• like foldl, foldr but respects associativity
• Examples:
[*] 1..$x
[**] 1..$x # 1 ** ( 2 ** ( 3 **…$x ) )
[<] @list or [>] @list
Matt Follett matt.follett@gmail.com

96. Hyper Meta Operator
• Written as Unicode ‘»’, ‘«‘ or ASCII ‘>>’, ‘<<‘
• Performs the operations as fast as possible
• Can parallelize these operations
• Does not guarantee order of results
• Examples:
(1..10) >>+<< (21..30);
my @nums_squared = @nums >>**>> 2;
my @hellos = "Hello, " <<~<< <Christian
John Michael Eleanor Chris>;
@hellos>>.say;
Matt Follett matt.follett@gmail.com

97. Hyper Meta Operator
• Written as Unicode ‘»’, ‘«‘ or ASCII ‘>>’, ‘<<‘
• Performs the operations as fast as possible
• Can parallelize these operations
• Does not guarantee order of results
• Examples:
(1..10) >>+<< (21..30);
my @nums_squared = @nums >>**>> 2;
my @hellos = "Hello, " <<~<< <Christian
John Michael Eleanor Chris>;
@hellos>>.say;
Matt Follett matt.follett@gmail.com

98. Hyper Meta Operator
• Written as Unicode ‘»’, ‘«‘ or ASCII ‘>>’, ‘<<‘
• Performs the operations as fast as possible
• Can parallelize these operations
• Does not guarantee order of results
• Examples:
(1..10) >>+<< (21..30);
my @nums_squared = @nums >>**>> 2;
my @hellos = "Hello, " <<~<< <Christian
John Michael Eleanor Chris>;
@hellos>>.say;
Matt Follett matt.follett@gmail.com

99. Hyper Meta Operator
• Written as Unicode ‘»’, ‘«‘ or ASCII ‘>>’, ‘<<‘
• Performs the operations as fast as possible
• Can parallelize these operations
• Does not guarantee order of results
• Examples:
(1..10) >>+<< (21..30);
my @nums_squared = @nums >>**>> 2;
my @hellos = "Hello, " <<~<< <Christian
John Michael Eleanor Chris>;
@hellos>>.say;
Matt Follett matt.follett@gmail.com

100. Hyper Meta Operator
• Written as Unicode ‘»’, ‘«‘ or ASCII ‘>>’, ‘<<‘
• Performs the operations as fast as possible
• Can parallelize these operations
• Does not guarantee order of results
• Examples:
(1..10) >>+<< (21..30);
my @nums_squared = @nums >>**>> 2;
my @hellos = "Hello, " <<~<< <Christian
John Michael Eleanor Chris>;
@hellos>>.say;
Matt Follett matt.follett@gmail.com

101. Cross Meta Operator
• Written as ‘X’
• Crosses two arrays, making tuples of each cell then applying
the operator to them
• examples:
(1,2) X* (3,4);
Matt Follett matt.follett@gmail.com

102. Cross Meta Operator
• Written as ‘X’
• Crosses two arrays, making tuples of each cell then applying
the operator to them
• examples:
(1,2) X* (3,4);#((1,3),(1,4)(2,3),(2,4))
Matt Follett matt.follett@gmail.com

103. Cross Meta Operator
• Written as ‘X’
• Crosses two arrays, making tuples of each cell then applying
the operator to them
• examples:
(1,2) X* (3,4);#((1*3),(1*4)(2*3),(2*4))
Matt Follett matt.follett@gmail.com

104. Cross Meta Operator
• Written as ‘X’
• Crosses two arrays, making tuples of each cell then applying
the operator to them
• examples:
(1,2) X* (3,4);#(3,4,6,8)
Matt Follett matt.follett@gmail.com

105. Cross Meta Operator
• Written as ‘X’
• Crosses two arrays, making tuples of each cell then applying
the operator to them
• examples:
(1,2) X* (3,4);#(3,4,6,8)
< > X~ ('A',2..10,'J','Q','K');
Matt Follett matt.follett@gmail.com

106. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

107. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

108. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

109. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

110. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

111. Junctive Operators
• A variable can be any of some number of values via ‘|’
• A variable can be all of some number of values via ‘&’
my $superposition = 4 | 5 | 6;
$superposition += 1; # 5|6|7
6 ~~ $superposition; #true
9 ~~ $superposition; #false
my $qualifications = *.can('sort')
& *.can('push')
& *.can('pop');
@array ~~ $qualifications; # true
$scalar ~~ $qualifications; # false
Matt Follett matt.follett@gmail.com

112. Custom Operators
• Any unicode string
• Define precedence
 ‘is tighter’ - higher precedence than the given operator
 ‘is looser’ - lower precedence
 ‘is equiv’ - same precedence
• Many types
 infix
 postfix
 prefix
 circumfix
 postcircumfix
Matt Follett matt.follett@gmail.com

113. Custom Operator Example
sub infix:<⊕> ($a, $b) is tighter(&infix:<*>)
{
sqrt($a**2+$b**2);
};
say 2 ⊕ 4;
Matt Follett matt.follett@gmail.com

114. Custom Operator Example
sub infix:<⊕> ($a, $b) is tighter(&infix:<*>)
{
sqrt($a**2+$b**2);
};
say 2 ⊕ 4;
Matt Follett matt.follett@gmail.com

115. Grammars
• Composed of rules and tokens
• Reusable through inheritance
• Defined like classes or modules
• starts from the TOP rule
Matt Follett matt.follett@gmail.com

116. grammar Mercurial::rc {
rule TOP {^<line>*$};
rule line {<header>|<assignment>|<comment>};
rule header {'[' ~ ']' <header_name> };
rule assignment {<variable>'='<value>};
rule comment { '#' <message> };
token header_name {w<-[]]>+};
token variable {<-[=]>+};
token value {.*};
token message {.*};
}
Matt Follett matt.follett@gmail.com

117. [ui]
username=Matt Follett
email=matt.follett@gmail.com
[extensions]
#best extension ever!
hg.cowlog=
Matt Follett matt.follett@gmail.com

118. Where to go for more
• Try Rakudo: http://try.rakudo.org
• Using Perl 6: http://github.com/perl6/book/downloads
• Get Rakudo: http://rakudo.org/how-to-get-rakudo
• The official Perl 6 site: http://www.perl6.org
• Perl 6 synopses: http://perlcabal.org/syn/
• Planet Perl 6: http://planetsix.perl.org/
• Rosetta Code: http://www.rosettacode.org
• My posts: http://mfollett.com/tag/perl6
Matt Follett matt.follett@gmail.com