Mostly get rid of Parcel

Author: moritz

lib/Language/5to6-perlop.pod

@@ -199,7 +199,7 @@ specifically documented.
 =head2 Comma Operator
 
 The comma operator works mostly as expected, but technically it creates
-Parcels (see L<http://doc.perl6.org/type/Parcel>) or separates arguments
+L<Lists|/type/List>) or separates arguments
 in function calls. Also, there is a C<:> variant that turns function
 calls into method calls - see
 L<http://doc.perl6.org/language/operators#infix_%3A>.

lib/Language/containers.pod

@@ -113,39 +113,40 @@ signature parameter marked as C<is rw>.
 =head2 Scalar containers and listy things
 
 There are a number of positional container types with slightly different
-semantics in Perl 6. The most basic one is I<Parcel>, short for
-I<Parenthesis cell>. It is created by the comma operator and often delimited
-by round parentheses -- hence the name.
+semantics in Perl 6. The most basic one is L<List|/type/List>
+It is created by the comma operator.
 
-    say (1, 2, 3).WHAT;     # (Parcel)
+    say (1, 2, 3).WHAT;     # (List)
 
-A parcel is immutable, which means you cannot change the number of elements
-in a parcel. But if one of the elements happens to be a scalar container,
+A list is immutable, which means you cannot change the number of elements
+in a list. But if one of the elements happens to be a scalar container,
 you can still assign to it:
 
     my $x = 42;
     ($x, 1, 2)[0] = 23;
     say $x;                 # 23
     ($x, 1, 2)[1] = 23;     # Error: Cannot modify an immutable value
 
-So the parcel doesn't care about whether its elements are values or
+So the list doesn't care about whether its elements are values or
 containers, they just store and retrieve whatever was given to them.
 
-A C<List> has the same attitude of indifference towards containers. But it
-allows modifying the length (for example with C<push>, C<pop>, C<shift> and
-C<unshift>), and it is also lazy.
+Lists can also be lazy, so elements at the end are generated on demand from an
+iterator.
 
 An C<Array> is just like a list, except that it forces all its elements to
-be containers. Thus you can say
+be containers, which means that you can always assign to elements:
 
     my @a = 1, 2, 3;
     @a[0] = 42;
     say @a;         # 42 2 3
 
-and C<@a> actually stores three scalar containers. C<@a[0]> returns one of
+C<@a> actually stores three scalar containers. C<@a[0]> returns one of
 them, and the assignment operator replaces the integer value stored in that
 container with the new one, C<42>.
 
+An L<Array> also has methods that can change the number of elements, notably
+C<push>, C<pop>, C<shift>, C<unshift> and C<splice>.
+
 =head2 Assigning and binding to array variables
 
 Assigning to a scalar variable and to an array variable both do basically
@@ -162,7 +163,7 @@ makes no such effort.
 To place a non-C<Array> into an array variable, binding works:
 
     my @a := (1, 2, 3);
-    say @a.WHAT;                # (Parcel)
+    say @a.WHAT;                # (List)
 
 =head2 Binding to array elements
 
@@ -241,7 +242,7 @@ container:
       @b = @($item), 4, 5;      # a shortcut
       @b = @$item, 4, 5;        # another shortcut
 
-Other methods on lists also return flat lists/parcels, so for example
+Other methods on lists also return flat lists, so for example
 
    my $item = [1, 2, 3];
    my @b = $item.sort, 4, 5;    # 5 elems
@@ -327,7 +328,7 @@ And a few that don't flatten:
 =item .tree
 
 The first two cannot flatten, otherwise it would be very hard to get access
-to the structure that's actually stored in the list or parcel and the whole
+to the structure that's actually stored in the list and the whole
 point of C<.tree> is not to flatten.
 
 =end pod

lib/Language/objects.pod

@@ -319,7 +319,7 @@ order|https://en.wikipedia.org/wiki/C3_linearization>.  You can ask a type
 for its MRO through a call to its meta class:
 
 =for code :allow<B L>
-say ParcelB<.^L<mro>>;    # Parcel() Cool() Any() Mu()
+say List<.^L<mro>>;      # List() Cool() Any() Mu()
 
 If a class does not specify a parent class, L<Any> is assumed by default.
 All classes directly or indirectly derive from L<Mu>, the root of the type

lib/Language/operators.pod

@@ -112,19 +112,17 @@ L</language/functions#Defining_Operators>.
 =head2 circumfix C«< >»
 
 The quote-words construct. Breaks up the contents on whitespace, and returns
-a C<Parcel> of the words. If a word
+a L<List|/type/List> of the words. If a word
 looks like a number literal or a C<Pair> literal, it is converted to the
 appropriate number.
 
     say <a b c>[1];     # b
 
-(Rakudo currently always returns a parcel of strings).
-
 =head2 circumfix C«( )»
 
 The grouping operator.
 
-An empty group C<()> creates an empty L<Parcel>.
+An empty group C<()> creates an empty L<List>.
 Parens around non-empty expressions simply structure the expression, but
 not have additional semantics.
 
@@ -271,15 +269,15 @@ Technically this is not an operator, but syntax special-cased in the compiler.
 =head2 postfix C«.+»
 
 C<$invocant.+method> calls all methods called C<method> from C<$invocant>,
-and returns a L<Parcel> of the results. Dies if no such method was found.
+and returns a L<List> of the results. Dies if no such method was found.
 
 Technically this is not an operator, but syntax special-cased in the compiler.
 
 =head2 postfix C«.*»
 
 C<$invocant.*method> calls all methods called C<method> from C<$invocant>,
-and returns a L<Parcel> of the results. If no such method was found, an empty
-L<Parcel> is returned.
+and returns a L<List> of the results. If no such method was found, an empty
+L<List> is returned.
 
 Technically this is not an operator, but syntax special-cased in the compiler.
 
@@ -470,12 +468,11 @@ Coerces the argument to L<Str> by calling the C<Str> method on it.
 
 =head2 prefix C«|»
 
-Flattens objects of type L<Capture>, L<Enum>, L<Pair>, L<List>, L<Parcel>,
+Flattens objects of type L<Capture>, L<Enum>, L<Pair>, L<List>
 L<EnumMap> and L<Hash> into an argument list.
 
-(In Rakudo, this is implemented not as a proper operator but as a special
-case in the compiler, which means it only works in argument lists, not in
-arbitrary code).
+Outside of argument lists, it returns a L<Slip|/type/Slip>, which makes it
+flatten into the outer list.
 
 =head2 prefix C«+^»
 
@@ -1343,9 +1340,9 @@ and returns the result.
 
 =head2 infix C«,»
 
-    sub infix:<,>(*@a) is assoc<list> returns Parcel:D
+    sub infix:<,>(*@a) is assoc<list> returns List:D
 
-Constructs a L<Parcel> from its arguments. Also used syntactically as the
+Constructs a L<List> from its arguments. Also used syntactically as the
 separator of arguments in calls.
 
 =head2 infix C«:»
@@ -1373,7 +1370,7 @@ the first input list is exhausted:
     say (1, 2 Z <a b c> Z <+ ->).perl;  # ((1, "a", "+"), (2, "b", "-")).list
 
 The C<Z> operator also exists as a meta operator, in which case the inner
-parcels are replaced by the value from applying the meta'ed operator to the
+lists are replaced by the value from applying the meta'ed operator to the
 list:
 
     say 100, 200 Z+ 42, 23;             # 142, 223
@@ -1392,7 +1389,7 @@ elements vary most rapidly
                  (3, 'a', 9), (3, 'b', 9), (3, 'c', 9)
 
 The C<X> operator also exists as a meta operator, in which case the inner
-parcels are replaced by the value from applying the meta'ed operator to the
+lists are replaced by the value from applying the meta'ed operator to the
 list:
 
     1..3 X~ <a b c> X~ 9

lib/Language/setbagmix.pod

@@ -84,7 +84,7 @@ equivalent ASCII version (like L<C<(elem)>|(elem)> or L<C<(|)>|(|)>).
 Most of the time, explicitly using C<Set> objects with these infixes is
 unnecessary. All of the infix operators will work on any objects of type
 L<C<Any>|Any> for its arguments (e.g., L<C<List>s|List>,
-L<C<Parcel>s|Parcel>, L<C<Mix>es|Mix>, etc.) and coerce them to C<Set>s
+L<C<Array>s|Array>, L<C<Mix>es|Mix>, etc.) and coerce them to C<Set>s
 where needed.
 
 In some cases, if the type of an argument is a L<Bag>, the infix operator

lib/Language/subscripts.pod

@@ -218,10 +218,7 @@ So even a one-element list returns a slice, whereas a bare scalar value doesn't:
 
 (The angle-bracket form for associative subscripts works out because
 L<word quoting|/language/quoting#Word_quoting:_qw> conveniently returns a
-L<Str> in case of a single word, but a L<Parcel> in case of multiple words.)
-
-=comment TODO: Revisit the above paragraph after the GLR, when it will probably
-               be a List instead of a Parcel.
+L<Str> in case of a single word, but a L<List> in case of multiple words.)
 
 For a normal slice, the content of (L<the current dimension of|#Multiple
 dimensions>) the subscript is I<flattened> before its members are interpreted
@@ -263,12 +260,9 @@ returns the subscripted object itself. Since it is empty but returns
 everything, it is known as a "Zen slice".
 
 It is different both from passing a Whatever-star (which, like a normal slice,
-always returns a Parcel of elements no matter the type of the original object)
+always returns a List of elements no matter the type of the original object)
 and from passing an empty list (which returns an empty slice):
 
-=comment TODO: Revisit the above paragraph after the GLR, when it will probably
-               be a List instead of a Parcel.
-
     my %bag := ("orange" => 1, "apple" => 3).Bag;
     dd %bag<>;    #-> ("orange"=>1,"apple"=>3).Bag
     dd %bag{};    #-> ("orange"=>1,"apple"=>3).Bag

lib/Language/terms.pod

@@ -90,15 +90,15 @@ the C<:!identifier> form is C<Bool::False>.
 If used in an argument list, all of these forms count as named arguments,
 with the exception of C<< 'quoted string' => $value >>.
 
-=head2 Parcel
+=head2 List
 
     ()
     1, 2, 3
     <a b c>
     «a b c»
     qw/a b c/
 
-L<Parcel> literals are: the empty pair of parens C<()>, a comma-separated
+L<List> literals are: the empty pair of parens C<()>, a comma-separated
 list, or several quoting constructs.
 
 =head2 term *

lib/Language/variables.pod

@@ -63,7 +63,7 @@ seen in the current expression or declarator:
     say @bar.perl;          # [7, 9]<>
 
     (my $baz) = 11, 13;     # list assignment
-    say $baz.WHAT;          # Parcel
+    say $baz.WHAT;          # (List)
     say $baz.perl;          # (11, 13)
 
 Thus, the behavior of an assignment contained within a list assignment depends
@@ -90,7 +90,7 @@ expression determines the type of assignment:
     my ( @foo, $bar );
     @foo = ($bar) = 42, "str";       # list assignment: uses parens
     say @foo.perl;                   # [42, "str"]<> (an Array)
-    say $bar.perl;                   # $(42, "str")  (a Parcel)
+    say $bar.perl;                   # $(42, "str")  (a List)
 
 However, if the internal assignment is neither a declarator nor an
 expression, but is part of a larger expression, the context of the

lib/Type/Cool.pod

@@ -21,7 +21,7 @@ The following built-in types inherit from C<Cool>:
 L<Array> L<Backtrace> L<Bag> L<Baggy> L<Bool> L<Complex> L<Cool>
 L<Duration> L<Enumeration> L<EnumMap> L<FatRat> L<Hash> L<Instant>
 L<Int> L<KeyHash> L<KeySet> L<List>
-L<Nil> L<Num> L<Numeric> L<Parcel>
+L<Nil> L<Num> L<Numeric>
 L<Range> L<Real> L<Seq> L<Set> L<Stash> L<Str> L<Stringy>
 
 The following table summarizes the methods that C<Cool> provides, and

lib/Type/List.pod

@@ -17,7 +17,7 @@ Arrays to have every value of the list stored in a container.
 
 In Perl 6, assigning a C<List> to a scalar variable does not lose
 information. The difference is that iteration generally treats a
-list (or any other list-like object, like a C<Parcel> or an C<Array>)
+list (or any other list-like object, like a L<Seq> or an L<Array>)
 inside a scalar as a single element.
 
     my @a = 1, 2, 3;
@@ -130,7 +130,7 @@ C<map> inspects the arity of the code object, and tries to pass as many argument
 
 iterates the list two items at a time.
 
-Note that C<map> does not flatten embedded lists and parcels, so
+Note that C<map> does not flatten embedded lists and array, so
 
     ((1, 2), <a b>).map({ .join(',')})
 
@@ -143,7 +143,7 @@ passes C<(1, 2)> and C<< <a b> >> in turn to the block, leading to a total of tw
 Like C<map> iterates over the elements of the invocant list, feeding each
 element in turn to the code reference, and assembling the return values from these invocations in a result list.
 
-Unlike C<map> it flattens non-itemized lists and parcels, so
+Unlike C<map> it flattens non-itemized lists and arrays, so
 
     say ((1, 2), <a b>).flatmap(&uc).join('|');     # 1|2|A|B
 
@@ -559,17 +559,19 @@ assigning it:
 
 =head2 routine zip
 
-    sub zip(List:D:, List:D:, ...) returns List:D
+    sub zip(List:D:, List:D:, ...) returns Seq:D
 
 Zip two or more lists together by interleaving their elements.  If the lists
 have different lengths, then the lists are zipped to the length of the
 shortest list; elements of the longer list(s) are discarded.
 
 In order to support parallel iteration over multiple arrays, Perl 6
-has a C<zip> function that builds a list of C<Parcel> objects from the
+has a C<zip> function that builds a list of C<List> objects from the
 elements of two or more arrays.  In ordinary list context this behaves
 as a list of C<Captures> and automatically flattens.
 
+=comment TODO: GLR
+
     for zip(@names; @codes) -> $name, $zip {
         say "Name: $name;   Zip code: $zip";
     }
@@ -596,7 +598,7 @@ skip missing entries, use L<roundrobin|/type/List#sub_roundrobin> instead:
 
 =head2 sub roundrobin
 
-    multi roundrobin(List:D: --> Parcel)
+    multi roundrobin(List:D: --> Seq)
 
 C<roundrobin> is very similar to L<zip|/type/List#routine_zip>.  The
 difference is that C<roundrobin> will not stop on lists that run out of