I "misread"
say 1, 1, * + * ...^ *>= 100;
thinking "shouldn't it be '<=' as you want the total to be less than 100?" but
$ raku -e 'say 1, 1, * + * ...^ *<= 100;'
===SORRY!=== Error while compiling -e
Whitespace required before <= operator
at -e:1
------> say 1, 1, * + * ...^ *<= 100;⏏<EOL>
expecting any of:
postfix
and
$ raku -e 'say 1, 1, * + * ...^ * <= 100;'
()
$ raku -e 'say 1, 1, * + * ...^ * >= 100;'
(1 1 2 3 5 8 13 21 34 55 89)
So, then it dawned on me that the '>=' is "binding" (right word?) to the "*"
marking the end of the sequence as "until I am ge 100". Though that doesn't
quite work,
$ raku -e 'say 1, 1, * + * ...^ * <= 100;'
()
Ah, I see, it does work. The end of the sequence is the first number less than
100, so 1 succeeds. I guess the sequence never gets started.
________________________________
From: yary <[email protected]>
Sent: Tuesday, August 24, 2021 8:39 PM
To: William Michels <[email protected]>
Cc: Marc Chantreux <[email protected]>; raku-users <[email protected]>
Subject: Re: [better solution] pairs of separators from a string
CAUTION - EXTERNAL:
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
<[email protected]<mailto:[email protected]>> 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
<[email protected]<mailto:[email protected]>> wrote:
hello everyone,
I made a mistake while replying to all of us so anwsers never reached
your boxes. I'll summerize in one answer:
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
CAUTION - EXTERNAL EMAIL: This email originated outside the Judiciary. Exercise
caution when opening attachments or clicking on links.
