Re: real ranges

```HaloO,

Luke Palmer wrote:
```
```In fact, it might even bug me more.  I'm a proponent of the idea that
one name (in a particular scope) is one concept.  We don't overload +
to mean "concatenation", we don't overload << to mean "output", and we
don't overload > to mean "outside".
```
```
I agree. And have converted inside to be implemented by ~~ as
hinted by Juerd. But even with the previous idea 1..10 < -5
would have been false I guess:

1..10 < -5 === 1 < -5 < 10
=== 1 < -5 && -5 < 10 === false

Actually +(10..1) == -9 because the measure is always .max - .min
even if .max < .min! But the Range role might be applicable where
the strict ordering < and > don't. E.g. in the complex plane ranges
form rectangles or ring segments depending on the parametrisation
choosen. In the ifinitesimal (point)limit both coincide, of course!

```
```Supposing you fixed those operators, I really think that this is a job
for a module.  All the syntax and semantics you propose can be easily
```
implemented by a module, except for the basic definition of "..".
```
Which was the actual reason to post the idea in the first place.
Note that the proposed ,, and ;; nicely complement the other
list constructors. The infinite lazy list might actually be
written  with pre- or postfix ,,, without running into the same
problem as ... which in my conception of .. as numeric nicely denotes
a Code that doesn't actually iterate a Num. Also the ^..^ forms
are much less important since we've got the unary ^ now. Character
doubling and trippling is actually a theme in Perl6 operator design.

Just compare @a[[;]0,1,2] to @a[0;;2] visually. Not to mention
the---at least to my eye---very strange @; slice vars. BTW, is @foo
automagically related to @;foo? S02 is actually very close to
@foo[1;;5] with its @foo[1;*;5] form. The fact that the [;] reduce
form as slice actually means [<==] makes things not easier.

Here is an idea to replace @;x just with a code var:

my &x;
&x <==  %hash.keys.grep: {/^X/};
&x <== =<>;
&x <== 1,,,;  # note the ,,,
&x <== gather { loop { take rand 100 } };

%hash{x} # nice usage of closure index

which to me looks much nicer and increases the importance of
the & sigil and code types! At the first invocation of <== the
Pipe is autovivified in &x and the second invocation adds to the
outer dimension of the List of Pipe. Note that I think that in

x <== 1,,4;

operator <== sees a :(Call of x) type as lhs. What semantic
that might have I don't now. But if that's not an error then perhaps
the former content is lost, an empty code ref is autovivified into &x
and given to <== as lhs. YMMV, though ;)

Actually evaluating a Pipe stored in a & var might just result
in unboxing the Pipe without changing the former content.

&x <== 1,,4;

&x <== x <== x <== x; # &x now is Pipe (1,,4;1,,4;1,,4)

Also I realized that the zip, each, roundrobin and cat functions
mentioned in S03 are somewhat redundant with proper typing.
What diffentiates

cat(@x;@y)

from

(@x,@y)  #?

Or

for zip(@names; @codes) -> [\$name, \$zip] {...}

from

for (@names; @codes) -> [\$name, \$zip] {...} #?

And why is

for each(@names; @codes) -> \$name, \$zip {...}

not just

for (@names; @codes) -> \$name, \$zip {...}  #?

Apart from beeing good documentation, of course.

Yet another thing I didn't mention so far is that I see , and ;
as corresponding to ~ for strings. So parts of the conclomerat of
roles for Num and List is replicated with a different syntactical
wrapper for Str. And user defined classes can hook into this at will

At a lower level all this is unified syntactically! But how much
the syntax there resembles the humanized forms of Perl6, I can only
guess. On the engine level the only thing that remains is MMD and
error handling.

```
```Maybe you could make it your first Perl 6 module?
```
```
Uhh, let's see what I can do about that. Unfortunately
I'm lazy there... *\$TSa :)
--
```