The discussion about x/xx made me wonder. We have this table:
string list
x xx
~ ,
And we also have this table:
string number
~ +
-
x *
eq ==
But there is overlap between the two tables:
string number list
x * xx
~ + ,
Let's add the other operators:
string number list
x * xx
~ + ,
-
eq ==
The list form of eq/== is known in eq and ==, but these don't
work well when the types are not balanced.
And the string form of minus is currently spelled s/foo//. There is, as
far as I know, no listy minus.
I suggest we add operators to fill this the void and add to TIMTOWTDI.
Because the ASCIIbet is exhausted, I'll use existing numeric operators
enclosed in square brackets.
string number list
x * xx
~ + , [+]
- [-]
eq == [~~]
I chose chosen smart match instead of equality here, because of the
balancedness thing. [~~] is like the rather verbose all(... ~~ ...):
if (all(@foo ~~ @bar) { ... }
if (@foo [~~] @bar) { ... }
The difference between , and [+] is precedence:
my @foo = (@bar, @baz);
my @foo = @bar [+] @baz;
This buys us a nice alternative for push too. It's like the much
discussed ,= but communicating the same thing better:
push @foo, @bar;
@foo [+]= @bar;
This is still rather boring. It gets more interesting when we add minus:
splice @foo, $_, 1 given first { @foo[$_] ~~ 15 }, [EMAIL PROTECTED];
@foo [-] 15; # whoa!
Note that grep solves a different problem: it would remove all
occurrences of 15, instead of only the first encountered. And, this can
remove multiple elements at once:
splice @foo, $_, 1 given first { @foo[$_] ~~ 15 }, [EMAIL PROTECTED];
splice @foo, $_, 1 given first { @foo[$_] ~~ 15 }, [EMAIL PROTECTED];
splice @foo, $_, 1 given first { @foo[$_] ~~ 42 }, [EMAIL PROTECTED];
@foo [-] (15, 15, 42);
If we allow all() to be a special case on the RHS, we get a synonym for
grep too, now communicating what we want gone instead of what we want to
be left with:
@foo .= grep :{ not /\W/ };
@foo [-]= all /\W/;
Consistency would want any() to remove a random matching element, and the
default to really justs imply one().
There's one hole left in the table. Stringy minus can just be ~-:
string number list
x * xx
~ + , [+]
- [-]
eq == [~~]
This wants ~ to be an abbreviation for ~+, and eq for ~==, which if we
grab the table for bitwise operations and put everything to gether, gets
us ?== for boolean equality.
do { ($temp = $foo) ~~ s/gone//; $temp }
$foo ~- foo;
Of course, you'd want to allow regexes too:
do { ($temp = $foo) ~~ s/g+one//; $temp }
$foo ~- /g+one/;
We're now communicating that we want to remove something, instead of
replace it with an empty string. This is very powerful self-documentation.
Again, if we want to remove all of them, a conjunction comes to our
resque.
do { ($temp = $foo) ~~ s/g+one//; $temp }
$foo ~- all /g+one/;
But, of course, :each should work too.
More dwimmery can probably be invented by looking at the operator table
in S03 and applying the same logic.
[+] should probably be spelled (+) but that's uglier. Other alternatives
are @+ (but this REALLY says array, while it's for lists) and *+ (hard
to read, but ~^ and ~- have the same problem).
Juerd
--
http://convolution.nl/maak_juerd_blij.html
http://convolution.nl/make_juerd_happy.html
http://convolution.nl/gajigu_juerd_n.html
