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

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

Important safety tips • This is all preliminary • Larry may change his mind at any time • I don’t do syntax

Biggest change first • Dereference arrow is now the dot • Concatenate is now the _ • (Or at least it was last week) • Everyone can deal with this, I expect • Liking it is optional

The New bits • Variable notation • Syntax fixes • Control flow • Regexes • Objects

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

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

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

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

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 sub bar (Dog $foo) is multi {…} sub bar (Cat $foo) is multi {…} • Engine dispatches based on the runtime signature of the sub or method call • Requires explicit declarations • Can’t happen by accident

=~ is now the DWIM operator

=~ is now the smart match operator • Still does a regex match • Also 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

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 $b @foo = sort {$b cmp $a} @foo

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

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

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 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 {…}

Hyper-operators • Allow you to work on all the elements of an aggregate at once • Noted by a ^ (no relation to the curried ^) @total = @a ^+ @b • By default just iterates over the aggregates • Overridable if you want to do Clever Things @Matrix_C = @Matrix_A ^* @Matrix_B

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 • <$foo> to interpolate as regex • @foo interpolates as an alternation • <@foo> 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 Warning! This is even more preliminary than anything we’ve covered so far!

Perl 6 style objects • Much more structured than perl 5 objects • Much more compile-time restricted • Full hiding from parent and child classes • Most of Damian’s Odd Things (e.g. NEXT, Class::Delegation) are in • Better dispatch control

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? ?

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