Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:98477
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.161.181 as permitted sender)
MIME-Version: 1.0
Date: Sat, 11 Mar 2017 11:36:38 +0500
Message-ID: <CAEDdnaXrRnYQ24Dh7RdYmVdiYbBcXjnxo4_B0cNFe=FGewEbvQ@mail.gmail.com>
To: PHP Internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=94eb2c071944580d15054a6eb391
Subject: [PHP-DEV] Type variants
From: michael.vostrikov@gmail.com (Michael Vostrikov)

--94eb2c071944580d15054a6eb391
Content-Type: text/plain; charset=UTF-8

Hello. I have an idea which seems rather useful. I would like to know your
opinion,

Let's say we have class Rectangle and need to have class Square which will
be used in some operations. We don't need any rectangle, this must be only
square.
What if we could describe a type which is the same as another type but have
some restrictions for properties?

Something like this:

class Rectangle
{
    private $x;
    private $y;
    private $width;
    private $height;

    public function __construct($x, $y, $width, $height)
    {
        $this->x = $x;
        $this->y = $y;
        $this->width = $width;
        $this->height = $height;
    }
}

class Square variant of Rectangle
{
    public function __match()
    {
        if ($this->width != $this->height) {
            return ['width' => 'Width and height have to be the same'];
        }

        return true;
    }
}

function drawSquare(Square $square)
{
    // ...
}

$rectangle = new Rectagle(0, 0, 10, 10);
drawSquare($rectangle);

When drawSquare() is called, the check 'instanceof' is performed. It calls
magic method __match().
If __match() does not return true, it throws an exception with the data
returned:
'Order does not match OrderForCheckout. Reason: ...'.


Technically, we don't have method __match() in $rectangle object. So it can
be static, or a proxy object can be created here.

The second variant can be extended.
We may not to inherit implementation of methods, and describe another
interface instead, for example new object can be read only.

class Square variant of Rectangle
{
    public function ___match()
    {
        // ...
    }

    public function getWidth()
    {
        return parent::getWidth();
    }
}

With some changes in syntax it can be defined in this way:

class Square variant of Rectangle
{
    ...

    getWidth: base::getWidth;
}


This is like inheritance, but semantically differs a little.
Inheritance has vertical direction, type variants have horisontal one.
Also type variants have an access for all methods and properties of base
class, even for private.


Another example. Let's say we have an order checkout process which is
splitted into 3 steps - cart for products, date page, delivery address page.
This is not an input validation, this is a validation in business logic.

class Order
{
    public $products;
    public $date;
    public $address;
}

class OrderForCheckout variant of Order
{
    public function __match()
    {
        $errors = [];
        if (empty($this->products)) {
            $errors['products'] = 'Product list is empty';
        }
        if ($this->date === null) {
            $errors['date'] = 'Date is not selected';
        }
        if (empty($this->products)) {
            $errors['address'] = 'Address is not selected';
        }

        return (empty($errors) ? true : $errors);
    }
}

public function checkout(OrderForCheckout $order)
{
    ...
}

$order = findCurrentOrder();
checkout($order);  // if $order does not match requirements, the exception
will be thrown

--94eb2c071944580d15054a6eb391--