Front page | perl.perl6.users | Postings from August 2021

## Re: [better solution] pairs of separators from a string

From:
yary
Date:
August 25, 2021 01:39
Subject:
Re: [better solution] pairs of separators from a string
Message ID:
CAG2CFAaRLK3hqN-YVGje-3NG3ztXyKOWY2tMHvaX3UnzgnZurA@mail.gmail.com
```Hi Bill,

When building a range that's an arithmetic or geometric progression, the
sequence operator is a little quicker to type. And thus also more likely to
be understood more quickly too.

> ('a' .. 'h')[(0..*-1).grep: * %% 2 ]
(a c e g)
> ('a' .. 'h')[ 0, 2 ... * ]
(a c e g)

> ('a' .. 'h')[(0..*-1).grep: * % 2 ]
(b d f h)
> ('a' .. 'h')[1, 3...*]
(b d f h)

# Geometric example- powers of 2
> ('a' .. 'z')[1, 2, 4...*]
(b c e i q)

There isn't a simple translation for the is-prime example that I can think
of, that is a good use for "grep"

Ranges also support arbitrary functions, the doc page shows a Fibonacci
number generator
https://docs.raku.org/language/operators#index-entry-sequence_operator
"This allows you to write

say 1, 1, * + * ...^ *>= 100;
# OUTPUT: «(1 1 2 3 5 8 13 21 34 55 89)␤»

to generate all Fibonacci numbers up to but excluding 100."

-y

On Tue, Aug 24, 2021 at 6:36 PM William Michels via perl6-users <
perl6-users@perl.org> wrote:

> Hi Marc,
>
> My understanding is that ranges are pretty cheap to construct, and in any
> case, the range @x[0..*-1] is just the index of all elements in @x. The
> .grep() approach may be most useful if you have a function (e.g. %, %%, and
> .is-prime shown below):
>
> > (0...9)
> (0 1 2 3 4 5 6 7 8 9)
> > (0...9)[0..*-1]
> (0 1 2 3 4 5 6 7 8 9)
> > (0...9)[(0..*-1).grep: * ]
> (0 1 2 3 4 5 6 7 8 9)
> > (0...9)[(0..*-1).grep: * %% 2 ]
> (0 2 4 6 8)
> > (0...9)[(0..*-1).grep: * % 2 ]
> (1 3 5 7 9)
> > (0...9)[(0..*-1).grep: *.is-prime ]
> (2 3 5 7)
> >
>
> You can find a related example in the docs (
> https://docs.raku.org/routine/grep#class_HyperSeq). Anyway, I'm sure each
> approach has its fans,
>
> Best, Bill.
>
> On Tue, Aug 24, 2021 at 3:59 AM Marc Chantreux <eiro@phear.org> wrote:
>
>> hello everyone,
>>
>> I made a mistake while replying to all of us so anwsers never reached
>>
>> Bill:
>>
>> > Is it just even/odd elements that you want to separate out? If so, maybe
>> > .grep() is your friend here
>>
>> I don't think it is: 0, 2 ... * seems to be
>>
>> * closer to what i have in mind when i think about the problem
>>   (so i invoke readability there)
>> * probably more efficient than (0..*).grep(* % 2) that
>>   * generate twice the number of required elements
>>   * need to filter the result
>>
>> Also, trying to play with this version:
>>
>> my (\$a,\$b) =
>>     .[0,2...*],
>>     .[1,3...*]
>>     with <AaBbCc>.comb;
>>
>> just don't work because the lists are squashed into scalar context
>> in the process.
>>
>> So Brian and Fernando made my day with := and the unexpected power of
>> the [] operator.
>>
>>     my (@a,@b) := <AaBbCc>.comb[ [0,2...*], [1,3...*] ];
>>
>> I really like how declarative it is. Also the use of := now seems
>> obvious to me.
>>
>> Sigils still remains something strange to me desprite all your examples
>> but i'll take some time. thanks everyone.
>>
>> marc
>>
>>

```