Why do these 2 for looping over sequences differ?

Question

First:

$ raku -e "for 1...6, 7...15 { .say }"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Now:

$ raku -e "for 1...3, 7...15 { .say }"
1
2
3
7
11
15

I would expect this case to print 1,2,3,7,8,... 15.

What's happening here?

Answer 1

I think you might want the raku Range operator .. (two dots) and not the raku Sequence operator ... (three dots).

Here's how you examples look with the Range operator instead:

> raku -e 'for 1..6, 7..15 { .say }'
1..6
7..15

Oh, that's not good ... looks like for is just iterating over the two things 1..6 and 7..15 and stringifying them.

We can use a Slip | to fix that:

> raku -e 'for |(1..6), |(7..15) { .say }'
1
2
... (all the numbers)
14
15

And then:

raku -e 'for |(1..3), |(7..15) { .say }'
1
2
3
7
8
9
10
11
12
13
14
15

With the Sequence operator, you have made something like:

>raku -e 'for 3,7...15 { .say }'
3
7
11
15

That is raku for "make a sequence that starts with 3, then 7, then all the values until you get to the last at 15" ... and since the gap from 3 to 7 is 4, raku will count up in steps of 4. Then you began it with 1..3. ;-)

~p6steve

Answer 2

TL;DR This answer focuses on addressing what you originally asked (which was about "sequences") and precisely what the code you wrote is doing, rather than providing a solution (using ranges instead).

This is a work in progress dealing with something that seems both poorly documented and hard to fathom (which may explain part though not all of the doc situation). Please bear with me! (And I may just end up deleting this answer.)

1 ... 3, 7 ... 15 ≡ 1 ... (3, 7) ... 15

In the absence of parentheses, operators within an expression are applied according to rules of "precedence" and "associativity".

Infix , has a higher precedence than infix ....¹ The above two lines of code thus produce the same result (1␤2␤3␤7␤11␤15␤):

for 1 ...  3, 7  ... 15 { .say }  # Operator evaluation by precedence
for 1 ... (3, 7) ... 15 { .say }  # Operator evaluation by parentheses

That said, while the result is what, given a glance at the code, I would expect based on my own "magical" DWIM ("Do What I Mean") thinking, I must say I don't yet know what the precise Raku(do)'s rule(s) are that lead to it DWIMing.

The doc for infix ... says:

If the endpoint is not *, it's smartmatched against each generated element and the sequence is terminated when the smartmatch succeeded.

But that seems overly simple. What if the endpoint of one sequence is another sequence? (As, at least taking a naive view, appears to be the case in your code.)

Also, as @MustafaAydin has noted:

how does your post explain the irregular last step size (of 2) instead of 3? I mean 4, 7 ... 15 alone produces (4, 7, 10, 13). But 1... 4, 7...15 now produces 7, 10, 13, 15 in the tail. Why is 15 included? Maybe i'm missing something idk

I'm at least as confused as Mustafa.

Indeed, I'm confused about several things. How come Raku(do) flattens the two sequences? [D'oh. Because the infix comma is higher precedence than the infix ....] Why doesn't it repeat the 3 in the final combined list? [Perhaps because multiple infix ...s are smart about what to do when there's an expression that's the endpoint of one sequence and the start of another?]

I'm going to go read the old design docs and/or spelunk roast and/or the Rakudo compiler code to see if I can see what's supposedly/actually going on. But not tonight.

Footnotes

¹ There's a table of operators in the current official operator doc. Supposedly this table:

summarizes the precedence levels offered by Raku, listing them in order from high to low precedence.

Unfortunately, at the time of writing this, the central operator table in the Operators page is profoundly wrong #4071.

Until that's fixed, here are "official" and "unofficial" options for determining the precedence of operators:

• "official" Use in page search to search the official doc operator page for the operator of interest. Skip to the match in the entries on the left hand side of that same page. As you'll see, infix ,' is one level higher precedence than infix ...`:

  Comma operator precedence

  • infix ,

  • infix :

  List infix precedence

  • infix Z

  • infix X

  • infix ...

• "unofficial" Look at the corresponding page of a staging site for an improved doc site. (I don't know how up to date it is, but the central table appears to list operators by precedence order as it claims.)

Answer 3

It's because it is two deductive sequences.

1...3

Is obviously a sequence where you add 1 to each successive value.

1, 2, 3

And since 7 is 4 more than 3, this is a sequence where you add 4 to each successive value.

3, 7 ... 15

3, 7, 11, 15

---

To get what you want, you could use a flattened Range.

1...3, |(7..15)

Or even a flattened Sequence.

1...3, |(7...15)