1 / 37

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)

gurit
Download Presentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


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

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

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

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

  14. =~ is now the DWIM operator

  15. =~ 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

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

  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 Warning! This is even more preliminary than anything we’ve covered so far!

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

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

More Related