You surely heard about the upcoming Perl 6 (http://dev.perl.org/perl6/) language.
This language will be endowed with a set of features so rich that every Greek and Trojan is eager to see a full working implementation.
Among these features,
there are operators,
many of them.
Perl 6 was even said () to be an operator-oriented language,
with a yet larger diversity than Perl 5 already has.

Perl 6 has an operator Z,
named zip,
to interleave elements of two or more arrays.

my @a = 1,2 Z -1,-2; # (1,-1),(2,-2)

The zip is one of the list generating operators that gives the language some flavor of functional programming. This gets further as the usual semantics for lists is to get lazy generation, which means easy/efficient handling of large lists (and also the extreme case of infinite lists).

In Perl 5, we expect values to DWIM (do what I mean) in various contexts. For example, if we use a string containg 42? as a number we expect it automagically act as a number. Perl 6 keeps this tradition of DWIMmery and introduces several new explicit coercion operations.

In the article on coercion operators, we got to know the prefix operator '?' which converts values into Bool::True or Bool::False. Like it happens with '~' for strings, '?' is recurrent for boolean operators.

Among the new Perl 6 operators, there is the handy operator '//', known as defined-or or the default operator. This novelty was anticipated by the introduction of this syntactic bit in Perl 5 (see the upcoming 5.10 release)  so you wont need to wait for Perl 6 to start using it.

We already have seen two Perl 6 meta-operators in articles of this series: namely, the negate and the reduction operators. These are two of the five standard meta-operators of the language. What makes meta-operators interesting is how Perl automatically generates new operators from others (user-defined or builtins) with some straightforward semantics derived from the transformation of the base operators.

This time, we approach mutating operators, which are a shortcut for typical assignments where the assignment target and the first operand are the same variable.