I just wonder if '=>' is good choice?

A legitimate question. Let me try and explain.

comma (,) and fat arrow (=>) can be used pretty much interchangeably. The main difference is that fat arrow forces string context on its left hand argument. This is notably useful for hash keys that are matched by \w+, since it means you can do away with single quoting of keys. Less noise, less fuss, less chance of error.

In the case of join, I can make a pretty strong argument for why the use of fat comma is a good idea as well. Look at the prototype for join:

     perl -le 'print prototype "CORE::join"'
     # prints '$@'
[download]

That is, join takes a scalar and a list. Which makes sense when you know what join does. It takes the first argument and applies it to the rest of the arguments. Thus, the use of fat arrow here serves as a discriminant to better help you distinguish between the first argument and the rest of the list. In my code, one of the most frequent characters I use to join arrays is... a comma! From a whitespace point of view, I like my commas to cuddle up right behind the preceding argument, which means I find that

     join( ',', '-', '.', '"' );
[download]

much harder to parse than

     join( ',' => '-', '.', '"' );
[download]

Regardless of whether the above is a highly contrived example, just the apostrophe, comma, apostrophe, comma by itself gives me a headache. This doesn't mean you should go overboard and use fat comma anywhere and everywhere, but I think that in the case of join the result is worth it.

I dislike "cute" uses of fat arrow, because the following code is broken:

use constant COMMA => ',';
...
my $result = join COMMA => @list;
# should be: my $result = join COMMA, @list;
[download]

Yes, smart people know that fat arrow autoquotes the left argument. But why should you require your code to be maintained by smart people?

Be kind to your maintenance programmer. Don't use fat arrow except when you want the quoting feature.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

I also dislike cute uses of fat comma. It was meant to separate a hash key from a hash value. And in Perl6, using it for something other than that is likely to break (as near as I can tell).

I only use fat comma when the thing on the left is a string (which all hash keys must be) and the thing on the right is a scalar (which all hash values must be). If it weren't for the immediate proliferation of cute uses of fat comma, fat comma might have been improved to provide scalar context to it's right so that my %hash= ( foo=>getFoo(), bar=>getBar() ); would no longer be susceptible to getFoo returning an empty list (or more than one item).

But I do sometimes use fat comma when the left-hand side must not be quoted, just like I sometimes use $hash{...} when the key expression must not be quoted. These are a couple of the reasons why I make it a habit to write COMMA() not COMMA if it is a constant (subroutine).

When I see =>, I think "key => value". Some people use cute fat commas to provide extra separation between things. Some people use cute fat commas to show a closer association between two items (like it was intended to be used when listing the key/value pairs for a hash). Some people use cute fat commas to indicate a direction of flow (which can only be done it one direction, of course). I'm surprised these people don't get really annoyed at other people's conflicting uses of fat comma. If the fat comma doesn't mean "key => value", then it is just (usually minor) obfuscation to me, since I don't keep a list of which authors use their cute fat commas which ways; I only track what the purpose of the fat comma was.

- tye