Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:96928
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.214.45 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <CAA69SC4th-Hkxj162xn3RWAG44tFkhGTo3Pm=mephPdSHfcHsw@mail.gmail.com>
References: <CAA69SC4th-Hkxj162xn3RWAG44tFkhGTo3Pm=mephPdSHfcHsw@mail.gmail.com>
Date: Wed, 16 Nov 2016 13:37:55 -0200
Message-ID: <CAEsg9X1uBMuTubtuo0ULkhPLr22HaNSFBrijnw7S7TO7Wuxhgg@mail.gmail.com>
To: =?UTF-8?Q?Silvio_Mariji=C4=87?= <marijic.silvio@gmail.com>
Cc: PHP Internals List <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Subject: Re: [PHP-DEV] Immutability RFC
From: david.proweb@gmail.com (David Rodrigues)

2016-11-16 11:57 GMT-02:00 Silvio Mariji=C4=87 <marijic.silvio@gmail.com>:
> If we treat those objects as values then this should return true. But the=
n
> again there might be some confusion because then two operators are doing
> the same thing. Maybe throw an error ? Suggestions ?

I just thinking about "how it will be done"?
I imagine that we should store all calling to memory, then I see two
problems for this case:

1. High memory consumption: all immutable objects should be stored on
memory eternally (or until the script ends). I mean: if I call it a
hundred times with differents parameters, I'll have a hundred of used
memory, that will avoid any used variables of be GC (once that it
should stores it for references).

2. High CPU consumption: every time that I instantiate an immutable
class, the engine will loop on each possibilities and check if all
parameters match to then return the same object (or then, create a
new). Then the major question for it is: should all parameters of an
immutable constructor be considered on instantiate? Should I pass the
exactly copy (read "reference") of object to the parameter to return
the same instance or a "shallow copy"?

For both problems above, I guess that a "factory pattern with cache"
should works better, once that I could consider the exact value where
it requires to be immutable, and I could cache only if it is really
required, for instance:

class SomeFactory {
    private static $cache =3D [];

    public static function getType(Type $type) {
        if (!$type->shouldBeCache()) {
            // Code flexibility...
            return new self($type);
        }

        if (!array_key_exists($type->id, self::$cache) {
            self::$cache[$type->id] =3D new self($type);
        }

        return self::$cache[$type->id];
    }
}


--=20
David Rodrigues