'function' calls without parentheses

[g0n]

Hi all,

I have some code that uses Term::ReadKey to get some user input, but 99 times out of 100 when this script is run, it picks the data up from a file instead, and Term::Readkey isn't needed. So I figure why not do away with the dependency, and require Term::ReadKey in when needed.

But the sub that uses it contains a couple of statements like this:

ReadMode 1;
# some stuff
ReadMode 2;

Intrigued by this - apparently a function call without parentheses - I asked in the CB, and was told that the parentheses are optional for a single param function call. But this test case:

testcall 1;
testcall(2);

sub testcall
{
    print $_[0];
    print "\n";
}

fails to compile with:

Number found where operator expected at fcall.pl line 1, near "testcal
+l 1"
        (Do you need to predeclare testcall?)
syntax error at fcall.pl line 1, near "testcall 1"
Execution of fcall.pl aborted due to compilation errors.

(On AS perl, 5.6.1). Term::ReadKey doesn't appear to use prototypes incidentally.

I'm intrigued - is there a functional difference between ReadMode 1; and ReadMode(1); and if so, what? Or am I being really, really dense?

Thanks.

Update: thanks to duff. I'd sort of always assumed that

callsub();
sub callsub{#dostuff}

and

sub callsub(){#dostuff}
callsub();

were equivalent, and never encountered anything that proved me wrong. I know better now :-)

[duff]

Put the sub definition before the call and it'll work just fine. If perl doesn't recognize the name, it treats it as a bareword.

[McDarren]

Quoting directly from the Camel (3rd Ed, Page 218):

NAME(LIST)            # & is optional with parentheses.
NAME LIST             # Parens optional if sub predeclared/imported.
&NAME                 # Exposes current @_ to that subroutine,
                      # (and circumvents prototypes).

Cheers,
Darren :)

[tye]

You might find (tye)Re: A question of style a useful summary.

[Errto]

One other thing not mentioned so far. What you were told in the CB isn't quite right. A subroutine called without parentheses or & is a list operator (except in the special case where you use the () or ($) prototypes), which means that it can take any number of arguments:

sub foo {
  # do stuff
}
foo 1, 2, 3, 4;

is perfectly valid.