Probably better bundled under request #52583 -- the RFC linked to there is specifically to deal with casting to scalar types, but the syntax suggested in the feature request is general enough to deal with arrays.

I found that request when researching this one. I read that as casting *to* an object not casting *from* an object. 

Am I missing something?

You are quite correct about request #52583. My apologies. I
remember skimming it when it came in, but obviously not very well. :)

To be honest, I think this is a better candidate for a thread on the
Internals mailing list or an RFC than a feature request here. I also
think this is extremely unlikely to make it in in any case,
particularly without a patch.

Nevertheless, I'll reopen this for now.

@aharvey: Couldn't the patch in the RFC you mentioned be modified to support arrays, too? Or would the implementation for arrays be completely different to the one for arrays?

I've found that when I have an object I need to behave like an array in some contexts that it is worth the time to implement Iterator and Array in the object, which allows the object to behave like an array.  It takes more effort than implementing a theoretical magic __toArray() method, but its worth it. 

Read here for information on doing this: http://php.net/manual/en/language.oop5.iterations.php

@dmgx This is not the problem the bug is about. What if you have some library 
which casts variables to arrays, like Zend_XMLRPC for example. Iterator or 
ArrayAccess will not do the job, since you need control over casting your class to 
array.

I really think this is relevant.
PHP 5.4 introduced something similar with the JsonSerializable interface.
When you call json_encode on an object that implements it, it automatically calls the jsonSerialize() method that returns a string, an array, an integer, a float or a boolean.

When you implement the jsonSerialize() method, you generally want to have a json-friendly representation of your current object, and you normally return an associative array with the properties you want to output. That looks like a __toArray() method, doesn't it ?

What would be very nice is the following code to work :
class A {

    protected   $property1 = 'foo', 
                $property2 = ['foo', 'bar'], 
                $property3;

    public function __toArray() {
        return [
            'property1' =>  $this->property1,
            'property2' =>  $this->property2,
        ];
    }

}

class B {
    public static function doSomethingWithData(array $data) {
        // ...
    }
}

$a  =   new A;
B::doSomethingWithData((array) $a);
array_change_key_case($a, CASE_UPPER); // Would automatically cast $a to array and output ['PROPERTY1' => 'foo, 'PROPERTY2' => ['foo', 'bar']]

Something that should be pointed out in the issue is that (array)$object is one of the most common object casts used out there. String casting are useful in templating, while array casting is useful for API returns, for instance... And there's currently no way to instinctively do this call in a protective way, as we can do with (string)$object.

Calling $object->toArray() is bulky and unreliable: if the developer knows the object will have that method (so they can call it), he already knows it needs further processing, just like string casts do.
Furthermore, implicit casts are always unreliable without a __toArray() magic method.

As an API developer for a couple of years, I've stumbled upon this API discrepancy between magic __toString() and explicit toArray() implementations. That's quite a bad smell for PHP's OO system.

It seems there's already an RFC with a patch to discuss that. How's this going?
https://wiki.php.net/rfc/object_cast_to_types

Hi there,

sorry for warming this up one more time, but I think __toArray() isn't the perfect solution to the problem. Since PHP is already able to use an object as an array using the Iterator interface, why don't we just extend this?

I made my thoughts a bit clearer in request #72579, if anyone is interested.

Because e.g. array_chunk() won't accept an object even if it meticulously implements all the gazillion iteration and array access interfaces.

A lot of functions depends on pure arrays even if any collection will be good enough.

So I suggest that object implementing __toArray() magic method will be casted using this method.

There is already a respective RFC[1] (currently under discussion),
so I'm suspending this ticket for the time being.

[1] <https://wiki.php.net/rfc/to-array>