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

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

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

The New bits Variable notation Syntax fixes Control flow Regexes Objects

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

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]

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]

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]

References act as the = “Foo”; $bar 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

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

Syntax Fixes Multi-way comparisons work $x <= 12 <= $y Logical operators properly propagate

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

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

~~ is the DWIM operator

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

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

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”} }

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

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”);

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 = sort {$b cmp

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 = sort {$^b cmp

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 = sort {$^b cmp Work in closures too $foo = {print “Hi “, $^a}; $foo->(“Fred”); Prints Hi Fred

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

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

Hyper-operators Allow you to work on all the elements of an aggregate at once Noted by a »« (Or you can use >> and By default just iterates over the aggregates Overridable if you want to do Clever

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

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

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

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

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

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

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

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…

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

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

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

Questions? ?