Hi Bill,
maybe this example will help clarify the "theoretical" syntax explanations
of what happens with, and without, the empty parens.
First, there's a method ".perl" that shows what it's called on- it
serializes its object if it can. For code it shows that it's a block with a
ID.
$ perl6
To exit type 'exit' or '^D'
> q<Here's a string>.perl
"Here's a string"
> (2/3).perl
<2/3>
> (11,22,33,44).perl
(11, 22, 33, 44)
> { say "this is code" }.perl
-> ;; $_? is raw { #`(Block|140455367275128) ... }
Here's a sub that says its arguments-
sub show_args { say @_.perl }
Called by itself, or in a context without any ambiguity, parens are
optional calling a sub.
> show_args
[]
> show_args()
[]
> show_args 11,22,33
[11, 22, 33]
> show_args(11,22,33)
[11, 22, 33]
> show_args 11,22,33, { say "this is code" }
[11, 22, 33, -> ;; $_? is raw { #`(Block|140455367731128) ... }]
> show_args(11,22,33, { say "this is code" })
[11, 22, 33, -> ;; $_? is raw { #`(Block|140306311748968) ... }]
Now let's say we want to loop over the return value of show_args (which is
the value of the last statement in it, "say", which returns True when it
says successfully )
> for show_args(11,22,33) { say "show_args returned $_" }
[11, 22, 33]
show_args returned True
> for show_args 11,22,33 { say "show_args returned $_" }
[11, 22, 33]
show_args returned True
> for show_args 11, 22, 33, { say "this is code" } { say "show_args
returned $_" }
[11, 22, 33, -> ;; $_? is raw { #`(Block|140306324890560) ... }]
show_args returned True
That last two examples shows parens still optional, there's no ambiguity
where the list of args for "show_args" ends, and the start of for's block
begins.
In the below, is the code block the first arg to show_args, or is it part
of the for loop?
for show_args { say "this is code" }
Perl6 is consistent and parses the block as show_args's first parameter-
these are all the same class of syntax error.
> for show_args 11;
===SORRY!=== Error while compiling:
*Missing block*
> for show_args(11);
===SORRY!=== Error while compiling:
*Missing block*
> for show_args {say "code here"};
===SORRY!===
Function 'show_args' needs parens to avoid gobbling block
------> for show_args {say "code here"}⏏;
*Missing block* (apparently claimed by 'show_args')
> for show_args({say "code here"});
===SORRY!===
Function 'show_args' needs parens to avoid gobbling block
at line 5
------> for show_args({say "code here"}⏏);
*Missing block* (apparently claimed by 'show_args')
- the last two show the truth of the 'Missing block'- adding parens doesn't
create the block out of thin air, I placed the parens to emphasize how
Perl6 parses without them.
> for show_args({say "code here"}) { say "show_args returned $_" }
[-> ;; $_? is raw { #`(Block|140485954938480) ... }]
show_args returned True
> for show_args() { say "show_args returned $_" }
[]
show_args returned True
Hope a light bulb went off—and sorry that I am not at this week's P6 study
group at the Oakland City Museum café, if you happen to be there this very
moment!
-y
On Fri, Aug 2, 2019 at 11:12 PM William Michels via perl6-users <
perl6-us...@perl.org> wrote:
> Hi Richard, I'm not able to come to the same conclusions.
> Specifically, the previous code examples starting with 'for lines()'
> always have to have parentheses following 'lines' (as in 'lines()
> {...}'), otherwise Perl_6 balks (examples 6 and 7 previously posted).
> This is whether 'information is being passed' or not (i.e. empty
> parentheses are required):
>
> #example 6:
> mbook:~ homedir$ perl6 -e ' for lines() { say .split(":")[0, 2, 1,
> 5].join("\t") };' six_fruits1.txt
> apple carrot banana favabean
> apricot cabbage basil fennel
> acai celery beets figs
>
> #example 6 no-parens:
> mbook:~ homedir$ perl6 -e ' for lines { say .split(":")[0, 2, 1,
> 5].join("\t") };' six_fruits1.txt
> ===SORRY!===
> Function 'lines' needs parens to avoid gobbling block
> at -e:1
> ------> say .split(":")[0, 2, 1, 5].join("\t") };
> Missing block (apparently claimed by 'lines')
> at -e:1
> ------> say .split(":")[0, 2, 1, 5].join("\t") };
>
> #example 7:
> mbook:~ homedir$ perl6 -e 'for lines() {.split(":")[0, 2, 1,
> 5].join("\t").say};' six_fruits1.txt
> apple carrot banana favabean
> apricot cabbage basil fennel
> acai celery beets figs
>
> #example 7 no-parens:
> mbook:~ homedir$ perl6 -e 'for lines {.split(":")[0, 2, 1,
> 5].join("\t").say};' six_fruits1.txt
> ===SORRY!===
> Function 'lines' needs parens to avoid gobbling block
> at -e:1
> ------> {.split(":")[0, 2, 1, 5].join("\t").say};
> Missing block (apparently claimed by 'lines')
> at -e:1
> ------> {.split(":")[0, 2, 1, 5].join("\t").say};
>
> mbook:~ homedir$ perl6 --version
> This is Rakudo version 2019.07.1 built on MoarVM version 2019.07.1
> implementing Perl 6.d.
> mbook:~ homedir$
>
> Other Perl_6 users have replied with a general discussion of
> differences between using lines() as a method, or in a subroutine. I
> still have to review some of those comments. However, as I'm using the
> latest Perl_6 version (2019.07.1), I'm fairly confident in the results
> above (and below).
>
> Also, the examples below show that 'for lines[0..2] {...}' works,
> despite the previous error message insisting on parentheses ("Function
> 'lines' needs parens to avoid gobbling block at -e:1"). Taken
> together, the results above and below seem to indicate to me that the
> use of a bare 'lines' sub is disallowed, at least in a 'for' loop.
> --Best Regards, Bill.
>
> #example 10:
> mbook:~ homedir$ perl6 -e 'for lines { say .split(":")[0, 2, 1,
> 5].join("\t") };' six_fruits1.txt
> ===SORRY!===
> Function 'lines' needs parens to avoid gobbling block
> at -e:1
> ------> say .split(":")[0, 2, 1, 5].join("\t") };
> Missing block (apparently claimed by 'lines')
> at -e:1
> ------> say .split(":")[0, 2, 1, 5].join("\t") };
>
> #example 11:
> mbook:~ homedir$ perl6 -e 'for lines() { say .split(":")[0, 2, 1,
> 5].join("\t") };' six_fruits1.txt
> apple carrot banana favabean
> apricot cabbage basil fennel
> acai celery beets figs
>
> #example 12:
> mbook:~ homedir$ perl6 -e 'for lines[0..2] { say .split(":")[0, 2, 1,
> 5].join("\t") };' six_fruits1.txt
> apple carrot banana favabean
> apricot cabbage basil fennel
> acai celery beets figs
>
>
> On Fri, Aug 2, 2019 at 1:20 AM Richard Hainsworth
>
> <rnhainswo...@gmail.com> wrote:
> >
> > Not quite sure what sort of "rule" you want.
> >
> > You used () and [] which do different things and the results were
> exactly what I would expect. They are covered in the documentation.
> Basically, () without a space, eg xxxx() not xxxx (), is used to pass
> information to the sub or method xxxx.
> > If no information is being passed, then no need to use (). The way xxxx
> responds to no data provided depends on the way xxxx is written. The
> programmer could provide default values for the arguments it expects. Perl6
> also makes the value of the default variable, eg $_, to xxxx.
> > If you put a space between xxxx (), then () is interpreted as an empty
> list and provide to xxxx as a single piece of information.
> > [] Are used to dereference a list (sequence or array, they are all
> slightly different).
> >
> > I'll comment more below. Sometimes I think through the process using
> slightly different and less exact words. My comments are illustrative.
> >
> > On Fri, 2 Aug 2019, 04:50 William Michels, <w...@caa.columbia.edu>
> wrote:
> >>
> >> Hi Richard, I'm trying to figure out when the parentheses in 'lines()'
> >> can be dropped, and 'lines' used instead. Any pointers? I have about
> >> nine or so working examples below, but formulating a clear
> >> rule-of-thumb is proving elusive. Any help appreciated, --Best, Bill.
> >>
> >> # test file: six_fruits1.txt
> >> mbook:~ homedir$ cat six_fruits1.txt
> >> apple:banana:carrot:dragonfruit:eggplant:favabean
> >> apricot:basil:cabbage:dill:escarole:fennel
> >> acai:beets:celery:daikon:endive:figs
> >>
> >> mbook:~ homedir$ perl6 -e '.say for lines()' six_fruits1.txt
> >> apple:banana:carrot:dragonfruit:eggplant:favabean
> >> apricot:basil:cabbage:dill:escarole:fennel
> >> acai:beets:celery:daikon:endive:figs
> >
> > Here 'lines ()' is the same as 'lines'.
> > The program in the string after -e is provided with the data inside the
> file.
> >>
> >>
> >> mbook:~ homedir$ perl6 -e '.say for lines' six_fruits1.txt
> >> apple:banana:carrot:dragonfruit:eggplant:favabean
> >> apricot:basil:cabbage:dill:escarole:fennel
> >> acai:beets:celery:daikon:endive:figs
> >
> > The top two are equivalent
> >>
> >>
> >> mbook:~ homedir$ perl6 -e '.say for lines("a\nb\n")' six_fruits1.txt
> >> a
> >> b
> >
> > Here you provided data to 'lines' which it was able to interpret as a
> set of lines. So it printed them. The data in six_fruits is ignored because
> you provided the data explicitly.
> >>
> >>
> >> mbook:~ homedir$ perl6 -e '.say for lines[0]' six_fruits1.txt
> >> apple:banana:carrot:dragonfruit:eggplant:favabean
> >
> > Six_fruits has 3 lines. Lines has processed the data. But you wrote
> '[0]' which extracted the first line, and that was processed by the 'for'
> loop. In other words the 'for' was only given one piece of information to
> process.
> >>
> >>
> >> mbook:~ homedir$ perl6 -e '.say for lines[0..1]' six_fruits1.txt
> >> apple:banana:carrot:dragonfruit:eggplant:favabean
> >> apricot:basil:cabbage:dill:escarole:fennel
> >
> > The '[0..1]' extracts the first three pieces of data from 'lines' and
> they are processed by the 'for'
> >>
> >>
> >> mbook:~ homedir$ perl6 -e ' for lines() { say .split(":")[0, 2, 1,
> >> 5].join("\t") };' six_fruits1.txt
> >> apple carrot banana favabean
> >> apricot cabbage basil fennel
> >> acai celery beets figs
> >
> > Could be just 'lines', which provides a list of the lines in the file to
> the 'for'
> > Inside the 'for' the data is in the topic or default variable. You could
> access it as $_ but '.split' accesses it automatically. Split generates
> another list. '[0,2,1,5]' extracts the relevant elements of the list and
> generates another list which is passed to the'join'. The output from join
> is passed to 'say' which is written in sub form. Sub form means you write
> the name of the sub first, then you write where the data is coming from.
> >
> >>
> >> mbook:~ homedir$ perl6 -e ' for lines() {.split(":")[0, 2, 1,
> >> 5].join("\t").say};' six_fruits1.txt
> >> apple carrot banana favabean
> >> apricot cabbage basil fennel
> >> acai celery beets figs
> >
> > Exactly the same for perl6 as before except that 'say' is written in sub
> form above and in method form here. Method form means you can append the
> 'say' to a chain of processing units.
> >>
> >>
> >> mbook:~ homedir$ perl6 -e 'for "six_fruits1.txt".IO.lines()
> >> {.split(/\:/)[0, 2, 1, 5].join("\t").say};'
> >> apple carrot banana favabean
> >> apricot cabbage basil fennel
> >> acai celery beets figs
> >
> > Here just accessing the data in the file explicitly in perl6.
> >>
> >>
> >> mbook:~ homedir$ perl6 -e 'for "six_fruits1.txt".IO.lines
> >> {.split(/\:/)[0, 2, 1, 5].join("\t").say};'
> >> apple carrot banana favabean
> >> apricot cabbage basil fennel
> >> acai celery beets figs
> >
> > Same as above. No () on lines
> >>
> >>
> >>
> >>
> >>
> >> On Mon, Jul 29, 2019 at 1:07 AM Richard Hainsworth
> >> <rnhainswo...@gmail.com> wrote:
> >> >
> >> > Also no need for all the brackets
> >> >
> >> > .say for lines;
> >> >
> >> > This is quite idiomatic Perl 6 and not golfing
> >> >
> >> > On Mon, 29 Jul 2019, 07:13 Joseph Brenner, <doom...@gmail.com> wrote:
> >> >>
> >> >> > Hmmm. I would expect that to be in the Perl 5 to Perl 6 Migration
> Guides, but I do not see it there.
> >> >>
> >> >> Exactly, I was just looking there, and I ended up playing around with
> >> >> the method form of lines, and didn't think to try the function
> >> >> form of it.
> >> >>
> >> >> To summarize, if the goal is to write a "simple_echo" script that
> >> >> can work with a file name or with lines on standard input:
> >> >>
> >> >> simple_echo lines.txt
> >> >> cat lines.txt | simple_echo
> >> >>
> >> >> The perl5 version would probably be:
> >> >>
> >> >> #!/usr/bin/env perl
> >> >> while(<>){
> >> >> print;
> >> >> }
> >> >>
> >> >> The perl6 version would be something like:
> >> >>
> >> >> #!/usr/bin/env perl6
> >> >> use v6;
> >> >> for lines() {
> >> >> say $_;
> >> >> }
> >> >>
> >> >>
> >> >> The kind of thing I was playing with was:
> >> >>
> >> >> #!/usr/bin/env perl6
> >> >> use v6;
> >> >> my @lines = $*ARGFILES.IO.lines;
> >> >> say @lines;
> >> >>
> >> >> That works for lines from a file, but not from standard input, and
> the
> >> >> error message isn't tremendously helpful:
> >> >>
> >> >> No such method 'lines' for invocant of type 'IO::Special'
> >> >>
> >> >>
> >> >>
> >> >>
> >> >> On 7/28/19, Bruce Gray <robertbrucegr...@gmail.com> wrote:
> >> >> >
> >> >> >
> >> >> >> On Jul 28, 2019, at 6:20 PM, Joseph Brenner <doom...@gmail.com>
> wrote:
> >> >> >>
> >> >> >> I was just wondering if there's some direct analog in perl6 to the
> >> >> >> perl5 construct:
> >> >> >>
> >> >> >> while(<>){ ... }
> >> >> >>
> >> >> >> If I'm planning on passing a filename on the command-line, I can
> just
> >> >> >> get it out of $*ARGFILES easily enough, but what if I also wanted
> it
> >> >> >> to work on lines passed in via standard input?
> >> >> >
> >> >> >
> >> >> > `lines` , as a sub instead of a method, and no arguments.
> >> >> >
> >> >> > See: https://docs.perl6.org/routine/lines#(Cool)_routine_lines
> >> >> > Without any arguments, sub lines operates on $*ARGFILES,
> which defaults to
> >> >> > $*IN in the absence of any filenames.
> >> >> >
> >> >> > For example:
> >> >> > perl6 -e 'say .join("\t") for lines().rotor(4);'
> path/to/file.txt
> >> >> >
> >> >> > Hmmm. I would expect that to be in the Perl 5 to Perl 6 Migration
> Guides,
> >> >> > but I do not see it there.
> >> >> >
> >> >> > —
> >> >> > Hope this helps,
> >> >> > Bruce Gray (Util of PerlMonks)
> >> >> >
> >> >> >
>
