OK, back from hiatus. We paused a while over the holidays to allow A6
to come to a simmer... it's probably still not going to come off the
stove *too* soon, though, so I suggest we move on.
When we left off, we were talking about context vs. type on p6l. That
didn't really go anywhere, and won't until after A6, probably. So
let's skip it.
STATUS UPDATE:
(1) We have some good stuff on the simplest types of scalar values;
namely, numerics and strings.
(2) We don't have docs on the other scalar types (Ref, Code, etc.)
That's OK, we can fill them in later.
(3) I have some fluff on variables/types/values loosely adapted from
http://cog.cognitivity.com/perl6/val.html
(It needs some proofing and cleanup, and I need to make a tree
structure out of it, but I think we can make some of the initial dumb
"what's the word 'variable' mean" subsections using that text.)
After I fixup (3), I'll have a crude document put together that's the
tree-ified composite of everything we have so far, which I'll post.
CURRENT TASKS:
All of that is still only a small part of what is in, or was implied
by, A2. Assuming we can skip the rest of the scalar stuff, that leads
us to arrays and hashes. Here's a *very* crude outline of what needs
to be covered for arrays:
- The Array Type
[] declaring an Array
[] general case: C<my @v is Array of Blah>
[] simplified: C<my @v of Blah> or C<my @v returns Blah>
[] simplified: C<my Blah @v>
[] complex types
[] C<my @v is Array of Array of Hash of num>, etc.
[] Perl6 builtin Array types (just the one?)
[] subclassing Array
[] to store a specific type
[] ex: C<class IntArray is Array of Int>
[] to create an alternate implementation
(overview; see elsewhere for details)
[] arrays vs. references to arrays
[] C<my @v> vs. C<my $v>
[] an array returns a ref to itself in scalar context
[] declaring literal arrays
[] () vs. []
[] [1,2,3] means scalar(list(1,2,3))
(or is it scalar(array(1,2,3))?)
[] .. (range operator)
[] : (step operator)
[] lazy
[] ( 1 .. Inf )
[] accessing
[] by index []
[] @arr[-1] (negative indices)
[] slices
[] using indices
[] using ranges
[] using steps
[] *@arr to flatten
[] lazily
[] ( 1 .. Inf )
[] ($first,@rest) = ( 1 .. Inf ) (needs to work)
[] Using an array in other contexts
[] Using an array in scalar context
[] boolean
[] numeric
[] string
[] C<"blah @foo blah">
[] rule
[] Using an array in list/array context
[] the difference between lists and arrays
[] Using an array in hash context
Hashes should have a similar-but-larger outline. Am I missing anything?
If anyone wants to take this on, or just parts of it, let us know. If
anyone has any big questions we need resolution for, plz post here or
on perl6-language. I know I'll have a few.
MikeL
