Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:67147
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: error (pb1.pair.com: domain mindplay.dk from 209.85.212.44 cause and error)
MIME-Version: 1.0
Date: Thu, 25 Apr 2013 08:47:21 -0400
Message-ID: <CADqTB_gkE-2mmnE8AKWCx3rcHf8DVsgxVPO00usErnaoKjAv7g@mail.gmail.com>
To: PHP internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=bcaec50405c0cc861704db2ed1d4
Subject: property de-referencing
From: rasmus@mindplay.dk (Rasmus Schultz)

--bcaec50405c0cc861704db2ed1d4
Content-Type: text/plain; charset=ISO-8859-1

Okay,

No one seemed extremely interested in my notes about static
type-references<http://marc.info/?t=136327849600002&r=1&w=2>- I want
to bring up something closely related that could possibly be even
more useful, in particular for things like form-helpers, which remains as
one of the things that just can't be done in PHP as elegantly as it can in
some other languages.

I'm not sure if de-referencing is the correct term? I'm talking about the
ability to use a property-reference indirectly - meaning, don't read the
property, don't write the property, but reference the property in a way
that permits you to read/write the property later on.

In this example, I'm using ^ as the de-reference operator:

class User
{
    public $email;
}

$user = new User();

$form = new FormHelper($user);

echo $form->textInput(^$user->email);

Note the ^ operator in the last line - we're not passing the value of
$user->email to FormHelper::textInput() but a reference to it... assuming a
new internal PropertyReference class, it's declaration might look like this:

class FormHelper
{
    public function textInput(PropertyReference $prop)
    {
        $name = $prop->className . '[' . $prop->propertyName . ']';
        $value = $prop->getValue();

        return "<input type='text' name='{$name}' value='{$value}' />";
    }

    ....
}


The new PropertyReference class might have an interface like the following:

class PropertyReference
{
    public readonly object $object; // the object that was referenced
    public readonly string $className; // the type of object that was
referenced
    public readonly string $propertyName; // the name of the property that
was referenced

    public function getValue(); // read and return the property-value
    public function setValue($value); // write the property-value
}


For a statement like this:

$prop = ^$user->email;

The ^ operator does something equivalent to:

$prop = new PropertyReference();

$prop->object = $user;
$prop->className = get_class($user);
$prop->propertyName = 'email';

$prop->getValue = function () use ($user) {
    return $user->email;
};

$prop->setValue = function ($value) use ($user) {
    $user->email = $value;
};


So essentially, you get all the information about the object and property,
and a way to read/write that property, with one character - something that
would enable hugely convenient APIs for things like form-helpers,
data-mappers and object/relational-mappers.

When the object-type is known in IDEs (as it is in properly documented
code) this also addresses the same issue as static type-references,
allowing for static analysis and automated refactoring, but with a much
shorter and more convenient syntax - not needing to explicitly reference
the class-name, and with the added benefit of knowing the instance, both of
which are hugely important for form-helpers and mappers.

Note that the getValue() and setValue() closures resolve properties the
usual way - that is, you can de-reference magic properties too, since no
attempt is made to read or write the property until getValue() or
setValue() is made.

Most use-cases for referencing class and property-names are situations like
these, so this kind of kills two birds with one stone - a static way to
reference properties, but with the addition of providing the actual
object-context. And the shortest possible syntax.

What do you think?

- Rasmus Schultz

--bcaec50405c0cc861704db2ed1d4--