$@%!»; – Perl 6

$@%!»; – Perl 6

Frank Blendinger

2013-10-21

This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a

letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

[email protected]

204/20/23 / Method Park Software AG

Disclaimer


6 != 5

»The Perl 6 design process is about keeping what works in Perl 5, fixing what doesn't, and adding what's missing. That means there will be a few fundamental changes to the language, a large number of extensions to existing features, and a handful of completely new ideas. These modifications, enhancements, and innovations will work together to make the future Perl even more insanely great – without, we hope, making it even more greatly insane.«

Damian Conway


Perl Philosophy

TIMTOWTDO: There Is More Than One Way To Do It

DWIM: Do What I Mean

Keep easy things easy and hard things possible

slurp("filename").lines

Huffman coding Common things → short name Crazy stuff → long names “Weird things should look weird”


A Little Perl History

1987: Perl 1.0, 1994: Perl 5.0, 2013-05-18: Perl 5.18

2000: Perl 6 project started

New language – no compatibility with Perl 5

use v6; *.pl/.pm vs. *.p6

Intended for friendly coexistence with Perl 5 (still developed)

Some Perl 6 features backported to Perl 5(say, given/when, ~~, various CPAN modules: Perl6::*)


Perl 6: Community Driven Development

»Perl 5 was my rewrite of Perl. I want Perl 6 to be the community's rewrite of Perl and of the community.«

Larry Wall


Perl 6 Language Specification

http://perlcabal.org/syn/



https://github.com/perl6/specs




Perl 6 Implementations

»Perl 6 is anything that passes the official test suite.«

Larry Wall, “Synopsis 1: Overview”


Perl 6 Compilers / Interpreters / VMs

Rakudo Parrot VM backend JVM backend

Niecza compiles to CLR (.NET/Mono)

Pugs one of the first Perl 6 compilers no longer maintained

STD Larry Wall’s reference implementation


Release Date: Christmas

Rakudo and Niecza are pretty closehttp://perl6.org/compilers/features

Want to play with Perl 6 right now? Use Rakudo *!

Rakudo * = Rakudo Perl 6 compiler, debugger, modules+ Parrot VM

Windows installer, Debian package, cygwin, tarball

PATH=$PATH:…/rakudo/binperl6 helloworld.p6


Remove Inconsistencies

»In Perl 6, we decided it would be better to fix the language than fix the user.«

Larry Wall


Perl 5

#!/usr/bin/env perl use strict; use warnings;

…


Perl 6

#!/usr/bin/env perl6

use v6;

# implicit strict & warnings pragmas# Can be turned off with:# no strict;# no warnings;# but you don’t want to!


Sigil Invariance

Perl 5

my $scalar = "sclr";

my @array = (1, 2, 3);

my %hash = (foo => 23, bar => 42);


Sigil Invariance

Perl 5

my $scalar = "sclr"; my @array = (1, 2, 3); my %hash = (foo => 23, bar => 42); print $scalar . "\n"; print @array[0] . "\n"; # works, but warning print %hash{'foo'} . "\n"; # syntax error


Sigil Invariance

Perl 5

my $scalar = "sclr"; my @array = (1, 2, 3); my %hash = (foo => 23, bar => 42); print $scalar . "\n"; print $array[1] . "\n"; print $hash{'bar'} . "\n";


Sigil Invariance

Perl 6


my @array = (1, 2, 3);

my %hash = (foo => 23, bar => 42);

print $scalar ~ "\n";

print @array[0] ~ "\n";

print %hash{'foo'} ~ "\n";


Sigil Invariance

Perl 6

my $scalar = "sclr"; my @array = (1, 2, 3); my %hash = (foo => 23, bar => 42); print $scalar ~ "\n"; print @array[0] ~ "\n"; print %hash{'foo'} ~ "\n"; print $array[1] ~ "\n";# Variable '$array' is not declared. # Did you mean '@array'?


Sigil Invariance

Perl 6


my @array = (1, 2, 3);

my %hash = (foo => 23, bar => 42);

print $scalar ~ "\n";

print @array[0] ~ "\n";

print %hash{'foo'} ~ "\n";


Sigil Invariance

Perl 6

my $scalar = "sclr"; my @array = 1, 2, 3; my %hash = foo => 23, bar => 42; say $scalar; say @array[0]; say %hash{'foo'};


Sigil Invariance

Perl 6

my $scalar = "sclr"; my @array = 1, 2, 3; my %hash = foo => 23, bar => 42; say $scalar; say @array[0]; say %hash<foo>;


Sigil Invariance

# Perl 5: get list from hash of hashes

my @verbs = @{ $dict { 'verb' }{ 'transitive' } };

# Perl 6: get list from hash of hashesmy @verbs = %dict{ 'verb' }{ 'transitive' };

# Perl 6: or even like thismy @verbs = %dict<verb><transitive>;


Perl 6 Basics


Subroutines

sub square-and-sum($x, $y) { return $x*$x + $y*$y; } my $a = 3; my $b = 4; say "{$a}² + {$b}² = {square-and-sum($a, $b)}";# 3² + 4² = 25


Subroutines

sub stutter($word) {

my $first-letter = substr($word, 0, 1); my $wwwword = ($first-letter ~ "-") x 3 ~ $word;

say $wwwword;

}

stutter("what"); # w-w-w-what


Subroutines

sub stutterify($word) { my $first-letter = substr($word, 0, 1);

my $wwwword = ($first-letter ~ "-") x 3 ~

$word; $word = $wwwword; # no-no! $word is read-

only! }


Subroutines

sub stutterify($word is rw) { my $first-letter = substr($word, 0, 1); my $wwwword = ($first-letter ~ "-") x 3 ~ $word; $word = $wwwword; }


Subroutines

sub stutterify($word is rw) { my $first-letter = substr($word, 0, 1); my $wwwword = ($first-letter ~ "-") x 3 ~ $word; $word = $wwwword; }

my $word = "hello"; $word.say; # hello stutterify($word); $word.say; # h-h-h-hello


Subroutines

# pass-by-valuesub say-next-num($num is copy) { say ++$num; } my $num-of-truth = 42; say-next-num($num-of-truth); say "The truth is still $num-of-truth";


Dealing with Arrays

sub shout-words(@words) { for @words -> $word { say uc($word); } }


Dealing with Arrays

sub shout-words(@words) { for @words { say uc($_); # topic variable

} }


Dealing with Arrays

sub shout-words(@words) { for @words { say uc($_) }} my @words = <hey ho let's go>; shout-words(@words);

# HEY# HO# LET'S# GO


Dealing with Hashes

sub say-names-with-age(%people) {

for %people.kv -> $key, $value {

say $key ~ " (" ~ $value ~ ")";

}

}


Dealing with Hashes


for %people {

say $_.key ~ " (" ~ $_.value ~ ")";

}}


Dealing with Hashes


for %people {

say .key ~ " (" ~ .value ~ ")";

}

}


Dealing with Hashes

sub say-names-with-age(%people) { for %people { say .key ~ " (" ~ .value ~ ")"; } }

my %white-family = Walter => 52, Skyler => 41, "Walter Jr." => 17, Holly => 2; say-names-with-age(%white-family);


Optional Parameters

sub whatever($optional?) { if defined($optional) { say "$optional is pretty cool."; } else { say "Whatever, man."; } }

whatever("The dude"); whatever();


Named Parameters

sub protip(:$what, :$who) { say "Use $what, $who!"; } protip(:what("the force"), :who("Luke"));protip(:who("Luke"), :what("the force"));


Named Parameters

sub protip(:$what, :$who) { say "Use $what, $who!"; } # short form for strings protip(:who<Luke>, :what<the force>);


Named Parameters

sub protip(:$what, :$who) { say "Use $what, $who!"; } my $thing = "the force";

my $guy = "Luke";

#protip( $thing, $guy); # Nope. #protip(:$thing, :$guy); # Also, nope.protip(:what($thing), :who($guy));


Named Parameters

sub protip(:$what, :$who) { say "Use $what, $who!"; } my $what = "the force";

my $who = "Luke";

protip(:$who, :$what); # names match → magic!


Required Named Parameters

sub protip(:$what, :$who) { say "Use $what, $who!"; } # named params are optional by defaultprotip();# use of uninitialized value of type …


Required Named Parameters

sub protip(:$what!, :$who!) { say "Use $what, $who!"; } # named params are optional by defaultprotip();# Required named parameter 'what' not passed


Varargs with Slurpy Arrays

# varargs with slurpy arrays (* prefix) sub sum(*@nums) { [+] @nums; } say sum 42, 23, 1337;


Varargs with Slurpy Arrays

# default (no "()" given!) is *@_, so:

sub sum {

[+] @_;

}

say sum 42, 23, 1337;


Procedural vs. Object Oriented

Perl 6 is object-oriented at its core

You can use it, but you don’t have to (TIMTOWTDI!)





# proceduralsay split(" ", capitalize("hello world"))[1]; # World





# proceduralsay split(" ", capitalize("hello world"))[1]; # World

# object oriented"hello world".capitalize.split(" ")[1].say;# World


Objects

Everything is an object

my $x = "foo"; # Str objectmy $y = 42; # Int objectmy $z = Int; # Int class


Objects



my &code = { say "Ohai." };&code();


Objects



my &code = { say "Ohai." };&code(); &code = sub ($name) { say "Ohai {$name}." }; &code("Alice");


Introspection

What are you?

42.WHAT; # (Int)(1/2).WHAT; # (Rat)


Introspection

What are you?

42.WHAT; # (Int)(1/2).WHAT; # (Rat)

What can you do for me?

42.^methods(); # Int Num Rat FatRat abs Bridge chr # sqrt base expmod is-prime floor # ceiling round lsb msb sign conj

rand # sin …


Type Objects vs. Instance Objects

my $i = Int;

say $i.WHAT; # (Int)

say $i.defined; # False

say $i; # (Int)

$i = Int.new; # or: $i = $i.new or: $i .= new; say $i.WHAT; # (Int)

say $i.defined; # True

say $i; # 0


Perlify!

my %complicatedObj = Hash.new;

%complicatedObj{'string'} = "this is foo";

%complicatedObj{'list'} = [4, 5, 6];

%complicatedObj{'parcel'} = 4, 5, 6;%complicatedObj{'range'} = 10..15;

%complicatedObj{'inner hash'} = x => 1.1, y => 2.5;

%complicatedObj.perl.say;

# ("string" => "this is foo", "list" => [4, 5, 6],"parcel" => $(4, 5, 6), "range" => 10..15,"inner hash" => $("x" => 1.1, "y" => 2.5)).hash


We Have to Go Deeper!


DUMP

my %complicatedObj = Hash.new;

%complicatedObj{'string'} = "this is foo";

%complicatedObj{'list'} = [4, 5, 6];

%complicatedObj{'parcel'} = 4, 5, 6;%complicatedObj{'range'} = 10..15;

%complicatedObj{'inner hash'} = x => 1.1, y =>

2.5;

%complicatedObj.DUMP.say;


DUMP

Hash<1>( :$!descriptor(Perl6::Metamodel::ContainerDescriptor<2>(...)), :$!storage(Hash<3>( string => ▶"this is foo", list => ▶Array<5>( :$!flattens(True), :$!items(QRPA<7>( ▶4, ▶5, ▶6 )), :$!nextiter(▶Mu) ), parcel => ▶Parcel<12>(:$!storage(RPA<13>( =Int<8>, =Int<9>, =Int<10> ))),

range => ▶Range<14>( :min(▶10), :max(▶15), :excludes_min(▶False), :excludes_max(▶False) ), inner hash => ▶Parcel<18>(:$!storage(RPA<19>( Pair<20>( :key(▶"x"), :value(▶1.1) ), Pair<23>( :key(▶"y"), :value(▶2.5) ) ))) )))


DUMP

Hash<1>( :$!descriptor(Perl6::Metamodel::ContainerDescriptor<2>(...)), :$!storage(Hash<3>( string => ▶"this is foo", list => ▶Array<5>( :$!flattens(True), :$!items(QRPA<7>( ▶4, ▶5, ▶6 )), :$!nextiter(▶Mu) ), parcel => ▶Parcel<12>(:$!storage(RPA<13>( =Int<8>, =Int<9>, =Int<10> ))),

range => ▶Range<14>( :min(▶10), :max(▶15), :excludes_min(▶False), :excludes_max(▶False) ), inner hash => ▶Parcel<18>(:$!storage(RPA<19>( Pair<20>( :key(▶"x"), :value(▶1.1) ), Pair<23>( :key(▶"y"), :value(▶2.5) ) ))) )))


Type System: Dynamic Types

my @untypedArray; @untypedArray.push(23).push("foo").push([1, 2]); @untypedArray.perl.say;# Array.new(23, "foo", [1, 2])


Type System: Static Types

my @untypedArray; @untypedArray.push(23).push("foo").push([1, 2]); @untypedArray.perl.say;# Array.new(23, "foo", [1, 2])

my Int @intArray; @intArray.push(23).push("foo");# Type check failed in .push; expected 'Int' but

got 'Str'


Beyond Type Safety: Contraints

sub div(Real $x, Real $y where $y != 0) { $x / $y };

div(1, 2).say;# 0.5 div(1, 0).say;# Constraint type check failed for parameter

'$y'


Default Parameters

sub draw-ascii-rectangle(Int $width where 1..10 = 2, Int $height where 1..10 = $width) { for ^$height { for ^$width { print "#"; } print "\n"; } }


Default Parameters

sub draw-ascii-rectangle(Int $width where 1..10 = 2, Int $height where 1..10 = $width) { for ^$height { for ^$width { print "#"; } print "\n"; } } draw-ascii-rectangle(10, 1); draw-ascii-rectangle(); draw-ascii-rectangle(4);


Default Parameters

sub draw-ascii-rectangle(Int $width where 1..10 = 2, Int $height where 1..10 = $width) { for ^$height { for ^$width { print "#"; } print "\n"; } } draw-ascii-rectangle(10, 1); draw-ascii-rectangle(); draw-ascii-rectangle(4);

##########

##

##

####

####

####

####


Object Oriented Programming


Classes

class Point { has $!x; # private has $!y; # private

method to-string() { "[$!x/$!y]"; } } my $point = Point.new;


Classes

class Point { has $!x; # private has $!y; # private method to-string() { "[$!x/$!y]"; } } my $point = Point.new; $point.to-string().say; # use of unit. value…

#$point.x.say; # no access, private $point.DUMP.say; # Point<1>(:$!x(Any), :$!

y(Any))


Classes

class Point { has $.x; # public has $.y; # public

method to-string() { "[$!x/$!y]"; } } my $point = Point.new(:x(1), :y(2));

$point.to-string().say; # [1/2]


Classes


method to-string() { "[$!x/$!y]"; } } my $point = Point.new(x => 1, y => 2);



Attributes vs. Accessor Methods

class Foo { has $.bar; method bar { $!bar * 10 } method use-attribute { say "bar is $!bar" } method use-accessor { say "bar is $.bar" }} Foo.new(bar => 10).use-attribute; # bar is 10

Foo.new(bar => 10).use-accessor; # bar is 100


Read/Write Attributes


method to-string() { "[$!x/$!y]"; } } my $point = Point.new(x => 1, y => 2);

$point.x = 23; # NOPE! $!x is readonly


Read/Write Attributes

class Point { has $.x is rw; has $.y is rw;

method to-string() { "[$!x/$!y]"; } } my $point = Point.new(x => 1, y => 2); $point.x = 23;$point.y = 42;



Default Values for Attributes

class Point { has $.x = 0; has $.y = $!x;

method to-string() { "[$!x/$!y]"; } } Point.new.to-string.say; # [0/0]Point.new(x => 9).to-string.say; # [9/9]


Inheritance

class Mother { method i-am { say "I am your mother" } }

class Father { method i-am { say "I am your father" } }

class Child is Father is Mother {}

Child.new.i-am;


Inheritance

class Mother { method i-am { say "I am your mother" } }

class Father { method i-am { say "I am your father" } }

class Child is Father is Mother {}

Child.new.i-am; # I am your father

Child.^mro.say; # (Child) (Father) (Mother) (Any)

(Mu)


Inheritance – Private vs. Public Methods

class Dog { method !do-private { say "This is dog." } method do-public { self!do-private } } class Pug is Dog { method access-dog-public { self.do-public } method access-dog-private { self!do-private }} Dog.new.do-public;



class Dog { method !do-private { say "This is dog." } method do-public { self!do-private } } class Pug is Dog { method access-dog-public { self.do-public } method access-dog-private { self!do-private }} Dog.new.do-public; # ok Pug.new.do-public;



class Dog { method !do-private { say "This is dog." } method do-public { self!do-private } } class Pug is Dog { method access-dog-public { self.do-public } method access-dog-private { self!do-private }} Dog.new.do-public; # ok Pug.new.do-public; # ok Pug.new.access-dog-public;



class Dog { method !do-private { say "This is dog." } method do-public { self!do-private } } class Pug is Dog { method access-dog-public { self.do-public } method access-dog-private { self!do-private }} Dog.new.do-public; # ok Pug.new.do-public; # ok Pug.new.access-dog-public; # ok Pug.new.access-dog-private;



class Dog { method !do-private { say "This is dog." } method do-public { self!do-private } } class Pug is Dog { method access-dog-public { self.do-public } method access-dog-private { self!do-private }} Dog.new.do-public; # ok Pug.new.do-public; # ok Pug.new.access-dog-public; # ok Pug.new.access-dog-private; # NOPE


Roles

role Happy { method have-fun { say ":-)" } } role Sad { method frown { say ":-/" } } class Guy does Happy does Sad { method code-some-perl6 { self.have-fun } method do-powerpoint-pres { self.frown } }


Roles

role Happy { method have-fun { say ":-)" } } role Sad { method frown { say ":-/" } } class Guy does Happy does Sad { method code-some-perl6 { self.have-fun } method do-powerpoint-pres { self.frown } } my $me = Guy.new; $me.code-some-perl6; # :-) $me.do-powerpoint-pres; # :-/ $me.have-fun; # :-)


Stubs

role AbstractSerializable { method serialize() { ... } }


Stubs

role AbstractSerializable { method serialize() { ... } } # not allowed: class APoint does AbstractSerializable { has $.x; has $.y; } # -> Method 'serialize' must be implemented by APoint…


Stubs

role AbstractSerializable { method serialize() { ... } } # not allowed: class APoint does AbstractSerializable { has $.x; has $.y; } # -> Method 'serialize' must be implemented by APoint… # this works: class SPoint does AbstractSerializable { has $.x; has $.y; method serialize() { "p($.x, $.y)" } }


Functional Programming


Closures

my @times = (); # Array.new

for 1..10 {

my $multiplicant = $_;

@times[$_] = sub ($a) { $a * $multiplicant };

}


Closures

my @times = (); # Array.new for 1..10 { my $multiplicant = $_; @times[$_] = sub ($a) { $a * $multiplicant };} say @times[3](4); # 12 say @times[5](20); # 100 say @times[7](3); # 21


Infinite Lists, Lazy Evaluation

my @all-the-integers = 0..Inf; for ^10 { say @all-the-integers[$_] }


Infinite Lists, Lazy Evaluation

my @all-the-integers = 0..Inf; for ^10 { say @all-the-integers[$_] }


map


map

(1..10).map( { $_ * $_ } ).join(", ").say;


map

(1..10).map( { $_ * $_ } ).join(", ").say;

# 1, 4, 9, 16, 25, 36, 49, 64, 81, 100


Z – the zip operator



my @zipped-array = zip (1, 2, 3), (10, 20, 30);

@zipped-array.join(", ").say;# 1, 10, 2, 20, 3, 30



my @zipped-array = (1, 2, 3) Z (10, 20, 30);

@zipped-array.join(", ").say;# 1, 10, 2, 20, 3, 30



Application: iterating two lists in parallel

sub are-pairwise-greater(@array1, @array2) { for @array1 Z @array2 -> $x, $y { return False if $x <= $y; } return True; }



Application: iterating two lists in parallel

sub are-pairwise-greater(@array1, @array2) { for @array1 Z @array2 -> $x, $y { return False if $x <= $y; } return True; } are-pairwise-greater(2..11, 1..10).say; # True are-pairwise-greater(2..11, 1..5).say; # True are-pairwise-greater(2..3, 1..15).say; # True are-pairwise-greater((3,3,3), (1,2,3)).say; #

False


Meta Operators


Meta Operators

Reduce meta operator: [op]

Infix operator → list operator

1 + $x + 5 + $y

[+] (1, $x, 5, $y)


Meta Operators

# multiply all elements of @a my $prod = [*] @a; # calculate mean of @a my $mean = ([+] @a) / @a.elems;

# true if elements of @a are numerically sorted my $sorted = [<=] @a; # find the smallest element of @a and @b combinedmy $min = [min] @a, @b;


The Hyper Meta Operators: » / «


The Hyper Operators: » / «

Sum of two lists

my @a = 1..10; my @b = 11..20;

my @sums = (); for @a Z @b -> $x, $y { @sums.push($x + $y);} @sums.join(", ").say;



Sum of two lists

my @a = 1..10; my @b = 11..20;

(@a »+« @b).join(", ").say;



Sum of two lists

my @a = 1..10; my @b = 11..20;

(@a »+« @b).join(", ").say;

# >>+<< works too.# But it’s not that cool.



# increment all elements @a = 1, 7, 9; @a»++; @a.join(", ").say; # get pairwise minimum @a = 1, 7, 9; @b = 4, 2, 9; my @minima = @a »min« @b; @minima.join(", ").say;


Multi


Multi

class Human { has $.name }

class CodeMonkey is Human {}

class BusinessGuy is Human {}

multi sub greet(Human $h) { say "Hello {$h.name}." }

multi sub greet(CodeMonkey $h) { say "Hey {$h.name}, sup dude?" }

multi sub greet(BusinessGuy $h) { say "Nice to meet you, {$h.name}."}


Multi

class Human { has $.name }

class CodeMonkey is Human {}

class BusinessGuy is Human {}

multi sub greet(Human $h) { say "Hello {$h.name}." }

multi sub greet(CodeMonkey $h) { say "Hey {$h.name}, sup dude?" }

multi sub greet(BusinessGuy $h) { say "Nice to meet you, {$h.name}."}

my $john = CodeMonkey.new(name => "John Johnson");

my $jack = BusinessGuy.new(name => "Jack Jackson");

greet $john; # Hey John Johnson, sup dude?

greet $jack; # Nice to meet you, Jack Jackson.


Multi with Constraints

multi sub mysign(Int $x where $x == 0) { 0 } multi sub mysign(Int $x where $x < 0) { -1 } multi sub mysign(Int $x) { +1 } for -2, 0, 2 { say mysign($_) }# -1# 0# 1


Command Line Parsing with multi MAIN

multi sub MAIN('add‚ , $x, $y) { say "$x + $y = {$x + $y}" }multi sub MAIN('sub', $x, $y) { say "$x - $y = {$x - $y}" }multi sub MAIN('mult', $x, $y) { say "$x * $y = {$x * $y}" }multi sub MAIN('div', $x, $y) { say "$x / $y = {$x / $y}" }

│% ./cmdline_args.p6│Usage:│ ./cmdline_args.p6 add <x> <y>│ ./cmdline_args.p6 sub <x> <y>│ ./cmdline_args.p6 mult <x> <y>│ ./cmdline_args.p6 div <x> <y>


Command Line Parsing with multi MAIN

multi sub MAIN('add‚ , $x, $y) { say "$x + $y = {$x + $y}" }multi sub MAIN('sub', $x, $y) { say "$x - $y = {$x - $y}" }multi sub MAIN('mult', $x, $y) { say "$x * $y = {$x * $y}" }multi sub MAIN('div', $x, $y) { say "$x / $y = {$x / $y}" }

│% ./cmdline_args.p6 add 23 42│23 + 42 = 65

│% ./cmdline_args.p6 mult 23 42│23 * 42 = 966


given/when


given/when

my $thing = 17.23; given $thing { when Bool { say "yes/no" } when Real { say "number" } default { say $thing.WHAT } }


given/when

my $n = 17; given $n { when $n < 10 { say "small" } when $n < 100 { say "medium" } default { say "big" } }


given/when

my ($x, $y) = 12, 23; given $x, $y { when $x < $y { say "smaller" } when $x > $y { say "greater" } when $x == $y { say "same" } }


Smart Matching with ~~



class A {} class B is A {} class C {} my $b = B.new; say "b is a A" if $b ~~ A; # yep. say "b is a B" if $b ~~ B; # yep. say "b is a C" if $b ~~ C; # certainly not



my $num = 23; say "num has two digits" if $num ~~ 10..99;

my @list1 = 1, 2, 3, 4; my @list2 = 1..4; say "list are identical" if @list1 ~~ @list2;



my @list = 1, 2, 3; say (1 ~~ any(@list)) ?? "yes" !! "nope" ; say (6 ~~ any(@list)) ?? "yes" !! "nope" ;

my $text = "sOme tExT hEre"; say "matches" if $text ~~ m:i/text/;


One More Thing

Awesome new regex syntax

… and beyond: rules, tokens, grammars

It’s a parsing wonderland!


One More Thing

Awesome new regex syntax

… and beyond: rules, tokens, grammars

It’s a parsing wonderland!

Maybe another talk,if anyone cares. :-)


References

http://perl6.org/ #perl6 @ FreeNode

https://github.com/perl6

https://github.com/perl6/book/

http://perl6advent.wordpress.com/

http://perl6maven.com/

http://rakudo.org/


Questions?

Documents

$@%!»; – Perl 6