1. What’s new in Perl 6 (The short form) Dan Sugalski dan@sidhe.org

2. Important safety tips This is not quite final Larry may change his mind at any time, and has before I don’t do syntax

3. Biggest change first Dereference arrow is now the dot Concatenate is now the ~ Everyone can deal with this, I expect Liking it is optional

4. The New bits Variable notation Syntax fixes Control flow Regexes Objects

5. Variables preserve sigils Perl 5 $foo[1] $foo{bar} @foo{“a”, “b”} Perl 6 @foo[1] %foo{bar} %foo{“a”, “b”}

6. Why? Less confusion when you write code Lexer doesn’t need the changed sigil to figure out what’s going on Since the sigil is invariant, all the dereference dots are optional Was:$foo->[1]

7. Why? Less confusion when you write code Lexer doesn’t need the changed sigil to figure out what’s going on Since the sigil is invariant, all the dereference dots are optional Is:$foo.[1]

8. Why? Less confusion when you write code Lexer doesn’t need the changed sigil to figure out what’s going on Since the sigil is invariant, all the dereference dots are optional Can be:$foo[1]

9. References act as the referent @array[12] = “Foo”; $bar = @array; print $bar[12]; Prints Foo Works for anything the reference points to The reference to the array acts as the array does Aggregates in scalar context return a reference

10. Typed Variables Typing is still optional! Declares what a variable returns and takes my int @foo; The engine will use this to optimize for space and speed Can get fancier my @foo is Matrix of int; Syntax still up in the air a bit

11. Syntax Fixes Multi-way comparisons work $x <= 12 <= $y Logical operators properly propagate context @foo = @a || @b || @c

12. All blocks are closures Well, they are Though often it doesn’t matter Makes it much easier to write your own version of perl’s control structures

13. Multiple dispatch Multiple subs and methods with the same name, differing only in their signature multi sub bar (Dog $foo) {…} multi sub bar (Cat $foo) {…} Engine dispatches based on the runtime signature of the sub or method call Requires explicit declarations Can’t happen by accident

14. ~~ is the DWIM operator

15. ~~ is the smart match operator Does The Right Thing (all 35 of them) based on the types of the left and right sides For example @foo ~~ @bar true if an array intersection @foo ~~ /bar/ true if any entry in array matches %foo ~~ /bar/ true if any key matches $obj ~~ Class true if $obj isa Class

16. Built-in switch Like the CPAN SWITCH module, only moreso Uses ~~ DWIMmery

17. Built-in switch given ($foo) { when 1 {print “A number”} when “a” {print “A letter”} print “Trying plan B”; when /\b\w+\b/ {print “A word”} default {print “Dunno”} }

18. Real exception handling Catch exceptions with CATCH special block Just throw them in any try block try { CATCH {warn “Help!”} print 1 / 0; } The try’s actually optional You can when the exception object

19. Named parameters in subs You can now name the parameters to a subroutine or method sub some_sub ($foo, $bar) {…} When you call that sub or method, you can pass them by name or position some_sub(bar => 12, foo => 8); some_sub(“a”, “b”);

20. Curried functions Really a shorthand for named parameters Noted by a ^ between the sigil and variable name We sort them Unicodely, then substitute in For example, they lets us kill the global $a and $b @foo = sort {$b cmp $a} @foo

21. Curried functions Really a shorthand for named parameters Noted by a ^ between the sigil and variable name We sort them Unicodely, then substitute in For example, they lets us kill the global $a and $b @foo = sort {$^b cmp $^a} @foo

22. Curried functions Really a shorthand for named parameters Noted by a ^ between the sigil and variable name We sort them Unicodely, then substitute in For example, they lets us kill the global $a and $b @foo = sort {$^b cmp $^a} @foo Work in closures too $foo = {print “Hi “, $^a}; $foo->(“Fred”); Prints Hi Fred

23. More parens are optional Don’t need them for if, while, or for Other than that, not a big deal You can still use them

24. For is fancier for is a bit different for @bar -> $baz {…} Works across multiple arrays for @bar, @baz -> $x, $y {…} Runs until the end of the longest aggregate Short aggregates fill with undefs Counts don’t have to match for @foo, @bar -> $x, $y, $z {…}

25. Hyper-operators Allow you to work on all the elements of an aggregate at once Noted by a »« (Or you can use >> and <<) @total = @a »+« @b By default just iterates over the aggregates Overridable if you want to do Clever Things @Matrix_C = @Matrix_A »*« @Matrix_B

26. Regexes Lots of changes here Regex engine is getting full lexing and parsing support (Everyone tries anyway, so we might as well do it right) Full object-oriented, inheritable, overridable grammar system

27. The Rationale Regexes started simply They definitely aren’t simple any more The wrong things are short Too much is wedged into that damn (?thingie) construct Annoying and it all looks the same Very bad

28. Big changes /x is now the default Modifiers move to the front Colon separates modifiers $foo =~ s:i/\bfred\b/Barney/; Or inside if you’d rather if ($bar =~ /:i \ba\w+\b/) { print “Word starting with A”} Variable-length lookbehind works

29. Syntax changes () capturing parens [] non-capturing parens {} closures that execute when control passes over them <> mark assertions : leads off metasyntactic things

30. Interpolation Changes $foo interpolates literally to interpolate as regex @foo interpolates as an alternation interpolates alternations of regexes %foo matches against alternation of %foo’s keys

31. Useful new modifiers :p5 makes regex use perl 5 syntax :nth maches or substitutes the nth occurrence :nx matches n times :every when paired with :nth matches/substitutes every nth occurrence

32. Powerful enough to parse perl Perl 6 grammar is really a perl 6 grammar That means you can change it if you want Don’t like. for deref? Change it It’s OO, so just change the parts you want to If we can parse perl, we can parse anything

33. New object model Because almost anything’s better than what we have now Though it works out OK for Perl 5 and Python If you don’t poke it too hard…

34. Perl 6 style objects Much more structured than perl 5 objects Much more compile-time restricted Full hiding from parent and child classes Better dispatch control More introspection and overriability

35. Attributes Class-specific per-object data elements Only visible from within methods of the defining class May be exposed by lvalue methods (Though it’s still not direct access) Fixes, more or less, the fragile base class problem

36. Built-in delegation support Useful when subclassing classes with different core semantics (perl 5, Java, or.NET objects, for example) I have no idea how this will look It will work, though

37. Questions? ?