I am working on the most mysterious Perl expressions that I can find. In the book "Effective Perl Programming" (old, but useful in this regard), I found these 2 "one liners" to determine which is the lesser between 2 numbers;

first:         [ $a => $b ] -> [ $b <= $a ]
second:   ( $a, $b )[ $b <= $a ]

The second (that the book defines as "less elegant"!?) was inmediate: create a list of two elements, and index the array with 0 or 1 (depending if b is > or < than a). Fine.

The first instead deeply intrigued me (I was sure that there was a typo, until I executed it and I saw it working). Finally I could deconstruct it as:
  [ $a => $b ]      # reference to an array with elements $a, $b
                              # here the => is using the hash "syntactic
                              # sugar" for ... comma !

   [ $a => $b ] -> [ $b <= $a ]  
                         # this part derefs the reference to point to the
                         # array just created! (with index 0 or 1, as per
                         # previous solution).

What is my question? assuming that my interpretation above is right (I still am not sure!), how can Perl determines that  in the first part,  ( i.e. [ $a => $b ]), the "=>" is the comma, and not the relational operator?

Of course, one could say: well, if we took it as the relat operator (as the underwriter did for quite a while and going nowhere with it!), it would not work, because the list so created would contain only one element (0 or 1), while it is being indexed by an index that has 2 values! (aside from the fact that we lose the values of $a and $b).
But this is human (and let's confess it, empyric and opportunistic) reasoning; how Perl does it?

thanks for anyone with the "light",
raul

Of course, I saw the "light" only after the posting.  The relational operator for "greater or equal" is (conveniently) ">=" , not =>, so there is no confusion with the "hash comma"!
Aarrgh!
raul

Welcome, Raul, and glad you got it sorted.  There are just a few times that Perl is overclever in what it can do ... you're not the first (and you won't be the last) to be caught between

=>  (a synonym for , )
>=  (greater than or equal to, numerically)

---