Re: **@args question

2019-01-04 Thread ToddAndMargo via perl6-users

On 1/3/19 12:43 AM, Richard Hainsworth wrote:




The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.



Well Golly!

$ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
abc 1 def

$ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
abc 1 def

Question:
$ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
abc xyz def

Are the spaces suppose to be there?


In each case you are using 'print @args', then `printx` adds on a "\n" 
either to the last item or the final string, which in each case results 
in exactly the same string. The way 'print' handles an array is to put a 
space between each item, which can be very confusing when dealing with 
items that are themselves strings with spaces.


For other "stringifications" of an array, try 'print @args.fmt("%s,")' 
if you want a comma, or 'print @args.perl'.


I find '.say for @args' is better because I get an item on each line.

Also 'dd @args' is quite useful.



Thank you!


Re: **@args question

2019-01-04 Thread ToddAndMargo via perl6-users

On 1/4/19 11:39 AM, ToddAndMargo via perl6-users wrote:

On 1/3/19 2:58 AM, Brad Gilbert wrote:

On Thu, Jan 3, 2019 at 12:43 AM ToddAndMargo via perl6-users
 wrote:


On 1/2/19 10:17 PM, ToddAndMargo via perl6-users wrote:

  > On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
  >  wrote:
  >>
  >> Hi All,
  >>
  >> Looking at
  >>
  >>  https://docs.perl6.org/routine/print
  >>
  >> I see
  >>
  >>  multi sub print(**@args --> True)
  >>
  >> Question.  If I wanted to create my own print routine
  >> using **@args, how would I declare it?
  >>
  >>  sub printx( **@args data ) {...}
  >>
  >>
  >> Many thanks,
  >> -T


On 1/2/19 10:06 PM, Brad Gilbert wrote:

The variable name in :(**@args) is @args, it could be any valid array
identifier like @data

  sub printx( **@data ){…}

Note that there are several forms for slurpy positional arguments.

  :(   @a ) # not slurpy at all, takes one Positional argument and
aliases it as @a.

  :(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) →
1,2,3
  :( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and 
((1,),2,3) →

((1,),2,3) # note there is no change
  :(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and 
((1,),2,3)

→ (1,),2,3 # note that the second one changes

Note that itemized values do not get flattened for :(*@a), and that
Array values are itemized.

I like to consider the one-arg rule slurpy :(+@a) to be like a
combination between non-slurpy :(@a) and structured slurpy :(**@a)
That is a one-arg rule slurpy will sometimes be like an alias to a
singular positional, otherwise it will act like a structured slurpy.

Note that all but the [aliasing] non-slurpy :(@a) are [almost] always
Array's.

---

The one-arg rule slurpy is the oddest one of the bunch so here is some
brief information:

The one-arg rule slurpy can be sigiless :(+a), in which case it will
be a List instead of an Array or an alias to the single argument
depending on what it was.

  sub one-arg-rule ( +args ){
  say args.^name, " # ", args.perl;
  }

  one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
  one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
  one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq #
one-arg rule
  one-arg-rule(  1..3   ); # List # (1, 2, 3)
  one-arg-rule( (1..3,) ); # List # (1..3,)

  sub one-arg-Array ( +@args ){
  say @args.^name, " # ", @args.perl;
  }

  one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
  one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
  one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
  one-arg-Array(  1..3   ); # Array # [1, 2, 3]
  one-arg-Array( (1..3,) ); # Array # [1..3,]

The one-arg rule exists because people tend to write the following:

  my @a = [1,2,3];

When the correct way to write it is:

  my @a = 1,2,3;

There are various other places where the one-arg rule is also used, so
it was made available to everyone.

---

Don't get too flustered if you don't understand all of the nuances, it
take everybody a while to understand them.



Thank you!

The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.



Well Golly!

$ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
abc 1 def

$ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
abc 1 def

Question:
$ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
abc xyz def

Are the spaces suppose to be there?


The spaces are there because you are passing `@args` to `print` as a
single value.
`print` coerces all its values to `Str` before printing, and an Array
adds spaces between elements when turned into a Str.

Simple fix use `|@args` to Slip it into the call to `print`

 $ p6 'sub printx(**@args){print( |@args, "\n" )};
printx("abc","xyz","def");'
 abcxyzdef



$ p6 'sub printx(**@args){print(|@args)}; printx("abc", "xyz","def\n");'
abcxyzdef

Sweet!  Thank you!



Follow up:


unit module PrintColors;

#`{

 There subs give you the ability to print to the stand output and 
standard error

 with color.

 To use these, place the following at the top(ish) of your program
use lib "/home/linuxutil";
use PrintColors;  # qx[ PrintRed  PrintGreen PrintBlue PrintErr 
PrintRedErr PrintGreenErr PrintBlueErr ]


}

use Terminal::ANSIColor;  # qx[ color ];

sub PrintRed   ( **@args ) is export { print color('bold'), 
color('red'),   |@args, color('reset'); }
sub PrintGreen ( **@args ) is export { print color('bold'), 
color('green'), |@args, color('reset'); }
sub PrintBlue  ( **@args ) is export { print color('bold'), 
color('blue'),  |@args, color('reset'); }


sub PrintErr   ( **@args ) is export { $*ERR.print: |@args; }

sub PrintRedErr   ( **@args ) is export { $*ERR.print: color('bold'), 
color('red'),   |@args, color('reset'); }
sub PrintGreenErr ( **@args ) is export { $*ERR.print: color('bold'), 

Re: **@args question

2019-01-04 Thread ToddAndMargo via perl6-users

On 1/3/19 2:58 AM, Brad Gilbert wrote:

On Thu, Jan 3, 2019 at 12:43 AM ToddAndMargo via perl6-users
 wrote:


On 1/2/19 10:17 PM, ToddAndMargo via perl6-users wrote:

  > On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
  >  wrote:
  >>
  >> Hi All,
  >>
  >> Looking at
  >>
  >>  https://docs.perl6.org/routine/print
  >>
  >> I see
  >>
  >>  multi sub print(**@args --> True)
  >>
  >> Question.  If I wanted to create my own print routine
  >> using **@args, how would I declare it?
  >>
  >>  sub printx( **@args data ) {...}
  >>
  >>
  >> Many thanks,
  >> -T


On 1/2/19 10:06 PM, Brad Gilbert wrote:

The variable name in :(**@args) is @args, it could be any valid array
identifier like @data

  sub printx( **@data ){…}

Note that there are several forms for slurpy positional arguments.

  :(   @a ) # not slurpy at all, takes one Positional argument and
aliases it as @a.

  :(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) →
1,2,3
  :( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3) →
((1,),2,3) # note there is no change
  :(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3)
→ (1,),2,3 # note that the second one changes

Note that itemized values do not get flattened for :(*@a), and that
Array values are itemized.

I like to consider the one-arg rule slurpy :(+@a) to be like a
combination between non-slurpy :(@a) and structured slurpy :(**@a)
That is a one-arg rule slurpy will sometimes be like an alias to a
singular positional, otherwise it will act like a structured slurpy.

Note that all but the [aliasing] non-slurpy :(@a) are [almost] always
Array's.

---

The one-arg rule slurpy is the oddest one of the bunch so here is some
brief information:

The one-arg rule slurpy can be sigiless :(+a), in which case it will
be a List instead of an Array or an alias to the single argument
depending on what it was.

  sub one-arg-rule ( +args ){
  say args.^name, " # ", args.perl;
  }

  one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
  one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
  one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq #
one-arg rule
  one-arg-rule(  1..3   ); # List # (1, 2, 3)
  one-arg-rule( (1..3,) ); # List # (1..3,)

  sub one-arg-Array ( +@args ){
  say @args.^name, " # ", @args.perl;
  }

  one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
  one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
  one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
  one-arg-Array(  1..3   ); # Array # [1, 2, 3]
  one-arg-Array( (1..3,) ); # Array # [1..3,]

The one-arg rule exists because people tend to write the following:

  my @a = [1,2,3];

When the correct way to write it is:

  my @a = 1,2,3;

There are various other places where the one-arg rule is also used, so
it was made available to everyone.

---

Don't get too flustered if you don't understand all of the nuances, it
take everybody a while to understand them.



Thank you!

The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.



Well Golly!

$ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
abc 1 def

$ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
abc 1 def

Question:
$ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
abc xyz def

Are the spaces suppose to be there?


The spaces are there because you are passing `@args` to `print` as a
single value.
`print` coerces all its values to `Str` before printing, and an Array
adds spaces between elements when turned into a Str.

Simple fix use `|@args` to Slip it into the call to `print`

 $ p6 'sub printx(**@args){print( |@args, "\n" )};
printx("abc","xyz","def");'
 abcxyzdef



$ p6 'sub printx(**@args){print(|@args)}; printx("abc", "xyz","def\n");'
abcxyzdef

Sweet!  Thank you!

--
~~
Computers are like air conditioners.
They malfunction when you open windows
~~


Re: **@args question

2019-01-03 Thread Brad Gilbert
On Thu, Jan 3, 2019 at 12:43 AM ToddAndMargo via perl6-users
 wrote:
>
> On 1/2/19 10:17 PM, ToddAndMargo via perl6-users wrote:
> >  > On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
> >  >  wrote:
> >  >>
> >  >> Hi All,
> >  >>
> >  >> Looking at
> >  >>
> >  >>  https://docs.perl6.org/routine/print
> >  >>
> >  >> I see
> >  >>
> >  >>  multi sub print(**@args --> True)
> >  >>
> >  >> Question.  If I wanted to create my own print routine
> >  >> using **@args, how would I declare it?
> >  >>
> >  >>  sub printx( **@args data ) {...}
> >  >>
> >  >>
> >  >> Many thanks,
> >  >> -T
> >
> >
> > On 1/2/19 10:06 PM, Brad Gilbert wrote:
> >> The variable name in :(**@args) is @args, it could be any valid array
> >> identifier like @data
> >>
> >>  sub printx( **@data ){…}
> >>
> >> Note that there are several forms for slurpy positional arguments.
> >>
> >>  :(   @a ) # not slurpy at all, takes one Positional argument and
> >> aliases it as @a.
> >>
> >>  :(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) →
> >> 1,2,3
> >>  :( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3) →
> >> ((1,),2,3) # note there is no change
> >>  :(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3)
> >> → (1,),2,3 # note that the second one changes
> >>
> >> Note that itemized values do not get flattened for :(*@a), and that
> >> Array values are itemized.
> >>
> >> I like to consider the one-arg rule slurpy :(+@a) to be like a
> >> combination between non-slurpy :(@a) and structured slurpy :(**@a)
> >> That is a one-arg rule slurpy will sometimes be like an alias to a
> >> singular positional, otherwise it will act like a structured slurpy.
> >>
> >> Note that all but the [aliasing] non-slurpy :(@a) are [almost] always
> >> Array's.
> >>
> >> ---
> >>
> >> The one-arg rule slurpy is the oddest one of the bunch so here is some
> >> brief information:
> >>
> >> The one-arg rule slurpy can be sigiless :(+a), in which case it will
> >> be a List instead of an Array or an alias to the single argument
> >> depending on what it was.
> >>
> >>  sub one-arg-rule ( +args ){
> >>  say args.^name, " # ", args.perl;
> >>  }
> >>
> >>  one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
> >>  one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
> >>  one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq #
> >> one-arg rule
> >>  one-arg-rule(  1..3   ); # List # (1, 2, 3)
> >>  one-arg-rule( (1..3,) ); # List # (1..3,)
> >>
> >>  sub one-arg-Array ( +@args ){
> >>  say @args.^name, " # ", @args.perl;
> >>  }
> >>
> >>  one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
> >>  one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
> >>  one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
> >>  one-arg-Array(  1..3   ); # Array # [1, 2, 3]
> >>  one-arg-Array( (1..3,) ); # Array # [1..3,]
> >>
> >> The one-arg rule exists because people tend to write the following:
> >>
> >>  my @a = [1,2,3];
> >>
> >> When the correct way to write it is:
> >>
> >>  my @a = 1,2,3;
> >>
> >> There are various other places where the one-arg rule is also used, so
> >> it was made available to everyone.
> >>
> >> ---
> >>
> >> Don't get too flustered if you don't understand all of the nuances, it
> >> take everybody a while to understand them.
> >>
> >
> > Thank you!
> >
> > The term "slurpy" did help a lot.
> >
> > :-)
> >
> > I am writing your explanation down for my records.
>
>
> Well Golly!
>
> $ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
> abc 1 def
>
> $ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
> abc 1 def
>
> Question:
> $ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
> abc xyz def
>
> Are the spaces suppose to be there?

The spaces are there because you are passing `@args` to `print` as a
single value.
`print` coerces all its values to `Str` before printing, and an Array
adds spaces between elements when turned into a Str.

Simple fix use `|@args` to Slip it into the call to `print`

$ p6 'sub printx(**@args){print( |@args, "\n" )};
printx("abc","xyz","def");'
abcxyzdef


Re: **@args question

2019-01-03 Thread Richard Hainsworth




The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.



Well Golly!

$ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
abc 1 def

$ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
abc 1 def

Question:
$ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
abc xyz def

Are the spaces suppose to be there?


In each case you are using 'print @args', then `printx` adds on a "\n" 
either to the last item or the final string, which in each case results 
in exactly the same string. The way 'print' handles an array is to put a 
space between each item, which can be very confusing when dealing with 
items that are themselves strings with spaces.


For other "stringifications" of an array, try 'print @args.fmt("%s,")' 
if you want a comma, or 'print @args.perl'.


I find '.say for @args' is better because I get an item on each line.

Also 'dd @args' is quite useful.


Re: **@args question

2019-01-02 Thread ToddAndMargo via perl6-users

On 1/2/19 10:17 PM, ToddAndMargo via perl6-users wrote:

 > On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
 >  wrote:
 >>
 >> Hi All,
 >>
 >> Looking at
 >>
 >>  https://docs.perl6.org/routine/print
 >>
 >> I see
 >>
 >>  multi sub print(**@args --> True)
 >>
 >> Question.  If I wanted to create my own print routine
 >> using **@args, how would I declare it?
 >>
 >>  sub printx( **@args data ) {...}
 >>
 >>
 >> Many thanks,
 >> -T


On 1/2/19 10:06 PM, Brad Gilbert wrote:

The variable name in :(**@args) is @args, it could be any valid array
identifier like @data

 sub printx( **@data ){…}

Note that there are several forms for slurpy positional arguments.

 :(   @a ) # not slurpy at all, takes one Positional argument and
aliases it as @a.

 :(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) → 
1,2,3

 :( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3) →
((1,),2,3) # note there is no change
 :(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3)
→ (1,),2,3 # note that the second one changes

Note that itemized values do not get flattened for :(*@a), and that
Array values are itemized.

I like to consider the one-arg rule slurpy :(+@a) to be like a
combination between non-slurpy :(@a) and structured slurpy :(**@a)
That is a one-arg rule slurpy will sometimes be like an alias to a
singular positional, otherwise it will act like a structured slurpy.

Note that all but the [aliasing] non-slurpy :(@a) are [almost] always 
Array's.


---

The one-arg rule slurpy is the oddest one of the bunch so here is some
brief information:

The one-arg rule slurpy can be sigiless :(+a), in which case it will
be a List instead of an Array or an alias to the single argument
depending on what it was.

 sub one-arg-rule ( +args ){
 say args.^name, " # ", args.perl;
 }

 one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
 one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
 one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq # 
one-arg rule

 one-arg-rule(  1..3   ); # List # (1, 2, 3)
 one-arg-rule( (1..3,) ); # List # (1..3,)

 sub one-arg-Array ( +@args ){
 say @args.^name, " # ", @args.perl;
 }

 one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
 one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
 one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
 one-arg-Array(  1..3   ); # Array # [1, 2, 3]
 one-arg-Array( (1..3,) ); # Array # [1..3,]

The one-arg rule exists because people tend to write the following:

 my @a = [1,2,3];

When the correct way to write it is:

 my @a = 1,2,3;

There are various other places where the one-arg rule is also used, so
it was made available to everyone.

---

Don't get too flustered if you don't understand all of the nuances, it
take everybody a while to understand them.



Thank you!

The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.



Well Golly!

$ p6 'sub printx(**@args){print(@args)}; printx("abc",1,"def\n");'
abc 1 def

$ p6 'sub printx(**@args){print @args, "\n"}; printx("abc",1,"def");'
abc 1 def

Question:
$ p6 'sub printx(**@args){print(@args)}; printx("abc","xyz","def\n");'
abc xyz def

Are the spaces suppose to be there?


Re: **@args question

2019-01-02 Thread ToddAndMargo via perl6-users

> On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
>  wrote:
>>
>> Hi All,
>>
>> Looking at
>>
>>  https://docs.perl6.org/routine/print
>>
>> I see
>>
>>  multi sub print(**@args --> True)
>>
>> Question.  If I wanted to create my own print routine
>> using **@args, how would I declare it?
>>
>>  sub printx( **@args data ) {...}
>>
>>
>> Many thanks,
>> -T


On 1/2/19 10:06 PM, Brad Gilbert wrote:

The variable name in :(**@args) is @args, it could be any valid array
identifier like @data

 sub printx( **@data ){…}

Note that there are several forms for slurpy positional arguments.

 :(   @a ) # not slurpy at all, takes one Positional argument and
aliases it as @a.

 :(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) → 1,2,3
 :( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3) →
((1,),2,3) # note there is no change
 :(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3)
→ (1,),2,3 # note that the second one changes

Note that itemized values do not get flattened for :(*@a), and that
Array values are itemized.

I like to consider the one-arg rule slurpy :(+@a) to be like a
combination between non-slurpy :(@a) and structured slurpy :(**@a)
That is a one-arg rule slurpy will sometimes be like an alias to a
singular positional, otherwise it will act like a structured slurpy.

Note that all but the [aliasing] non-slurpy :(@a) are [almost] always Array's.

---

The one-arg rule slurpy is the oddest one of the bunch so here is some
brief information:

The one-arg rule slurpy can be sigiless :(+a), in which case it will
be a List instead of an Array or an alias to the single argument
depending on what it was.

 sub one-arg-rule ( +args ){
 say args.^name, " # ", args.perl;
 }

 one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
 one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
 one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq # one-arg rule
 one-arg-rule(  1..3   ); # List # (1, 2, 3)
 one-arg-rule( (1..3,) ); # List # (1..3,)

 sub one-arg-Array ( +@args ){
 say @args.^name, " # ", @args.perl;
 }

 one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
 one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
 one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
 one-arg-Array(  1..3   ); # Array # [1, 2, 3]
 one-arg-Array( (1..3,) ); # Array # [1..3,]

The one-arg rule exists because people tend to write the following:

 my @a = [1,2,3];

When the correct way to write it is:

 my @a = 1,2,3;

There are various other places where the one-arg rule is also used, so
it was made available to everyone.

---

Don't get too flustered if you don't understand all of the nuances, it
take everybody a while to understand them.



Thank you!

The term "slurpy" did help a lot.

:-)

I am writing your explanation down for my records.


Re: **@args question

2019-01-02 Thread Brad Gilbert
The variable name in :(**@args) is @args, it could be any valid array
identifier like @data

sub printx( **@data ){…}

Note that there are several forms for slurpy positional arguments.

:(   @a ) # not slurpy at all, takes one Positional argument and
aliases it as @a.

:(  *@a ) # flattening slurpy  (1,),2,3 → 1,2,3 and ((1,),2,3) → 1,2,3
:( **@a ) # structured slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3) →
((1,),2,3) # note there is no change
:(  +@a ) # one-arg rule slurpy (1,),2,3 → (1,),2,3 and ((1,),2,3)
→ (1,),2,3 # note that the second one changes

Note that itemized values do not get flattened for :(*@a), and that
Array values are itemized.

I like to consider the one-arg rule slurpy :(+@a) to be like a
combination between non-slurpy :(@a) and structured slurpy :(**@a)
That is a one-arg rule slurpy will sometimes be like an alias to a
singular positional, otherwise it will act like a structured slurpy.

Note that all but the [aliasing] non-slurpy :(@a) are [almost] always Array's.

---

The one-arg rule slurpy is the oddest one of the bunch so here is some
brief information:

The one-arg rule slurpy can be sigiless :(+a), in which case it will
be a List instead of an Array or an alias to the single argument
depending on what it was.

sub one-arg-rule ( +args ){
say args.^name, " # ", args.perl;
}

one-arg-rule(  (1,),2,3  ); # List # ((1,), 2, 3)
one-arg-rule( ((1,),2,3) ); # List # ((1,), 2, 3) # one-arg rule
one-arg-rule( ((1,),2,3).Seq ); # Seq # ((1,), 2, 3).Seq # one-arg rule
one-arg-rule(  1..3   ); # List # (1, 2, 3)
one-arg-rule( (1..3,) ); # List # (1..3,)

sub one-arg-Array ( +@args ){
say @args.^name, " # ", @args.perl;
}

one-arg-Array(  (1,),2,3  ); # Array # [(1,), 2, 3]
one-arg-Array( ((1,),2,3) ); # Array # [(1,), 2, 3]
one-arg-Array( ((1,),2,3).Seq ); # List # ((1,), 2, 3)
one-arg-Array(  1..3   ); # Array # [1, 2, 3]
one-arg-Array( (1..3,) ); # Array # [1..3,]

The one-arg rule exists because people tend to write the following:

my @a = [1,2,3];

When the correct way to write it is:

my @a = 1,2,3;

There are various other places where the one-arg rule is also used, so
it was made available to everyone.

---

Don't get too flustered if you don't understand all of the nuances, it
take everybody a while to understand them.

On Wed, Jan 2, 2019 at 8:41 PM ToddAndMargo via perl6-users
 wrote:
>
> Hi All,
>
> Looking at
>
> https://docs.perl6.org/routine/print
>
> I see
>
> multi sub print(**@args --> True)
>
> Question.  If I wanted to create my own print routine
> using **@args, how would I declare it?
>
> sub printx( **@args data ) {...}
>
>
> Many thanks,
> -T
>
>
> --
> ~~
> When you say, "I wrote a program that
> crashed Windows," people just stare at
> you blankly and say, "Hey, I got those
> with the system, for free."
>   -- Linus Torvalds
> ~~