1: <?php declare(strict_types = 1);
2:
3: namespace PHPStan;
4:
5: use PHPStan\Type\BooleanType;
6: use PHPStan\Type\Constant\ConstantBooleanType;
7: use function array_column;
8: use function max;
9: use function min;
10:
11: /**
12: * @api
13: * @see https://en.wikipedia.org/wiki/Three-valued_logic
14: */
15: class TrinaryLogic
16: {
17:
18: private const YES = 1;
19: private const MAYBE = 0;
20: private const NO = -1;
21:
22: /** @var self[] */
23: private static array $registry = [];
24:
25: private function __construct(private int $value)
26: {
27: }
28:
29: public static function createYes(): self
30: {
31: return self::$registry[self::YES] ??= new self(self::YES);
32: }
33:
34: public static function createNo(): self
35: {
36: return self::$registry[self::NO] ??= new self(self::NO);
37: }
38:
39: public static function createMaybe(): self
40: {
41: return self::$registry[self::MAYBE] ??= new self(self::MAYBE);
42: }
43:
44: public static function createFromBoolean(bool $value): self
45: {
46: $yesNo = $value ? self::YES : self::NO;
47: return self::$registry[$yesNo] ??= new self($yesNo);
48: }
49:
50: private static function create(int $value): self
51: {
52: self::$registry[$value] ??= new self($value);
53: return self::$registry[$value];
54: }
55:
56: public function yes(): bool
57: {
58: return $this->value === self::YES;
59: }
60:
61: public function maybe(): bool
62: {
63: return $this->value === self::MAYBE;
64: }
65:
66: public function no(): bool
67: {
68: return $this->value === self::NO;
69: }
70:
71: public function toBooleanType(): BooleanType
72: {
73: if ($this->value === self::MAYBE) {
74: return new BooleanType();
75: }
76:
77: return new ConstantBooleanType($this->value === self::YES);
78: }
79:
80: public function and(self ...$operands): self
81: {
82: $operandValues = array_column($operands, 'value');
83: $operandValues[] = $this->value;
84: return self::create(min($operandValues));
85: }
86:
87: /**
88: * @template T
89: * @param T[] $objects
90: * @param callable(T): self $callback
91: */
92: public function lazyAnd(
93: array $objects,
94: callable $callback,
95: ): self
96: {
97: if ($this->no()) {
98: return $this;
99: }
100:
101: $results = [];
102: foreach ($objects as $object) {
103: $result = $callback($object);
104: if ($result->no()) {
105: return $result;
106: }
107:
108: $results[] = $result;
109: }
110:
111: return $this->and(...$results);
112: }
113:
114: public function or(self ...$operands): self
115: {
116: $operandValues = array_column($operands, 'value');
117: $operandValues[] = $this->value;
118: return self::create(max($operandValues));
119: }
120:
121: /**
122: * @template T
123: * @param T[] $objects
124: * @param callable(T): self $callback
125: */
126: public function lazyOr(
127: array $objects,
128: callable $callback,
129: ): self
130: {
131: if ($this->yes()) {
132: return $this;
133: }
134:
135: $results = [];
136: foreach ($objects as $object) {
137: $result = $callback($object);
138: if ($result->yes()) {
139: return $result;
140: }
141:
142: $results[] = $result;
143: }
144:
145: return $this->or(...$results);
146: }
147:
148: public static function extremeIdentity(self ...$operands): self
149: {
150: if ($operands === []) {
151: throw new ShouldNotHappenException();
152: }
153: $operandValues = array_column($operands, 'value');
154: $min = min($operandValues);
155: $max = max($operandValues);
156: return self::create($min === $max ? $min : self::MAYBE);
157: }
158:
159: /**
160: * @template T
161: * @param T[] $objects
162: * @param callable(T): self $callback
163: */
164: public static function lazyExtremeIdentity(
165: array $objects,
166: callable $callback,
167: ): self
168: {
169: if ($objects === []) {
170: throw new ShouldNotHappenException();
171: }
172:
173: $lastResult = null;
174: foreach ($objects as $object) {
175: $result = $callback($object);
176: if ($lastResult === null) {
177: $lastResult = $result;
178: continue;
179: }
180: if ($lastResult->equals($result)) {
181: continue;
182: }
183:
184: return self::createMaybe();
185: }
186:
187: return $lastResult;
188: }
189:
190: public static function maxMin(self ...$operands): self
191: {
192: if ($operands === []) {
193: throw new ShouldNotHappenException();
194: }
195: $operandValues = array_column($operands, 'value');
196: return self::create(max($operandValues) > 0 ? 1 : min($operandValues));
197: }
198:
199: /**
200: * @template T
201: * @param T[] $objects
202: * @param callable(T): self $callback
203: */
204: public static function lazyMaxMin(
205: array $objects,
206: callable $callback,
207: ): self
208: {
209: $results = [];
210: foreach ($objects as $object) {
211: $result = $callback($object);
212: if ($result->yes()) {
213: return $result;
214: }
215:
216: $results[] = $result;
217: }
218:
219: return self::maxMin(...$results);
220: }
221:
222: public function negate(): self
223: {
224: return self::create(-$this->value);
225: }
226:
227: public function equals(self $other): bool
228: {
229: return $this === $other;
230: }
231:
232: public function compareTo(self $other): ?self
233: {
234: if ($this->value > $other->value) {
235: return $this;
236: } elseif ($other->value > $this->value) {
237: return $other;
238: }
239:
240: return null;
241: }
242:
243: public function describe(): string
244: {
245: static $labels = [
246: self::NO => 'No',
247: self::MAYBE => 'Maybe',
248: self::YES => 'Yes',
249: ];
250:
251: return $labels[$this->value];
252: }
253:
254: /**
255: * @param mixed[] $properties
256: */
257: public static function __set_state(array $properties): self
258: {
259: return self::create($properties['value']);
260: }
261:
262: }
263: