On Thu, Jun 16, 2005 at 01:05:22PM -0700, Dave Whipp wrote:
: Larry Wall wrote:
: > You must
: >specify @foo[[;[EMAIL PROTECTED] or @foo[()] <== @bar to get the special
mark.
:
: I'm uncomfortable with the specific syntax of @a[()] because generated
: code might sometimes want to generate an empty list, and special-casing
: that sort of thing is always a pain (and fragile). An empty list of
: subscripts should return an empty slice.
If you don't actually pipe to it, a null list is exactly what it would be
interpreted as, so I don't think it's a very big problem. And outside
of generated code, () is always intentional. If there's a potential
problem, it's with expecting
@a ==>
foo().bar()
to feed bar() rather than foo(). So maybe that would have to be written
@a ==>
foo().bar(())
or
@a ==>
foo(()).bar()
Or maybe as you say we just need a special term, though I don't think ...
is it.
: What this mark is really trying to say is "The definition of the indices
: is coming from elsewhere". I'm wondering if these semtantics would make
: it appropriate to use the yada operator here:
:
: @foo[...] <== @bar;
That's cute, but I think that might be overloading the ... token a
bit too much, and it's also rather likely to be confused with the
postfix ... operator within subscripts. These would be too close,
visually speaking:
@foo[...]
@foo[0...]
I suppose a case could be made for
@[EMAIL PROTECTED]
or some such, since it's an inside out iterator. But () is prettier.
Alternately we could go with the unix pipe character:
@foo[|]
Or maybe a splat
@foo[*]
Or go with the parens with something in them to indicate the positive
absence of something.
@foo[(*)]
Anyone else want to have a go at this bikeshed?
Larry
