Changeset 21928 for examples

Show
Ignore:
Timestamp:
08/18/08 00:20:07 (3 months ago)
Author:
rhr
Message:

syntax fixes from STD++

Location:
examples
Files:
2 modified

Legend:

Unmodified
Added
Removed

  • examples/password-manager.p6

    r17701 r21928  
    5959my Hash of Str %pw; 
    6060 
    61 sub help(-->) { warn $=USAGE; } 
     61sub help(--> Void) { warn $=USAGE; } 
    6262 
    6363my Code &abort := -> Str $err { warn "$err\n"; return; } 
    6464 
    65 sub search(Str $pat -->) { 
     65sub search(Str $pat --> Void) { 
    6666        for %pw.keys -> $k { say %pw{$k}<user>, "\t", $k if $k ~~ /<$pat>/ } 
    6767} 
    6868 
    69 sub mk(Str $acct, Str $pass is copy, Str $user -->) { 
     69sub mk(Str $acct, Str $pass is copy, Str $user --> Void) { 
    7070        $changed = True; 
    7171        $pass = randpass if $pass eq 'R'; 
    … …  
    7373} 
    7474 
    75 sub del(Str $acct -->) { 
     75sub del(Str $acct --> Void) { 
    7676        abort "No account $acct" unless %pw{$acct}.:exists; 
    7777        $changed = True; 
    … …  
    7979} 
    8080 
    81 sub pr(Str $acct -->) { 
     81sub pr(Str $acct --> Void) { 
    8282        abort "No account $acct" unless %pw{$acct}.:exists; 
    8383        say %pw{$acct}<user pass>.join("\t"); 
    8484} 
    8585 
    86 sub wxclip(Str $acct -->) { 
     86sub wxclip(Str $acct --> Void) { 
    8787        abort "No account $acct" unless %pw{$acct}.:exists; 
    8888        xclip %pw{$acct}<pass>; 
    8989} 
    9090 
    91 sub xclip(Str $s -->) { 
     91sub xclip(Str $s --> Void) { 
    9292        my IO $xclip = Pipe.to: 'xclip' orelse abort 'No xclip - use .p'; 
    9393        $xclip.print: $s; 
    … …  
    9595} 
    9696 
    97 sub sx(Str $s -->) { 
     97sub sx(Str $s --> Void) { 
    9898        my Str $pw = %pw{$s}<pass> // 
    9999                first Str, (%pw{$_}<pass> if /$s/ for %pw.keys) 
    … …  
    116116} 
    117117 
    118 sub cmt(-->) { 
     118sub cmt(--> Void) { 
    119119        unlink 'pwd.gpg.old' orelse abort "Couldn't unlink: $!"; 
    120120        rename 'pwd.gpg', 'pwd.gpg.old' orelse abort "Couldn't rename: $!"; 
    … …  
    131131regex cmd { 
    132132        ^^ 
    133         [ '/' $<pat> := [ \N* ] { search $<pat> } 
    134         | \s* <!before '.'> $<acct> := [ \T+? ] \s* $$ { sx $<acct> } 
    135         | '.'   [ n     [ \t $<acct> := [ \T+ ] \t $<pass> := [ \T+ ] \t $<user> := [ \T+ ] $$ 
     133        [ '/' $<pat> = [ \N* ] { search $<pat> } 
     134        | \s* <!before '.'> $<acct> = [ \T+? ] \s* $$ { sx $<acct> } 
     135        | '.'   [ n     [ \t $<acct> = [ \T+ ] \t $<pass> = [ \T+ ] \t $<user> = [ \T+ ] $$ 
    136136                                { mk $<acct>, $<pass>, $<user> } 
    137137                        | { warn ".n [tab] account [tab] password [tab] username\n" } <commit> <fail> 
    138138                        ] 
    139                 | d     [ \s+ $<acct> := [ \T+? ] \s* $$ { del $<acct> } 
     139                | d     [ \s+ $<acct> = [ \T+? ] \s* $$ { del $<acct> } 
    140140                        | { warn ".d account\n" } <commit> <fail> 
    141141                        ] 
    142                 | p     [ \s+ $<acct> := [ \T+? ] \s* $$ { pr $<acct> } 
     142                | p     [ \s+ $<acct> = [ \T+? ] \s* $$ { pr $<acct> } 
    143143                        | { warn ".p account\n" } <commit> <fail> 
    144144                        ] 
    145                 | x     [ \s+ $<acct> := [ \T+? ] \s* $$ { wxclip $<acct> } 
     145                | x     [ \s+ $<acct> = [ \T+? ] \s* $$ { wxclip $<acct> } 
    146146                        | { warn ".x account\n" } <commit> <fail> 
    147147                        ] 
    148                 | l     [ \s+ $<len> := [ \d+ ] \s* $$ { $len = $<len> } 
     148                | l     [ \s+ $<len> = [ \d+ ] \s* $$ { $len = $<len> } 
    149149                        | { warn ".l length\nlength is $len\n" } <commit> <fail> 
    150150                        ] 
    … …  
    163163 
    164164regex pwent { 
    165         ^^ $<acct> := [ \T+ ] \t $<pass> := [ \T+ ] \t $<user> := [ \T+ ] $$ 
     165        ^^ $<acct> = [ \T+ ] \t $<pass> = [ \T+ ] \t $<user> = [ \T+ ] $$ 
    166166} 
    167167 

  • examples/rules/unitsdat-grammar.pm

    r17704 r21928  
    55    has Bool $.is_linear; 
    66    # For nonlinear units only 
    7     has Num %.input_units 
    8     has method &.cv_to_fund(Num --> Num); 
    9     has method &.cv_from_fund(Num --> Num); 
    10  
    11     multi submethod BUILD(Num :%def -->) { 
     7    has Num %.input_units; 
     8    has Method &.cv_to_fund:(Num --> Num); 
     9    has Method &.cv_from_fund:(Num --> Num); 
     10 
     11    multi submethod BUILD(Num :%def --> Void) { 
    1212        %.fund_units = $.defreduce(%def); 
    1313        $.is_linear = True; 
    1414    } 
    1515 
    16     multi submethod BUILD(Num :$num -->) { 
     16    multi submethod BUILD(Num :$num --> Void) { 
    1717        %.fund_units = { :factor($num) }; 
    1818        $.is_linear = True; 
    … …  
    2020 
    2121    multi submethod BUILD(Num :%def, Num :%input, 
    22         Code :&to_fund:(Num --> Num), Code :&from_fund:(Num --> Num) -->) { 
     22        Code :&to_fund:(Num --> Num), Code :&from_fund:(Num --> Num) --> Void) { 
    2323 
    2424        $.is_linear = False; 
    2525        %.fund_units = $.defreduce(%def); 
    2626        %.input_units = $.defreduce(%input); 
    27         &.cv_to_fund :=   method (Num $x --> Num) { 
     27        &.cv_to_fund := method :(Num $x --> Num) { 
    2828                to_fund($x); 
    2929            }; 
    30         &.cv_from_fund := method (Num $x --> Num) { 
     30        &.cv_from_fund := method :(Num $x --> Num) { 
    3131                from_fund($x); 
    3232            }; 
    … …  
    3535 
    3636class StrUnitdef is Unitdef { 
    37     has method &.cv_to_fund(Str, Num --> Num); 
    38     has method &.cv_from_fund(Str, Num --> Num); 
    39  
    40     multi submethod BUILD(Num :%def -->) { 
     37    has Method &.cv_to_fund:(Str, Num --> Num); 
     38    has Method &.cv_from_fund:(Str, Num --> Num); 
     39 
     40    multi submethod BUILD(Num :%def --> Void) { 
    4141        %.fund_units = $.defreduce(%def); 
    4242        $.is_linear = True; 
    4343    } 
    4444 
    45     multi submethod BUILD(Num :$num -->) { 
     45    multi submethod BUILD(Num :$num --> Void) { 
    4646        %.fund_units = { :factor($num) }; 
    4747        $.is_linear = True; 
    … …  
    4949 
    5050    multi submethod BUILD(Num :%def, Num :%input, 
    51         Code :&to_fund:(Str, Num --> Num), Code :&from_fund:(Str, Num --> Num) -->) { 
     51        Code :&to_fund:(Str, Num --> Num), Code :&from_fund:(Str, Num --> Num) --> Void) { 
    5252 
    5353        $.is_linear = False; 
    5454        %.fund_units = $.defreduce(%def); 
    5555        %.input_units = $.defreduce(%input); 
    56         &.cv_to_fund :=   method (Str $s, Num $x --> Num) { 
     56        &.cv_to_fund := method :(Str $s, Num $x --> Num) { 
    5757                to_fund($s, $x); 
    5858            }; 
    59         &.cv_from_fund := method (Str $s, Num $x --> Num) { 
     59        &.cv_from_fund := method :(Str $s, Num $x --> Num) { 
    6060                from_fund($s, $x); 
    6161            }; 
    … …  
    8989 
    9090    token float { 
    91         $<mantissa> := [ '-'? \d+ [ '.' \d+ ]? ] 
    92         [ e $<exp> := [ '-'? \d+ ] ]? 
     91        $<mantissa> = [ '-'? \d+ [ '.' \d+ ]? ] 
     92        [ e $<exp> = [ '-'? \d+ ] ]? 
    9393        { $<num> = $<mantissa> * 10 ** $<exp> } 
    9494    } 
    … …  
    108108 
    109109    rule basicnumber { 
    110         [ $<basicnumber> := <fraction> 
    111         | $<basicnumber> := <float> 
    112         | $<basicnumber> := <builtin_func> 
     110        [ <basicnumber=fraction> 
     111        | <basicnumber=float> 
     112        | <basicnumber=builtin_func> 
    113113        ] 
    114114        { $<num> := $<basicnumber><num> } 
    … …  
    121121 
    122122    rule number_pow { 
    123         [ $<lhs> := <basicnumber> 
    124         | $<lhs> := <number_paren> 
     123        [ <lhs=basicnumber> 
     124        | <lhs=number_paren> 
    125125        ] 
    126126        <?p> 
    127         [ $<rhs> := <basicnumber> 
    128         | $<rhs> := <number_paren> 
     127        [ <rhs=basicnumber> 
     128        | <rhs=number_paren> 
    129129        # right assoc 
    130         | $<rhs> := <number_pow> 
     130        | <rhs=number_pow> 
    131131        ] 
    132132        { $<num> = $<lhs><num> ** $<rhs><num> } 
    … …  
    135135    rule number_mult(Bool :$flip = False) { 
    136136        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    137         [ $<lhs> := <basicnumber> 
    138         | $<lhs> := <number_paren> 
    139         | $<lhs> := <number_pow> 
    140         ] 
    141         [ <?m> [ $<rhs> := <basicnumber> 
    142                | $<rhs> := <number_paren> 
    143                | $<rhs> := <number_pow> 
     137        [  <lhs=basicnumber> 
     138        |  <lhs=number_paren> 
     139        |  <lhs=number_pow> 
     140        ] 
     141        [ <?m> [  <rhs=basicnumber> 
     142               |  <rhs=number_paren> 
     143               |  <rhs=number_pow> 
    144144               # really left assoc 
    145                | $<rhs> := <number_mult> 
     145               |  <rhs=number_mult> 
    146146               ] 
    147147           { $<num> = $<lhs><num> * $<rhs><num> ** $sign } 
    148         | '/'  [ $<rhs> := <basicnumber> 
    149                | $<rhs> := <number_paren> 
    150                | $<rhs> := <number_pow> 
     148        | '/'  [  <rhs=basicnumber> 
     149               |  <rhs=number_paren> 
     150               |  <rhs=number_pow> 
    151151               # really left assoc - flip the next one to fix 
    152                | $<rhs> := <number_mult(:flip)> 
     152               |  <rhs=number_mult(:flip)> 
    153153               ] 
    154154           { $<num> = $<lhs><num> / $<rhs><num> ** $sign } 
    … …  
    158158    rule number_add(Bool :$flip = False) { 
    159159        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    160         [ $<lhs> := <basicnumber> 
    161         | $<lhs> := <number_paren> 
    162         | $<lhs> := <number_pow> 
    163         | $<lhs> := <number_mult> 
    164         ] 
    165         [ '+' [ $<rhs> := <basicnumber> 
    166               | $<rhs> := <number_paren> 
    167               | $<rhs> := <number_pow> 
    168               | $<rhs> := <number_mult> 
     160        [  <lhs=basicnumber> 
     161        |  <lhs=number_paren> 
     162        |  <lhs=number_pow> 
     163        |  <lhs=number_mult> 
     164        ] 
     165        [ '+' [  <rhs=basicnumber> 
     166              |  <rhs=number_paren> 
     167              |  <rhs=number_pow> 
     168              |  <rhs=number_mult> 
    169169              # really left assoc 
    170               | $<rhs> := <number_add> 
     170              |  <rhs=number_add> 
    171171              ] 
    172172            { $<num> = $<lhs><num> + $<rhs><num> * $sign } 
    173         | '-' [ $<rhs> := <basicnumber> 
    174               | $<rhs> := <number_paren> 
    175               | $<rhs> := <number_pow> 
    176               | $<rhs> := <number_mult> 
     173        | '-' [  <rhs=basicnumber> 
     174              |  <rhs=number_paren> 
     175              |  <rhs=number_pow> 
     176              |  <rhs=number_mult> 
    177177              # really left assoc - flip the next one to fix 
    178               | $<rhs> := <number_add(:flip)> 
     178              |  <rhs=number_add(:flip)> 
    179179              ] 
    180180            { $<num> = $<lhs><num> - $<rhs><num> * $sign } 
    … …  
    183183 
    184184    rule number { 
    185         [ $<number> := <basicnumber> 
    186         | $<number> := <number_paren> 
    187         | $<number> := <number_pow> 
    188         | $<number> := <number_mult> 
    189         | $<number> := <number_add> 
     185        [  <number=basicnumber> 
     186        |  <number=number_paren> 
     187        |  <number=number_pow> 
     188        |  <number=number_mult> 
     189        |  <number=number_add> 
    190190        ] 
    191191        { $<num> := $<number><num> } 
    … …  
    194194    token unitname { 
    195195        { $<factor> = 1; my Int $n = 0; } 
    196         [ @<prefix> := [ | @.prefixes ] 
     196        [ @<prefix> = [ | @.prefixes ] 
    197197            { $<factor> *= %.unitsdef{@<prefix>[$n++]}.fund_units<factor> } 
    198198        ]* 
    199         $<name> := [ | @.units ] s? 
     199        $<name> = [ | @.units ] s? 
    200200    } 
    201201 
    … …  
    222222    rule unitdef_mult(Bool :$flip = False) { 
    223223        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    224         [ $<lhs> := <basicunitdef> 
    225         | $<lhs> := <unitdef_paren> 
    226         ] 
    227         [ <?m>  [ $<rhs> := <basicunitdef> 
    228                 | $<rhs> := <unitdef_paren> 
     224        [  <lhs=basicunitdef> 
     225        |  <lhs=unitdef_paren> 
     226        ] 
     227        [ <?m>  [  <rhs=basicunitdef> 
     228                |  <rhs=unitdef_paren> 
    229229                # really left assoc 
    230                 | $<rhs> := <unitdef_mult> 
     230                |  <rhs=unitdef_mult> 
    231231                ] 
    232232            { $<def> = $.multdef($<lhs><def>, $<rhs><def>, $sign) } 
    233         | '/'   [ $<rhs> := <basicunitdef> 
    234                 | $<rhs> := <unitdef_paren> 
     233        | '/'   [  <rhs=basicunitdef> 
     234                |  <rhs=unitdef_paren> 
    235235                # really left assoc - flip the next one to fix 
    236                 | $<rhs> := <unitdef_mult(:flip)> 
     236                |  <rhs=unitdef_mult(:flip)> 
    237237                ] 
    238238            { $<def> = $.multdef($<lhs><def>, $<rhs><def>, -$sign) } 
    … …  
    242242    rule unitdef_add(Bool :$flip = False) { 
    243243        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    244         [ $<lhs> := <basicunitdef> 
    245         | $<lhs> := <unitdef_paren> 
    246         | $<lhs> := <unitdef_mult> 
    247         ] 
    248         [ '+' [ $<rhs> := <basicunitdef> 
    249               | $<rhs> := <unitdef_paren> 
    250               | $<rhs> := <unitdef_mult> 
     244        [  <lhs=basicunitdef> 
     245        |  <lhs=unitdef_paren> 
     246        |  <lhs=unitdef_mult> 
     247        ] 
     248        [ '+' [  <rhs=basicunitdef> 
     249              |  <rhs=unitdef_paren> 
     250              |  <rhs=unitdef_mult> 
    251251              # really left assoc 
    252               | $<rhs> := <unitdef_add> 
     252              |  <rhs=unitdef_add> 
    253253              ] 
    254254            { $<def> = $.adddef($<lhs><def>, $<rhs><def>, $sign) } 
    255         | '-' [ $<rhs> := <basicunitdef> 
    256               | $<rhs> := <unitdef_paren> 
    257               | $<rhs> := <unitdef_mult> 
     255        | '-' [  <rhs=basicunitdef> 
     256              |  <rhs=unitdef_paren> 
     257              |  <rhs=unitdef_mult> 
    258258              # really left assoc - flip the next one to fix 
    259               | $<rhs> := <unitdef_add(:flip)> 
     259              |  <rhs=unitdef_add(:flip)> 
    260260              ] 
    261261            { $<def> = $.adddef($<lhs><def>, $<rhs><def>, -$sign) } 
    … …  
    266266        | '(' <unitdef> ')' 
    267267            { $<def> = $<unitdef><def> } 
    268         | $<name> := [ | @.nl_units ] '(' <unitdef> ')' { 
     268        | $<name> = [ | @.nl_units ] '(' <unitdef> ')' { 
    269269                my Unitdef $u := %.unitsdef{$<name>}; 
    270270                die "Nonlinear input unit: { $<unitdef><def> } should be: { $u.input_units }\n" 
    … …  
    273273                $<def><factor> = $u.cv_to_fund($<def><factor>); 
    274274            } 
    275         | '~' $<name> := [ | @.nl_units ] '(' <unitdef> ')' { 
     275        | '~' $<name> = [ | @.nl_units ] '(' <unitdef> ')' { 
    276276                my Unitdef $u := %.unitsdef{$<name>}; 
    277277                die "Nonlinear input unit: { $<unitdef><def> } should be: { $u.fund_units }\n" 
    … …  
    283283 
    284284    rule unitdef { 
    285         [ $<unitdef> := <basicunitdef> 
    286         | $<unitdef> := <unitdef_paren> 
    287         | $<unitdef> := <unitdef_mult> 
    288         | $<unitdef> := <unitdef_add> 
     285        [  <unitdef=basicunitdef> 
     286        |  <unitdef=unitdef_paren> 
     287        |  <unitdef=unitdef_mult> 
     288        |  <unitdef=unitdef_add> 
    289289        ] 
    290290        { $<def> = $<unitdef><def> } 
    … …  
    299299 
    300300    rule nl_pow(Str $var, Num %def) { 
    301         [ $<lhs> := <nl_atom($var, %def)> 
    302         | $<lhs> := <nl_paren($var, %def)> 
     301        [  <lhs=nl_atom($var, %def)> 
     302        |  <lhs=nl_paren($var, %def)> 
    303303        ] 
    304304        <?p> 
    305         [ $<rhs> := <nl_atom($var, %def)> 
    306         | $<rhs> := <nl_paren($var, %def)> 
     305        [  <rhs=nl_atom($var, %def)> 
     306        |  <rhs=nl_paren($var, %def)> 
    307307        # right assoc 
    308         | $<rhs> := <nl_pow($var, %def)> 
     308        |  <rhs=nl_pow($var, %def)> 
    309309        ] { 
    310310            die "Non-unitless exponent { $<rhs><def> }\n" 
    311311                unless all($<rhs><def>.k) eq any('factor', @.fund_unitless); 
    312312            $<def> = $<lhs><def>; 
    313             for $<rhs><def>.kv -> my Str $u, my Num $p { 
     313            for $<rhs><def>.kv -> Str $u, Num $p { 
    314314                next if $u eq 'factor'; 
    315315                $<def>{$u} += $p; 
    316316            } 
    317             $<def>.v »*=» $<rhs><def><factor>; 
     317            $<def>.values »*=» $<rhs><def><factor>; 
    318318            $<closure> := sub (Num $x --> Num) { 
    319319                $<lhs><closure>.($x) ** $<rhs><closure>.($x); 
    … …  
    324324    rule nl_mult(Str $var, Num %def, Bool :$flip = False) { 
    325325        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    326         [ $<lhs> := <nl_atom($var, %def)> 
    327         | $<lhs> := <nl_paren($var, %def)> 
    328         | $<lhs> := <nl_pow($var, %def)> 
    329         ] 
    330         [ <?m>  [ $<rhs> := <nl_atom($var, %def)> 
    331                 | $<rhs> := <nl_paren($var, %def)> 
    332                 | $<rhs> := <nl_pow($var, %def)> 
     326        [  <lhs=nl_atom($var, %def)> 
     327        |  <lhs=nl_paren($var, %def)> 
     328        |  <lhs=nl_pow($var, %def)> 
     329        ] 
     330        [ <?m>  [  <rhs=nl_atom($var, %def)> 
     331                |  <rhs=nl_paren($var, %def)> 
     332                |  <rhs=nl_pow($var, %def)> 
    333333                # really left assoc 
    334                 | $<rhs> := <nl_mult($var, %def)> 
     334                |  <rhs=nl_mult($var, %def)> 
    335335                ] { 
    336336                    $<def> := $.multdef($<lhs><def>, $<rhs><def>, $sign); 
    … …  
    339339                    } 
    340340                } 
    341         | '/'   [ $<rhs> := <nl_atom($var, %def)> 
    342                 | $<rhs> := <nl_paren($var, %def)> 
    343                 | $<rhs> := <nl_pow($var, %def)> 
     341        | '/'   [  <rhs=nl_atom($var, %def)> 
     342                |  <rhs=nl_paren($var, %def)> 
     343                |  <rhs=nl_pow($var, %def)> 
    344344                # really left assoc - flip the next one to fix 
    345                 | $<rhs> := <nl_mult($var, %def, :flip)> 
     345                |  <rhs=nl_mult($var, %def, :flip)> 
    346346                ] { 
    347347                    $<def> := $.multdef($<lhs><def>, $<rhs><def>, -$sign); 
    … …  
    355355    rule nl_add(Str $var, Num %def, Bool :$flip = False) { 
    356356        { my Int $sign = $flip ?? -1 !! 1 } <!{0}>#XXX !! confuses perl6.vim 
    357         [ $<lhs> := <nl_atom($var, %def)> 
    358         | $<lhs> := <nl_paren($var, %def)> 
    359         | $<lhs> := <nl_pow($var, %def)> 
    360         | $<lhs> := <nl_mult($var, %def)> 
    361         ] 
    362         [ '+'   [ $<rhs> := <nl_atom($var, %def)> 
    363                 | $<rhs> := <nl_paren($var, %def)> 
    364                 | $<rhs> := <nl_pow($var, %def)> 
    365                 | $<rhs> := <nl_mult($var, %def)> 
     357        [  <lhs=nl_atom($var, %def)> 
     358        |  <lhs=nl_paren($var, %def)> 
     359        |  <lhs=nl_pow($var, %def)> 
     360        |  <lhs=nl_mult($var, %def)> 
     361        ] 
     362        [ '+'   [  <rhs=nl_atom($var, %def)> 
     363                |  <rhs=nl_paren($var, %def)> 
     364                |  <rhs=nl_pow($var, %def)> 
     365                |  <rhs=nl_mult($var, %def)> 
    366366                # really left assoc 
    367                 | $<rhs> := <nl_add($var, %def)> 
     367                |  <rhs=nl_add($var, %def)> 
    368368                ] { 
    369369                    $<def> := $.adddef($<lhs><def>, $<rhs><def>, $sign); 
    … …  
    372372                    } 
    373373                } 
    374         | '-'   [ $<rhs> := <nl_atom($var, %def)> 
    375                 | $<rhs> := <nl_paren($var, %def)> 
    376                 | $<rhs> := <nl_pow($var, %def)> 
    377                 | $<rhs> := <nl_mult($var, %def)> 
     374        | '-'   [  <rhs=nl_atom($var, %def)> 
     375                |  <rhs=nl_paren($var, %def)> 
     376                |  <rhs=nl_pow($var, %def)> 
     377                |  <rhs=nl_mult($var, %def)> 
    378378                # really left assoc - flip the next one to fix 
    379                 | $<rhs> := <nl_add($var, %def, :flip)> 
     379                |  <rhs=nl_add($var, %def, :flip)> 
    380380                ] { 
    381381                    $<def> := $.adddef($<lhs><def>, $<rhs><def>, -$sign); 
    … …  
    388388 
    389389    rule nl_expr(Str $var, Num %def) { 
    390         [ $<nl> := <nl_atom($var, %def)> 
    391         | $<nl> := <nl_paren($var, %def)> 
    392         | $<nl> := <nl_pow($var, %def)> 
    393         | $<nl> := <nl_mult($var, %def)> 
    394         | $<nl> := <nl_add($var, %def)> 
     390        [  <nl=nl_atom($var, %def)> 
     391        |  <nl=nl_paren($var, %def)> 
     392        |  <nl=nl_pow($var, %def)> 
     393        |  <nl=nl_mult($var, %def)> 
     394        |  <nl=nl_add($var, %def)> 
    395395        ] { 
    396396            $<closure> := $<nl><closure>; 
    … …  
    400400 
    401401    rule nl_func(Str $var, Num %def) { 
    402         | $<name> := [ | @.nl_units ] 
    403             $<inner> := <nl_paren($var, %def)> 
     402        | $<name> = [ | @.nl_units ] 
     403             <inner=nl_paren($var, %def)> 
    404404            { 
    405                 My Unitdef $u := %.unitsdef{$<name>}; 
     405                my Unitdef $u := %.unitsdef{$<name>}; 
    406406                die "Nonlinear input unit: { $<inner><def> } should be: { $u.input_units }\n" 
    407407                    if !$.defeqv($<inner><def>, $u.input_units); 
    … …  
    412412            } 
    413413        # ~nlfunc(...) means the inverse conversion function 
    414         | '~' $<name> := [ | @.nl_units ] 
    415             $<inner> := <nl_paren($var, %def)> 
     414        | '~' $<name> = [ | @.nl_units ] 
     415             <inner=nl_paren($var, %def)> 
    416416            { 
    417                 My Unitdef $u := %.unitsdef{$<name>}; 
     417                my Unitdef $u := %.unitsdef{$<name>}; 
    418418                die "Nonlinear input unit: { $<inner><def> } should be: { $u.fund_units }\n" 
    419419                    if !$.defeqv($<inner><def>, $u.fund_units); 
    … …  
    426426 
    427427    token nl_atom(Str $var, Num %def) { 
    428         [ $<nl> := <nl_unitdef> 
    429         | $<nl> := <var($var, %def)> 
    430         | $<nl> := <nl_func($var, %def)> 
     428        [  <nl=nl_unitdef> 
     429        |  <nl=var($var, %def)> 
     430        |  <nl=nl_func($var, %def)> 
    431431        ] { 
    432432            $<closure> := $<nl><closure>; 
    … …