Well, method $obj $arg; would be an error. Update: Actually, that's not an error at all. rir++ for the catch. I updated the next paragraph to reflect this.

You can't distinguish between

method( $obj, $arg);
$obj->method( $arg);
method $obj $arg;
[download]

Similarly, you can't distinguish between

"Classname"->method( $arg);
method "Classname" $arg;
method( "Classname", $arg);
[download]

Class->method($arg);
method Class $arg;
Class::method("Class", $arg);
[download]

You can determine if the method was called as a class method or an instance method by checking the refness of the first argument but you can't determine the exact syntax.

-sauoq
"My two cents aren't worth a dime.";

method $obj $arg; is not an error.


"Classname"->method( $arg); 
method "Classname" $arg; 
method( "Classname", $arg);
[download]

The first two act just like the last one.

Not so. Consider:

#!/usr/bin/perl -w
use strict;

package Base;
sub base {
    print "Base::base called\n";
}


package Derived;
use vars qw( @ISA);
@ISA = ( "Base");


package main;

Derived::base Derived "hello";
Derived::base( Derived,"hello");   #  undefined
Derived::base "Derived" "hello";   # syntax error
[download]

method $obj $arg;is not an error.

You are right. It isn't. I don't know what I was thinking.

Before going on, I should clarify my point. Once a method is called, there is no way to determine the syntax used to invoke it. Your addition of a Derived class does nothing to show otherwise.

That said, I made a couple of poor assumptions. One was that "Classname" in the original wasn't really meant to be a quoted string but a bareword. I also assumed that method would be the appropriate name for the method regardless of context. There really was no good reason to assume either and I should have requested clarification.

# Actual original post        # What I assumed the OP meant
"Classname"->method( $arg);   # Class->method($arg);
method "Classname" $arg;      # method Class $arg;  
method( "Classname", $arg);   # Class::method(Class, $arg);
[download]

Mistakes, assumptions, and mistaken assumptions aside, if I understand the original post, the answer is still "No."

-sauoq
"My two cents aren't worth a dime.";

use strict;
use warnings;

{
  package foo;
  
  use UNIVERSAL qw(isa);

  sub new { bless {}, shift }

  sub callme {
    my $invoker = (@_ == 2 ? shift : '');
    my $package = [caller]->[0];
    
    if(ref $invoker and isa($invoker, __PACKAGE__)) {
      if($package ne __PACKAGE__) {
        print 'called: $obj->method(@args)', $/;
      } else {
        print 'called: method($obj, @args)', $/;
      }
    } elsif($invoker eq __PACKAGE__) {
      if($package ne __PACKAGE__) {
        print 'called: foo->method(@args)', $/;
      } else {
        print 'called: method("foo", @args)', $/;
      }
    } elsif($invoker eq '') {
      if($package ne __PACKAGE__) {
        print 'called: foo::method(@args)', $/;
      } else {
        print 'called: method(@args)', $/;
      }
    }
  }
}

my $o   = foo->new;
my $arg = 'a string';

$o->callme($arg);
foo->callme($arg);
foo::callme($arg);

callme $o $arg;      # same as $o->callme($arg);
# callme 'foo' $arg; # syntax error

{
  package foo;
  callme($o, $arg);
  callme('foo', $arg);
  callme($arg);
}

__output__

called: $obj->method(@args)
called: foo->method(@args)
called: foo::method(@args)
called: $obj->method(@args)
called: method($obj, @args)
called: method("foo", @args)
called: method(@args)
[download]

_________
broquaint

You can only distinguish between the first three and the last three calls:

package Classname;
sub method {
        print ref($_[0]) ? 'Object method' : 'Class method';
        print "\n";
}

package main;
my $obj = bless {},Classname;
my $arg = 1;

# calls here

method $obj $arg;
Classname::method( $obj, $arg);  # added Classname::
$obj->method( $arg);
"Classname"->method( $arg);
method Classname $arg;
Classname::method( "Classname", $arg); # added Classname::

__END__
prints:

Object method
Object method
Object method
Class method
Class method
Class method
[download]

-- 
Joost       downtime n. The period during which a system
            is error-free and immune from user input.
[download]

There's nothing I can (nor probably could) add to the sage wisdom already given, but I did get to wondering:

Why did you want to make these distinctions in the firstplace?

Why did you want to make these distinctions in the firstplace?

I don't! But the Calling Madness thread made me curious.

Apparently, someone wanted to allow some various types of calls to be equivalent.
So that his client authors could be completely naive.