<?php
interface Equalable {
    function isEqualTo($other): bool;
}
/**
 * @method Ordering comparedTo(self $other)
 * @method static int compare(self $a, self $b)
 * @method static int compareReversed(self $a, self $b)
 * @method bool isLessThan(self $other)
 * @method bool isLessThanOrEqualTo(self $other)
 * @method bool isGreaterThan(self $other)
 * @method bool isGreaterThanOrEqualTo(self $other)
 */
interface Comparable extends Equalable {
    static function getCompareClosure(): Closure;
    static function getCompareReversedClosure(): Closure;
}
/**
 * @mixin Comparable
 */
trait Comparison /*requires Comparable*/ {
    abstract public function comparedTo(self $other): Ordering;
    final public static function compare(self $a, self $b): int {
        return $a->comparedTo($b)->getOrdinal();
    }
    final public static function getCompareClosure(): Closure {
        return Closure::fromCallable([static::class, 'compare']);
    }
    final public static function compareReversed(self $a, self $b): int {
        return $a->comparedTo($b)->getReverse()->getOrdinal();
    }
    final public static function getCompareReversedClosure(): Closure {
        return Closure::fromCallable([static::class, 'compareReversed']);
    }
    final public function isLessThan(self $other): bool {
        return $this->comparedTo($other)->isLess();
    }
    final public function isLessThanOrEqualTo(self $other): bool {
        return $this->comparedTo($other)->isLessOrEqual();
    }
    public function isEqualTo($other): bool {
        return $other instanceof $this && $this->comparedTo($other)->isEqual();
    }
    final public function isGreaterThan(self $other): bool {
        return $this->comparedTo($other)->isGreater();
    }
    final public function isGreaterThanOrEqualTo(self $other): bool {
        return $this->comparedTo($other)->isGreaterOrEqual();
    }
}
/*enum*/ final class Ordering implements Comparable {
    use Comparison;
    public const LT = -1;
    public const EQ = 0;
    public const GT = 1;
    private static $less;
    private static $equal;
    private static $greater;
    private $ordinal;
    private function __construct(int $ordinal) {
        assert(self::LT <= $ordinal && $ordinal <= self::GT);
        $this->ordinal = $ordinal;
    }
    public static function createFromOrdinal(int $ordinal): Ordering {
        if ($ordinal < self::EQ) {
            return self::LESS();
        }
        if ($ordinal > self::EQ) {
            return self::GREATER();
        }
        return self::EQUAL();
    }
    public static function LESS(): Ordering {
        return self::$less ?? self::$less = new static(self::LT);
    }
    public static function EQUAL(): Ordering {
        return self::$equal ?? self::$equal = new static(self::EQ);
    }
    public static function GREATER(): Ordering {
        return self::$greater ?? self::$greater = new static(self::GT);
    }
    public function comparedTo(self $other): Ordering {
        return self::createFromOrdinal($this->ordinal <=> $other->ordinal);
    }
    public function getOrdinal(): int {
        return $this->ordinal;
    }
    public function getReverse(): Ordering {
        return self::createFromOrdinal(-$this->ordinal);
    }
    public function isLess(): bool {
        return $this->ordinal === self::LT;
    }
    public function isLessOrEqual(): bool {
        return $this->isLess() || $this->isEqual();
    }
    public function isEqual(): bool {
        return $this->ordinal === self::EQ;
    }
    public function isGreater(): bool {
        return $this->ordinal === self::GT;
    }
    public function isGreaterOrEqual(): bool {
        return $this->isGreater() || $this->isEqual();
    }
}
$data = [Ordering::GREATER(), Ordering::LESS(), Ordering::EQUAL()];
usort($data, Ordering::getCompareClosure());
var_dump($data);
usort($data, Ordering::getCompareReversedClosure());
var_dump($data);
[$gt, $eq, $lt] = $data;
var_dump(
    $lt->isLessThan($lt),
    $lt->isLessThanOrEqualTo($lt),
    $lt->isEqualTo($lt),
    $lt->isGreaterThan($lt),
    $lt->isGreaterThanOrEqualTo($lt),
    $lt->isEqualTo('garbage')
);
// TypeError :)
var_dump($lt->comparedTo('garbage'));