$x[12]=$x[123]=$x=$_="";
print "match one\n" if /$x[123]/;
print "match two\n" if /$x[12]/;
[download]

So totally awful, I'll have to clean it first.

$ perl -MO=Deparse blurp.pl # normalize Code with B::Deparse
$x[12] = $x[123] = $x = $_ = '';
print "match one\n" if /${x}[123]/; # array fail, characterclass win
print "match two\n" if /$x[12]/;
blurp.pl syntax OK
[download]

---

print+qq(\L@{[ref\&@]}@{['@'x7^'!#2/"!4']});

If you want a better convenient inconsistent regular expression behavior, ask yourself why the following are not endless loops:

@matches = ("foo" =~ /o?/g);
my @chars = split //, "foo";
[download]

An inconsistency that I like is the (now useless) feature that the line "nose hairs"; generates a warning but "ignore my nose hairs, please"; does not. See How to make warnings disappear for further discussion and an explanation. It also explains why the feature has been useless since before I learned Perl.

If you want a lot more inconsistency for the sake of convenience though, consider how context works in Perl and look how core parts of the language such as localtime, grep, and @array behave depending on context.

And one general thought for this thread. As you review these examples, ask yourself whether it is a coincidence that Larry Wall was a repeat winner of the International Obfuscated C Contest? Or that his 1986 win was in the category Useful Obfuscation?

Your split example is, of course, inconsistent in a way you didn't mention: but for the magic of split (or lack of magic, as perlre puts it), that // would probably mean /o?/.

For example the while clause could better be written as

for (<$filehandle>) { 
   ...
}
[download]

And it would work without any special magic. People don't do this, because it slurps the while file into memory. But that could be changed. For example by making <$filehandle> return a lazy list, or an iterator that for knows how to iterate.

The while statement modifier works differently with do than with other statements.

print "This doesn't print.\n"        while 2 + 2 == 5;
do {print "But this prints once.\n"} while 2 + 2 == 5;
[download]

print lc, $/;
##    ^^
## call lc with no args, return the result:
[download]

         map chop, @items;
##           ^^^^
## calls map with first argument = sub{ chop; }
## doesn't change current value of $_

anyotherfunc chop, @items;
##           ^^^^
## calls anyotherfunc with first argument = result of chop($_)
## changes current value of $_ !!
[download]

That doesn't actually have anything to do really with function names -- map and grep take an expression, up to the comma, and lambda it, for instance map $_ * $_, 1 .. 10 or grep exists $stuff{$_}, @things. It's syntactic sugar for map BLOCK LIST and grep BLOCK LIST, which are already kind of sugary themselves... but it's consistent if you understand what it does.