Why are the comma's excluded in some spots and not others?

  map {/dothis/} @variable;
  grep {/more stuff/} @more;
[download]

  map(sub {/dothis/}, @variable);
  grep(sub {/more stuff/}, @more);
[download]

As for:

  print A "hello";
  print $somevar, "can be seperated like this";
[download]

  print STDOUT $somevar, "can be seperated like this";
[download]

How does this work with your own prototypes and subroutines?

Which perldoc covers this in depth?

-David

David,

Thanks for the response! The map and grep is a lot clearer (kind of).

#ex 1
map (sub {/dothis/},@_);
map {/and this/}, @_; #now doesnt compile

#ex 2
print STDOUT "hello";
print <STDOUT> , "Hello"; #runs
[download]

In the above example. The first line is making sense and opened my eyes to that for the map. As well the print uses a comma when a proper file handle '<' and '>' are used. Why do the use of proper terms affect the use of commas?

print <STDOUT> , "Hello"; #runs

That doesn't do what you think.

<STDOUT> reads from the STDOUT filehandle (which won't do anything useful).

You can't put a comma between the file-handle and the printable content, the syntax is not short for any other syntax.

  print HANDLE expression

is the normal form.

  print expression

is parsed by perl to mean   print LATESTHANDLE expression

where LATESTHANDLE is the last handle given to select() (the default is STDOUT).

-David

zer: As well the print uses a comma when a
proper file handle '<' and '>' are used. Why do the use of proper
terms affect the use of commas

As has been said in another response,
the  print <STDOUT> , "Hello";
invokes reading a filehandle in list context and printing
the result afterwards - but *not* through your "proper file handle" ;-)
It has probably also been noted elswhere
that this is like  print STDOUT <STDOUT>, "Hello";

The notation print filehandle LIST stems (IIRC) from the
"indirect object notation", like  $q = new CGI; #(no comma)
which would, in "direct" object notation read:  $q = CGI->new()

From this point of view, the file example might be equivalent
to  STDOUT->print("Hello"); #, which indeed is the case.
The above idioms can be used in Perl after including the IO::Handle
module, then it'll look like (pseudocode):

    # from http://perldoc.perl.org/IO/Handle.html
    $io = new IO::Handle;                   # indirect object notation
+!
    if ($io->fdopen(fileno(STDOUT),"w")) {
        $io->print("Hello");                # direct object notation!
    }
[download]

See: IO::Handle documentation

Regards
mwa

$ perl -le '
-> @arr = qw{a b c};
-> map { tr/[a-z]/[A-Z]/ } @arr;
-> print qq{@arr};'
A B C
$ perl -le '
-> @arr = qw{a b c};
-> map tr/[a-z]/[A-Z]/, @arr;
-> print qq{@arr};'
A B C
$
[download]

Cheers,

JohnGG

if (COND) BLOCK
[download]

The only difference between those languages and perl¹ is that perl allow more freedom: in some cases you can avoid (), there are more tokens which means the same (for, foreach), and the same token may have more available syntaxes (if (COND) { BLOCK },  EXPR if COND;) and so on. Probably Wirth would not like it, but i don't like pascal, so... :)

Oha

1 - The OP didn't compared perl to other langs, but i hope this diversion can be partially OT.

map BLOCK LIST
map EXPR,LIST
[download]

"{" starts both hash references and blocks, so "map { ..." could be either the start of map BLOCK LIST or map EXPR, LIST. Because perl doesn’t look ahead for the closing "}" it has to take a guess at which its dealing with based what it finds just after the "{". Usually it gets it right, but if it doesn’t it won’t realize something is wrong until it gets to the "}" and encounters the missing (or unexpected) comma.

Hope it's clear now why map {/and this/}, @_; won't even compile.

Is actually a strange form of indirect method invocation, except that its a special case in that you can use it without using any modules, and that the method form *requires* you to use the IO::Handle module before it is used. (This will hopefully not be necessary to do in 5.10.1). In other words it is much the same as saying my $obj=new Class::Name

demerphq using a computer he cant be bothered to log in from

rmap { print }, 1..3;
               ^-------- bad news, you get and empty list:
rmap(sub { print $_; }), 1..3;
[download]

Why are the commas excluded in some spots and not others?

Because of choices the designers made, either to reduce ambiguity or reduce typing. You always need a comma, except in the cases you noted: map, grep, and print FILEHANDLE.

How does this work with your own prototypes and subroutines?

Your own subroutines need commas between their arguments, with one exception. When using the & prototype in the first position and calling the subroutines without parentheses, you may use for that argument a plain BLOCK, rather than "sub BLOCK" followed by a comma. (Note that the reverse is NOT true; map( sub {$_ + 1}, 1, 2, 3 ) will produce a list of code references instead of (2, 3, 4).)

99% of the time you don't need prototypes anyway.

Which perldoc covers this in depth?

For how to call built-in functions, see perlfunc. For how to write prototypes and subroutines, see perlsub.