Advogato: Mixins for PHP

I find mixins very useful in other languages. In Ruby, any class that implements the each method can utilize the Enumerable mixin. Enumerable is a class containing functions which use the each method including: find, grep, and reject. The functions are mixed into the new class's set of functions. Incidentally, that PHP does not implement mixins natively is not a criticism of PHP. PHP's design goals are different from Ruby's.

So how are mixins allowed in PHP? We can thank equal parts class methods, introspection, and dynamic function generation. Oh and I'm working with PHP 4.1.0+.

Class Methods

One other developer I communicate with asked me to show him the syntax for calling methods of a parent class within a child class. I worked up this example for him:

class Person {
    var $job = "person";
    function show_job() {
        echo "Hi, I work as a {$this->job}.";
    }
}

 class Bartender {
    var $job = "bartender";
    function show_job() {
        echo "BARTENDER: ";
        Person::show_job();
    }
}
$b = new Bartender;
$b->show_job();

The example worked just as I had eagerly anticipated, printing:

BARTENDER: Hi, I work as a bartender.

I scanned over the code once, ready to drop it in an e-mail. But then I noticed that I hadn't actually extended the Bartender class from Person. But the program worked perfectly. How could this be? Well, of course, you may already know this but class methods can be called anywhere, not just in a derived class. What's better, when run in the context of an instance of another class type, the method still uses $this properly. I just hadn't seen it spelled out for me like this. I simply assumed differently.

Oh, this is great I thought. I just need to find a way to introduce wrapper code into each class. I envisioned a mixin function that would take a class and mix it into a class like this:

class Bartender {
    var $job = "bartender";
    mixin( "Person" );
}

The Bartender class code produced would then look like this:

class Bartender {
    var $job = "bartender";
    function show_job()
    {
        return Person::show_job();
    }
}

Of course, running a function right inside a class like I show with the mixin function above isn't possible. Class declarations must be pure variable and method declarations. Knowing this, I speculated on other possible contexts for executing the mixin function.

// Mixin through the constructor...
class Bartender {
     function Bartender() {
        mixin( "Person" );
    }
}

 // Mixin through an instance... singleton...
$b = new Bartender;
mixin( $b, "Person" );

I figured one of these would work out. With enough willpower, perhaps more than one.

Introspection

The first step in mixing in functions from another class is to get a list of the functions, so we can clone them. PHP has a healthy list of introspective functions, one of which is get_class_methods. This function takes a class name and returns an array of the names of the functions defined for that class. So, the basic recipe for our mixin function will loop through the get_class_methods for a to-be-mixed-in class, generating wrapper functions inside the new class.

Dynamic Function Generation

Hopefully you can understand that I didn't exactly want to use eval(). I knew that there were other ways of generating functions dynamically. I found create_function, but it was a glorified eval(), accepting the function code as a string. Also, the create_function couldn't add methods.

One thing create_function could afford us, though. It would help us mixin through an instance.

$b = new Bartender;
$b->show_job = create_function( '', 'return Person::show_job();' );
$b->show_job();

This won't work properly, though. Close but no cigar. If you echo the $b->show_job variable, you'll see it print: lambda_1. That's because create_function actually creates the function lambda_1, so that when you run the variable as a function (i.e. $func_var();), it just performs a variable substitution and runs lambda_1.

As a result, I haven't yet found a way to mix in with an instance, singleton-style. Feel free to trump me by showing me a way around.

So it was back to eval(). I started with a useful function that I knew was possible at this point. The create_mixed_class takes a string for a new class name and an array of classes to mix into the class, in order of precedence. This function creates the new class, adding wrapper functions for the methods of the other classes. Note there's no error-checking here.

function create_mixed_class( $new_class, $based_on )
{
    $code = "
        class $new_class
        {";
    $func_code = array();
    foreach( $based_on as $b )
    {
        foreach( get_class_methods( $b ) as $bm )
        {
            if ( isset( $func_code[$bm] ) )
                continue;
            $func_code[$bm] = "
                function $bm() {
                    $args = func_get_args();
                    eval( '$ret = $b::$bm( $args['
                        . implode( '], $args[', array_keys( $args ) )
                        . '] );' );
                    return $ret;
                }";
        }
    }
    $code .= implode( " ", $func_code ) . "}";
    eval( $code );
}

This doesn't exactly let us mix into a class we're defining. But we can create a MixedBartender class, which acts as a proxy class between the classes:

create_mixed_class( "MixedBartender", array( "Bartender", "Person" ) );
$b = new MixedBartender();
echo $b->show_job();

My example at this point is rather awful, as it's still uni(?)-morphic. And you're probably thinking that this isn't really in fact a mixin as the title promised and that you've wasted your time. Well, I can do a bit better. Just a bit. I can give you a function to give you an instance of mixed classes.

The new_mixed_class takes an array of class names. A new, "anonymous" class will be generated with create_mixed_class. Then, we'll pass back an instance. In case you don't want to come up with names for your mixed classes. No, I didn't get this idea from create_function.

function new_mixed_class( $based_on )
{
    $mixed_name = "mixed_class_" . implode( "_", $based_on );
    if ( !class_exists( $mixed_name ) )
        create_mixed_class( $mixed_name, $based_on );
    eval( "$m = new $mixed_name;" );
    return $m;
}

Yep, had to use eval again.

Conclusion

So ultimately, I got close to the goal and brought some fraction of the mixin philosophy to PHP. I planned on using mixins for the next version of Psychoo. These two mixin functions give me what I need.

Yet, I had hoped to find a way to add mixins within the class declarations. Who knows. Maybe it'll work out someday.

(A copy of this article is also archived here at the Javuh Codelab.)

Mixins for PHP

Posted 2 May 2002 at 04:46 UTC by whytheluckystiff

what is the design goal of PHP?, posted 2 May 2002 at 21:34 UTC by sye » (Journeyer)

There's supposed to be a design goal?, posted 3 May 2002 at 01:50 UTC by amars » (Journeyer)

Simplicity, a goal, posted 3 May 2002 at 03:39 UTC by whytheluckystiff » (Master)

Design Goal, posted 3 May 2002 at 13:00 UTC by rasmus » (Master)

my apology..., posted 3 May 2002 at 18:25 UTC by sye » (Journeyer)

Worse is Better, or how languages become popular, posted 3 May 2002 at 20:03 UTC by raph » (Master)

Errata, posted 3 May 2002 at 21:58 UTC by whytheluckystiff » (Master)

at best..., posted 5 May 2002 at 12:13 UTC by sye » (Journeyer)

what?, posted 5 May 2002 at 16:35 UTC by amars » (Journeyer)

in Ancient China..., posted 5 May 2002 at 19:16 UTC by sye » (Journeyer)

and yet, posted 5 May 2002 at 20:38 UTC by amars » (Journeyer)

PHP flame war, posted 6 May 2002 at 13:46 UTC by brlewis » (Journeyer)

Aggregation, posted 7 May 2002 at 20:01 UTC by andrei » (Master)

Ah, recompiling..., posted 7 May 2002 at 23:32 UTC by whytheluckystiff » (Master)

It fills a need, posted 8 May 2002 at 19:24 UTC by andrei » (Master)

OK. i want to learn Arabic Fonts, posted 9 May 2002 at 15:29 UTC by sye » (Journeyer)

instance_mixin(), posted 11 May 2002 at 23:55 UTC by whytheluckystiff » (Master)