Proposal: Type Casting User Classes

Hey everyone,

I want to get a feel for something I would like to implement into PHP core.
I would like to be able to cast objects to my own class types. Similar to
already available PHP syntax:

$foo = (string) $bar;

The syntax would look like this:

$foo = (\My\FooObject) $bar;

It would also support:

$foo = ( (\My\FooObject) $bar )->myFooObjectFunction();

I'm still trying to decide what would happen internally and I would like
some feedback. I'm thinking of 3 different things it could do:

1. Directly change the class type, functionally equivalent to:

   function castType($object, $type) {
   return unserialize(preg_replace("/^O:[0-9]+:"[^"]+":/i",
   "O:".strlen($type).":"$type":", serialize($object)));
   }

2. Throw a fatal error if the object doesn't match the type trying to be
   cast.

3. Add a new static magic method called __cast() that would allow the
   developer to decide what happens. Like this:

namespace \My;

class FooObject {
public static function __cast($foo) {
// Do stuff here
return new FooObject;
}
}

I'm willing to implement this myself if everybody else likes this idea.
Thanks!

Chris London

Hi

Do you have any use cases why this would be useful?

IMO an object is only meant to do what it is created for.
Converting objects to different types can have very unexpected results.
If you want to reuse code, you can just use traits, or you can use
dependency injection to get functionality of one object inside another.
Also what would happen if you cast objects to invalid types?
E.G if you convert a person entity to a product entity, which doesn't have
the same properties or methods?

Hi Chris

-----Original Message-----
From: Chris London [mailto:me@chrislondon.co]
Sent: Thursday, November 14, 2013 7:40 PM
To: internals@lists.php.net
Subject: [PHP-DEV] Proposal: Type Casting User Classes

Hey everyone,

I want to get a feel for something I would like to implement into PHP
core.
I would like to be able to cast objects to my own class types. Similar
to
already available PHP syntax:

$foo = (string) $bar;

The syntax would look like this:

$foo = (\My\FooObject) $bar;

It would also support:

$foo = ( (\My\FooObject) $bar )->myFooObjectFunction();

I'm still trying to decide what would happen internally and I would like
some
feedback. I'm thinking of 3 different things it could do:

1. Directly change the class type, functionally equivalent to:

   function castType($object, $type) {
   return unserialize(preg_replace("/^O:[0-9]+:"[^"]+":/i",
   "O:".strlen($type).":"$type":", serialize($object)));
   }

[Robert Stoll]
Seems a bad idea to me. Would be slow and is not really a cast but a
conversion.

2. Throw a fatal error if the object doesn't match the type trying to be
   cast.

[Robert Stoll]
That's what I would expect from a runtime type checking mechanism

3. Add a new static magic method called __cast() that would allow the
   developer to decide what happens. Like this:

namespace \My;

class FooObject {
public static function __cast($foo) {
// Do stuff here
return new FooObject;
}
}

[Robert Stoll]
This is interesting but goes beyond casts and is a conversion mechanism
again. But would be truly helpful for utility classes like Email etc. (there
was already another discussion about this feature as far as I remember)

I'm willing to implement this myself if everybody else likes this idea.
Thanks!

Chris London

You might be interested in my project Type-Safe PHP (TSPHP):
http://tsphp.tutteli.ch

It is far from a real release candidate but that's mostly because I am the
only developer contributing to this project so far (and unfortunately I do
not really have time lately).
Other contributors are welcome ;-)

TSPHP would substitute object casts for you (without the performance penalty
of an additional function call and the use of is_a) but you could emulate it
with a function this way:

function cast($object, $type){
if($object == null || \is_a($object,$type)){
return $object;
}else{
trigger_error('cast error, $object was not of type '.$type);
}
}

I have chosen trigger_error to be consistent with (int), (string) etc. which
trigger an error as well if something goes wrong. Replace it with a throw if
you like.

And use it like this - a one liner as well ;-)
class A{}
class B extends A{}
$a = new B();
$a = cast($a, "A");

Of course, $a will not change its type but is guaranteed to be of type A.
There was a discussion about down casting in another email. That's not
possible with this function since it is a cast and not a conversion. Btw the
Liskov Substitution Principle tells that you should be able to replace your
class with your sub-class without breaking things but not that a class
magically can do the same thing as a sub-class. But you were probably
thinking about a conversion/mapping and fair enough, that might be possible
but there are a lot of cases where this is not as straight forward as you
may think.

Cheers,
Robert

As a thought. Would it not be possible to, instead of implementing a new
__cast method, make use of the existing __clone functionality? Effectively
aren't you trying to clone one object into another just of another type?

While I can't think of many use cases off the top of my head, I certainly
see the benefit of this proposal and it doesn't seem to have any BC that I
can see.

(First post so please excuse me if I'm missing things / making a daft
point.)

Cheers.
Jonny.

Hey everyone,

I want to get a feel for something I would like to implement into PHP core.
I would like to be able to cast objects to my own class types. Similar to
already available PHP syntax:

$foo = (string) $bar;

The syntax would look like this:

$foo = (\My\FooObject) $bar;

It would also support:

$foo = ( (\My\FooObject) $bar )->myFooObjectFunction();

I'm still trying to decide what would happen internally and I would like
some feedback. I'm thinking of 3 different things it could do:

1. Directly change the class type, functionally equivalent to:

   function castType($object, $type) {
   return unserialize(preg_replace("/^O:[0-9]+:"[^"]+":/i",
   "O:".strlen($type).":"$type":", serialize($object)));
   }

2. Throw a fatal error if the object doesn't match the type trying to be
   cast.

3. Add a new static magic method called __cast() that would allow the
   developer to decide what happens. Like this:

namespace \My;

class FooObject {
public static function __cast($foo) {
// Do stuff here
return new FooObject;
}
}

I'm willing to implement this myself if everybody else likes this idea.
Thanks!

Chris London

Hey everyone,

I want to get a feel for something I would like to implement into PHP core.
I would like to be able to cast objects to my own class types. Similar to
already available PHP syntax:

$foo = (string) $bar;

I've thought about this feature before in the context of PHP because I
do think it would be useful, but I'm not sure if there's really a way
to implement it that is any better than userland solutions. Your
proposed __cast() call means that every object needs to know about
every object which breaks down when multiple projects are involved.
(Sure, it solves some cases nicely.)

And I wouldn't be a fan of implicit conversions like:

function foo (Foo $foo) { }
foo(new Bar());

Assuming Bar does not descend from Foo, I wouldn't want a cast to Foo
to be implicitly performed even if Bar had an appropriate "cast"
method.

So ultimately, I don't really see how a PHP solution is any better
than just using home made explicit casts:

$bar = cast_foo_to_bar($foo);

or

$bar = $foo->castToBar();

So I think the idea has merit, but I don't know that there's a good
way to implement it.

--
Matthew Leverton