I'm not entirely clear what you're trying to do - there are approximately 2 different call styles in perl. And they all have their nuances, none of which are necessarily completely obvious to the casual newbie.

Style 1: Direct calling

This is where you call a function directly. There is no runtime lookup of where a function is, which gains some speed, at the expense of flexibility (which, to be honest, is not wanted most of the time anyway).

There are two variations here. The first variation is what you're used to: some_func(). The nuance? That some_func may be declared in the same file as where you're calling it, or it may be exported there from another package (or namespace). Note that even if it's exported, Perl only looks in the current namespace or package to find it - the act of exporting merely makes a copy of the function from the originating namespace/package in to your namespace/package. No extra parameters are used:

  my $returned = some_func($sent);
  # ...
  sub some_func
  {
    my $received = shift;
    # ...
    $value;
  }
[download]

The second variation, which I think is what you're looking for, is fully-qualified naming. It's the same as the previous one, but is longer-winded.

  my $returned = Foo::Bar::some_func($sent);
  # in Foo::Bar:
  sub some_func
  {
    my $received = shift;
    #...
    $value;
  }
[download]

Style 2: Indirect calling

Here we tell Perl where to start looking. It may decide to look elsewhere after that if it can't find the function you're asking for. This can chew up a few cycles just resolving the function call. You can distinguish this style from the previous one by the fact that the arrow notation is used.

The first variation is class-indirect. This is used primarily for constructors and by File::Spec. If you don't know why File::Spec does it this way, you probably don't want to do it yourself - it's somewhat advanced, IMO. And I've never needed to do it, either, so it's a good bet you probably don't either.

  my $returned = Foo::Bar->some_func($sent);
  # in Foo::Bar (or any package that Foo::Bar derives from)
  sub some_func
  {
    my $class_name = shift; # will be Foo::Bar, even if we aren't in t
+hat package right now
    my $received = shift;
    # ...
    $value
  }
[download]

The other variation is object-indirect. This is where you have an object created via a constructor, and then call methods on it. This is a very popular style as it is what allows us to call perl "Object Oriented" (as much as, say, C++ or Java are, but not as much as other languages such as Smalltalk). Perl starts with the package of the object given, and walks up the @ISA inheritance tree the same as before if it can't find the method in the starting package.

  my $returend = $obj->some_func($sent);
  # in the package that $obj is blessed into, or any package it is der
+ived from
  sub some_func
  {
    my $self = shift;
    my $received = shift;
    #...
    $value;
  }
[download]

Named subs are also used as class or object methods. The only difference between a method and a named subroutine is the first argument passed: if you call methods on an object the first argument passed will be the object and if you call a method on a class the first argument will be that class (i.e. the name of the package).

package MyPackage;
sub new {
  return bless {},shift; # create an empty object of class MyPackage
}

sub called {
  my (@args) = @_;
  print "called with args @args\n";
}

package main;

MyPackage::called(1,2,3);  # call as a normal subroutine

MyPackage->called(1,2,3);  # call as a class method

my $object = MyPackage->new(); # create object
$object->called(1,2,3);    # call as an object method.
[download]

Update: and subroutines always return whatever is passed to return() or failing that, the value of the last expression.

What you show is typical for class methods, though $_[0] would ordinarily be called $class or $stash when it's shifted in.

Usually the leading underscore signifies an internal function which should not be called from other namespaces. That is a convention, Perl does nothing to enforce it.

If you want an ordinary function, not a class method, leave out the class name shift and call like this:

$foo = Whaterverlib::pmfile::nameoffunction($sent);
[download]

sub nameoffucntion {
    my $recieved = shift;

    my $value = whatever;
 
    return $value;
}
[download]

In general, dereference arrow notation puts an extra argument in @_ - either the name of the class, or a reference to the instance which called the object method.