Okay, before we go any further, I think it's important to note that
we're going to restrict ourselves to unidimensional slices for the
time being. Yes, I know, we probably need to deal with
multidimensional slices at some point (and I say probably since there
are quite a number of different ways to specify and iterate over
multidimensional slices--I don't think there'll be any one true way
for those, which makes me think perhaps slices aren't the way to go
there) but for now unidimensional slices are enough of an issue.

I can see the point of having each list element of a slice being an
iterator rather than a set of discreet start/end pairs. That'd be
handy in some cases, and avoid having the perl 6 compiler having to
construct iterators by hand rather with slices. (On the other hand,
I'm perfectly fine with that, too)

So, given that, should plain scalars act as iterators holding a
single value and implement the iterator protocol? That'd make slice
implementation easier, but there's that whole nasty complexity thing
there. (Though without it there's the issue of complexity
elsewhere--no real win here, just a matter of deciding where to lose
less)
--
                                Dan

--------------------------------------it's like this-------------------
Dan Sugalski                          even samurai
d...@sidhe.org                         have teddy bears and even
                                       teddy bears get drunk