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