Author: lwall
Date: 2010-03-15 18:39:10 +0100 (Mon, 15 Mar 2010)
New Revision: 30092
Modified:
docs/Perl6/Spec/S03-operators.pod
Log:
[S03] add Z to go with X metaop
note that X and Z desugar to higher-order methods, crosswith and zipwith
speculate about how to zip/cross dwimmily with non-identical ops
possibly creating a real use case for surreal precedence :)
Modified: docs/Perl6/Spec/S03-operators.pod
===================================================================
--- docs/Perl6/Spec/S03-operators.pod 2010-03-15 17:02:04 UTC (rev 30091)
+++ docs/Perl6/Spec/S03-operators.pod 2010-03-15 17:39:10 UTC (rev 30092)
@@ -15,8 +15,8 @@
Created: 8 Mar 2004
- Last Modified: 2 Mar 2010
- Version: 196
+ Last Modified: 15 Mar 2010
+ Version: 197
=head1 Overview
@@ -1732,6 +1732,9 @@
1,2 Z 3,4 # (1,3),(2,4)
+The C<Z> operator is actually a degenerate case of the C<Z> zipwith
+metaoperator (see L<Zip operators> below).
+
=item *
C<< infix:<minmax> >>, the minmax operator
@@ -3841,14 +3844,16 @@
operators yourself. Similarly, the carets that exclude the endpoints
on ranges are there by convention only.
-In contrast to that, Perl 6 has seven standard metaoperators for
+In contrast to that, Perl 6 has eight standard metaoperators for
turning a given existing operator into a related operator that is
more powerful (or at least differently powerful). These differ from a
mere naming convention in that Perl automatically generates these new
operators from user-defined operators as well as from builtins.
In fact, you're not generally supposed to define the individual
metaoperations--their semantics are supposed to be self-evident by
-the transformation of the base operator.
+the transformation of the base operator. In other words, these
+metaoperators are really just shorthand for higher-order functions
+(functions that take other functions as arguments).
Constructs containing metaoperators are considered "metatokens",
by which we mean that they are not subject to ordinary longest-token
@@ -4396,19 +4401,33 @@
=head2 Cross operators
The cross metaoperator, C<X>, may be followed by any infix operator.
-It applies the
-modified operator across all groupings of its list arguments as returned
-by the ordinary C<< infix:<X> >> operator. All
-generated cross operators are of list infix precedence, and are list
associative.
+It applies the modified operator across all groupings of its list
+arguments as returned by the ordinary C<< infix:<X> >> operator.
+All generated cross operators are of list infix precedence, and are
+list associative.
The string concatenating form is:
- <a b> X~ <1 2> # 'a1', 'a2', 'b1', 'b2'
+ <a b> X~ 1,2 # 'a1', 'a2', 'b1', 'b2'
-The C<X~> operator desugars to something like:
+The C<X~> operator desugars to:
- [~]«( <a b> X, <1 2> ) # 'a1', 'a2', 'b1', 'b2'
+ (<a b>; 1,2).crosswith(&[~])
+which in turn means
+
+ (<a b>; 1,2).cross.slice.map { .reduce(&[~]) }
+
+And
+
+ <a b> X~ 1,2 X+ 3,4
+
+might mean
+
+ (<a b>; 1,2; 3,4).cross.slice.map { .reduce(&[~],&[+]) }
+
+(But see below.)
+
The list concatenating form, C<X,>, when used like this:
<a b> X, 1,2 X, <x y>
@@ -4424,7 +4443,8 @@
('b', 2, 'x'),
('b', 2, 'y')
-The list form is common enough to have a shortcut, the ordinary infix
+The C<X,> operator is perhaps more clearly written as C<X[,]>. However,
+this list form is common enough to have a shortcut, the ordinary infix
C<X> operator described earlier.
For the general form, any existing, non-mutating infix operator
@@ -4447,8 +4467,85 @@
Note that only the first term of an C<X> operator may reasonably be
an infinite list.
-Multidimensional lists should be handled properly.
+All lists are assumed to be flat; multidimensional lists are
+handled by treating the first dimension as the only dimension.
+=head2 Zip operators
+
+The zip metaoperator, C<Z>, may be followed by any infix operator.
+It applies the modified operator across all groupings of its list
+arguments as returned by the ordinary C<< infix:<Z> >> operator.
+All generated zip operators are of list infix precedence, and are
+list associative.
+
+The string concatenating form is:
+
+ <a b> Z~ 1,2 # 'a1', 'b2'
+
+The C<Z~> operator desugars to:
+
+ (<a b>; 1,2).zipwith(&[~])
+
+which in turn means
+
+ (<a b>; 1,2).zip.slice.map { .reduce(&[~]) }
+
+And
+
+ <a b> Z~ 1,2 Z+ 3,4 # 'a4', 'b6'
+
+would mean
+
+ (<a b>; 1,2; 3,4).zip.slice.map { .reduce(&[~],&[+]) }
+
+implying that multi-function reduce knows how to compare the precedence
+of its operator arguments somehow. That seems unreasonable. The clean
+way to solve this might involve giving C<X> and C<Z> metaoperators a
+subprecedence within listop precedence corresponding to the original
+operator's precedence, so that C<Z~> and C<Z+> actually have different
+precedences within listop precedence. Then the above would parse as if
+you'd said C<< <a b> Z~ ( 1,2 Z+ 3,4> ) >>, but the lists would still
+parse at list infix precedence, with comma tighter than the zips.
+(This would actually be fairly trivial to implement, given how we
+represent our precedence as strings.) Also, though it's complicated to
+explain, subprecedence within C<Z> might be exactly what the naive user
expects.
+
+The list concatenating form, C<Z,>, when used like this:
+
+ <a b> Z, 1,2 Z, <x y>
+
+produces
+
+ ('a', 1, 'x'),
+ ('b', 2, 'y')
+
+The C<Z,> operator is perhaps more clearly written as C<Z[,]>. However,
+this list form is common enough to have a shortcut, the ordinary infix
+C<Z> operator described earlier.
+
+For the general form, any existing, non-mutating infix operator
+may be used.
+
+ 1,2 Z* 3,4 # 3,8
+
+(Note that C<< <== >> and C<< ==> >> are considered mutating, as well as
+all assignment operators.)
+
+If the underlying operator is non-associating, so is the cross operator:
+
+ @a Zcmp @b Zcmp @c # ILLEGAL
+ @a Zeq @b Zeq @c # ok
+
+In fact, though the C<Z> operators are all list associative
+syntactically, the underlying operator is always applied with its
+own associativity, just as the corresponding reduce operator would do.
+
+Note that, unlike the C<X> operator, all the terms of a C<Z> operator
+may reasonable be infinite lists, since zipping is lazy.
+
+All lists are assumed to be flat; multidimensional lists are
+handled by treating the first dimension as the only dimension.
+
=head2 Sequential operators
The sequence metaoperator, C<S>, may be followed by any non-fiddly infix
operator.
