Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Perl6 signatures

258 views

Published on

Slides from my talk at London Perl Mongers on 2018-03-22 covering Perl6 Signatures in detail.
Special bonus slides for Type Checking and Multi methods.

Published in: Technology
  • Be the first to comment

Perl6 signatures

  1. 1. Perl6 Signatures Everything you didn’t realise you wanted to know, and a whole lot more!
  2. 2. No Signature sub foo { @_.say; } ● Should be familiar to Perl devs ● All arguments put into lexical @_ array ● @_ array only populated with arguments in this case
  3. 3. No Signature (Note) sub foo { @_.say; } foo( A => 1 ); *ERRORS* foo( ( A => 1 ) ); [A => 1] When calling a sub (or method) a Pair using either A => 1 or :A(1) syntax will be treated as a named argument.
  4. 4. Empty Signature sub foo() { say “I take orders from no one”; } ● Specifically states this subroutine takes no arguments. ● Will error (generally at compile time) if called with arguments. ● Not just constants : eg. outer scope, state declarations
  5. 5. Empty Signature (methods) method foo() { say self.bar; } ● Methods with an empty signature also error if called with arguments. ● Have access to self (and the $ alias) though.
  6. 6. Positional Arguments sub foo($a,$b,$c) { say “$a : $b : $c”; } ● Maps arguments to lexical variables based on position ● Errors unless the exact number of arguments are passed
  7. 7. Positional Arguments (methods) method foo($foo: $a) { say “{$foo.attr} : $a”; } ● Optional initial argument separated with : defines another reference for self that can be used in the method ● Useful with where clauses and multi methods ● Also can be used to specify class methods
  8. 8. Positional Arguments : Defaults and optional sub foo($a,$b?,$c = 5) { say “$a : $b : $c”; } foo(1,2) 1 : 2 : 5 ● Any positions not filled will get their defaults ● Mark an argument as optional with ? after the name.
  9. 9. Positional Arguments : Sigils sub foo(@a) { say @a; } foo(1,2) Errors foo( [1,2] ) [1,2] @ and % sigils are type signifiers for Positional and Associative roles.
  10. 10. Positional Arguments : Flattening Slurpy sub foo(*@a) { say @a; } foo(1,2) [1,2] foo( 1,[2,3] ) [1,2,3] Single * will slurp and flatten all remaining positional arguments. foo(1,(2,3)) [1,2,3] foo(1,{2 => 3}) [1,{2=>3}]
  11. 11. Positional Arguments : Non Flattening Slurpy sub foo(**@a) { say @a; } foo(1,2) [1,2] foo( 1,[2,3] ) [1,[2,3]] Double * will slurp all remaining positional arguments but not flatten lists or hashes. foo(1,(1,2)) [1,(1,2)] foo(1,{2 => 3}) [1,{2=>3}]
  12. 12. Positional Arguments : Single Rule Slurpy sub foo(+@a) { say @a; } foo(1) [1] foo( [2,3] ) [2,3] A + slurpy will flatten a single iterable object into the arguments array. Otherwise it works like **. foo(1,[2,3]) [1,[2,3]] foo(1,{2 => 3}) [1,{2=>3}]
  13. 13. Positional Arguments : Combinations sub foo($a,*@b) { say “$a : {@b.perl}”; } foo(1) 1 : [] foo( 1,[2,3] ) 1 : [2,3] ● You can combine positional and slurpy argument. ● The slurpy has to come last. ● You can only have one slurpy argument. foo(1,2,3) 1 : [2,3] foo(1,2,3,{a => 5}) 1:[2,3,:a(5)]
  14. 14. Named Arguments sub foo(:$a,:$b!) { say “$a & $b”; } foo(a=>”b”,b=>”c”) b & c foo(:a<bar>) Required named parameter 'b' not passed ● Define named arguments with a ‘:’ in front of the lexical variable. ● Named arguments are not required. ● Append the name with ! to make it required. foo(:b<bar>) & bar Use of uninitialized value $a of type Any in string context.
  15. 15. Alternate Named Arguments sub foo(:bar(:$b)) { say $b; } foo(b=>”a”) a foo(:bar<bar>) bar ● Alternate argument names can be nested multiple times : ○ :$val ○ :v($val) ■ :v() in call ○ :v(:$val) ■ :v() or :val() ○ :valid(:v(:$val)) ● All referenced as $val in the sub ● Useful for sub MAIN
  16. 16. Combining Named and Positional Arguments sub foo($a,:$b) { say $a if $b; } foo(“Hi”,:b) Hi foo(“Crickets”) ● Positional arguments have to be defined before named. ● You can combine a slurpy positional and named arguments.
  17. 17. Named Arguments : Slurpy Hash sub foo(*%a) { say %a; } foo(a=>b) {a => b} Using * on a hash will take all the named argument pairs and put them in the given hash. foo( b => [5,6], :a(b) ) {b => [5,6], a => b} foo( :a, :!b ) { a => True, b => False }
  18. 18. Bonus Slide : Types sub num-in-country(:$num, :$ccode){...} sub num-in-country(UInt :$num, Str :$ccode){...} sub num-in-country(UInt :$num, Str :$ccode where * ~~ /^ <[a..z]> ** 2 $/ ){...} subset CCode of Str where * ~~ /^ <[a..z]> ** 2 $/; sub num-in-country(UInt :$num, CCode :$ccode){...} Sub coerced-type( Str() $a ) { say “$a could have been many...” }
  19. 19. Bonus Slide : Multi Call subset Seven of Int where * == 7; multi sub foo() { 'No args' } multi sub foo(5) { 'Called with 5' } multi sub foo(Seven $) { 'Called with 7' } multi sub foo( *@a ) { '*@a' } multi sub foo( $a ) { '$a' } multi sub foo( Cool $b ) { 'Cool $b' } multi sub foo( Int $b ) { 'Int $b' } multi sub foo( Int $b where * > 0 ) { 'Int $b where * > 0' }

×