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



 (@x,@y)  #?


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


   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
by means of role composition and operator overloading.

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 :)

Reply via email to