• Method is created and returned when the object is created. It is not yet evaluated.

There is one little mystery left, though. Code references are dereferenced using the //$ref->(@args)// syntax. //$ref->function(@args)// syntax is reserved for objects. We shouldn't be able to call $ob->get_street() in our example on a code reference -- unless that code reference has been blessed into a package. It just so happens that that is exactly what //MessageMethod// does.

  package MessageMethod;

  sub new {
    my $type = shift;
    return $type->new(@_) if ref $type eq __PACKAGE__;
    my $ref = shift; ref $ref eq 'CODE' or die;
    bless $ref, $type;
  }

  sub AUTOLOAD {
    my $me = shift;
    (my $method) = $AUTOLOAD =~ m/::(.*)$/;
    return undef if $method eq 'DESTROY';
    return wantarray ? ($me->($method, @_)) : scalar $me->($method, @_);
  }

  1;

Given a code reference, //MessageMethod// blesses it into its own package. There are no methods aside from //new()// and //AUTOLOAD()//. //AUTOLOAD()// handles undefined methods for Perl, and since there are no methods, it handles all of them. (There is an exception to that, where new() has to pass off requests). //AUTOLOAD()// merely takes the name of the function it is standing in for and sends that as the first argument to a call to the code reference, along with the rest of the arguments. We're translating //$ob->foo('bar')// into //$ob->('foo', 'bar')//. This does nothing but let us decorate our code reference with a nice OO style syntax.

This is similar to Python's method lookup logic XXX, in that it returns the method as an object.

Blessed Hash full of Coderefs

The previous example was simplicity itself. This one is usefullness itself. Doing //if// and //elsif// in a chain to inspect an argument to see which clause to run to simulate methods is the LambdaProgramming paradigm, but ObjectOriented's concept of automatically dispatching to methods is superior. Obviously, a single code reference isn't enough to let OO do its dispatch magic. We need something larger - something like a hashref that contains a bunch of coderefs, one coderef per method. The normal thing to do in Perl is to put all of the code directly in the package, using the symbol table (or stash, or namespace, or what have you) to hold all of the code references, and define the code references using a simple named //sub// statement. This doesn't allow each instance of the object to have different code references lexically bound to different InstanceVariables. We need private storage for the code references and the anonymous version of the //sub// statement. We need //hashclosure.pm//.

  # place this code in hashclosure.pm

  # tell Perl how to find methods in this object - run the lambda closures the object contains

  sub AUTOLOAD {
      (my $method) = $AUTOLOAD =~ m/::(.*)$/;
      return if $method eq 'DESTROY';
      our $this = shift;
      if(! exists $this->{$method}) {
        my $super = "SUPER::$method";
        return $this->$super(@_);
      }
      $this->{$method}->(@_);
  } 

  
  1;

This code translates method calls into invocations of anonymous subroutines by the same name inside of a blessed hash: when a method is called, we look for a hash element of that name, and if we find it, we execute it as a code reference.

XXX - diagram here.

Dropping the above code verbatum into a .pm file it doesn't change package (there is no //package// statement), so it defines an //AUTOLOAD()// method for the current package. This is a WrapperModule of sorts. LambdaClosures and our //AUTOLOAD()// method work together to provide ImplicitThis-like easy access to //$this// and InstanceVariables. We can use object instance specific field variables directly without having to dereference a hash.

  package Foo;

  sub new {

    my $class = shift;  
    my %args = @_;
    our $this;

    my $foo;
    my $bar;

    bless {

      get_foo => sub { return $foo },
      set_foo => sub { $foo = shift },
      get_bar => sub { return $bar },
      set_bar => sub { $bar = shift },

      get_foo_bar_qux => sub {
        return $this->get_foo(), $this->get_bar(), get_qux();
      },

      dump_args => sub {
        foreach my $i (keys %args) {
          print $i, '=', $args{$i}, "\n";
        }
      },

    }, $class;

  }

  sub get_qux { return 300; }

This blesses an anonymous hash reference into our package, //Foo//. This hash reference contains method names as keys and anonymous subroutines as values. //AUTOLOAD()// knows how to look into our hash and find methods by name, and run them, rather than looking for methods in the normal place.

//our// is a strange beast. It gives us a //my// style lexical alias to a //local// style variable. We could use a //local// variable here, but //our// has a nicer syntax, and it keeps us in the lexical mode of thought.

//$foo//, //$bar//, //$this//, //$class// and //%args// are all lexical variables, and the subroutines we create with //sub { }// are LambdaClosures because they reference these variables. By referencing them, they bind to the one specific copy that was created when //new()// is entered. That means that each object has its own private //$foo//, for instance, and can access it directly. //get_qux()// is defined as a normal method in the preceding example. In any OO Perl code, failing to do something like //$this->method()// to call other functions in your code prevents inheritance from overriding those methods. Using this syntax keeps open the possibility of creating TemplateMethod. Where we explicit don't want subclass redefinitions of methods to be used, way can use the //$this->Foo::method()// syntax, where //Foo// is the name of the class to search for //method()// in, usually our own package or our direct parent.

Methods may also be defined normally and placed next to //new()//. This is useful for utility methods, or //static// methods in C++ or Java. Methods must be defined this way to be called without using the //$this->method()// syntax. //$this->method()// is required to get the //AUTOLOAD()// logic to kick in as otherwise Perl has no knowledge of how to locate the code responsible for handing your method.

This is my own personal favorite idiom for creating objects in Perl: it requires the least code to acheive, and the least work on my part, and the least chance of error.

In other news, PerlMonks:116725 defines a //class// package usabe as such:

    my $class = new class sub{
        my $field = shift;
        $this->field = $field;
        $this->arrayref = [1,2,3];
        $this->hashref = {a => b, c => d};
        $this->method = sub{ return $this->field };
    };

...allowing the anonymous, inline construction of classes.

• Faking delegation using autoload[?]
• Wrapper module[?]
• Lambda closure[?]
• Lambda programming[?]
• Passing pattern[?]
• Template method[?]