Modified:
doc/trunk/design/syn/S03.pod
Log:
tweaks to crossop syntax
Modified: doc/trunk/design/syn/S03.pod
==============================================================================
 doc/trunk/design/syn/S03.pod (original)
+++ doc/trunk/design/syn/S03.pod Tue Sep 12 21:09:33 2006
@@ 1031,14 +1031,22 @@
=head1 Cross operators
The final metaoperator is the C<X> metaoperator. It applies the
+The final metaoperator is the cross metaoperator. It is formed syntactically
+by placing an infix operator between two C<X> characters. It applies the
modified operator across all permutations of its list arguments. All
C<X> operators are of list infix precedence, and are list associative.
+cross operators are of list infix precedence, and are list associative.
The bare form of C<X> is considered an operator in its own right.
Saying:
+The string concatenating form is:
+
+ <a b> X~X <1 2> # 'a1', 'a2', 'b1', 'b2'
+
+The C<X~X> operator desugars to something like:
+
+ [~]«( <a b> X <1 2> ) # 'a1', 'a2', 'b1', 'b2'
 <a b> X 1,2 X <x y>
+The list concatenating form
+
+ <a b> X,X 1,2 X,X <x y>
produces
@@ 1051,33 +1059,25 @@
['b', 2, 'x'],
['b', 2, 'y']
The string concatenating form is:

 <a b> X~ <1 2> # 'a1', 'a2', 'b1', 'b2'

As a metaoperator, C<X~> operator desugars to something like:

 [~]«( <a b> X <1 2> ) # 'a1', 'a2', 'b1', 'b2'
+The string and list forms are common enough to have shortcuts, C<X>
+and C<XX> respectively. See below.
Any existing, nonmutating infix operator may be used after the C<X>.
+For the general form, any existing, nonmutating infix operator
+may be used.
 1,2 X* 3,4 # 3,4,6,8
+ 1,2 X*X 3,4 # 3,4,6,8
(Note that C<< <== >> and C<< ==> >> are considered mutating, as well as
all assignment operators.)
If the underlying operator is nonassociating, so is the metaoperator:
 @a Xcmp @b Xcmp @c # ILLEGAL
 @a Xeq @b Xeq @c # ok
+ @a XcmpX @b XcmpX @c # ILLEGAL
+ @a XeqX @b XeqX @c # ok
In fact, though the C<X> operators are all list associative
syntactically, the underlying operator is always applied with its
own associativity.

Unlike bare C<X>, the C<X,> form flattens much like C<[,]> does.

 <a b> X, <1 2> # 'a', '1', 'a', '2', 'b', '1', 'b', '2'
+own associativity, just as the corresponding reduce operator would do.
Note that only the first term of an C<X> operator may reasonably be
an infinite list.
@@ 1460,16 +1460,24 @@
=head1 Crossing arrays
In contrast to the zip operator, the C<X> operator returns all the
+In contrast to the zip operator, the C<XX> operator returns all the
permutations of its sublists. Hence you may say:
 <a b> X <1 2>
+ <a b> XX <1 2>
and you end up with
['a', '1'], ['a', '2'], ['b', '1'], ['b', '2']
It is really a variant of the C<X> metaoperator mentioned earlier.
+The C<X> variant crosses the arrays but concatenates strings:
+
+ <a b> X <1 2>
+
+produces
+
+ 'a1', 'a2', 'b1', 'b2'
+
+The resemblance to C<x> and C<xx> is not entirely accidental.
=head1 Minimal whitespace DWIMmery
@@ 1551,7 +1559,7 @@
!!! ... ???
[+] [*] [<] [,] [\+] [\*] etc.
(also = as list assignment)
 list infix ¥ <== ==> X X~ X* Xeqv etc.
+ list infix ¥ <== ==> X XX X~X X*X XeqvX etc.
loose and and
loose or or xor err
expr terminator ; {} as control block, statement modifiers
...and later...
> +The C<X> variant crosses the arrays but concatenates strings:
> +
> + <a b> X <1 2>
> +
> +produces
> +
> + 'a1', 'a2', 'b1', 'b2'
If the C<X> variant already concatenates strings, why is it done
explicitly in the desugaring of C<X~X>? Probably not what you
intended.
Kindly,
// masak
Yes, I suspected so too, though I wasn't sure so I didn't write it. :)
Even better, it could be changed into C<X,X>, unnecessitating another
desugaring (mental or parseal).
// Carl