Moar classes. Roles. And stuff. And dispatch

todo : muti dispatch

perl6.html.markdown

@@ -70,6 +70,52 @@ my &other-s = sub { say "anonymous function !" }
 # `->`, lambda with arguments, and string interpolation
 my &lambda = -> $argument { "The argument passed to this lambda is $argument" }
 
+# add 3 to each value of an array using map :
+map({ $_ + 3 }, @array); # $_ is the implicit argument (the same as for `given` and `for`)
+
+# 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) {
+  map({ return True if $_ == $elem }, @array); # this will `return` out of `is-in`
+}
+sub truthy-array(@array) {
+  # this will produce an array of `True` and `False` :
+  # (you can also say `anon sub` for "anonymous subroutine")
+  map(sub { if $_ { return True } else { return False } }, @array);
+}
+
+# `-> {}` and `{}` are pretty much the same thing, except taht the former can take arguments,
+#  and that the latter can be mistaken as a hash by the compiler
+
+# You can also use the "whatever star" to create an anonymous function :
+map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }`
+map(*+*+3, @array); # also works. Same as `-> $a, $b -> { $a + $b + 3 }`
+
+# 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); # same as the above
+
+# Note : those are sorted lexicographically. `{ $^b / $^a }` is like `-> $a, b { $ b / $a }`
+
+## Multiple Dispatch
+# Perl 6 can decide which variant of a `sub` to call based on the type of the arguments,
+# or on arbitrary preconditions, using `where` :
+
+# with types
+multi sub sayit(Int $n) { # note the `multi` keyword here
+  say "Number: $n";
+}
+multi sayit(Str $s) } # the `sub` is implicit
+  say "String: $s";
+}
+sayit("foo"); # prints "String: foo"
+sayit(True); # fails at *compile time* with "calling 'sayit' will never work with arguments of types ..."
+
+# with arbitrary precondition :
+multi is-big(Int $n where * > 10) { True }
+multi is-big(Int $) { False }
+
 ### Containers
 # 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
@@ -95,6 +141,7 @@ say $x; #=> 52
 
 ## Conditionals
 
+# - `if`
 if True {
   say "It's true !";
 }
@@ -103,10 +150,12 @@ unless False {
   say "It's not false !";
 }
 
-
 # if (true) say; # Won't work
 
-# `given`-`when` looks like other languages `switch`, but it's much more powerful thanks to smart matching :
+# - Ternary conditional
+my $a = $condition ?? $value-if-true !! $value-if-false; # `??` and `!!` are like `?` and `:` in other languages'
+
+# - `given`-`when` looks like other languages `switch`, but it's much more powerful thanks to smart matching :
 given "foo bar" { # given just puts its argument into `$_`, and `when` uses it using the "smart matching" operator.
   when /foo/ { # you'll read about the smart-matching operator below
     say "Yay !";
@@ -118,7 +167,7 @@ given "foo bar" { # given just puts its argument into `$_`, and `when` uses it u
 
 ## Looping constructs
 
-### - `loop` is an infinite loop if you don't pass it arguments, but can also be a c-style `for` :
+# - `loop` is an infinite loop if you don't pass it arguments, but can also be a c-style `for` :
 loop {
   say "This is an infinite loop !";
   last; # last breaks out of the loop, like the `break` keyword in other languages
@@ -130,7 +179,7 @@ loop (my $i = 0; $i < 5; $i++) {
   say "This is a C-style for loop !";
 }
 
-### - `for` - Foreaches an array
+# - `for` - Foreaches an array
 for @array -> $variable {
   say "I've found $variable !";
 }
@@ -147,69 +196,74 @@ if long-computation() -> $result {
 
 
 
-# Operators
+### Operators
 
 ## 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 :
-### - "prefix" : before (like `!` in `!True`).
+# - "prefix" : before (like `!` in `!True`).
-### - "postfix" : after (like `++` in `$a++`).
+# - "postfix" : after (like `++` in `$a++`).
-### - "infix" : in between (like `*` in `4 * 3`).
+# - "infix" : in between (like `*` in `4 * 3`).
-### - "circumfix" : around (like `[`-`]` in `[1, 2]`).
+# - "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
 
-### - `==` is numeric comparison
+# - `==` is numeric comparison
 3 == 4; # False
 3 != 4; # True
 
-### - `eq` is string comparison
+# - `eq` is string comparison
 'a' eq 'b';
 'a' ne 'b'; # not equal
 'a' !eq 'b'; # same as above
 
-### - `eqv` is canonical equivalence
+# - `eqv` is canonical equivalence
 (1, 2) eqv (1, 3);
 
-### - `~~` is smart matching
+# - `~~` is smart matching
-### for a complete combinations list, use this table : http://perlcabal.org/syn/S03.html#Smart_matching
+# for a complete combinations list, use this table : http://perlcabal.org/syn/S03.html#Smart_matching
 'a' ~~ /a/; # true if matches regexp
 'key' ~~ %hash; # true if key exists in hash
 $arg ~~ &bool-returning-function; # true if the function, passed `$arg` as an argument, returns True
 1 ~~ Int; # "is of type"
 
-### - `===` is value identity and uses `.WHICH` on the objects to compare them
+# - `===` is value identity and uses `.WHICH` on the objects to compare them
-### - `=:=` is container identity and uses `VAR()` on the objects to compare them
+# - `=:=` is container identity and uses `VAR()` on the objects to compare them
 
-### You also, of course, have `<`, `<=`, `>`, `>=`.
+# You also, of course, have `<`, `<=`, `>`, `>=`.
-### Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`.
+# Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`.
 3 > 4;
 
 ## * Range constructors
 3 .. 7; # 3 to 7, both included
-### `^` on either side them exclusive on that side :
+# `^` on either side them exclusive on that side :
 3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`)
 
-# * And, Or
+## * And, Or
 3 && 4; # True. Calls `.Bool` on `3`
 0 || False; # False. Calls `.Bool` on `0`
 
-## Short-circuit (and tight)
+## Short-circuit (and tight) versions of the above
 $a && $b && $c; # returns the first argument that evaluates to False, or the last argument
 $a || $b;
 
-# Perl 6 has a quite comprehensive class system
+### Object Model
+
+## Perl 6 has a quite comprehensive object model
 ## You declare a class with the keyword `class`, fields with `has`, methods with `method`
 ## `$.` declares a public field, `$!` declares a private field
 ## (a public field also has `$!`, which is its private interface)
 
+# (Perl 6's object model ("P6Model") is very flexible, and allows you to dynamically add methods,
+#  change semantics, etc -- This will not be covered here, and you should refer to the Synopsis)
+
 class A {
   has $.field;
   has Int $!private-field = 10;
@@ -227,6 +281,10 @@ class A {
                     
     $!field = $n;   # This works, because `$!` is always mutable
   }
+  
+  method !private-method {
+    say "This method is private to the class !";
+  }
 };
 
 # Create a new instance of A with $.field set to 5 :
@@ -235,22 +293,79 @@ my $a = A.new(field => 5);
 $a.get-value; #=> 18
 #$a.field = 5; # This fails, because the `has $.field` is lacking the `is rw`
 
+## Perl 6 also has inheritance (along with multiple inheritance ... Considered a misfeature by many)
 
-# More operators thingies !
+class A {
+  has $.val;
+  
+  submethod not-inherited {
+    say "This method won't be available on B.";
+    say "This is most useful for BUILD, which we'll see later";
+  }
+  
+  method bar { $.val * 5 }
+}
+class B is A { # inheritance uses `is`
+  method foo {
+    say $.val;
+  }
+  
+  method bar { $.val * 10 } # this shadows A's `bar`
+}
+
+my B $b .= new(val => 5); # When you use `my T $var`, `$var` starts off with `T` itself in it, so you can call `new` on it
+                # (`.=` is just the compound operator composed of the dot-call and of the assignment operator)
+                #
+                # Also note that `BUILD` (the method called inside `new`)  will set parent properties too,
+                # so you can pass `val => 5` 
+# $b.not-inherited; # This won't work, for reasons explained above
+$b.foo; # prints 5
+$b.bar; #=> 50, since it calls B's `bar`
+
+## Roles are supported too (also called Mixins in other languages)
+role PrintableVal {
+  has $!counter = 0;
+  method print {
+    say $.val;
+  }
+}
+
+# you "use" a mixin with "does" :
+class Item does PrintableVal {
+  has $.val;
+  
+  # When `does`-ed, a `role` literally "mixes in" the class :
+  # the methods and fields are put together, which means a class can access
+  # the private fields/methods of its roles (but not the inverse !) :
+  method access {
+    say $!counter++;
+  }
+  
+  # However, this :
+  # method print {}
+  # is an error, since the compiler wouldn't know which `print` to use :
+  # contrarily to inheritance, methods mixed in can't be shadowed - they're put at the same "level"
+  
+  # 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
+}
+
+
+### More operators thingies !
 
 ## Everybody loves operators ! Let's get more of them
 
 ## The precedence list can be found here : http://perlcabal.org/syn/S03.html#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
@@ -258,7 +373,7 @@ $a ! $b ! $c; # with a list-associative `!`, this is `infix:<>`
 ## And to end the list of operators ...
 
 ## * Sort comparison
-### They return one value of the `Order` enum : `Less`, `Same` and `More` (which numerify to -1, 0 or +1).
+# 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