develooper Front page | perl.perl6.language | Postings from March 2009

r25809 - docs/Perl6/Spec src/perl6 t/perl5 t/spec/S02-literals t/spec/S12-methods

From:
pugs-commits
Date:
March 12, 2009 20:16
Subject:
r25809 - docs/Perl6/Spec src/perl6 t/perl5 t/spec/S02-literals t/spec/S12-methods
Message ID:
20090312231549.6988.qmail@feather.perl6.nl
Author: lwall
Date: 2009-03-13 00:15:48 +0100 (Fri, 13 Mar 2009)
New Revision: 25809

Modified:
   docs/Perl6/Spec/S02-bits.pod
   docs/Perl6/Spec/S03-operators.pod
   docs/Perl6/Spec/S04-control.pod
   docs/Perl6/Spec/S12-objects.pod
   src/perl6/STD.pm
   t/perl5/roundtrip.t
   t/spec/S02-literals/pairs.t
   t/spec/S02-literals/sub-calls.t
   t/spec/S12-methods/instance.t
   t/spec/S12-methods/syntax.t
Log:
[STD] special named forms foo() .foo() and $.foo() no longer support
the dereferencing .() postfix syntax, since they don't actually do
any dereferencing!  You may still insert space using "unspace" however.
This decrease in consistency on the syntactic level is offset by an
increase in consistency on the semantic level, as suggested by rouso++.
(We'd already gotten rid of the dot forms of adverbs some time ago,
for similar reasons.  We just didn't quite carry the idea through.)


Modified: docs/Perl6/Spec/S02-bits.pod
===================================================================
--- docs/Perl6/Spec/S02-bits.pod	2009-03-12 22:34:06 UTC (rev 25808)
+++ docs/Perl6/Spec/S02-bits.pod	2009-03-12 23:15:48 UTC (rev 25809)
@@ -1597,7 +1597,7 @@
 
 Unlike in Perl 5, the notation C<&foo> merely stands for the C<foo>
 function as a Code object without calling it.  You may call any Code
-object with parens after it (which may, of course, contain arguments):
+object by dereferencing it with parens (which may, of course, contain arguments):
 
     &foo($arg1, $arg2);
 
@@ -1613,6 +1613,29 @@
         embedded comment
     ].($arg1, $arg2);
 
+Note however that the parentheses around arguments in the "normal"
+named forms of function and method calls are not postfix operators, so do
+not allow the C<.()> form, because the dot is indicative of an actual
+dereferencing operation, which the named forms aren't doing.  You
+may, however, use "unspace" to install extra space before the parens
+in the forms:
+
+    foo()       # okay
+    foo\ ()     # okay
+    foo.()      # means foo().()
+
+    .foo()      # okay
+    .foo\ ()    # okay
+    .foo.()     # means .foo().()
+
+    $.foo()     # okay
+    $.foo\ ()   # okay
+    $.foo.()    # means $.foo().()
+
+If you I<do> use the dotty form on these special forms, it will
+assume you wanted to call the named form without arguments, and
+then dereference the result of that.
+
 =item *
 
 With multiple dispatch, C<&foo> may actually be the name of a set

Modified: docs/Perl6/Spec/S03-operators.pod
===================================================================
--- docs/Perl6/Spec/S03-operators.pod	2009-03-12 22:34:06 UTC (rev 25808)
+++ docs/Perl6/Spec/S03-operators.pod	2009-03-12 23:15:48 UTC (rev 25809)
@@ -2576,12 +2576,13 @@
 (except for postfix adverbs, which may follow the parentheses provided they
 would not attach to some other operator by the rules of precedence).
 
-Other than various forms of parentheses, all other postfixes are
+Other than parentheses, all other postfixes are
 disallowed immediately after a list operator, even if there are no
 arguments.  To add a postfix to an argumentless list operator you
 must write it as a function call with empty parentheses:
 
     foo.[]      # ILLEGAL
+    foo.()      # ILLEGAL
     foo++       # ILLEGAL
     foo().[]    # legal
     foo()++     # legal (if foo() is rw)
@@ -2613,7 +2614,7 @@
     say foo++;                          ILLEGAL, need parens
 
     say foo($bar+1),$baz                say(foo($bar+1), $baz);
-    say foo.($bar+1),$baz               say(foo($bar+1), $baz);
+    say foo.($bar+1),$baz               ILLEGAL, need space or parens
     say foo ($bar+1),$baz               say(foo($bar+1, $baz));
     say foo .($bar+1),$baz              say(foo($_.($bar+1), $baz));
 

Modified: docs/Perl6/Spec/S04-control.pod
===================================================================
--- docs/Perl6/Spec/S04-control.pod	2009-03-12 22:34:06 UTC (rev 25808)
+++ docs/Perl6/Spec/S04-control.pod	2009-03-12 23:15:48 UTC (rev 25809)
@@ -1193,8 +1193,8 @@
     $scalar = ($x);     # grouping parens because term expected
     if $term($x)        # function call because operator expected
     if $term ($x)       # syntax error (two terms in a row)
-    if $term.($x)       # valid function call with dot
-    if $term\ .($x)     # valid function call with "unspace"
+    if $term.($x)       # valid function call with explicit dot deref
+    if $term\ .($x)     # valid function call with "unspace" and dot
 
 Outside of any kind of expression brackets, a final closing curly
 on a line (not counting whitespace or comments) always reverts

Modified: docs/Perl6/Spec/S12-objects.pod
===================================================================
--- docs/Perl6/Spec/S12-objects.pod	2009-03-12 22:34:06 UTC (rev 25808)
+++ docs/Perl6/Spec/S12-objects.pod	2009-03-12 23:15:48 UTC (rev 25809)
@@ -12,9 +12,9 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 27 Oct 2004
-  Last Modified: 9 Mar 2009
+  Last Modified: 12 Mar 2009
   Number: 12
-  Version: 75
+  Version: 76
 
 =head1 Overview
 
@@ -386,23 +386,27 @@
 Parentheses (or a colon) are required on the dot/bang notations if there
 are any arguments (not counting adverbial arguments).  There may be
 no space between the method name and the left parenthesis unless you
-use the dot form of parentheses or otherwise make use of "unspace":
+make use of "unspace":
 
     .doit       # okay, no arguments
     .doit()     # okay, no arguments
     .doit ()    # ILLEGAL (two terms in a row)
-    .doit.()    # okay, no arguments, same as .doit()
     .doit\ ()   # okay, no arguments, same as .doit() (unspace form)
-    .doit\ .()  # okay, no arguments, same as .doit.() (unspace form)
 
-However, you can turn any of the legal forms above into a list
+Note that the named method call forms are special and do not use the dot
+form of postfix.  If you attempt to use the postfix operator form, it
+will assume you want to call the method with no arguments and then call
+the result of I<that>:
+
+    .doit.()    # okay, no arguments *twice*, same as .doit().()
+    .doit\ .()  # okay, no arguments *twice*, same as .doit.().() (unspace form)
+
+However, you can turn any of the named forms above into a list
 operator by appending a colon:
 
     .doit: 1,2,3        # okay, three arguments
     .doit(1): 2,3       # okay, one argument plus list
     .doit (): 1,2,3     # ILLEGAL (two terms in a row)
-    .doit.(1): 2,3      # okay, same as .doit(1,2,3)
-    .doit\ .(1,2): 3    # okay, same as .doit(1,2,3)
 
 In particular, this allows us to pass a closure in addition to the
 "normal" arguments:
@@ -612,14 +616,16 @@
 any of those as an attribute -- a C<method foo> declaration can work
 just as well.
 
-The dot form can take an argument list as well.  These are all equivalent:
+As with the normal method call forms, only dotless parentheses may contain arguments.
+If you use the C<.()> form it will perform an extra level of indirection after
+the method call:
 
     self.foo(1,2,3);    # a regular method call
-    self.foo.(1,2,3);   # ditto
+    self.foo.(1,2,3);   # self.foo().(1,2,3), call .() on closure returned by .foo
     $.foo(1,2,3);       # calls self.foo under $ context
-    $.foo.(1,2,3);      # ditto
-    @.foo(1,2,3);       # calls self.foo under @ context
-    @.foo.(1,2,3);      # ditto
+    $.foo.(1,2,3);      # $.foo().(1,2,3), call .() on closure returned by .foo
+    &.foo(1,2,3);       # calls self.foo under & context
+    &.foo.(1,2,3);      # &.foo().(1,2,3), call .() on closure returned by .foo
 
 Pseudo-assignment to an attribute declaration specifies the default
 value.  The value on the right is treated as an implicit closure and
@@ -1466,7 +1472,8 @@
 Like type names, enum names are parsed as standalone tokens
 representing scalar values, and don't look for any arguments.
 Unlike type names which are undefined protoobjects, enums are defined
-constant values.  Also unlike types, they do not respond to C<.()>.
+constant values.  Also unlike types, they do not respond to C<.()>
+unless you mix in C<Callable> somehow.
 They may not be post-declared.
 
     our enum Maybe <OK FAIL>;
@@ -1474,7 +1481,7 @@
     $x = OK;   # certainly the enum value
     $x = OK()  # certainly the function
 
-Since there is an enum OK, the function OK may only be
+Since there is an enum C<OK>, the function C<OK> may only be
 called using parentheses, never in list operator form.  (If there is
 a collision on two enum values that cancels them both, the function
 still may only be called with parentheses, since the enum symbol

Modified: src/perl6/STD.pm
===================================================================
--- src/perl6/STD.pm	2009-03-12 22:34:06 UTC (rev 25808)
+++ src/perl6/STD.pm	2009-03-12 23:15:48 UTC (rev 25809)
@@ -1608,7 +1608,7 @@
     :dba('method arguments')
     [
     | ':' <?before \s> <!{ $*inquote }> <arglist>
-    | <?[.(]> <args>
+    | <?[\\(]> <args>
     ]?
 }
 
@@ -2118,10 +2118,12 @@
 
     { my $t = $<twigil>; $twigil = $t.[0].Str if @$t; }
     [ <?{ $twigil eq '.' }>
-        <.unsp>? <?before '('> <postcircumfix> {*}          #= methcall
+        [<.unsp> | '\\' | <?> ] <?before '('> <postcircumfix> {*}          #= methcall
     ]?
 }
 
+
+
 # Note, don't reduce on a bare sigil unless you don't want a twigil or
 # you otherwise don't care what the longest token is.
 
@@ -3822,7 +3824,7 @@
 {
     :my $name;
     :my $pos;
-    <identifier> <?before ['.'?'(']?>
+    <identifier> <?before [<unsp>|'(']? >
     { $name = $<identifier>.Str; $pos = $¢.pos; }
     <args( $¢.is_name($name) )>
     { self.add_mystery($name,$pos) unless $<args><invocant>; }
@@ -3839,9 +3841,9 @@
     :my $INVOCANT_OK is context<rw> = 1;
     :my $INVOCANT_IS is context<rw>;
     [
-    | :dba('argument list') '.(' ~ ')' <semiarglist> {*}             #= func args
+#    | :dba('argument list') '.(' ~ ')' <semiarglist> {*}             #= func args
     | :dba('argument list') '(' ~ ')' <semiarglist> {*}              #= func args
-    | :dba('argument list') <.unsp> '.'? '(' ~ ')' <semiarglist> {*} #= func args
+    | :dba('argument list') <.unsp> '(' ~ ')' <semiarglist> {*} #= func args
     |  { $listopish = 1 } [<?before \s> <!{ $istype }> <.ws> <!infixstopper> <arglist>]?
     ]
     { $<invocant> = $*INVOCANT_IS; }

Modified: t/perl5/roundtrip.t
===================================================================
--- t/perl5/roundtrip.t	2009-03-12 22:34:06 UTC (rev 25808)
+++ t/perl5/roundtrip.t	2009-03-12 23:15:48 UTC (rev 25809)
@@ -25,8 +25,8 @@
 my $japh2   = -> $name { "Just another $name hacker" };
 my $id      = eval('sub { Id->new($_[0]) }', :lang<perl5>);
 
-is($id($japh).identity.('Pugs'), 'Just another Pugs hacker', "Closure roundtrips");
-is($id($japh2).identity.('Pugs'), 'Just another Pugs hacker', "Closure roundtrips");
+is($id($japh).identity('Pugs'), 'Just another Pugs hacker', "Closure roundtrips");
+is($id($japh2).identity('Pugs'), 'Just another Pugs hacker', "Closure roundtrips");
 
 my $keys_p5 = eval('sub {keys %{$_[0]}}', :lang<perl5>);
 my $tohash_p5 = eval('sub { return {map {$_ => 1} @_ } }', :lang<perl5>);

Modified: t/spec/S02-literals/pairs.t
===================================================================
--- t/spec/S02-literals/pairs.t	2009-03-12 22:34:06 UTC (rev 25808)
+++ t/spec/S02-literals/pairs.t	2009-03-12 23:15:48 UTC (rev 25809)
@@ -50,7 +50,7 @@
     is f2(:a(42)),      "Int", "':a(42)' is a named";
     is f2(:a),          "Int", "':a' is a named";
 
-    is(f2.(:a),         "Int",  "in 'f2.(:a)', ':a' is a named");
+    is(&f2.(:a),         "Int",  "in '&f2.(:a)', ':a' is a named");
     is $f2(:a),         "Int",  "in '\$f2(:a)', ':a' is a named";
     is $f2.(:a),        "Int",  "in '\$f2.(:a)', ':a' is a named";
 
@@ -61,7 +61,7 @@
     dies_ok { f2(("a" => 42)) }, "'(\"a\" => 42)' is a pair";
     dies_ok { f2((:a(42)))    }, "'(:a(42))' is a pair";
     dies_ok { f2((:a))        }, "'(:a)' is a pair";
-    dies_ok { f2.((:a))       }, "in 'f2.((:a))', '(:a)' is a pair";
+    dies_ok { &f2.((:a))       }, "in '&f2.((:a))', '(:a)' is a pair";
     
     #?rakudo 4 todo 'not every pair acts as named parameters'
     dies_ok { $f2((:a))       }, "in '\$f2((:a))', '(:a)' is a pair";

Modified: t/spec/S02-literals/sub-calls.t
===================================================================
--- t/spec/S02-literals/sub-calls.t	2009-03-12 22:34:06 UTC (rev 25808)
+++ t/spec/S02-literals/sub-calls.t	2009-03-12 23:15:48 UTC (rev 25809)
@@ -23,13 +23,13 @@
 
     eval_lives_ok q/foo;      /, 'call with no args, no parens';
     eval_lives_ok q/foo();    /, 'call with no args, has parens';
-    eval_lives_ok q/foo.();   /, 'call with no args, has dot and parens';
-    eval_lives_ok q/foo\ .(); /, 'call with no args, has long dot and parens';
+    eval_lives_ok q/&foo.();   /, 'call with no args, has dot and parens';
+    eval_lives_ok q/&foo\ .(); /, 'call with no args, has long dot and parens';
 
     eval_lives_ok q/foo 1;    /, 'call with one arg, no parens';
     eval_lives_ok q/foo(1);   /, 'call with one arg, has parens';
-    eval_lives_ok q/foo.(1);  /, 'call with one arg, has dot and parens';
-    eval_lives_ok q/foo\ .(1);/, 'call with one arg, has long dot and parens';
+    eval_lives_ok q/&foo.(1);  /, 'call with one arg, has dot and parens';
+    eval_lives_ok q/&foo\ .(1);/, 'call with one arg, has long dot and parens';
     #?pugs todo 'unspecced'
     #?rakudo todo 'unspecced'
     eval_lives_ok q/foo'bar'; /, 'call with one arg, has no space and no parens';
@@ -42,9 +42,9 @@
     eval_lives_ok q/foo :bar; /, 'call with adverb after space';
 
     eval_lives_ok q/foo(:bar);  /, 'call with adverb in parens';
-    eval_lives_ok q/foo.(:bar); /, 'call with adverb in dotted-parens';
+    eval_lives_ok q/&foo.(:bar); /, 'call with adverb in dotted-parens';
     #?rakudo todo 'long dot'
-    eval_lives_ok q/foo\.(:bar);/, 'call with adverb in long-dotted parens';
+    eval_lives_ok q/&foo\.(:bar);/, 'call with adverb in long-dotted parens';
 }
 
 

Modified: t/spec/S12-methods/instance.t
===================================================================
--- t/spec/S12-methods/instance.t	2009-03-12 22:34:06 UTC (rev 25808)
+++ t/spec/S12-methods/instance.t	2009-03-12 23:15:48 UTC (rev 25809)
@@ -2,7 +2,7 @@
 
 use Test;
 
-plan 28;
+plan 26;
 
 =begin pod
 
@@ -39,22 +39,6 @@
 
 {
     my $val;
-    lives_ok {
-        $val = $foo.noargs.();
-    }, "... '.' + parentheses after method", :todo<bug>;
-    is($val, 42, '... we got the value correctly', :todo<feature>);
-}
-
-{
-    my $val;
-    lives_ok {
-        $val = $foo.noargs\ .();
-    }, "... <unspace> + '.' + parentheses after method", :todo<bug>;
-    is($val, 42, '... we got the value correctly', :todo<feature>);
-}
-
-{
-    my $val;
     lives_ok { $val = $foo.nobrackets() }, 'method declared with no brackets';
     is($val, 'mice', '... we got the value correctly');
 }

Modified: t/spec/S12-methods/syntax.t
===================================================================
--- t/spec/S12-methods/syntax.t	2009-03-12 22:34:06 UTC (rev 25808)
+++ t/spec/S12-methods/syntax.t	2009-03-12 23:15:48 UTC (rev 25809)
@@ -1,7 +1,7 @@
 use v6;
 use Test;
 
-plan 13;
+plan 10;
 
 # L<S12/Methods/"no space between the method name and the left parenthesis">
 
@@ -16,18 +16,15 @@
 
 is .doit,       'empty',        'plain call with no args';
 is .doit(),     'empty',        'method call with parens and no args';
-is .doit.(),    'empty',        'method call with dot-parens and no args';
 eval_dies_ok '.doit ()',        '.doit () illegal';
 is .doit\ (),   'empty',        'method call with unspace';
-is .doit\ .(),  'empty',        'method call with dotty unspace';
 
 is (.doit: 1, 2, 3),    'a:1|b:2!3',    'list op with colon';
 is (.doit: 1, 2, 3, 4), 'a:1|b:2!3!4',  'list op with colon, slurpy';
-#?rakudo 4 skip 'adverbial listop form'
+#?rakudo 3 skip 'switch-from-paren-to-listop form'
 is (.doit(1): 2, 3),    'a:1|b:2!3',    'list op with colon';
 is (.doit(1, 2): 3),    'a:1|b:2!3',    'list op with colon';
 is (.doit\  (1, 2): 3), 'a:1|b:2!3',    'list op with colon, unspace';
-is (.doit\ .(1, 2): 3), 'a:1|b:2!3',    'list op with colon, dotty unspace';
 
 # L<S12/Methods/"if any term in a list is a bare closure">
 #?rakudo skip 'adverbial closures'




nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About