Author: lwall Date: 2010-02-01 21:33:47 +0100 (Mon, 01 Feb 2010) New Revision: 29605
Modified: docs/Perl6/Spec/S02-bits.pod docs/Perl6/Spec/S03-operators.pod docs/Perl6/Spec/S04-control.pod Log: [S02,S03,S04] more @@ removal; some s/Capture/Parcel/ cleanup Modified: docs/Perl6/Spec/S02-bits.pod =================================================================== --- docs/Perl6/Spec/S02-bits.pod 2010-02-01 20:14:16 UTC (rev 29604) +++ docs/Perl6/Spec/S02-bits.pod 2010-02-01 20:33:47 UTC (rev 29605) @@ -1600,7 +1600,6 @@ % unordered hash (associative array) & code/rule/token/regex :: package/module/class/role/subset/enum/type/grammar - @@ slice view of @ Within a declaration, the C<&> sigil also declares the visibility of the subroutine name without the sigil within the scope of the declaration: @@ -2124,7 +2123,7 @@ operators: print $( foo() ) # foo called in item context - print @@( foo() ) # foo called in slice context + print %( foo() ) # foo called in hash context In declarative constructs bare sigils may be used as placeholders for anonymous variables: Modified: docs/Perl6/Spec/S03-operators.pod =================================================================== --- docs/Perl6/Spec/S03-operators.pod 2010-02-01 20:14:16 UTC (rev 29604) +++ docs/Perl6/Spec/S03-operators.pod 2010-02-01 20:33:47 UTC (rev 29605) @@ -15,8 +15,8 @@ Created: 8 Mar 2004 - Last Modified: 30 Jan 2010 - Version: 188 + Last Modified: 1 Feb 2010 + Version: 189 =head1 Overview @@ -205,7 +205,6 @@ %z $^a $?FILE - @@slice &func &div:(Int, Int --> Int) @@ -217,7 +216,6 @@ @() %() &() - @@() =item * @@ -919,11 +917,10 @@ @list xx $count Evaluates the left argument in list context, replicates the resulting -C<Capture> value the number of times specified by the right argument and -returns the result in a context dependent fashion. If the operator -is being evaluated in ordinary list context, the operator returns a -flattened list. In slice (C<@@>) context, the operator converts each C<Capture> -to a separate sublist and returns the list of those sublists. +C<Parcel> value the number of times specified by the right argument +and returns the result as a list of C<Parcels> (which will behave +differently depending on whether it's bound into a flat context or +a slice context). If the count is less than 1, returns the empty list, C<()>. If the count is C<*>, returns an infinite list (lazily, since lists @@ -1703,11 +1700,11 @@ ('a', '1'), ('a', '2'), ('b', '1'), ('b', '2') -This becomes a flat list in C<@> context and a list of arrays in C<@@> context: +This becomes a flat list in flat context and a list of arrays in slice context: - say @(<a b> X <1 2>) + say flat(<a b> X <1 2>) 'a', '1', 'a', '2', 'b', '1', 'b', '2' - say @@(<a b> X <1 2>) + say slice(<a b> X <1 2>) ['a', '1'], ['a', '2'], ['b', '1'], ['b', '2'] The operator is list associative, so @@ -2358,7 +2355,7 @@ The forms with the double angle append rather than clobber the sink's todo list. The C<<< ==>> >>> form always looks ahead for an appropriate target to append to, either the final sink in the chain, or the next -filter stage with an explicit C<@(*)> or C<@@(*)> target. This means +filter stage with an explicit C<@(*)> or C<@(**)> target. This means you can stack multiple feeds onto one filter command: source1() ==>> @@ -4655,7 +4652,7 @@ turn into subarrays, and each element would then have to be unpacked by the signature: - for @@(zip(@names; @codes)) -> [$name, $zip] { + for slice(zip(@names; @codes)) -> [$name, $zip] { print "Name: $name; Zip code: $zip\n"; } Modified: docs/Perl6/Spec/S04-control.pod =================================================================== --- docs/Perl6/Spec/S04-control.pod 2010-02-01 20:14:16 UTC (rev 29604) +++ docs/Perl6/Spec/S04-control.pod 2010-02-01 20:33:47 UTC (rev 29605) @@ -352,9 +352,9 @@ iteration. Iterations that return a null list (such as by calling C<next> with no extra return arguments) interpolate no values in the resulting list. (This list is actually a two-dimensional list of -C<Capture>s (a "slice") with dimensional boundaries at each iteration. +C<Parcel>s (a "slice") with dimensional boundaries at each iteration. Normal list context ignores these boundaries and flattens the list. -Slice context turns the captures into subarrays, so an iteration +Slice context turns the parcels into sublists, so an iteration returning a null list does show up as a null subarray when viewed as a slice.) @@ -688,16 +688,18 @@ the statement or block in sink (void) context; its return value is instead specified by calling the C<take> list prefix operator one or more times within the dynamic scope of the C<gather>. The C<take> function's -signature is like that of C<return>; it merely captures the C<Capture> +signature is like that of C<return>; it merely wraps up a C<Parcel> of its arguments without imposing any additional constraints (in the absence of context propagation by the optimizer). The value returned -by the C<take> to its own context is that same C<Capture> object (which +by the C<take> to its own context is that same C<Parcel> object (which is ignored when the C<take> is in sink context). Regardless of the -C<take>'s context, the C<Capture> object is also added to the list of +C<take>'s context, the C<Parcel> object is also added to the list of values being gathered, which is returned by the C<gather> in the form -of a lazy slice, with each slice element corresponding to one C<take> -capture. (A list of C<Capture>s is lazily flattened in normal list context, -but you may "unflatten" it again with a C<@@()> contextualizer.) +of a lazy list of C<Parcel>s, with each element corresponding to one C<take> +parcel. (A C<Parcel>s is normally flattened when bound into slurpy context, +but when bound into a slice context, the C<Parcel> objects become real +sublists. The eventual binding context thus determines whether to +throw away or keep the groupings resulting from each individual C<take> call.) Because C<gather> evaluates its block or statement in sink context, this typically causes the C<take> function to be evaluated in sink @@ -714,15 +716,15 @@ The C<take> function essentially has two contexts simultaneously, the context in which the C<gather> is operating, and the context in which the C<take> is operating. These need not be identical contexts, since they -may bind or coerce the resulting captures differently: +may bind or coerce the resulting parcels differently: my @y; - @x = gather for 1..2 { # @() context for list of captures - my $x = take $_, $_ * 10; # $() context for individual capture + @x = gather for 1..2 { # flat context for list of parcels + my $x = take $_, $_ * 10; # item context for individual parcel push @y, $x; } # @x contains 4 Ints: 1,10,2,20 - # @y contains 2 Captures: (1,10),(2,20) + # @y contains 2 Parcels: (1,10),(2,20) Likewise, we can just remember the gather's result by binding and later coerce it: @@ -730,9 +732,9 @@ $c := gather for 1..2 { take $_, $_ * 10; } - # @$c produces 1,10,2,20 -- flatten fully into a list of Ints. - # @@$c produces (1,10),(2,20) -- list of Captures, a 2-D list. - # $$c produces ((1,10),(2,20)) -- the saved Capture itself as one item in item context. + # $c.flat produces 1,10,2,20 -- flatten fully into a list of Ints. + # $c.slice produces (1,10),(2,20) -- list of Parcels, a 2-D list. + # $c.item produces ((1,10),(2,20)) -- the saved Parcel itself as one item in item context. Note that the C<take> itself is in sink context in this example because the C<for> loop is in sink context.