diff options
| author | Luis F. Uceta <uzluisf@protonmail.com> | 2018-12-19 17:15:21 -0500 |
|---|---|---|
| committer | Luis F. Uceta <uzluisf@protonmail.com> | 2018-12-19 17:15:21 -0500 |
| commit | fadf0fc0c112ad785a14c574a97c29a0db7a3f7f (patch) | |
| tree | 5d7e8e1037d7bbcfcc2eef12128de644782b453b /perl6.html.markdown | |
| parent | d5b09d5b13f2dcb29b812c6b55011ab8bab8d1be (diff) | |
Add some changes
- format consistently
- remove whitespace
- add example(s)
- fix typos
Diffstat (limited to 'perl6.html.markdown')
| -rw-r--r-- | perl6.html.markdown | 2069 |
1 files changed, 1118 insertions, 951 deletions
diff --git a/perl6.html.markdown b/perl6.html.markdown index 7c776db4..cb64b646 100644 --- a/perl6.html.markdown +++ b/perl6.html.markdown @@ -13,24 +13,28 @@ least the next hundred years. The primary Perl 6 compiler is called [Rakudo](http://rakudo.org), which runs on the JVM and [the MoarVM](http://moarvm.com). -Meta-note : double pound signs (##) are used to indicate paragraphs, while -single pound signs (#) indicate notes. +Meta-note: double pound signs (`##`) are used to indicate paragraphs, +while single pound signs (`#`) indicate notes. `#=>` represents the output of a command. ```perl6 -# Single line comment start with a pound +# Single line comments start with a pound sign. -#`( - Multiline comments use #` and a quoting construct. +#`( Multiline comments use #` and a quoting construct. (), [], {}, 「」, etc, will work. ) + +# Use the same syntax for multiline comments to embed comments. +for #`(each element in) @array { + put #`(or print element) $_ #`(with newline); +} ``` ## Variables ```perl6 -## In Perl 6, you declare a lexical variable using `my` +## In Perl 6, you declare a lexical variable using the `my` keyword: my $variable; ## Perl 6 has 3 basic types of variables: scalars, arrays, and hashes. ``` @@ -38,79 +42,81 @@ my $variable; ### Scalars ```perl6 -# Scalars represent a single value. They start with a `$` - +# Scalars represent a single value. They start with the `$` sigil: my $str = 'String'; -# double quotes allow for interpolation (which we'll see later): + +# Double quotes allow for interpolation (which we'll see later): my $str2 = "String"; ## Variable names can contain but not end with simple quotes and dashes, -## and can contain (and end with) underscores : -my $weird'variable-name_ = 5; # works ! +## and can contain (and end with) underscores: +my $person's-belongings = 'towel'; # this works! -my $bool = True; # `True` and `False` are Perl 6's boolean values. -my $inverse = !$bool; # You can invert a bool with the prefix `!` operator -my $forced-bool = so $str; # And you can use the prefix `so` operator - # which turns its operand into a Bool +my $bool = True; # `True` and `False` are Perl 6's boolean values. +my $inverse = !$bool; # Invert a bool with the prefix `!` operator. +my $forced-bool = so $str; # And you can use the prefix `so` operator +$forced-bool = ?$str; # to turn its operand into a Bool. Or use `?`. ``` ### Arrays and Lists ```perl6 -## Arrays represent multiple values. Their name start with `@`. -## Lists are similar but are an immutable type. +## Arrays represent multiple values. An array variable starts with the `@` +## sigil. Unlike lists, from which arrays inherit, arrays are mutable. my @array = 'a', 'b', 'c'; -# equivalent to : +# equivalent to: my @letters = <a b c>; # array of words, delimited by space. # Similar to perl5's qw, or Ruby's %w. -my @array = 1, 2, 3; +@array = 1, 2, 3; -say @array[2]; # Array indices start at 0 -- This is the third element +say @array[2]; # Array indices start at 0. Here the third element + # is being accessed. -say "Interpolate all elements of an array using [] : @array[]"; -#=> Interpolate all elements of an array using [] : 1 2 3 +say "Interpolate an array using []: @array[]"; +#=> Interpolate an array using []: 1 2 3 -@array[0] = -1; # Assign a new value to an array index -@array[0, 1] = 5, 6; # Assign multiple values +@array[0] = -1; # Assigning a new value to an array index +@array[0, 1] = 5, 6; # Assigning multiple values my @keys = 0, 2; @array[@keys] = @letters; # Assignment using an array containing index values -say @array; #=> a 6 b +say @array; #=> a 6 b ``` ### Hashes, or key-value Pairs. ```perl6 -## Hashes are pairs of keys and values. -## You can construct a Pair object using the syntax `Key => Value`. -## Hash tables are very fast for lookup, and are stored unordered. -## Keep in mind that keys get "flattened" in hash context, and any duplicated -## keys are deduplicated. -my %hash = 1 => 2, - 3 => 4; -my %hash = foo => "bar", # keys get auto-quoted - "some other" => "value", # trailing commas are okay - ; +## Hashes are pairs of keys and values. You can construct a `Pair` object +## using the syntax `Key => Value`. Hash tables are very fast for lookup, +## and are stored unordered. Keep in mind that keys get "flattened" in hash +## context, and any duplicated keys are deduplicated. +my %hash = 'a' => 1, 'b' => 2; + +%hash = a => 1, # keys get auto-quoted when => (fat comma) is used. + b => 2, # Trailing commas are okay. +; ## Even though hashes are internally stored differently than arrays, ## Perl 6 allows you to easily create a hash from an even numbered array: -my %hash = <key1 value1 key2 value2>; - -my %hash = key1 => 'value1', key2 => 'value2'; # same result as above - -## You can also use the "colon pair" syntax: -## (especially handy for named parameters that you'll see later) -my %hash = :w(1), # equivalent to `w => 1` - # this is useful for the `True` shortcut: - :truey, # equivalent to `:truey(True)`, or `truey => True` - # and for the `False` one: - :!falsey, # equivalent to `:falsey(False)`, or `falsey => False` - ; - -say %hash{'key1'}; # You can use {} to get the value from a key -say %hash<key2>; # If it's a string, you can actually use <> - # (`{key1}` doesn't work, as Perl6 doesn't have barewords) +%hash = <key1 value1 key2 value2>; # Or: +%hash = "key1", "value1", "key2", "value2"; + +%hash = key1 => 'value1', key2 => 'value2'; # same result as above + +## You can also use the "colon pair" syntax. This syntax is especially +## handy for named parameters that you'll see later. +%hash = :w(1), # equivalent to `w => 1` + :truey, # equivalent to `:truey(True)` or `truey => True` + :!falsey, # equivalent to `:falsey(False)` or `falsey => False` +; +## The :truey and :!falsey constructs are known as the +## `True` and `False` shortcuts respectively. + +say %hash{'key1'}; # You can use {} to get the value from a key. +say %hash<key2>; # If it's a string without spaces, you can actually use + # <> (quote-words operator). `{key1}` doesn't work, + # as Perl6 doesn't have barewords. ``` ## Subs @@ -120,112 +126,112 @@ say %hash<key2>; # If it's a string, you can actually use <> ## created with the `sub` keyword. sub say-hello { say "Hello, world" } -## You can provide (typed) arguments. -## If specified, the type will be checked at compile-time if possible, -## otherwise at runtime. -sub say-hello-to(Str $name) { +## You can provide (typed) arguments. If specified, the type will be checked +## at compile-time if possible, otherwise at runtime. +sub say-hello-to( Str $name ) { say "Hello, $name !"; } -## A sub returns the last value of the block. -sub return-value { - 5; -} -say return-value; # prints 5 -sub return-empty { -} -say return-empty; # prints Nil +## A sub returns the last value of the block. Similarly, the semicolon in +## the last can be omitted. +sub return-value { 5 } +say return-value; # prints 5 -## Some control flow structures produce a value, like if: +sub return-empty { } +say return-empty; # prints Nil + +## Some control flow structures produce a value, like `if`: sub return-if { - if True { - "Truthy"; - } + if True { "Truthy" } } -say return-if; # prints Truthy +say return-if; # prints Truthy -## Some don't, like for: +## Some don't, like `for`: sub return-for { - for 1, 2, 3 { } + for 1, 2, 3 { 'Hi' } } -say return-for; # prints Nil +say return-for; # prints Nil -## A sub can have optional arguments: -sub with-optional($arg?) { # the "?" marks the argument optional - say "I might return `(Any)` (Perl's 'null'-like value) if I don't have - an argument passed, or I'll return my argument"; +## Positional arguments are required by default. To make them optional, use +## the `?` after the parameters' names. +sub with-optional( $arg? ) { + # This sub returns `(Any)` (Perl's null-like value) if + # no argument is passed. Otherwise, it returns its argument. $arg; } -with-optional; # returns Any -with-optional(); # returns Any -with-optional(1); # returns 1 +with-optional; # returns Any +with-optional(); # returns Any +with-optional(1); # returns 1 -## You can also give them a default value when they're not passed: -sub hello-to($name = "World") { - say "Hello, $name !"; +## You can also give them a default value when they're not passed. +## Required parameters must come before optional ones. +sub greeting( $name, $type = "Hello" ) { + say "$type, $name!"; } -hello-to; #=> Hello, World ! -hello-to(); #=> Hello, World ! -hello-to('You'); #=> Hello, You ! + +greeting("Althea"); #=> Hello, Althea! +greeting("Arthur", "Good morning"); #=> Good morning, Arthur! ## You can also, by using a syntax akin to the one of hashes -## (yay unified syntax !), pass *named* arguments to a `sub`. -## They're optional, and will default to "Any". -sub with-named($normal-arg, :$named) { - say $normal-arg + $named; +## (yay unified syntax !), pass *named* arguments to a `sub`. They're +## optional, and will default to "Any". +sub with-named( $normal-arg, :$named ) { + say $normal-arg + $named; } with-named(1, named => 6); #=> 7 -## There's one gotcha to be aware of, here: -## If you quote your key, Perl 6 won't be able to see it at compile time, -## and you'll have a single Pair object as a positional parameter, -## which means this fails: -with-named(1, 'named' => 6); -with-named(2, :named(5)); #=> 7 +## There's one gotcha to be aware of, here: If you quote your key, Perl 6 +## won't be able to see it at compile time, and you'll have a single `Pair` +## object as a positional parameter, which means +## `with-named(1, 'named' => 6);` fails. + +with-named(2, :named(5)); #=> 7 -## To make a named argument mandatory, you can use `?`'s inverse, `!` -sub with-mandatory-named(:$str!) { - say "$str !"; +## To make a named argument mandatory, you can append `!` to the parameter, +## which is the inverse of `?`: +sub with-mandatory-named( :$str! ) { + say "$str!"; } -with-mandatory-named(str => "My String"); #=> My String ! -with-mandatory-named; # run time error: "Required named parameter not passed" -with-mandatory-named(3);# run time error:"Too many positional parameters passed" +with-mandatory-named(str => "My String"); #=> My String! +with-mandatory-named; # runtime error:"Required named parameter not passed" +with-mandatory-named(3);# runtime error:"Too many positional parameters passed" -## If a sub takes a named boolean argument ... -sub takes-a-bool($name, :$bool) { - say "$name takes $bool"; +## If a sub takes a named boolean argument... +sub takes-a-bool( $name, :$bool ) { + say "$name takes $bool"; } ## ... you can use the same "short boolean" hash syntax: -takes-a-bool('config', :bool); # config takes True -takes-a-bool('config', :!bool); # config takes False +takes-a-bool('config', :bool); #=> config takes True +takes-a-bool('config', :!bool); #=> config takes False -## You can also provide your named arguments with defaults: -sub named-def(:$def = 5) { - say $def; +## You can also provide your named arguments with default values: +sub named-def( :$def = 5 ) { + say $def; } -named-def; #=> 5 +named-def; #=> 5 named-def(def => 15); #=> 15 ## Since you can omit parenthesis to call a function with no arguments, -## you need "&" in the name to store `say-hello` in a variable. +## you need `&` in the name to store `say-hello` in a variable. This means +## `&say-hello` is a code object and not a subroutine call. my &s = &say-hello; -my &other-s = sub { say "Anonymous function !" } +my &other-s = sub { say "Anonymous function!" } -## A sub can have a "slurpy" parameter, or "doesn't-matter-how-many" -sub as-many($head, *@rest) { #`*@` (slurpy) will "take everything else" -## Note: you can have parameters *before* a slurpy one (like here), -## but not *after*. - say @rest.join(' / ') ~ " !"; +## A sub can have a "slurpy" parameter, or "doesn't-matter-how-many". For +## this, you must use `*@` (slurpy) which will "take everything else". You can +## have as many parameters *before* a slurpy one, but not *after*. +sub as-many($head, *@rest) { + say @rest.join(' / ') ~ " !"; } -say as-many('Happy', 'Happy', 'Birthday'); #=> Happy / Birthday ! - # Note that the splat (the *) did not - # consume the parameter before. +say as-many('Happy', 'Happy', 'Birthday');#=> Happy / Birthday ! + # Note that the splat (the *) did not + # consume the parameter before it. -## You can call a function with an array using the -## "argument list flattening" operator `|` -## (it's not actually the only role of this operator, but it's one of them) +## You can call a function with an array using the "argument list flattening" +## operator `|` (it's not actually the only role of this operator, +## but it's one of them). sub concat3($a, $b, $c) { - say "$a, $b, $c"; + say "$a, $b, $c"; } concat3(|@array); #=> a, b, c # `@array` got "flattened" as a part of the argument list @@ -234,159 +240,188 @@ concat3(|@array); #=> a, b, c ## Containers ```perl6 -## In Perl 6, values are actually stored in "containers". -## The assignment operator asks the container on the left to store the value on -## its right. When passed around, containers are marked as immutable. -## Which means that, in a function, you'll get an error if you try to -## mutate one of your arguments. -## If you really need to, you can ask for a mutable container using `is rw`: -sub mutate($n is rw) { - $n++; - say "\$n is now $n !"; +## In Perl 6, values are actually stored in "containers". The assignment +## operator asks the container on the left to store the value on its right. +## When passed around, containers are marked as immutable which means that, +## in a function, you'll get an error if you try to mutate one of your +## arguments. If you really need to, you can ask for a mutable container by +## using the `is rw` trait: +sub mutate( $n is rw ) { + $n++; } my $m = 42; -mutate $m; # $m is now 43 ! +mutate $m; #=> 43 +say $m; #=> 43 -## This works because we are passing the container $m to mutate. If we try -## to just pass a number instead of passing a variable it won't work because -## there is no container being passed and integers are immutable by themselves: +## This works because we are passing the container $m to the `mutate` sub. +## If we try to just pass a number instead of passing a variable it won't work +## because there is no container being passed and integers are immutable by +## themselves: mutate 42; # Parameter '$n' expected a writable container, but got Int value -## If what you want a copy instead, use `is copy`. +## Similar error would be obtained, if a bound variable is passed to +## to the subroutine: + +my $v := 50; # binding 50 to the variable $v +mutate $v; # Parameter '$n' expected a writable container, but got Int value + +## If what you want is a copy instead, use the `is copy` trait which will +## cause the argument to be copied and allow you to modify the argument +## inside the routine. ## A sub itself returns a container, which means it can be marked as rw: my $x = 42; sub x-store() is rw { $x } x-store() = 52; # in this case, the parentheses are mandatory # (else Perl 6 thinks `x-store` is an identifier) -say $x; #=> 52 +say $x; #=> 52 ``` ## Control Flow Structures + ### Conditionals ```perl6 ## - `if` ## Before talking about `if`, we need to know which values are "Truthy" -## (represent True), and which are "Falsey" (or "Falsy") -- represent False. -## Only these values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or -## `Int`) and of course False itself. -## Every other value is Truthy. +## (represent True), and which are "Falsey" (represent False). Only these +## values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or `Int`) and +## of course False itself. Any other value is Truthy. if True { - say "It's true !"; + say "It's true!"; } unless False { - say "It's not false !"; + say "It's not false!"; } -## As you can see, you don't need parentheses around conditions. -## However, you do need the brackets around the "body" block: -# if (true) say; # This doesn't work ! +## As you can see, you don't need parentheses around conditions. However, you +## do need the curly braces around the "body" block. For example, +## `if (true) say;` doesn't work. -## You can also use their postfix versions, with the keyword after: -say "Quite truthy" if True; +## You can also use their statement modifier (postfix) versions: +say "Quite truthy" if True; #=> Quite truthy +say "Quite falsey" unless False; #=> Quite falsey -## - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages) -## returns $value-if-true if the condition is true and $value-if-false -## if it is false. -## my $result = $value condition ?? $value-if-true !! $value-if-false; +## - Ternary operator, "x ?? y !! z" +## This returns $value-if-true if the condition is true and $value-if-false +## if it is false. +## my $result = condition ?? $value-if-true !! $value-if-false; my $age = 30; say $age > 18 ?? "You are an adult" !! "You are under 18"; +#=> You are an adult ``` -### given/when, or switch +### given/when, or Perl 6's switch construct ```perl6 -## - `given`-`when` looks like other languages' `switch`, but is much more +## `given...when` looks like other languages' `switch`, but is much more ## powerful thanks to smart matching and Perl 6's "topic variable", $_. ## -## This variable contains the default argument of a block, -## a loop's current iteration (unless explicitly named), etc. +## The topic variable $_ contains the default argument of a block, a loop's +## current iteration (unless explicitly named), etc. ## ## `given` simply puts its argument into `$_` (like a block would do), ## and `when` compares it using the "smart matching" (`~~`) operator. ## ## Since other Perl 6 constructs use this variable (as said before, like `for`, -## blocks, etc), this means the powerful `when` is not only applicable along +## blocks, etc), this means the powerful `when` is not only applicable along ## with a `given`, but instead anywhere a `$_` exists. given "foo bar" { - say $_; #=> foo bar - when /foo/ { # Don't worry about smart matching yet – just know `when` uses it - # This is equivalent to `if $_ ~~ /foo/`. - say "Yay !"; - } - when $_.chars > 50 { # smart matching anything with True is True, - # i.e. (`$a ~~ True`) - # so you can also put "normal" conditionals. - # This `when` is equivalent to this `if`: - # if $_ ~~ ($_.chars > 50) {...} - # Which means: - # if $_.chars > 50 {...} - say "Quite a long string !"; - } - default { # same as `when *` (using the Whatever Star) - say "Something else" - } + say $_; #=> foo bar + when /foo/ { # Don't worry about smart matching yet. Just know + say "Yay !"; # `when` uses it. This is equivalent to `if $_ ~~ /foo/`. + + } + when $_.chars > 50 { # smart matching anything with True is True, + # i.e. (`$a ~~ True`) + # so you can also put "normal" conditionals. + # This `when` is equivalent to this `if`: + # `if $_ ~~ ($_.chars > 50) {...}` + # which means: `if $_.chars > 50 {...}` + say "Quite a long string !"; + } + default { # same as `when *` (using the Whatever Star) + say "Something else" + } } ``` ### Looping constructs ```perl6 -## - `loop` is an infinite loop if you don't pass it arguments, -## but can also be a C-style `for` loop: +## - `loop` is an infinite loop if you don't pass it arguments, but can also +## be a C-style `for` loop: loop { - say "This is an infinite loop !"; - last; # last breaks out of the loop, like the `break` keyword in other - # languages + say "This is an infinite loop !"; + last; # last breaks out of the loop, like + # the `break` keyword in other languages } loop (my $i = 0; $i < 5; $i++) { - next if $i == 3; # `next` skips to the next iteration, like `continue` + next if $i == 3; # `next` skips to the next iteration, like `continue` # in other languages. Note that you can also use postfix # conditionals, loops, etc. - say "This is a C-style for loop !"; + say "This is a C-style for loop!"; } -## - `for` - Passes through an array +## - `for` - Iterating through an array + +my @array = 1, 2, 6, 7, 3; + +## Accessing the array's elements with the topic variable $_. +for @array { + say "I've got $_ !"; +} + +## Accessing the array's elements with a "pointy block", `->`. +## Here each element is read-only. for @array -> $variable { - say "I've got $variable !"; + say "I've got $variable !"; } -## As we saw with given, for's default "current iteration" variable is `$_`. -## That means you can use `when` in a `for` just like you were in a `given`. +## Accessing the array's elements with a "doubly pointy block", `<->`. +## Here each element is read-write so mutating `$variable` mutates +## that element in the array. +for @array <-> $variable { + say "I've got $variable !"; +} + +## As we saw with given, a for loop's default "current iteration" variable +## is `$_`. That means you can use `when` in a `for`loop just like you were +## able to in a `given`. for @array { - say "I've got $_"; + say "I've got $_"; - .say; # This is also allowed. - # A dot call with no "topic" (receiver) is sent to `$_` by default - $_.say; # the above and this are equivalent. + .say; # This is also allowed. A dot call with no "topic" (receiver) + # is sent to `$_` by default + $_.say; # This is equivalent to the above statement. } for @array { - # You can... - next if $_ == 3; # Skip to the next iteration (`continue` in C-like languages) - redo if $_ == 4; # Re-do the iteration, keeping the same topic variable (`$_`) - last if $_ == 5; # Or break out of a loop (like `break` in C-like languages) + # You can... + next if $_ == 3; # Skip to the next iteration (`continue` in C-like lang.) + redo if $_ == 4; # Re-do iteration, keeping the same topic variable (`$_`) + last if $_ == 5; # Or break out of loop (like `break` in C-like lang.) } -## The "pointy block" syntax isn't specific to for. -## It's just a way to express a block in Perl6. +## The "pointy block" syntax isn't specific to the `for` loop. It's just a way +## to express a block in Perl 6. +sub long-computation { "Finding factors of large primes" } if long-computation() -> $result { - say "The result is $result"; + say "The result is $result."; } ``` ## Operators ```perl6 -## Since Perl languages are very much operator-based languages, -## Perl 6 operators are actually just funny-looking subroutines, in syntactic +## Since Perl languages are very much operator-based languages, Perl 6 +## operators are actually just funny-looking subroutines, in syntactic ## categories, like infix:<+> (addition) or prefix:<!> (bool not). ## The categories are: @@ -394,105 +429,127 @@ if long-computation() -> $result { ## - "postfix": after (like `++` in `$a++`). ## - "infix": in between (like `*` in `4 * 3`). ## - "circumfix": around (like `[`-`]` in `[1, 2]`). -## - "post-circumfix": around, after another term (like `{`-`}` in -## `%hash{'key'}`) +## - "post-circumfix": around, after another term (like `{`-`}` in +## `%hash{'key'}`) ## The associativity and precedence list are explained below. -## Alright, you're set to go ! +## Alright, you're set to go! -## * Equality Checking +## Equality Checking +##------------------ ## - `==` is numeric comparison -3 == 4; # False -3 != 4; # True +3 == 4; #=> False +3 != 4; #=> True ## - `eq` is string comparison -'a' eq 'b'; -'a' ne 'b'; # not equal -'a' !eq 'b'; # same as above +'a' eq 'b'; #=> False +'a' ne 'b'; #=> True, not equal +'a' !eq 'b'; #=> True, same as above ## - `eqv` is canonical equivalence (or "deep equality") -(1, 2) eqv (1, 3); +(1, 2) eqv (1, 3); #=> False +(1, 2) eqv (1, 2); #=> True +Int === Int #=> True -## - Smart Match Operator: `~~` +## - `~~` is the smart match operator ## Aliases the left hand side to $_ and then evaluates the right hand side. ## Here are some common comparison semantics: -## String or Numeric Equality - +## String or numeric equality 'Foo' ~~ 'Foo'; # True if strings are equal. -12.5 ~~ 12.50; # True if numbers are equal. +12.5 ~~ 12.50; # True if numbers are equal. ## Regex - For matching a regular expression against the left side. -## Returns a (Match) object, which evaluates as True if regexp matches. +## Returns a `Match` object, which evaluates as True if regexp matches. my $obj = 'abc' ~~ /a/; -say $obj; # ｢a｣ -say $obj.WHAT; # (Match) +say $obj; #=> ｢a｣ +say $obj.WHAT; #=> (Match) ## Hashes -'key' ~~ %hash; # True if key exists in hash - -## Type - Checks if left side "has type" (can check superclasses and roles) - -1 ~~ Int; # True +'key' ~~ %hash; # True if key exists in hash. -## Smart-matching against a boolean always returns that boolean (and will warn). +## Type - Checks if left side "is of type" (can check superclasses and +## roles). +say 1 ~~ Int; #=> True -1 ~~ True; # True -False ~~ True; # True +## Smart-matching against a boolean always returns that boolean +## (and will warn). +say 1 ~~ True; #=> True +say False ~~ True; #=> True -## General syntax is $arg ~~ &bool-returning-function; -## For a complete list of combinations, use this table: +## General syntax is `$arg ~~ &bool-returning-function;`. For a complete list +## of combinations, use this table: ## http://perlcabal.org/syn/S03.html#Smart_matching -## You also, of course, have `<`, `<=`, `>`, `>=`. -## Their string equivalent are also available : `lt`, `le`, `gt`, `ge`. -3 > 4; +## Of course, you also use `<`, `<=`, `>`, `>=` for numeric comparison. +## Their string equivalent are also available: `lt`, `le`, `gt`, `ge`. +3 > 4; # False +3 >= 4; # False +3 < 4; # True +3 <= 4; # True +'a' gt 'b'; # False +'a' ge 'b'; # False +'a' lt 'b'; # True +'a' le 'b'; # True + + +## Range constructor +##------------------ +3 .. 7; # 3 to 7, both included +3 ..^ 7; # 3 to 7, exclude right endpoint. +3 ^.. 7; # 3 to 7, exclude left endpoint. Same as `4..7`. +3 ^..^ 7; # 3 to 7, exclude both endpoints. Same as `4..6`. -## * Range constructors -3 .. 7; # 3 to 7, both included -## `^` on either side them exclusive on that side : -3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`) ## This also works as a shortcut for `0..^N`: -^10; # means 0..^10 +^10; # means 0..^10 ## This also allows us to demonstrate that Perl 6 has lazy/infinite arrays, ## using the Whatever Star: -my @array = 1..*; # 1 to Infinite ! `1..Inf` is the same. -say @array[^10]; # you can pass arrays as subscripts and it'll return - # an array of results. This will print - # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory !) -## Note : when reading an infinite list, Perl 6 will "reify" the elements +my @array = 1..*; # 1 to Infinite! Equivalent to `1..Inf`. +say @array[^10]; # You can pass ranges as subscripts and it'll return + # an array of results. This will print + # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory!) + +## Note: when reading an infinite list, Perl 6 will "reify" the elements ## it needs, then keep them in memory. They won't be calculated more than once. ## It also will never calculate more elements that are needed. -## Trying -## An array subscript can also be a closure. -## It'll be called with the length as the argument +## An array subscript can also be a closure. It'll be called with the length +## as the argument: say join(' ', @array[15..*]); #=> 15 16 17 18 19 ## which is equivalent to: say join(' ', @array[-> $n { 15..$n }]); + ## Note: if you try to do either of those with an infinite array, -## you'll trigger an infinite loop (your program won't finish) +## you'll trigger an infinite loop (your program won't finish). -## You can use that in most places you'd expect, even assigning to an array +## You can use that in most places you'd expect, even when assigning to +## an array: my @numbers = ^20; -## Here numbers increase by "6"; more on `...` operator later. -my @seq = 3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99; +## Here the numbers increase by 6, like an arithmetic sequence; more on the +## sequence (`...`) operator later. +my @seq = 3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99; @numbers[5..*] = 3, 9 ... *; # even though the sequence is infinite, # only the 15 needed values will be calculated. -say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87 - # (only 20 values) +say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87 + # (only 20 values) -## * And &&, Or || -3 && 4; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`. -0 || False; # False. Calls `.Bool` on `0` +## and (&&), or (||) +##------------------ +3 && 4; # 4, which is Truthy. Calls `.Bool` on both 3 and 4 and gets `True` + # so it returns 4 since both are `True`. +3 && 0; # 0 +0 && 4; # 0 -## * Short-circuit (and tight) versions of the above -# Returns the first argument that evaluates to False, or the last argument. +0 || False; # False. Calls `.Bool` on `0` and `False` which are both `False` + # so it retusns `False` since both are `False`. + +## Short-circuit (and tight) versions of the above +## Return the first argument that evaluates to False, or the last argument. my ( $a, $b, $c ) = 1, 0, 2; $a && $b && $c; # Returns 0, the first False value @@ -500,203 +557,242 @@ $a && $b && $c; # Returns 0, the first False value ## || Returns the first argument that evaluates to True $b || $a; # 1 -## And because you're going to want them, -## you also have compound assignment operators: -$a *= 2; # multiply and assignment. Equivalent to $a = $a * 2; -$b %%= 5; # divisible by and assignment +## And because you're going to want them, you also have compound assignment +## operators: +$a *= 2; # multiply and assignment. Equivalent to $a = $a * 2; +$b %%= 5; # divisible by and assignment. Equivalent to $b = $b %% 2; +$c div= 3; # return divisor and assignment. Equivalent to $c = $c div 3; +$d mod= 4; # return remainder and assignment. Equivalent to $d = $d mod 4; @array .= sort; # calls the `sort` method and assigns the result back ``` -## More on subs ! +## More on subs! ```perl6 -## As we said before, Perl 6 has *really* powerful subs. We're going to see -## a few more key concepts that make them better than in any other language :-). +## As we said before, Perl 6 has *really* powerful subs. We're going +## to see a few more key concepts that make them better than in any +## other language :-). ``` -### Unpacking ! +### Unpacking! ```perl6 -## It's the ability to "extract" arrays and keys (AKA "destructuring"). -## It'll work in `my`s and in parameter lists. +## Unpacking is the ability to "extract" arrays and keys +## (AKA "destructuring"). It'll work in `my`s and in parameter lists. my ($f, $g) = 1, 2; -say $f; #=> 1 -my ($, $, $h) = 1, 2, 3; # keep the non-interesting anonymous -say $h; #=> 3 +say $f; #=> 1 +my ($, $, $h) = 1, 2, 3; # keep the non-interesting values anonymous (`$`) +say $h; #=> 3 my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs" my (*@small) = 1; -sub unpack_array(@array [$fst, $snd]) { - say "My first is $fst, my second is $snd ! All in all, I'm @array[]."; +sub unpack_array( @array [$fst, $snd] ) { + say "My first is $fst, my second is $snd! All in all, I'm @array[]."; # (^ remember the `[]` to interpolate the array) } -unpack_array(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3 +unpack_array(@tail); #=> My first is 2, my second is 3! All in all, I'm 2 3. ## If you're not using the array itself, you can also keep it anonymous, ## much like a scalar: -sub first-of-array(@ [$fst]) { $fst } +sub first-of-array( @ [$fst] ) { $fst } first-of-array(@small); #=> 1 -first-of-array(@tail); # Throws an error "Too many positional parameters passed" - # (which means the array is too big). +first-of-array(@tail); # Error: "Too many positional parameters passed" + # (which means the array is too big). -## You can also use a slurp ... +## You can also use a slurp... sub slurp-in-array(@ [$fst, *@rest]) { # You could keep `*@rest` anonymous - say $fst + @rest.elems; # `.elems` returns a list's length. - # Here, `@rest` is `(3,)`, since `$fst` holds the `2`. + say $fst + @rest.elems; # `.elems` returns a list's length. + # Here, `@rest` is `(3,)`, since `$fst` + # holds the `2`. } -slurp-in-array(@tail); #=> 3 +slurp-in-array(@tail); #=> 3 ## You could even extract on a slurpy (but it's pretty useless ;-).) -sub fst(*@ [$fst]) { # or simply : `sub fst($fst) { ... }` - say $fst; +sub fst(*@ [$fst]) { # or simply: `sub fst($fst) { ... }` + say $fst; } -fst(1); #=> 1 +fst(1); #=> 1 fst(1, 2); # errors with "Too many positional parameters passed" -## You can also destructure hashes (and classes, which you'll learn about later) -## The syntax is basically `%hash-name (:key($variable-to-store-value-in))`. +## You can also destructure hashes (and classes, which you'll learn about +## later). The syntax is basically the same as +## `%hash-name (:key($variable-to-store-value-in))`. ## The hash can stay anonymous if you only need the values you extracted. -sub key-of(% (:value($val), :qua($qua))) { - say "Got val $val, $qua times."; +sub key-of( % (:value($val), :qua($qua)) ) { + say "Got val $val, $qua times."; } -## Then call it with a hash: (you need to keep the brackets for it to be a hash) -key-of({value => 'foo', qua => 1}); +## Then call it with a hash. You need to keep the curly braces for it to be a +## hash or use `%()` instead to indicate a hash is being passed. +key-of({value => 'foo', qua => 1}); #=> Got val foo, 1 times. +key-of(%(value => 'foo', qua => 1)); #=> Got val foo, 1 times. #key-of(%hash); # the same (for an equivalent `%hash`) -## The last expression of a sub is returned automatically -## (though you may use the `return` keyword, of course): -sub next-index($n) { - $n + 1; +## The last expression of a sub is returned automatically (though you may +## indicate explicitly by using the `return` keyword, of course): +sub next-index( $n ) { + $n + 1; } my $new-n = next-index(3); # $new-n is now 4 -## This is true for everything, except for the looping constructs -## (due to performance reasons): there's reason to build a list -## if we're just going to discard all the results. -## If you still want to build one, you can use the `do` statement prefix: -## (or the `gather` prefix, which we'll see later) -sub list-of($n) { - do for ^$n { # note the use of the range-to prefix operator `^` (`0..^N`) - $_ # current loop iteration - } +## This is true for everything, except for the looping constructs (due to +## performance reasons): there's no reason to build a list if we're just going to +## discard all the results. If you still want to build one, you can use the +## `do` statement prefix or the `gather` prefix, which we'll see later: + +sub list-of( $n ) { + do for ^$n { # note the range-to prefix operator `^` (`0..^N`) + $_ # current loop iteration known as the "topic" variable + } } my @list3 = list-of(3); #=> (0, 1, 2) ``` -### lambdas +### lambdas (or anonymous subroutines) ```perl6 -## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block") -my &lambda = -> $argument { "The argument passed to this lambda is $argument" } +## You can create a lambda with `-> {}` ("pointy block") , +## `{}` ("block") or `sub {}`. + +my &lambda1 = -> $argument { + "The argument passed to this lambda is $argument" +} + +my &lambda2 = { + "The argument passed to this lambda is $_" +} + +my &lambda3 = sub ($argument) { + "The argument passed to this lambda is $argument" +} + ## `-> {}` and `{}` are pretty much the same thing, except that the former can ## take arguments, and that the latter can be mistaken as a hash by the parser. -## We can, for example, add 3 to each value of an array using map: +## We can, for example, add 3 to each value of an array using the +## `map` function with a lambda: my @arrayplus3 = map({ $_ + 3 }, @array); # $_ is the implicit argument ## A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`): ## A block doesn't have a "function context" (though it can have arguments), -## which means that if you return from it, -## you're going to return from the parent function. Compare: -sub is-in(@array, $elem) { - # this will `return` out of the `is-in` sub - # once the condition evaluated to True, the loop won't be run anymore - map({ return True if $_ == $elem }, @array); -} -sub truthy-array(@array) { - # this will produce an array of `True` and `False`: - # (you can also say `anon sub` for "anonymous subroutine") - map(sub ($i) { if $i { return True } else { return False } }, @array); - # ^ the `return` only returns from the anonymous `sub` -} - -## You can also use the "whatever star" to create an anonymous function +## which means that if you return from it, you're going to return from the +## parent function. Compare: +sub is-in( @array, $elem ) { + # this will `return` out of the `is-in` sub once the condition evaluated + ## to True, the loop won't be run anymore. + map({ return True if $_ == $elem }, @array); +} +## with: +sub truthy-array( @array ) { + # this will produce an array of `True` and `False`: + # (you can also say `anon sub` for "anonymous subroutine") + map(sub ($i) { if $i { return True } else { return False } }, @array); + # ^ the `return` only returns from the anonymous `sub` +} + +## The `anon` declarator can be used to create an anonymous sub from a +## regular subroutine. The regular sub knows its name but its symbol is +## prevented from getting installed in the lexical scope, the method table +## and everywhere else. + +my $anon-sum = anon sub summation(*@a) { [+] *@a } +say $anon-sum.name; #=> summation +say $anon-sum(2, 3, 5); #=> 10 +#say summation; #=> Error: Undeclared routine: ... + +## You can also use the "whatever star" to create an anonymous subroutine. ## (it'll stop at the furthest operator in the current expression) -my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }` +my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }` my @arrayplus3 = map(*+*+3, @array); # Same as `-> $a, $b { $a + $b + 3 }` # also `sub ($a, $b) { $a + $b + 3 }` -say (*/2)(4); #=> 2 - # Immediately execute the function Whatever created. +say (*/2)(4); #=> 2 + # Immediately execute the function Whatever created. say ((*+3)/5)(5); #=> 1.6 - # works even in parens ! - -## But if you need to have more than one argument (`$_`) -## in a block (without wanting to resort to `-> {}`), -## you can also use the implicit argument syntax, `$^` : -map({ $^a + $^b + 3 }, @array); # equivalent to following: -map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`) - -## Note : those are sorted lexicographically. -# `{ $^b / $^a }` is like `-> $a, $b { $b / $a }` + # It works even in parens! + +## But if you need to have more than one argument (`$_`) in a block (without +## wanting to resort to `-> {}`), you can also use the implicit argument +## syntax, `$^`: +map({ $^a + $^b + 3 }, @array); +# which is equivalent to the following which uses a `sub`: +map(sub ($a, $b) { $a + $b + 3 }, @array); + +## The parameters `$^a`, `$^b`, etc. are known as placeholder parameters or +## self-declared positional parameters. They're sorted lexicographically so +## `{ $^b / $^a }` is equivalent `-> $a, $b { $b / $a }`. ``` ### About types... ```perl6 -## Perl6 is gradually typed. This means you can specify the type -## of your variables/arguments/return types, or you can omit them -## and they'll default to "Any". -## You obviously get access to a few base types, like Int and Str. -## The constructs for declaring types are "class", "role", -## which you'll see later. - -## For now, let us examine "subset": -## a "subset" is a "sub-type" with additional checks. -## For example: "a very big integer is an Int that's greater than 500" -## You can specify the type you're subtyping (by default, Any), -## and add additional checks with the "where" keyword: +## Perl 6 is gradually typed. This means you can specify the type of your +## variables/arguments/return types, or you can omit the type annotations in +## in which case they'll default to `Any`. Obviously you get access to a few +## base types, like `Int` and `Str`. The constructs for declaring types are +## "subset", "class", "role", etc. which you'll see later. + +## For now, let us examine "subset" which is a "sub-type" with additional +## checks. For example, "a very big integer is an Int that's greater than 500". +## You can specify the type you're subtyping (by default, `Any`), and add +## additional checks with the `where` clause: subset VeryBigInteger of Int where * > 500; +## Or the set of the whole numbers: +subset WholeNumber of Int where * >= 0; ``` ### Multiple Dispatch ```perl6 ## Perl 6 can decide which variant of a `sub` to call based on the type of the -## arguments, or on arbitrary preconditions, like with a type or a `where`: +## arguments, or on arbitrary preconditions, like with a type or `where`: -## with types -multi sub sayit(Int $n) { # note the `multi` keyword here +## with types: +multi sub sayit( Int $n ) { # note the `multi` keyword here say "Number: $n"; } -multi sayit(Str $s) { # a multi is a `sub` by default +multi sayit( Str $s ) { # a multi is a `sub` by default say "String: $s"; } -sayit("foo"); # prints "String: foo" -sayit(True); # fails at *compile time* with - # "calling 'sayit' will never work with arguments of types ..." +sayit("foo"); #=> "String: foo" +sayit(25); #=> "Number: 25" +sayit(True); # fails at *compile time* with "calling 'sayit' will never + # work with arguments of types ..." -## with arbitrary precondition (remember subsets?): -multi is-big(Int $n where * > 50) { "Yes !" } # using a closure -multi is-big(Int $ where 10..50) { "Quite." } # Using smart-matching - # (could use a regexp, etc) +## with arbitrary preconditions (remember subsets?): +multi is-big(Int $n where * > 50) { "Yes!" } # using a closure +multi is-big(Int $n where {$_ > 50}) { "Yes!" } # similar to above +multi is-big(Int $ where 10..50) { "Quite." } # Using smart-matching + # (could use a regexp, etc) multi is-big(Int $) { "No" } subset Even of Int where * %% 2; - multi odd-or-even(Even) { "Even" } # The main case using the type. # We don't name the argument. -multi odd-or-even($) { "Odd" } # "else" +multi odd-or-even($) { "Odd" } # "everthing else" hence the $ variable -## You can even dispatch based on a positional's argument presence ! -multi with-or-without-you(:$with!) { # You need make it mandatory to - # be able to dispatch against it. - say "I can live ! Actually, I can't."; +## You can even dispatch based on the presence of positional and +## named arguments: +multi with-or-without-you($with) { + say "I wish I could but I can't"; +} +multi with-or-without-you(:$with) { + say "I can live! Actually, I can't."; } multi with-or-without-you { - say "Definitely can't live."; + say "Definitely can't live."; } -## This is very, very useful for many purposes, like `MAIN` subs (covered -## later), and even the language itself is using it in several places. + +## This is very, very useful for many purposes, like `MAIN` subs (covered +## later), and even the language itself uses it in several places. ## ## - `is`, for example, is actually a `multi sub` named `trait_mod:<is>`, ## and it works off that. ## - `is rw`, is simply a dispatch to a function with this signature: ## sub trait_mod:<is>(Routine $r, :$rw!) {} ## -## (commented because running this would be a terrible idea !) +## (commented out because running this would be a terrible idea!) ``` ## Scoping @@ -705,175 +801,207 @@ multi with-or-without-you { ## In Perl 6, unlike many scripting languages, (such as Python, Ruby, PHP), ## you must declare your variables before using them. The `my` declarator ## you have learned uses "lexical scoping". There are a few other declarators, -## (`our`, `state`, ..., ) which we'll see later. -## This is called "lexical scoping", where in inner blocks, -## you can access variables from outer blocks. +## (`our`, `state`, ..., ) which we'll see later. This is called +## "lexical scoping", where in inner blocks, you can access variables from +## outer blocks. my $file_scoped = 'Foo'; sub outer { - my $outer_scoped = 'Bar'; - sub inner { - say "$file_scoped $outer_scoped"; - } - &inner; # return the function + my $outer_scoped = 'Bar'; + sub inner { + say "$file_scoped $outer_scoped"; + } + &inner; # return the function } -outer()(); #=> 'Foo Bar' +outer()(); #=> 'Foo Bar' ## As you can see, `$file_scoped` and `$outer_scoped` were captured. -## But if we were to try and use `$bar` outside of `foo`, +## But if we were to try and use `$outer_scoped` outside the `outer` sub, ## the variable would be undefined (and you'd get a compile time error). ``` ## Twigils ```perl6 -## There are many special `twigils` (composed sigil's) in Perl 6. -## Twigils define the variables' scope. +## There are many special `twigils` (composed sigils) in Perl 6. Twigils +## define the variables' scope. ## The * and ? twigils work on standard variables: ## * Dynamic variable ## ? Compile-time variable ## The ! and the . twigils are used with Perl 6's objects: -## ! Attribute (class member) +## ! Attribute (instance attribute) ## . Method (not really a variable) -## `*` Twigil: Dynamic Scope -## These variables use the`*` twigil to mark dynamically-scoped variables. +## `*` twigil: Dynamic Scope +## These variables use the `*` twigil to mark dynamically-scoped variables. ## Dynamically-scoped variables are looked up through the caller, not through -## the outer scope +## the outer scope. my $*dyn_scoped_1 = 1; my $*dyn_scoped_2 = 10; sub say_dyn { - say "$*dyn_scoped_1 $*dyn_scoped_2"; + say "$*dyn_scoped_1 $*dyn_scoped_2"; } sub call_say_dyn { my $*dyn_scoped_1 = 25; # Defines $*dyn_scoped_1 only for this sub. - $*dyn_scoped_2 = 100; # Will change the value of the file scoped variable. - say_dyn(); #=> 25 100 $*dyn_scoped 1 and 2 will be looked for in the call. - # It uses the value of $*dyn_scoped_1 from inside this sub's - # lexical scope even though the blocks aren't nested (they're - # call-nested). -} -say_dyn(); #=> 1 10 + $*dyn_scoped_2 = 100; # Will change the value of the file scoped variable. + say_dyn(); #=> 25 100, $*dyn_scoped 1 and 2 will be looked + # for in the call. + # It uses the value of $*dyn_scoped_1 from inside + # this sub's lexical scope even though the blocks + # aren't nested (they're call-nested). +} +say_dyn(); #=> 1 10 call_say_dyn(); #=> 25 100 # Uses $*dyn_scoped_1 as defined in call_say_dyn even though # we are calling it from outside. -say_dyn(); #=> 1 100 We changed the value of $*dyn_scoped_2 in call_say_dyn - # so now its value has changed. +say_dyn(); #=> 1 100 We changed the value of $*dyn_scoped_2 in + # call_say_dyn so now its value has changed. ``` ## Object Model ```perl6 ## To call a method on an object, add a dot followed by the method name: -## => $object.method +## `$object.method` + ## Classes are declared with the `class` keyword. Attributes are declared -## with the `has` keyword, and methods declared with `method`. -## Every attribute that is private uses the ! twigil for example: `$!attr`. -## Immutable public attributes use the `.` twigil. -## (you can make them mutable with `is rw`) -## The easiest way to remember the `$.` twigil is comparing it to how methods -## are called. - -## Perl 6's object model ("SixModel") is very flexible, -## and allows you to dynamically add methods, change semantics, etc ... -## (these will not all be covered here, and you should refer to: +## with the `has` keyword, and methods declared with the `method` keyword. + +## Every attribute that is private uses the ! twigil. For example: `$!attr`. +## Immutable public attributes use the `.` twigil which creates a read-only +## method named after the attribute. In fact, declaring an attribute with `.` +## is equivalent to declaring the same attribute with `!` and then creating +## a read-only method with the attribute's name. However, this is done for us +## by Perl 6 automatically. The easiest way to remember the `$.` twigil is +## by comparing it to how methods are called. + +## Perl 6's object model ("SixModel") is very flexible, and allows you to +## dynamically add methods, change semantics, etc... Unfortunately, these will +## not all be covered here, and you should refer to: ## https://docs.perl6.org/language/objects.html. -class Attrib-Class { - has $.attrib; # `$.attrib` is immutable. - # From inside the class, use `$!attrib` to modify it. - has $.other-attrib is rw; # You can mark a public attribute `rw`. - has Int $!private-attrib = 10; - - method get-value { - $.attrib + $!private-attrib; - } +class Human { + has Str $.name; # `$.name` is immutable but with an accessor method. + has Str $.bcountry; # Use `$!bplace` to modify it inside the class. + has Str $.ccountry is rw; # This attribute can be modified from outside. + has Int $!age = 0; # A private attribute with default value. - method set-value($param) { # Methods can take parameters - $!attrib = $param; # This works, because `$!` is always mutable. - # $.attrib = $param; # Wrong: You can't use the `$.` immutable version. + method birthday { + $!age += 1; # Add a year to human's age + } - $.other-attrib = 5; # This works, because `$.other-attrib` is `rw`. - } + method get-age { + return $!age; + } - method !private-method { - say "This method is private to the class !"; - } + # This method is private to the class. Note the `!` before the + # method's name. + method !do-decoration { + return "$!name was born in $!bcountry and now lives in $!ccountry." + } + + # This method is public, just like `birthday` and `get-age`. + method get-info { + self.do-decoration; # Invoking a method on `self` inside the class. + # Use `self!priv-method` for private method. + # Use `self.publ-method` for public method. + } }; -## Create a new instance of Attrib-Class with $.attrib set to 5 : +## Create a new instance of Human class with $.attrib set to 5. ## Note: you can't set private-attribute from here (more later on). -my $class-obj = Attrib-Class.new(attrib => 5); -say $class-obj.get-value; #=> 15 -# $class-obj.attrib = 5; # This fails, because the `has $.attrib` is immutable -$class-obj.other-attrib = 10; # This, however, works, because the public - # attribute is mutable (`rw`). +my $person1 = Human.new( + name => "Jord", + bcountry = "Iceland", + ccountry => "Iceland" +); + +say $person1.name; #=> Jord +say $person1.bcountry; #=> Togo +say $person1.ccountry; #=> Togo + + +# $person1.bcountry = "Mali"; # This fails, because the `has $.bcountry` + # is immutable. Jord can't change his birthplace. +$person1.ccountry = "France"; # This works because the `$.ccountry` is mutable + # (`is rw`). Now Jord's current country is France. + +# Calling methods on the instance objects. +$person1.birthday; #=> 1 +$person1.get-info; #=> Jord was born in Togo and now lives in France. +$person1.do-decoration; # This fails since the method `do-decoration` is + # private. ``` ### Object Inheritance ```perl6 -## Perl 6 also has inheritance (along with multiple inheritance) -## While `method`'s are inherited, `submethod`'s are not. -## Submethods are useful for object construction and destruction tasks, -## such as BUILD, or methods that must be overridden by subtypes. -## We will learn about BUILD later on. +## Perl 6 also has inheritance (along with multiple inheritance). While +## methods are inherited, submethods are not. Submethods are useful for +## object construction and destruction tasks, such as BUILD, or methods that +## must be overridden by subtypes. We will learn about BUILD later on. class Parent { - has $.age; - has $.name; - # This submethod won't be inherited by Child. - submethod favorite-color { - say "My favorite color is Blue"; - } - # This method is inherited - method talk { say "Hi, my name is $!name" } + has $.age; + has $.name; + + # This submethod won't be inherited by the Child class. + submethod favorite-color { + say "My favorite color is Blue"; + } + + # This method is inherited + method talk { say "Hi, my name is $!name" } } + # Inheritance uses the `is` keyword class Child is Parent { - method talk { say "Goo goo ga ga" } - # This shadows Parent's `talk` method, This child hasn't learned to speak yet! + method talk { say "Goo goo ga ga" } + # This shadows Parent's `talk` method. + # This child hasn't learned to speak yet! } + my Parent $Richard .= new(age => 40, name => 'Richard'); -$Richard.favorite-color; #=> "My favorite color is Blue" -$Richard.talk; #=> "Hi, my name is Richard" -## $Richard is able to access the submethod, he knows how to say his name. +$Richard.favorite-color; #=> "My favorite color is Blue" +$Richard.talk; #=> "Hi, my name is Richard" +## $Richard is able to access the submethod and he knows how to say his name. my Child $Madison .= new(age => 1, name => 'Madison'); -$Madison.talk; # prints "Goo goo ga ga" due to the overridden method. -# $Madison.favorite-color # does not work since it is not inherited +$Madison.talk; #=> "Goo goo ga ga", due to the overridden method. +# $Madison.favorite-color # does not work since it is not inherited. ## When you use `my T $var`, `$var` starts off with `T` itself in it, ## so you can call `new` on it. ## (`.=` is just the dot-call and the assignment operator: -## `$a .= b` is the same as `$a = $a.b`) +## `$a .= b` is the same as `$a = $a.b`) ## Also note that `BUILD` (the method called inside `new`) -## will set parent properties too, so you can pass `val => 5`. +## will set parent's properties too, so you can pass `val => 5`. ``` ### Roles, or Mixins ```perl6 -## Roles are supported too (also called Mixins in other languages) +## Roles are supported too (which are called Mixins in other languages) role PrintableVal { - has $!counter = 0; - method print { - say $.val; - } + has $!counter = 0; + method print { + say $.val; + } } -## you "import" a mixin (a "role") with "does": +## you "apply" a role (or mixin) with `does` keyword: class Item does PrintableVal { - has $.val; + has $.val; - ## When `does`-ed, a `role` literally "mixes in" the class: - ## the methods and attributes are put together, which means a class can access - ## the private attributes/methods of its roles (but not the inverse !): - method access { - say $!counter++; - } + ## When `does`-ed, a `role` literally "mixes in" the class: + ## the methods and attributes are put together, which means a class + ## can access the private attributes/methods of its roles (but + ## not the inverse!): + method access { + say $!counter++; + } ## However, this: ## method print {} @@ -881,9 +1009,9 @@ class Item does PrintableVal { ## (this means a parent class can shadow a child class's `multi print() {}`, ## but it's an error if a role does) - ## NOTE: You can use a role as a class (with `is ROLE`). In this case, - ## methods will be shadowed, since the compiler will consider `ROLE` to - ## be a class. + ## NOTE: You can use a role as a class (with `is ROLE`). In this case, + ## methods will be shadowed, since the compiler will consider `ROLE` + ## to be a class. } ``` @@ -891,91 +1019,109 @@ class Item does PrintableVal { ```perl6 ## Exceptions are built on top of classes, in the package `X` (like `X::IO`). -## In Perl6 exceptions are automatically 'thrown' -open 'foo'; #> Failed to open file foo: no such file or directory -## It will also print out what line the error was thrown at and other error info +## In Perl6 exceptions are automatically 'thrown': +open 'foo'; #=> Failed to open file foo: no such file or directory +## It will also print out what line the error was thrown at +## and other error info. ## You can throw an exception using `die`: die 'Error!'; #=> Error! ## Or more explicitly: -die X::AdHoc.new(payload => 'Error!'); +X::AdHoc.new(payload => 'Error!').throw; #=> Error! ## In Perl 6, `orelse` is similar to the `or` operator, except it only matches -## undefined variables instead of anything evaluating as false. +## undefined variables instead of anything evaluating as `False`. ## Undefined values include: `Nil`, `Mu` and `Failure` as well as `Int`, `Str` ## and other types that have not been initialized to any value yet. ## You can check if something is defined or not using the defined method: my $uninitialized; -say $uninitiazilzed.defined; #> False -## When using `orelse` it will disarm the exception and alias $_ to that failure -## This will avoid it being automatically handled and printing lots of scary -## error messages to the screen. -## We can use the exception method on $_ to access the exception +say $uninitiazilzed.defined; #=> False + +## When using `orelse` it will disarm the exception and alias $_ to that +## failure. This will prevent it to being automatically handled and printing +## lots of scary error messages to the screen. We can use the `exception` +## method on the `$_` variable to access the exception open 'foo' orelse say "Something happened {.exception}"; ## This also works: -open 'foo' orelse say "Something happened $_"; #> Something happened - #> Failed to open file foo: no such file or directory -## Both of those above work but in case we get an object from the left side that -## is not a failure we will probably get a warning. We see below how we can use -## `try` and `CATCH` to be more specific with the exceptions we catch. +open 'foo' orelse say "Something happened $_"; #=> Something happened + #=> Failed to open file foo: no such file or directory +## Both of those above work but in case we get an object from the left side +## that is not a failure we will probably get a warning. We see below how we +## can use try` and `CATCH` to be more specific with the exceptions we catch. ``` ### Using `try` and `CATCH` ```perl6 ## By using `try` and `CATCH` you can contain and handle exceptions without -## disrupting the rest of the program. `try` will set the last exception to -## the special variable `$!` Note: This has no relation to $!variables. +## disrupting the rest of the program. The `try` block will set the last +## exception to the special variable `$!` (known as the error variable). +## Note: This has no relation to $!variables seen inside class definitions. + try open 'foo'; -say "Well, I tried! $!" if defined $!; #> Well, I tried! Failed to open file - #foo: no such file or directory +say "Well, I tried! $!" if defined $!; +#=> Well, I tried! Failed to open file foo: no such file or directory + ## Now, what if we want more control over handling the exception? ## Unlike many other languages, in Perl 6, you put the `CATCH` block *within* -## the block to `try`. Similar to how $_ was set when we 'disarmed' the -## exception with orelse, we also use $_ in the CATCH block. -## Note: ($! is only set *after* the `try` block) -## By default, a `try` has a `CATCH` block that catches -## any exception (`CATCH { default {} }`). +## the block to `try`. Similar to how the `$_` variable was set when we +## 'disarmed' the exception with `orelse`, we also use `$_` in the CATCH block. +## Note: The `$!` variable is only set *after* the `try` block has caught an +## exception. By default, a `try` block has a `CATCH` block of its own that +## catches any exception (`CATCH { default {} }`). -try { my $a = (0 %% 0); CATCH { say "Something happened: $_" } } - #=> Something happened: Attempt to divide by zero using infix:<%%> +try { + my $a = (0 %% 0); + CATCH { + say "Something happened: $_" + } +} +#=> Something happened: Attempt to divide by zero using infix:<%%> + +## You can redefine it using `when`s (and `default`) to handle the exceptions +## you want to catch explicitly: -## You can redefine it using `when`s (and `default`) -## to handle the exceptions you want: try { open 'foo'; - CATCH { # In the `CATCH` block, the exception is set to $_ - when X::AdHoc { say "Error: $_" } - #=>Error: Failed to open file /dir/foo: no such file or directory - - ## Any other exception will be re-raised, since we don't have a `default` - ## Basically, if a `when` matches (or there's a `default`) marks the - ## exception as - ## "handled" so that it doesn't get re-thrown from the `CATCH`. - ## You still can re-throw the exception (see below) by hand. + CATCH { + # In the `CATCH` block, the exception is set to the $_ variable. + when X::AdHoc { + say "Error: $_" + } + when X::Numeric::DivideByZero { + say "Error: $_"; + } + ## Any other exceptions will be re-raised, since we don't have a `default`. + ## Basically, if a `when` matches (or there's a `default`), the + ## exception is marked as "handled" so as to prevent its re-throw + ## from the `CATCH` block. You still can re-throw the exception (see below) + ## by hand. } } +#=>Error: Failed to open file /dir/foo: no such file or directory ## There are also some subtleties to exceptions. Some Perl 6 subs return a -## `Failure`, which is a kind of "unthrown exception". They're not thrown until -## you tried to look at their content, unless you call `.Bool`/`.defined` on -## them - then they're handled. +## `Failure`, which is a wrapper around an `Exception` object which is +## "unthrown". They're not thrown until you try to use the variables containing +## them unless you call `.Bool`/`.defined` on them - then they're handled. ## (the `.handled` method is `rw`, so you can mark it as `False` back yourself) -## ## You can throw a `Failure` using `fail`. Note that if the pragma `use fatal` ## is on, `fail` will throw an exception (like `die`). + fail "foo"; # We're not trying to access the value, so no problem. try { - fail "foo"; - CATCH { - default { say "It threw because we tried to get the fail's value!" } + fail "foo"; + CATCH { + default { + say "It threw because we tried to get the fail's value!" + } } } ## There is also another kind of exception: Control exceptions. -## Those are "good" exceptions, which happen when you change your program's +## Those are "good" exceptions, which happen when you change your program's ## flow, using operators like `return`, `next` or `last`. ## You can "catch" those with `CONTROL` (not 100% working in Rakudo yet). ``` @@ -989,29 +1135,35 @@ try { ## Packages are important - especially as Perl is well-known for CPAN, ## the Comprehensive Perl Archive Network. -## You can use a module (bring its declarations into scope) with `use` +## You can use a module (bring its declarations into scope) with +## the `use` keyword: use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module say from-json('[1]').perl; #=> [1] ## You should not declare packages using the `package` keyword (unlike Perl 5). ## Instead, use `class Package::Name::Here;` to declare a class, or if you only -## want to export variables/subs, you can use `module`. +## want to export variables/subs, you can use `module` instead. + +module Hello::World { # bracketed form + # If `Hello` doesn't exist yet, it'll just be a "stub", + # that can be redeclared as something else later. -module Hello::World { # Bracketed form - # If `Hello` doesn't exist yet, it'll just be a "stub", - # that can be redeclared as something else later. - # ... declarations here ... + # ... declarations here ... } -unit module Parse::Text; # file-scoped form -grammar Parse::Text::Grammar { # A grammar is a package, which you could `use` -} # You will learn more about grammars in the regex section +unit module Parse::Text; # file-scoped form which extends until + # the end of the file + +grammar Parse::Text::Grammar { + # A grammar is a package, which you could `use`. + # You will learn more about grammars in the regex section +} ## As said before, any part of the six model is also a package. ## Since `JSON::Tiny` uses its own `JSON::Tiny::Actions` class, you can use it: my $actions = JSON::Tiny::Actions.new; -## We'll see how to export variables and subs in the next part: +## We'll see how to export variables and subs in the next part. ``` ## Declarators @@ -1020,36 +1172,38 @@ my $actions = JSON::Tiny::Actions.new; ## In Perl 6, you get different behaviors based on how you declare a variable. ## You've already seen `my` and `has`, we'll now explore the others. -## * `our` declarations happen at `INIT` time -- (see "Phasers" below) -## It's like `my`, but it also creates a package variable. -## (All packagish things (`class`, `role`, etc) are `our` by default) -module Var::Increment { - our $our-var = 1; # Note: you can't put a type constraint like Int on an - my $my-var = 22; # `our` variable. - our sub Inc { - - our sub available { # If you try to make inner `sub`s `our`... - # Better know what you're doing (Don't !). - say "Don't do that. Seriously. You'll get burned."; - } +## `our` - these declarations happen at `INIT` time -- (see "Phasers" below). +## It's like `my`, but it also creates a package variable. All packagish +## things such as `class`, `role`, etc. are `our` by default. - my sub unavailable { # `my sub` is the default - say "Can't access me from outside, I'm 'my'!"; - } - say ++$our-var; # Increment the package variable and output its value +module Var::Increment { + our $our-var = 1; # Note: `our`-declared variables cannot be typed. + my $my-var = 22; + + our sub Inc { + our sub available { # If you try to make inner `sub`s `our`... + # ... Better know what you're doing (Don't !). + say "Don't do that. Seriously. You'll get burned."; + } + + my sub unavailable { # `sub`s are `my`-declared by default + say "Can't access me from outside, I'm 'my'!"; + } + say ++$our-var; # Increment the package variable and output its value } } -say $Var::Increment::our-var; #=> 1 This works -say $Var::Increment::my-var; #=> (Any) This will not work. -Var::Increment::Inc; #=> 2 -Var::Increment::Inc; #=> 3 # Notice how the value of $our-var was - # retained. -Var::Increment::unavailable; #> Could not find symbol '&unavailable' +say $Var::Increment::our-var; #=> 1, this works! +say $Var::Increment::my-var; #=> (Any), this will not work! + +Var::Increment::Inc; #=> 2 +Var::Increment::Inc; #=> 3 , notice how the value of $our-var was + # retained. +Var::Increment::unavailable; #=> Could not find symbol '&unavailable' -## * `constant` (happens at `BEGIN` time) -## You can use the `constant` keyword to declare a compile-time variable/symbol: +## `constant` - these declarations happen at `BEGIN` time. You can use +## the `constant` keyword to declare a compile-time variable/symbol: constant Pi = 3.14; constant $var = 1; @@ -1057,12 +1211,12 @@ constant $var = 1; constant why-not = 5, 15 ... *; say why-not[^5]; #=> 5 15 25 35 45 -## * `state` (happens at run time, but only once) -## State variables are only initialized one time -## (they exist in other languages such as C as `static`) +## `state` - these declarations happen at run time, but only once. State +## variables are only initialized one time. In other languages such as C +## they exist as `static` variables. sub fixed-rand { - state $val = rand; - say $val; + state $val = rand; + say $val; } fixed-rand for ^10; # will print the same number 10 times @@ -1070,40 +1224,42 @@ fixed-rand for ^10; # will print the same number 10 times ## If you declare a function with a `state` within a loop, it'll re-create the ## variable for each iteration of the loop. See: for ^5 -> $a { - sub foo { - state $val = rand; # This will be a different value for every value of `$a` - } - for ^5 -> $b { - say foo; # This will print the same value 5 times, but only 5. - # Next iteration will re-run `rand`. - } + sub foo { + state $val = rand; # This will be a different value for + # every value of `$a` + } + for ^5 -> $b { + say foo; # This will print the same value 5 times, + # but only 5. Next iteration will re-run `rand`. + } } ``` ## Phasers ```perl6 -## Phasers in Perl 6 are blocks that happen at determined points of time in your -## program. They are called phasers because they mark a change in the phase -## of a program. For example, when the program is compiled, a for loop runs, -## you leave a block, or an exception gets thrown. -## (`CATCH` is actually a phaser!) -## Some of them can be used for their return values, some of them can't -## (those that can have a "[*]" in the beginning of their explanation text). -## Let's have a look ! - -## * Compile-time phasers +## Phasers in Perl 6 are blocks that happen at determined points of time in +## your program. They are called phasers because they mark a change in the +## phase of a program. For example, when the program is compiled, a for loop +## runs, you leave a block, or an exception gets thrown (The `CATCH` block is +## actually a phaser!). Some of them can be used for their return values, +## some of them can't (those that can have a "[*]" in the beginning of their +## explanation text). Let's have a look! + +## Compile-time phasers BEGIN { say "[*] Runs at compile time, as soon as possible, only once" } CHECK { say "[*] Runs at compile time, as late as possible, only once" } -## * Run-time phasers +## Run-time phasers INIT { say "[*] Runs at run time, as soon as possible, only once" } -END { say "Runs at run time, as late as possible, only once" } +END { say "Runs at run time, as late as possible, only once" } -## * Block phasers +## Block phasers ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" } -LEAVE { say "Runs everytime you leave a block, even when an exception - happened. Repeats on loop blocks." } +LEAVE { + say "Runs everytime you leave a block, even when an exception + happened. Repeats on loop blocks." +} PRE { say "Asserts a precondition at every block entry, @@ -1112,7 +1268,7 @@ PRE { an exception of type X::Phaser::PrePost is thrown."; } -## example: +## Example: for 0..2 { PRE { $_ > 1 } # This is going to blow up with "Precondition failed" } @@ -1123,83 +1279,86 @@ POST { say "If this block doesn't return a truthy value, an exception of type X::Phaser::PrePost is thrown, like PRE."; } + for 0..2 { POST { $_ < 2 } # This is going to blow up with "Postcondition failed" } -## * Block/exceptions phasers +## Block/exceptions phasers sub { KEEP { say "Runs when you exit a block successfully (without throwing an exception)" } - UNDO { say "Runs when you exit a block unsuccessfully + UNDO { say "Runs when you exit a block unsuccessfully (by throwing an exception)" } } -## * Loop phasers +## Loop phasers for ^5 { FIRST { say "[*] The first time the loop is run, before ENTER" } - NEXT { say "At loop continuation time, before LEAVE" } - LAST { say "At loop termination time, after LEAVE" } + NEXT { say "At loop continuation time, before LEAVE" } + LAST { say "At loop termination time, after LEAVE" } } -## * Role/class phasers +## Role/class phasers COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" } -## They allow for cute tricks or clever code ...: +## They allow for cute tricks or clever code...: say "This code took " ~ (time - CHECK time) ~ "s to compile"; ## ... or clever organization: sub do-db-stuff { - $db.start-transaction; # start a new transaction - KEEP $db.commit; # commit the transaction if all went well - UNDO $db.rollback; # or rollback if all hell broke loose + $db.start-transaction; # start a new transaction + KEEP $db.commit; # commit the transaction if all went well + UNDO $db.rollback; # or rollback if all hell broke loose } ``` ## Statement prefixes ```perl6 -## Those act a bit like phasers: they affect the behavior of the following code. -## Though, they run in-line with the executable code, so they're in lowercase. -## (`try` and `start` are theoretically in that list, but explained elsewhere) -## Note: all of these (except start) don't need explicit brackets `{` and `}`. +## Those act a bit like phasers: they affect the behavior of the following +## code. Though, they run in-line with the executable code, so they're in +## lowercase. (`try` and `start` are theoretically in that list, but explained +## elsewhere) Note: all of these (except start) don't need explicit curly +## braces `{` and `}`. -## - `do` (that you already saw) - runs a block or a statement as a term -## You can't normally use a statement as a value (or "term"): -## -## my $value = if True { 1 } # `if` is a statement - parse error -## -## This works: -my $a = do if True { 5 } # with `do`, `if` is now a term. - -## - `once` - Makes sure a piece of code only runs once -for ^5 { once say 1 }; #=> 1 - # Only prints ... once. -## Like `state`, they're cloned per-scope -for ^5 { sub { once say 1 }() } #=> 1 1 1 1 1 - # Prints once per lexical scope - -## - `gather` - Co-routine thread -## Gather allows you to `take` several values in an array, -## much like `do`, but allows you to take any expression. +## `do` - (which you already saw) runs a block or a statement as a term. +## Normally you cannot use a statement as a value (or "term"). `do` helps us +## do it. + +# my $value = if True { 1 } # this fails since `if` is a statement +my $a = do if True { 5 } # with `do`, `if` is now a term returning a value + +## `once` - makes sure a piece of code only runs once. +for ^5 { + once say 1 +}; #=> 1, only prints ... once + +## Similar to `state`, they're cloned per-scope. +for ^5 { + sub { once say 1 }() +}; #=> 1 1 1 1 1, prints once per lexical scope. + +## `gather` - co-routine thread. The `gather` constructs allows us to `take` +## several values from an array/list, much like `do`. say gather for ^5 { - take $_ * 3 - 1; - take $_ * 3 + 1; -} #=> -1 1 2 4 5 7 8 10 11 13 + take $_ * 3 - 1; + take $_ * 3 + 1; +} +#=> -1 1 2 4 5 7 8 10 11 13 + say join ',', gather if False { - take 1; - take 2; - take 3; -} # Doesn't print anything. + take 1; + take 2; + take 3; +} +# Doesn't print anything. -## - `eager` - Evaluate statement eagerly (forces eager context) +## `eager` - evaluates a statement eagerly (forces eager context) ## Don't try this at home: -## -## eager 1..*; # this will probably hang for a while (and might crash ...). -## +# eager 1..*; # this will probably hang for a while (and might crash ...). ## But consider: constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything - ## versus: constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2 ``` @@ -1207,102 +1366,105 @@ constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2 ## Iterables ```perl6 -## Iterables are objects that can be iterated similar to the `for` construct -## `flat`, flattens iterables: -say (1, 10, (20, 10) ); #> (1 10 (20 10)) Notice how grouping is maintained -say (1, 10, (20, 10) ).flat; #> (1 10 20 10) Now the iterable is flat +## Iterables are objects that can be iterated over which are +## are similar to the `for` construct. -## - `lazy` - Defer actual evaluation until value is fetched -## (forces lazy context) +## `flat` - flattens iterables. +say (1, 10, (20, 10) ); #=> (1 10 (20 10)), notice how neste lists are + # preserved +say (1, 10, (20, 10) ).flat; #=> (1 10 20 10), now the iterable is flat + +## - `lazy` - defers actual evaluation until value is fetched by forcing +## lazy context. my @lazy-array = (1..100).lazy; -say @lazy-array.is-lazy; #> True # Check for laziness with the `is-lazy` method. -say @lazy-array; #> [...] List has not been iterated on! +say @lazy-array.is-lazy; #=> True, check for laziness with the `is-lazy` method. +say @lazy-array; #=> [...] List has not been iterated on! my @lazy-array { .print }; # This works and will only do as much work as # is needed. -[//]: # ( TODO explain that gather/take and map are all lazy) -## - `sink` - An `eager` that discards the results (forces sink context) + +# ( **TODO** explain that gather/take and map are all lazy) + +## `sink` - an `eager` that discards the results by forcing sink context. constant nilthingie = sink for ^3 { .say } #=> 0 1 2 -say nilthingie.perl; #=> Nil +say nilthingie.perl; #=> Nil -## - `quietly` blocks will suppress warnings: +## `quietly` - suppresses warnings in blocks. quietly { warn 'This is a warning!' }; #=> No output -## - `contend` - Attempts side effects under STM -## Not yet implemented ! +## `contend` - attempts side effects under STM +## Not yet implemented! ``` -## More operators thingies ! +## More operators thingies! ```perl6 -## Everybody loves operators ! Let's get more of them +## Everybody loves operators! Let's get more of them. ## The precedence list can be found here: ## https://docs.perl6.org/language/operators#Operator_Precedence ## But first, we need a little explanation about associativity: -## * Binary operators: +## Binary operators: $a ! $b ! $c; # with a left-associative `!`, this is `($a ! $b) ! $c` $a ! $b ! $c; # with a right-associative `!`, this is `$a ! ($b ! $c)` $a ! $b ! $c; # with a non-associative `!`, this is illegal $a ! $b ! $c; # with a chain-associative `!`, this is `($a ! $b) and ($b ! $c)` $a ! $b ! $c; # with a list-associative `!`, this is `infix:<>` -## * Unary operators: +## Unary operators: !$a! # with left-associative `!`, this is `(!$a)!` !$a! # with right-associative `!`, this is `!($a!)` !$a! # with non-associative `!`, this is illegal ``` -### Create your own operators ! +### Create your own operators! ```perl6 -## Okay, you've been reading all of that, so I guess I should try -## to show you something exciting. -## I'll tell you a little secret (or not-so-secret): +## Okay, you've been reading all of that, so you might want to try something +## more exciting?! I'll tell you a little secret (or not-so-secret): ## In Perl 6, all operators are actually just funny-looking subroutines. ## You can declare an operator just like you declare a sub: -sub prefix:<win>($winner) { # refer to the operator categories - # (yes, it's the "words operator" `<>`) - say "$winner Won !"; +# prefix refers to the operator categories (prefix, infix, postfix, etc). +sub prefix:<win>( $winner ) { + say "$winner Won!"; } -win "The King"; #=> The King Won ! - # (prefix is before) +win "The King"; #=> The King Won! + # (prefix means 'before') ## you can still call the sub with its "full name": -say prefix:<!>(True); #=> False +say prefix:<!>(True); #=> False +prefix:<win>("The Queen"); #=> The Queen Won! -sub postfix:<!>(Int $n) { - [*] 2..$n; # using the reduce meta-operator ... See below ;-) ! +sub postfix:<!>( Int $n ) { + [*] 2..$n; # using the reduce meta-operator... See below ;-)! } say 5!; #=> 120 - # Postfix operators (after) have to come *directly* after the term. + # Postfix operators ('after') have to come *directly* after the term. # No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!` - -sub infix:<times>(Int $n, Block $r) { # infix in the middle - for ^$n { - $r(); # You need the explicit parentheses to call the function in `$r`, - # else you'd be referring at the variable itself, like with `&r`. - } +sub infix:<times>( Int $n, Block $r ) { # infix ('between') + for ^$n { + $r(); # You need the explicit parentheses to call the function in `$r`, + # else you'd be referring at the variable itself, like with `&r`. + } } 3 times -> { say "hello" }; #=> hello #=> hello #=> hello - # You're very recommended to put spaces - # around your infix operator calls. +## It's recommended to put spaces around your +## infix operator calls. ## For circumfix and post-circumfix ones -sub circumfix:<[ ]>(Int $n) { - $n ** $n +sub circumfix:<[ ]>( Int $n ) { + $n ** $n } say [5]; #=> 3125 - # circumfix is around. Again, no whitespace. + # circumfix means 'around'. Again, no whitespace. -sub postcircumfix:<{ }>(Str $s, Int $idx) { - ## post-circumfix is - ## "after a term, around something" - $s.substr($idx, 1); +sub postcircumfix:<{ }>( Str $s, Int $idx ) { + ## post-circumfix is 'after a term, around something' + $s.substr($idx, 1); } say "abc"{1}; #=> b # after the term `"abc"`, and around the index (1) @@ -1312,47 +1474,47 @@ say "abc"{1}; #=> b ## (a simple named argument underneath): %h{$key}:delete; ## equivalent to: -postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that) +postcircumfix:<{ }>( %h, $key, :delete ); # (you can call operators like this) -## It's *all* using the same building blocks! -## Syntactic categories (prefix infix ...), named arguments (adverbs), ..., -## - used to build the language - are available to you. -## (you are, obviously, recommended against making an operator out of -## *everything* -- with great power comes great responsibility) +## It's *all* using the same building blocks! Syntactic categories +## (prefix infix ...), named arguments (adverbs), ..., etc. used to build +## the language - are available to you. Obviously, you're advised against +## making an operator out of *everything* -- with great power comes great +## responsibility. ``` -### Meta operators ! +### Meta operators! ```perl6 -## Oh boy, get ready. Get ready, because we're delving deep -## into the rabbit's hole, and you probably won't want to go -## back to other languages after reading that. -## (I'm guessing you don't want to already at that point). +## Oh boy, get ready!. Get ready, because we're delving deep into the rabbit's +## hole, and you probably won't want to go back to other languages after +## reading this. (I'm guessing you don't want to go back at this point but +## let's continue, for the journey is long and enjoyable!). + ## Meta-operators, as their name suggests, are *composed* operators. -## Basically, they're operators that apply another operator. +## Basically, they're operators that act on another operators. + +## The reduce meta-operator is a prefix meta-operator that takes a binary +## function and one or many lists. If it doesn't get passed any argument, +## it either returns a "default value" for this operator (a meaningless value) +## or `Any` if there's none (examples below). Otherwise, it pops an element +## from the list(s) one at a time, and applies the binary function to the last +## result (or the list's first element) and the popped element. -## * Reduce meta-operator -## It's a prefix meta-operator that takes a binary function and -## one or many lists. If it doesn't get passed any argument, -## it either returns a "default value" for this operator -## (a meaningless value) or `Any` if there's none (examples below). -## -## Otherwise, it pops an element from the list(s) one at a time, and applies -## the binary function to the last result (or the list's first element) -## and the popped element. -## ## To sum a list, you could use the reduce meta-operator with `+`, i.e.: -say [+] 1, 2, 3; #=> 6 -## equivalent to `(1+2)+3` +say [+] 1, 2, 3; #=> 6, equivalent to (1+2)+3. -say [*] 1..5; #=> 120 -## equivalent to `((((1*2)*3)*4)*5)`. +## To multiply a list +say [*] 1..5; #=> 120, equivalent to ((((1*2)*3)*4)*5). ## You can reduce with any operator, not just with mathematical ones. -## For example, you could reduce with `//` to get -## the first defined element of a list: -say [//] Nil, Any, False, 1, 5; #=> False - # (Falsey, but still defined) +## For example, you could reduce with `//` to get first defined element +## of a list: +say [//] Nil, Any, False, 1, 5; #=> False + # (Falsey, but still defined) +## Or with relational operators, i.e., `>` to check elements of a list +## are ordered accordingly: +say say [>] 234, 156, 6, 3, -20; #=> True ## Default value examples: say [*] (); #=> 1 @@ -1365,15 +1527,14 @@ say [//]; #=> (Any) sub add($a, $b) { $a + $b } say [[&add]] 1, 2, 3; #=> 6 -## * Zip meta-operator -## This one is an infix meta-operator that also can be used as a "normal" -## operator. It takes an optional binary function (by default, it just creates -## a pair), and will pop one value off of each array and call its binary -## function on these until it runs out of elements. It returns an array with -## all of these new elements. -(1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function - # makes an array. -1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function +## The zip meta-operator is an infix meta-operator that also can be used as a +## "normal" operator. It takes an optional binary function (by default, it +## just creates a pair), and will pop one value off of each array and call +## its binary function on these until it runs out of elements. It returns an +## array with all of these new elements. +say (1, 2) Z (3, 4); #=> ((1, 3), (2, 4)), since by default the function + # makes an array. +say 1..3 Z+ 4..6; #=> (5, 7, 9), using the custom infix:<+> function ## Since `Z` is list-associative (see the list above), ## you can use it on more than one list @@ -1385,252 +1546,258 @@ say [[&add]] 1, 2, 3; #=> 6 ## And to end the operator list: -## * Sequence operator ## The sequence operator is one of Perl 6's most powerful features: ## it's composed of first, on the left, the list you want Perl 6 to deduce from ## (and might include a closure), and on the right, a value or the predicate -## that says when to stop (or Whatever for a lazy infinite list). -my @list = 1, 2, 3 ... 10; # basic deducing -#my @list = 1, 3, 6 ... 10; # this dies because Perl 6 can't figure out the end -my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element - # (the iteration when the predicate matches). -my @list = 1, 3, 9 ... * > 30; # you can use a predicate - # (with the Whatever Star, here). -my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above) - -my @fib = 1, 1, *+* ... *; # lazy infinite list of fibonacci series, - # computed using a closure! +## that says when to stop (or a Whatever Star for a lazy infinite list). + +my @list = 1, 2, 3...10; # basic arithmetic sequence +# my @list = 1, 3, 6...10; # this dies because Perl 6 can't figure out the end +my @list = 1, 2, 3...^10; # as with ranges, you can exclude the last element + # (the iteration ends when the predicate matches). +my @list = 1, 3, 9...* > 30; # you can use a predicate (with the Whatever Star). +my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above + # using a block here). + +my @fib = 1, 1, *+* ... *; # lazy infinite list of fibonacci sequence, + # computed using a closure! my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above) -my @fib = 1, 1, { $^a + $^b } ... *; #(... also equivalent to the above) +my @fib = 1, 1, { $^a + $^b } ... *; # (also equivalent to the above) ## $a and $b will always take the previous values, meaning here -## they'll start with $a = 1 and $b = 1 (values we set by hand). -## then $a = 1 and $b = 2 (result from previous $a+$b), and so on. +## they'll start with $a = 1 and $b = 1 (values we set by hand), +## then $a = 1 and $b = 2 (result from previous $a+$b), and so on. say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55 # (using a range as the index) -## Note : as for ranges, once reified, elements aren't re-calculated. +## Note: as for ranges, once reified, elements aren't re-calculated. ## That's why `@primes[^100]` will take a long time the first time you print -## it, then be instant. +## it, then will be instateneous. ``` ## Regular Expressions ```perl6 -## I'm sure a lot of you have been waiting for this one. -## Well, now that you know a good deal of Perl 6 already, we can get started. -## First off, you'll have to forget about "PCRE regexps" (perl-compatible -## regexps). +## I'm sure a lot of you have been waiting for this one. Well, now that you know +## a good deal of Perl 6 already, we can get started. First off, you'll have to +## forget about "PCRE regexps" (perl-compatible regexps). ## -## IMPORTANT: Don't skip them because you know PCRE. They're different. -## Some things are the same (like `?`, `+`, and `*`), -## but sometimes the semantics change (`|`). -## Make sure you read carefully, because you might trip over a new behavior. +## IMPORTANT: Don't skip them because you know PCRE. They're different. Some +## things are the same (like `?`, `+`, and `*`), but sometimes the semantics +## change (`|`). Make sure you read carefully, because you might trip over a +## new behavior. ## ## Perl 6 has many features related to RegExps. After all, Rakudo parses itself. -## We're first going to look at the syntax itself, -## then talk about grammars (PEG-like), differences between -## `token`, `regex` and `rule` declarators, and some more. -## Side note: you still have access to PCRE regexps using the `:P5` modifier. -## (we won't be discussing this in this tutorial, however) +## We're first going to look at the syntax itself, then talk about grammars +## (PEG-like), differences between `token`, `regex` and `rule` declarators, +## and some more. Side note: you still have access to PCRE regexps using the +## `:P5` modifier which we won't be discussing this in this tutorial, though. ## ## In essence, Perl 6 natively implements PEG ("Parsing Expression Grammars"). ## The pecking order for ambiguous parses is determined by a multi-level -## tie-breaking test: -## - Longest token matching. `foo\s+` beats `foo` (by 2 or more positions) -## - Longest literal prefix. `food\w*` beats `foo\w*` (by 1) +## tie-breaking test: +## - Longest token matching: `foo\s+` beats `foo` (by 2 or more positions) +## - Longest literal prefix: `food\w*` beats `foo\w*` (by 1) ## - Declaration from most-derived to less derived grammars -## (grammars are actually classes) +## (grammars are actually classes) ## - Earliest declaration wins -say so 'a' ~~ /a/; #=> True -say so 'a' ~~ / a /; #=> True # More readable with some spaces! +say so 'a' ~~ /a/; #=> True +say so 'a' ~~ / a /; #=> True, more readable with some spaces! ## In all our examples, we're going to use the smart-matching operator against -## a regexp. We're converting the result using `so`, but in fact, it's -## returning a `Match` object. They know how to respond to list indexing, -## hash indexing, and return the matched string. -## The results of the match are available as `$/` (implicitly lexically-scoped). -## You can also use the capture variables which start at 0: -## `$0`, `$1', `$2`... +## a regexp. We're converting the result using `so` to a Boolean value because, +## in fact, it's returning a `Match` object. They know how to respond to list +## indexing, hash indexing, and return the matched string. The results of the +## match are available in the `$/` variable (implicitly lexically-scoped). You +## can also use the capture variables which start at 0: `$0`, `$1', `$2`... ## -## You can also note that `~~` does not perform start/end checking -## (meaning the regexp can be matched with just one char of the string), -## we're going to explain later how you can do it. - -## In Perl 6, you can have any alphanumeric as a literal, -## everything else has to be escaped, using a backslash or quotes. -say so 'a|b' ~~ / a '|' b /; # `True`. Wouldn't mean the same if `|` wasn't - # escaped -say so 'a|b' ~~ / a \| b /; # `True`. Another way to escape it. - -## The whitespace in a regexp is actually not significant, -## unless you use the `:s` (`:sigspace`, significant space) adverb. -say so 'a b c' ~~ / a b c /; #> `False`. Space is not significant here -say so 'a b c' ~~ /:s a b c /; #> `True`. We added the modifier `:s` here. +## You can also note that `~~` does not perform start/end checking, meaning +## the regexp can be matched with just one character of the string. We'll +## explain later how you can do it. + +## In Perl 6, you can have any alphanumeric as a literal, everything else has +## to be escaped by using a backslash or quotes. +say so 'a|b' ~~ / a '|' b /; #=> `True`, it wouldn't mean the same thing if + # `|` wasn't escaped. +say so 'a|b' ~~ / a \| b /; #=> `True`, another way to escape it. + +## The whitespace in a regexp is actually not significant, unless you use the +## `:s` (`:sigspace`, significant space) adverb. +say so 'a b c' ~~ / a b c /; #=> `False`, space is not significant here! +say so 'a b c' ~~ /:s a b c /; #=> `True`, we added the modifier `:s` here. + ## If we use only one space between strings in a regex, Perl 6 will warn us: -say so 'a b c' ~~ / a b c /; #> 'False' #> Space is not significant here; -## please use quotes or :s (:sigspace) modifier (or, to suppress this warning, -## omit the space, or otherwise change the spacing) -## To fix this and make the spaces less ambiguous, either use at least two -## spaces between strings or use the `:s` adverb. +say so 'a b c' ~~ / a b c /; #=> `False`, with warning about space +say so 'a b c' ~~ / a b c /; #=> `False` + +## Please use quotes or :s (:sigspace) modifier (or, to suppress this warning, +## omit the space, or otherwise change the spacing). To fix this and make the +## spaces less ambiguous, either use at least two spaces between strings +## or use the `:s` adverb. -## As we saw before, we can embed the `:s` inside the slash delimiters, but we +## As we saw before, we can embed the `:s` inside the slash delimiters, but we ## can also put it outside of them if we specify `m` for 'match': -say so 'a b c' ~~ m:s/a b c/; #> `True` -## By using `m` to specify 'match', we can also use delimiters other -## than slashes: -say so 'abc' ~~ m{a b c}; #> `True` +say so 'a b c' ~~ m:s/a b c/; #=> `True` + +## By using `m` to specify 'match', we can also use delimiters other than +## slashes: +say so 'abc' ~~ m{a b c}; #=> `True` +say so 'abc' ~~ m[a b c]; #=> `True` +# m/.../ is equivalent to /.../ ## Use the :i adverb to specify case insensitivity: -say so 'ABC' ~~ m:i{a b c}; #> `True` +say so 'ABC' ~~ m:i{a b c}; #=> `True` -## It is, however, important as for how modifiers (that you're gonna see just -## below) are applied ... +## However, whitespace is important as for how modifiers are applied ( +## (which you'll see just below) ... ## Quantifying - `?`, `+`, `*` and `**`. -## - `?` - 0 or 1 -so 'ac' ~~ / a b c /; # `False` -so 'ac' ~~ / a b? c /; # `True`, the "b" matched 0 times. -so 'abc' ~~ / a b? c /; # `True`, the "b" matched 1 time. +## `?` - zero or one match +so 'ac' ~~ / a b c /; #=> `False` +so 'ac' ~~ / a b? c /; #=> `True`, the "b" matched 0 times. +so 'abc' ~~ / a b? c /; #=> `True`, the "b" matched 1 time. -## ... As you read just before, whitespace is important because it determines -## which part of the regexp is the target of the modifier: -so 'def' ~~ / a b c? /; # `False`. Only the `c` is optional -so 'def' ~~ / a b? c /; # `False`. Whitespace is not significant -so 'def' ~~ / 'abc'? /; # `True`. The whole "abc" group is optional. +## ...As you read before, whitespace is important because it determines which +## part of the regexp is the target of the modifier: +so 'def' ~~ / a b c? /; #=> `False`, only the `c` is optional +so 'def' ~~ / a b? c /; #=> `False`, whitespace is not significant +so 'def' ~~ / 'abc'? /; #=> `True`, the whole "abc" group is optional ## Here (and below) the quantifier applies only to the `b` -## - `+` - 1 or more -so 'ac' ~~ / a b+ c /; # `False`; `+` wants at least one matching -so 'abc' ~~ / a b+ c /; # `True`; one is enough -so 'abbbbc' ~~ / a b+ c /; # `True`, matched 4 "b"s - -## - `*` - 0 or more -so 'ac' ~~ / a b* c /; # `True`, they're all optional. -so 'abc' ~~ / a b* c /; # `True` -so 'abbbbc' ~~ / a b* c /; # `True` -so 'aec' ~~ / a b* c /; # `False`. "b"(s) are optional, not replaceable. - -## - `**` - (Unbound) Quantifier -## If you squint hard enough, you might understand -## why exponentation is used for quantity. -so 'abc' ~~ / a b**1 c /; # `True` (exactly one time) -so 'abc' ~~ / a b**1..3 c /; # `True` (one to three times) -so 'abbbc' ~~ / a b**1..3 c /; # `True` -so 'abbbbbbc' ~~ / a b**1..3 c /; # `False` (too much) -so 'abbbbbbc' ~~ / a b**3..* c /; # `True` (infinite ranges are okay) - -## - `<[]>` - Character classes -## Character classes are the equivalent of PCRE's `[]` classes, but -## they use a more perl6-ish syntax: -say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa' +## `+` - one or more matches +so 'ac' ~~ / a b+ c /; #=> `False`, `+` wants at least one matching +so 'abc' ~~ / a b+ c /; #=> `True`, one is enough +so 'abbbbc' ~~ / a b+ c /; #=> `True`, matched 4 "b"s + +## `*` - zero or more matches +so 'ac' ~~ / a b* c /; #=> `True`, they're all optional. +so 'abc' ~~ / a b* c /; #=> `True` +so 'abbbbc' ~~ / a b* c /; #=> `True` +so 'aec' ~~ / a b* c /; #=> `False`. "b"(s) are optional, not replaceable. + +## `**` - (Unbound) Quantifier +## If you squint hard enough, you might understand why exponentation is used +## for quantity. +so 'abc' ~~ / a b**1 c /; #=> `True`, (exactly one time) +so 'abc' ~~ / a b**1..3 c /; #=> `True`, (one to three times) +so 'abbbc' ~~ / a b**1..3 c /; #=> `True` +so 'abbbbbbc' ~~ / a b**1..3 c /; #=> `False, (too much) +so 'abbbbbbc' ~~ / a b**3..* c /; #=> `True`, (infinite ranges are okay) + +## `<[]>` - Character classes +## Character classes are the equivalent of PCRE's `[]` classes, but they use a +## more perl6-ish syntax: +say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa' ## You can use ranges: say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'ae' -## Just like in normal regexes, if you want to use a special character, -## escape it (the last one is escaping a space) +## Just like in normal regexes, if you want to use a special character, escape +## it (the last one is escaping a space which would be equivalent to using +## ' '): say 'he-he !' ~~ / 'he-' <[ a..z \! \ ]> + /; #=> 'he-he !' -## You'll get a warning if you put duplicate names -## (which has the nice effect of catching the wrote quoting:) -'he he' ~~ / <[ h e ' ' ]> /; # Warns "Repeated characters found in characters - # class" +## You'll get a warning if you put duplicate names (which has the nice effect +## of catching the raw quoting): +'he he' ~~ / <[ h e ' ' ]> /; +# Warns "Repeated character (') unexpectedly found in character class" -## You can also negate them ... (equivalent to `[^]` in PCRE) -so 'foo' ~~ / <-[ f o ]> + /; # False +## You can also negate character classes... (`<-[]>` equivalent to `[^]` in PCRE) +so 'foo' ~~ / <-[ f o ]> + /; #=> False -## ... and compose them: : -so 'foo' ~~ / <[ a..z ] - [ f o ]> + /; # False (any letter except f and o) -so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /; # True (no letter except f and o) -so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the +## ... and compose them: +so 'foo' ~~ / <[ a..z ] - [ f o ]> + /; #=> `False`, (any letter except f and o) +so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /; #=> `True`, (no letter except f and o) +so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; #=> `True`, (the + doesn't replace the # left part) ``` ### Grouping and capturing ```perl6 -## Group: you can group parts of your regexp with `[]`. -## These groups are *not* captured (like PCRE's `(?:)`). -so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing +## Group: you can group parts of your regexp with `[]`. Unlike PCRE's `(?:)`, +## these groups are *not* captured. +so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /; -## The previous line returns `True`. -## We match the "012" 1 or more time (the `+` was applied to the group). + +## The previous line returns `True`. The regex matches "012" 1 or more time +## (achieved by the the `+` applied to the group). ## But this does not go far enough, because we can't actually get back what ## we matched. -## Capture: We can actually *capture* the results of the regexp, -## using parentheses. + +## Capture: The results of a regexp can be *captured* by using parentheses. so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (using `so` # here, `$/` below) ## So, starting with the grouping explanations. -## As we said before, our `Match` object is available as `$/`: -say $/; # Will print some weird stuff (we'll explain) (or "Nil" if - # nothing matched). +## As we said before, our `Match` object is stored inside the `$/` variable: +say $/; # Will either print some weird stuff or `Nil` if nothing matched. ## As we also said before, it has array indexing: say $/[0]; #=> ｢ABC｣ ｢ABC｣ - # These weird brackets are `Match` objects. + # These corner brackets are `Match` objects. # Here, we have an array of these. -say $0; # The same as above. +say $0; # The same as above. -## Our capture is `$0` because it's the first and only one capture in the +## Our capture is `$0` because it's the first and only one capture in the ## regexp. You might be wondering why it's an array, and the answer is simple: -## Some capture (indexed using `$0`, `$/[0]` or a named one) will be an array -## IFF it can have more than one element -## (so, with `*`, `+` and `**` (whatever the operands), but not with `?`). +## Some captures (indexed using `$0`, `$/[0]` or a named one) will be an array +## if and only if they can have more than one element. Thus any capture with +## `*`, `+` and `**` (whatever the operands), but not with `?`. ## Let's use examples to see that: ## Note: We quoted A B C to demonstrate that the whitespace between them isn't -## significant. If we want the whitespace to *be* significant there, we +## significant. If we want the whitespace to *be* significant there, we ## can use the :sigspace modifier. -so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # `True` -say $/[0]; #=> ｢ABC｣ +say so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; #=> `True` +say $/[0]; #=> ｢ABC｣ say $0.WHAT; #=> (Match) # There can't be more than one, so it's only a single match object. -so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /; #=> True +say so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /; #=> True say $0.WHAT; #=> (Any) # This capture did not match, so it's empty -so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; # `True` +so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; #=> `True` say $0.WHAT; #=> (Array) # A specific quantifier will always capture an Array, - # may it be a range or a specific value (even 1). + # be a range or a specific value (even 1). -## The captures are indexed per nesting. This means a group in a group will be +## The captures are indexed per nesting. This means a group in a group will be ## nested under its parent group: `$/[0][0]`, for this code: 'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /; -say $/[0].Str; #=> hello~ +say $/[0].Str; #=> hello~ say $/[0][0].Str; #=> ~ -## This stems from a very simple fact: `$/` does not contain strings, integers -## or arrays, it only contains match objects. These contain the `.list`, `.hash` -## and `.Str` methods. (but you can also just use `match<key>` for hash access -## and `match[idx]` for array access) +## This stems from a very simple fact: `$/` does not contain strings, integers +## or arrays, it only contains Match objects. These contain the `.list`, `.hash` +## and `.Str` methods but you can also just use `match<key>` for hash access +## and `match[idx]` for array access. say $/[0].list.perl; #=> (Match.new(...),).list - # We can see it's a list of Match objects. Those contain - # a bunch of infos: where the match started/ended, - # the "ast" (see actions later), etc. + # We can see it's a list of Match objects. These contain + # a bunch of info: where the match started/ended, + # the "ast" (see actions later), etc. # You'll see named capture below with grammars. -## Alternatives - the `or` of regexps +## Alternation - the `or` of regexps ## WARNING: They are DIFFERENT from PCRE regexps. -so 'abc' ~~ / a [ b | y ] c /; # `True`. Either "b" or "y". -so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ... - -## The difference between this `|` and the one you're used to is LTM. -## LTM means "Longest Token Matching". This means that the engine will always -## try to match as much as possible in the strng -'foo' ~~ / fo | foo /; # `foo`, because it's longer. -## To decide which part is the "longest", it first splits the regex in +say so 'abc' ~~ / a [ b | y ] c /; #=> `True`. Either "b" or "y". +say so 'ayc' ~~ / a [ b | y ] c /; #=> `True`. Obviously enough... + +## The difference between this `|` and the one you're used to is +## LTM ("Longest Token Matching"). This means that the engine will always +## try to match as much as possible in the string. +say 'foo' ~~ / fo | foo /; #=> `foo`, instead of `fo`, because it's longer. + +## To decide which part is the "longest", it first splits the regex in ## two parts: ## The "declarative prefix" (the part that can be statically analyzed) -## and the procedural parts. -## Declarative prefixes include alternations (`|`), conjunctions (`&`), -## sub-rule calls (not yet introduced), literals, characters classes and +## and the procedural parts: +## - The declarative prefixes include alternations (`|`), conjunctions (`&`), +## sub-rule calls (not yet introduced), literals, characters classes and ## quantifiers. -## The latter include everything else: back-references, code assertions, -## and other things that can't traditionnaly be represented by normal regexps. +## - The procedural part include everything else: back-references, +## code assertions, and other things that can't traditionnaly be represented +## by normal regexps. ## ## Then, all the alternatives are tried at once, and the longest wins. ## Examples: @@ -1639,109 +1806,110 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ... ## DECLARATIVE (nested groups are not a problem) / \s* [ \w & b ] [ c | d ] /; ## However, closures and recursion (of named regexps) are procedural. -## ... There are also more complicated rules, like specificity -## (literals win over character classes) +## There are also more complicated rules, like specificity (literals win over +## character classes). ## Note: the first-matching `or` still exists, but is now spelled `||` -'foo' ~~ / fo || foo /; # `fo` now. +say 'foo' ~~ / fo || foo /; #=> `fo` now. ``` ## Extra: the MAIN subroutine ```perl6 -## The `MAIN` subroutine is called when you run a Perl 6 file directly. -## It's very powerful, because Perl 6 actually parses the arguments -## and pass them as such to the sub. It also handles named argument (`--foo`) -## and will even go as far as to autogenerate a `--help` -sub MAIN($name) { say "Hello, $name !" } +## The `MAIN` subroutine is called when you run a Perl 6 file directly. It's +## very powerful, because Perl 6 actually parses the arguments and pass them +## as such to the sub. It also handles named argument (`--foo`) and will even +## go as far as to autogenerate a `--help` flag. +sub MAIN($name) { + say "Hello, $name!"; +} ## This produces: -## $ perl6 cli.pl -## Usage: -## t.pl <name> +## $ perl6 cli.pl +## Usage: +## t.pl <name> ## And since it's a regular Perl 6 sub, you can have multi-dispatch: ## (using a "Bool" for the named argument so that we can do `--replace` -## instead of `--replace=1`) +## instead of `--replace=1`. The presence of `--replace` indicates truthness +## while its absence falseness). + subset File of Str where *.IO.d; # convert to IO object to check the file exists multi MAIN('add', $key, $value, Bool :$replace) { ... } multi MAIN('remove', $key) { ... } multi MAIN('import', File, Str :$as) { ... } # omitting parameter name + ## This produces: -## $ perl6 cli.pl -## Usage: -## t.pl [--replace] add <key> <value> -## t.pl remove <key> -## t.pl [--as=<Str>] import (File) -## As you can see, this is *very* powerful. -## It even went as far as to show inline the constants. -## (the type is only displayed if the argument is `$`/is named) +## $ perl6 cli.pl +## Usage: +## cli.p6 [--replace] add <key> <value> +## cli.p6 remove <key> +## cli.p6 [--as=<Str>] import <File> + +## As you can see, this is *very* powerful. It even went as far as to show inline +## the constants (the type is only displayed if the argument is `$`/is named). ``` ## APPENDIX A: ### List of things ```perl6 -## It's considered by now you know the Perl6 basics. -## This section is just here to list some common operations, -## but which are not in the "main part" of the tutorial to bloat it up +## It's assumed by now you know the Perl6 basics. This section is just here to +## list some common operations, but which are not in the "main part" of the +## tutorial to avoid bloating it up. ## Operators - -## * Sort comparison -## They return one value of the `Order` enum : `Less`, `Same` and `More` -## (which numerify to -1, 0 or +1). -1 <=> 4; # sort comparison for numerics -'a' leg 'b'; # sort comparison for string -$obj eqv $obj2; # sort comparison using eqv semantics - -## * Generic ordering -3 before 4; # True -'b' after 'a'; # True - -## * Short-circuit default operator -## Like `or` and `||`, but instead returns the first *defined* value : -say Any // Nil // 0 // 5; #=> 0 - -## * Short-circuit exclusive or (XOR) -## Returns `True` if one (and only one) of its arguments is true -say True ^^ False; #=> True -## * Flip Flop -## The flip flop operators (`ff` and `fff`, equivalent to P5's `..`/`...`). -## are operators that take two predicates to test: -## They are `False` until their left side returns `True`, then are `True` until -## their right side returns `True`. -## Like for ranges, you can exclude the iteration when it became `True`/`False` -## by using `^` on either side. -## Let's start with an example : +## Sort comparison - they return one value of the `Order` enum: `Less`, `Same` +## and `More` (which numerify to -1, 0 or +1 respectively). +1 <=> 4; # sort comparison for numerics +'a' leg 'b'; # sort comparison for string +$obj eqv $obj2; # sort comparison using eqv semantics + +## Generic ordering +3 before 4; # True +'b' after 'a'; # True + +## Short-circuit default operator - similar to `or` and `||`, but instead +## returns the first *defined* value: +say Any // Nil // 0 // 5; #=> 0 + +## Short-circuit exclusive or (XOR) - returns `True` if one (and only one) of +## its arguments is true +say True ^^ False; #=> True + +## Flip flops - these operators (`ff` and `fff`, equivalent to P5's `..` +## and `...`) are operators that take two predicates to test: They are `False` +## until their left side returns `True`, then are `True` until their right +## side returns `True`. Similar to ranges, you can exclude the iteration when +## it become `True`/`False` by using `^` on either side. Let's start with an +## example : for <well met young hero we shall meet later> { - # by default, `ff`/`fff` smart-match (`~~`) against `$_`: - if 'met' ^ff 'meet' { # Won't enter the if for "met" - # (explained in details below). - .say - } + # by default, `ff`/`fff` smart-match (`~~`) against `$_`: + if 'met' ^ff 'meet' { # Won't enter the if for "met" + .say # (explained in details below). + } - if rand == 0 ff rand == 1 { # compare variables other than `$_` - say "This ... probably will never run ..."; - } + if rand == 0 ff rand == 1 { # compare variables other than `$_` + say "This ... probably will never run ..."; + } } -## This will print "young hero we shall meet" (excluding "met"): -## the flip-flop will start returning `True` when it first encounters "met" -## (but will still return `False` for "met" itself, due to the leading `^` -## on `ff`), until it sees "meet", which is when it'll start returning `False`. - -## The difference between `ff` (awk-style) and `fff` (sed-style) is that -## `ff` will test its right side right when its left side changes to `True`, -## and can get back to `False` right away -## (*except* it'll be `True` for the iteration that matched) - -## While `fff` will wait for the next iteration to -## try its right side, once its left side changed: + +## This will print "young hero we shall meet" (excluding "met"): the flip-flop +## will start returning `True` when it first encounters "met" (but will still +## return `False` for "met" itself, due to the leading `^` on `ff`), until it +## sees "meet", which is when it'll start returning `False`. + +## The difference between `ff` (awk-style) and `fff` (sed-style) is that `ff` +## will test its right side right when its left side changes to `True`, and can +## get back to `False` right away (*except* it'll be `True` for the iteration +## that matched) while `fff` will wait for the next iteration to try its right +## side, once its left side changed: .say if 'B' ff 'B' for <A B C B A>; #=> B B # because the right-hand-side was tested # directly (and returned `True`). - # "B"s are printed since it matched that - # time (it just went back to `False` + # "B"s are printed since it matched that + # time (it just went back to `False` # right away). .say if 'B' fff 'B' for <A B C B A>; #=> B C B # The right-hand-side wasn't tested until @@ -1750,50 +1918,49 @@ for <well met young hero we shall meet later> { ## A flip-flop can change state as many times as needed: for <test start print it stop not printing start print again stop not anymore> { - .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop", - #=> "print it print again" + .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop", + #=> "print it print again" } -## You might also use a Whatever Star, -## which is equivalent to `True` for the left side or `False` for the right: +## You might also use a Whatever Star, which is equivalent to `True` for the +## left side or `False` for the right: for (1, 3, 60, 3, 40, 60) { # Note: the parenthesis are superfluous here # (sometimes called "superstitious parentheses") - .say if $_ > 50 ff *; # Once the flip-flop reaches a number greater than 50, - # it'll never go back to `False` - #=> 60 3 40 60 + .say if $_ > 50 ff *; # Once the flip-flop reaches a number greater + # than 50, it'll never go back to `False` + #=> 60 3 40 60 } -## You can also use this property to create an `If` -## that'll not go through the first time : +## You can also use this property to create an `if` that'll not go through the +## first time: for <a b c> { - .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`, - # but the `^` makes it *not run* on the first iteration - #=> b c + .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`, + # but the `^` makes it *not run* on the first iteration + #=> b c } - -## - `===` is value identity and uses `.WHICH` on the objects to compare them -## - `=:=` is container identity and uses `VAR()` on the objects to compare them - +## The `===` operator is the value identity operator and uses `.WHICH` on the +## objects to compare them while `=:=` is the container identity operator +## and uses `VAR()` on the objects to compare them. ``` If you want to go further, you can: - Read the [Perl 6 Docs](https://docs.perl6.org/). This is a great - resource on Perl6. If you are looking for something, use the search bar. + resource on Perl6. If you are looking for something, use the search bar. This will give you a dropdown menu of all the pages referencing your search - term (Much better than using Google to find Perl 6 documents!) + term (Much better than using Google to find Perl 6 documents!). - Read the [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). This - is a great source of Perl 6 snippets and explanations. If the docs don't + is a great source of Perl 6 snippets and explanations. If the docs don't describe something well enough, you may find more detailed information here. This information may be a bit older but there are many great examples and - explanations. Posts stopped at the end of 2015 when the language was declared + explanations. Posts stopped at the end of 2015 when the language was declared stable and Perl 6.c was released. - - Come along on `#perl6` at `irc.freenode.net`. The folks here are + - Come along on `#perl6` at `irc.freenode.net`. The folks here are always helpful. - - Check the [source of Perl 6's functions and - classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is + - Check the [source of Perl 6's functions and + classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is mainly written in Perl 6 (with a lot of NQP, "Not Quite Perl", a Perl 6 subset easier to implement and optimize). - - Read [the language design documents](http://design.perl6.org). They explain + - Read [the language design documents](http://design.perl6.org). They explain P6 from an implementor point-of-view, but it's still very interesting. |