in reply to Other form of greediness in Perl

If list contruction is greedy, that would make all binary ops be greedy as well.
If foo $x,$y,$z is greedy beacuse it means foo($x,$y,$z) and not foo($x),$y,$z,
then foo $x+$y+$z is greedy beacuse it means foo($x+$y+$z) and not foo($x)+$y+$z.

I think we don't talk of list being because it's easier to think it terms of how many operands are required. (e.g. 0, 3 or 4, any number, etc) Besides, it's just too inconsistent. 

foo $x,$y,$z    means           foo($x,$y,$z)    For functions,
bar $x,$y,$z    doesn't mean    bar($x,$y,$z)       it depends on the 
+prototype.
print $x,$y,$z  means           print($x,$y,$z)  For named operators,
chr $x,$y,$z    doesn't mean    chr($x,$y,$z)       it depends on the 
+prototype.
not $x+$y+$z    means           not($x+$y+$z)    For other operators,
!   $x+$y+$z    doesn't mean    !($x,$y,$z)         it depends on the 
+precedence.

[download]

Replies are listed 'Best First'.
Re^2: Other form of greediness in Perl
by naikonta (Curate) on Oct 04, 2007 at 15:29 UTC

    I think we don't talk of list being because it's easier to think it terms of how many operands are required. (e.g. 0, 3 or 4, any number, etc)

    It's not the same in term of whether a function takes list, or more than one scalar (also list), or aggregat variables. That's why I took a different approach. Besides, 'list constructs are greedy' is a general statement, based on the examples I presented. So it's not about list construct per se for the whole statement. But rather, how many execution units are there. To determine this, we need to look at which functions are involved and what kind of argument they take.

    Here, "kinds of argument" I excerpt from the perlfunc are:

    • aggregats (HASH, ARRAY), such in keys HASH, unshift ARRAY
    • lists (LIST), such as warn LIST, reverse LIST
    • scalars (NUMBER, FILEHANDLE, FILENAME), such as chr NUMBER, chdir FILEHANDLE, chroot FILENAME

    Of course, some functions doesn't take any argument at all, and some functions take all the kinds of argument, such as splice ARRAY,OFFSET,LENGTH,LIST. ARRAY is an aggregat, OFFSET and LENGTH are scalars, LIST is, well, a list. In this case, LIST is always greedy.

    If foo $x,$y,$z is greedy beacuse it means foo($x,$y,$z) and not foo($x),$y,$z, then foo $x+$y+$z is greedy beacuse it means foo($x+$y+$z) and not foo($x)+$y+$z.

    From this example, if foo is a unary operator, then in foo $x, $y, $z we have two execution units, foo $x and $y, $z separated by a comma (as a statement separator). The whole context then is foo($x), $y, $z. This is the list construct I'm talking about, foo($x), $y, and $z, so foo($x) is not greedy. But the whole list can be greedy depending what's before foo.

    Similiarly for foo $x + $y + $z. I agree that it means foo($x+$y+$z), but this is not greedy. I see there are two execution units here, $x+$y+$z and foo($x+$y+$z). Without parens, perl will without doubt parse it as foo($x+$y+$z) and not foo($x)+$y+$z, I think because the precedence of + operator. As expression (as in foo EXPR syntax description), the addition will be performed first, and the result will be fed to foo. This is similiar to, 

    $ perl -le 'print chr 66'
B
$ perl -le 'print chr 60 + 5 + 1'
B
$ perl -le 'print chr 60 + 5 + 1, 10'
B10

    [download]

    Open source softwares? Share and enjoy. Make profit from them if you can. Yet, share and enjoy!

[reply]
[d/l]
[select]

In Section Meditations