What’s new in Perl 6 (The short form)

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. Perl 5 $foo[1] $foo{bar} @foo{“a”, “b”} Perl 6 @foo[1] %foo{bar} %foo{“a”, “b”} Variables preserve sigils

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 • <$foo> to interpolate as regex • @foo interpolates as an alternation • <@foo> 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? ?