Type variants

'Order does not match OrderForCheckout. Reason: ...'.

Sorry, this is text for second example) I missed this moment. But I think
the idea is clear.

For manual call of __match() type casting can be used:
$orderForCheckout = (OrderForCheckout)$order;

Also this feature can be used for checking enum values or intervals.

class Value
{
public $value;

public function __construct($value)
{
    $this->value = $value;
}

}

class State variant of Value
{
const ACTIVE = 1;
const INACTIVE = 2;

public function __match()
{
    return in_array($this->value, [self::ACTIVE, self::INACTIVE]);
}

}

function setState(State $s)
{
...
}

setState(new State(3));

In constructions like "new State($value)" __match() can be called after
__construct().

If to add a possibility to use data types, class Value will not be needed:

class State variant of integer
{
...
public function __match()
{
return in_array($this, [self::ACTIVE, self::INACTIVE]);
}
}

setState(3);

PHP already has horizontal inheritance. They're called traits.

How is this an improvement in anyway?

On Sat, Mar 11, 2017 at 1:36 AM, Michael Vostrikov <
michael.vostrikov@gmail.com> wrote:

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

$rectangle = new Rectangle(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:

My problem here is with the reason for needing a different class for
'Square' when $rectangle->is_square() is a simple additional check on a
single Rectangle class. drawSquare() seems redundant when
$rectangle->draw() does the same job ... a lot of duplicate code for
little gain? My problem I think is 'instanceof' is being used
incorrectly here.

'Order does not match OrderForCheckout. Reason: ...'.

The class is 'Order' which in my book will be a variable list of
'LineItem' and each line item will have a status such as is_instock().
The Order status of is_shipable() flags an order that is ready for
shipment which will produce an answer of yes, partial or no.

Just as you don't need to change Rectangle->Square just because you want
to draw a square with a set of numbers which started as a Rectangle, you
don't want to change the class from Order to OrderForCheckout. The base
order simple has a set of constraints which must be met before is_ready
can apply and is_billable will flag if you only charge for a shipment,
or take a full payment with order. LineItem has a check on 'backorder'
to validate if it's allowed to add items which are out of stock.

While I think I can see the logic behind describing these as different
types of object I think it is the same mistake as strictly enforcing
'int' when the raw data you have is a string of numbers. And just
because you know you have a number for the quantity to buy you still
need to check that against the stock level and handle it differently if
there is not sufficient stock. Trying to create 'type's for all the
variants of the object is just wrong? int_instock, int_minorder,
int_backorder, int_special_production and so on as the types of LineItem
so 'instanceof' will work for you?

--
Lester Caine - G8HFL

Contact - http://lsces.co.uk/wiki/?page=contact
L.S.Caine Electronic Services - http://lsces.co.uk
EnquirySolve - http://enquirysolve.com/
Model Engineers Digital Workshop - http://medw.co.uk
Rainbow Digital Media - http://rainbowdigitalmedia.co.uk

Hi Michael,

On Sat, Mar 11, 2017 at 3:36 PM, Michael Vostrikov <
michael.vostrikov@gmail.com> wrote:

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;
}

}

DbC allows this kind of validation at development time.
I suppose you would like to check requirement at runtime always.
It would be nice to have feature, but I think

something like __requrie()

is better name for the method.
IMO, C# like getter/setter is better though.

http://stackoverflow.com/questions/11159438/looking-for-a-short-simple-example-of-getters-setters-in-c-sharp

Regards,

--
Yasuo Ohgaki
yohgaki@ohgaki.net