feat(types): Traceless types

docs/component/type.md

@@ -63,10 +63,10 @@
 
 #### `Interfaces`
 
-- [TypeInterface](./../../src/Psl/Type/TypeInterface.php#L14)
+- [TypeInterface](./../../src/Psl/Type/TypeInterface.php#L13)
 
 #### `Classes`
 
-- [Type](./../../src/Psl/Type/Type.php#L15)
+- [Type](./../../src/Psl/Type/Type.php#L14)
 
 

src/Psl/Internal/Loader.php

@@ -690,7 +690,6 @@ final class Loader
         'Psl\\Type\\Internal\\LiteralScalarType' => 'Psl/Type/Internal/LiteralScalarType.php',
         'Psl\\Type\\Internal\\BackedEnumType' => 'Psl/Type/Internal/BackedEnumType.php',
         'Psl\\Type\\Internal\\UnitEnumType' => 'Psl/Type/Internal/UnitEnumType.php',
-        'Psl\\Type\\Exception\\TypeTrace' => 'Psl/Type/Exception/TypeTrace.php',
         'Psl\\Type\\Exception\\AssertException' => 'Psl/Type/Exception/AssertException.php',
         'Psl\\Type\\Exception\\CoercionException' => 'Psl/Type/Exception/CoercionException.php',
         'Psl\\Type\\Exception\\Exception' => 'Psl/Type/Exception/Exception.php',

src/Psl/Type/Exception/AssertException.php

@@ -5,16 +5,33 @@
 namespace Psl\Type\Exception;
 
 use Psl\Str;
+use Psl\Vec;
+use Throwable;
 
 use function get_debug_type;
 
 final class AssertException extends Exception
 {
     private string $expected;
 
-    public function __construct(string $actual, string $expected, TypeTrace $typeTrace)
+    /**
+     * @param list<string> $paths
+     */
+    private function __construct(string $actual, string $expected, array $paths = [], ?Throwable $previous = null)
     {
-        parent::__construct(Str\format('Expected "%s", got "%s".', $expected, $actual), $actual, $typeTrace);
+        $first = $previous instanceof Exception ? $previous->getFirstFailingActualType() : $actual;
+
+        parent::__construct(
+            Str\format(
+                'Expected "%s", got "%s"%s.',
+                $expected,
+                $first,
+                $paths ? ' at path "' . Str\join($paths, '.') . '"' : ''
+            ),
+            $actual,
+            $paths,
+            $previous
+        );
 
         $this->expected = $expected;
     }
@@ -27,8 +44,11 @@ public function getExpectedType(): string
     public static function withValue(
         mixed $value,
         string $expected_type,
-        TypeTrace $trace
+        ?string $path = null,
+        ?Throwable $previous = null
     ): self {
-        return new self(get_debug_type($value), $expected_type, $trace);
+        $paths = $previous instanceof Exception ? [$path, ...$previous->getPaths()] : [$path];
+
+        return new self(get_debug_type($value), $expected_type, Vec\filter_nulls($paths), $previous);
     }
 }

src/Psl/Type/Exception/CoercionException.php

@@ -5,6 +5,7 @@
 namespace Psl\Type\Exception;
 
 use Psl\Str;
+use Psl\Vec;
 use Throwable;
 
 use function get_debug_type;
@@ -13,18 +14,24 @@ final class CoercionException extends Exception
 {
     private string $target;
 
-    public function __construct(string $actual, string $target, TypeTrace $typeTrace, string $additionalInfo = '')
+    /**
+     * @param list<string> $paths
+     */
+    private function __construct(string $actual, string $target, array $paths = [], ?Throwable $previous = null)
     {
+        $first = $previous instanceof Exception ? $previous->getFirstFailingActualType() : $actual;
+
         parent::__construct(
             Str\format(
-                'Could not coerce "%s" to type "%s"%s%s',
-                $actual,
+                'Could not coerce "%s" to type "%s"%s%s.',
+                $first,
                 $target,
-                $additionalInfo ? ': ' : '.',
-                $additionalInfo
+                $paths ? ' at path "' . Str\join($paths, '.') . '"' : '',
+                $previous && !$previous instanceof self ? ': ' . $previous->getMessage() : '',
             ),
             $actual,
-            $typeTrace,
+            $paths,
+            $previous
         );
 
         $this->target = $target;
@@ -38,22 +45,11 @@ public function getTargetType(): string
     public static function withValue(
         mixed $value,
         string $target,
-        TypeTrace $typeTrace
+        ?string $path = null,
+        ?Throwable $previous = null
     ): self {
-        return new self(get_debug_type($value), $target, $typeTrace);
-    }
+        $paths = $previous instanceof Exception ? [$path, ...$previous->getPaths()] : [$path];
 
-    public static function withConversionFailureOnValue(
-        mixed $value,
-        string $target,
-        TypeTrace $typeTrace,
-        Throwable $failure,
-    ): self {
-        return new self(
-            get_debug_type($value),
-            $target,
-            $typeTrace,
-            $failure->getMessage()
-        );
+        return new self(get_debug_type($value), $target, Vec\filter_nulls($paths), $previous);
     }
 }

src/Psl/Type/Exception/Exception.php

@@ -5,30 +5,50 @@
 namespace Psl\Type\Exception;
 
 use Psl\Exception\RuntimeException;
+use Throwable;
 
 abstract class Exception extends RuntimeException implements ExceptionInterface
 {
-    private TypeTrace $typeTrace;
     private string $actual;
 
-    public function __construct(
+    /**
+     * @var list<string>
+     */
+    private array $paths;
+
+    private string $first;
+
+    /**
+     * @param list<string> $paths
+     */
+    protected function __construct(
         string $message,
         string $actual,
-        TypeTrace $typeTrace
+        array $paths,
+        ?Throwable $previous = null
     ) {
-        parent::__construct($message);
+        parent::__construct($message, 0, $previous);
 
-        $this->actual    = $actual;
-        $this->typeTrace = $typeTrace;
+        $this->paths = $paths;
+        $this->first = $previous instanceof self ? $previous->first : $actual;
+        $this->actual = $actual;
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getPaths(): array
+    {
+        return $this->paths;
     }
 
     public function getActualType(): string
     {
         return $this->actual;
     }
 
-    public function getTypeTrace(): TypeTrace
+    public function getFirstFailingActualType(): string
     {
-        return $this->typeTrace;
+        return $this->first;
     }
 }

src/Psl/Type/Internal/BackedEnumType.php

@@ -43,21 +43,21 @@ public function coerce(mixed $value): BackedEnum
 
         foreach (($this->enum)::cases() as $case) {
             if (Type\string()->matches($case->value)) {
-                $string_value = Type\string()->withTrace($this->getTrace())->coerce($value);
+                $string_value = Type\string()->coerce($value);
 
                 if ($string_value === $case->value) {
                     return $case;
                 }
             } else {
-                $integer_value = Type\int()->withTrace($this->getTrace())->coerce($value);
+                $integer_value = Type\int()->coerce($value);
 
                 if ($integer_value === $case->value) {
                     return $case;
                 }
             }
         }
 
-        throw CoercionException::withValue($value, $this->toString(), $this->getTrace());
+        throw CoercionException::withValue($value, $this->toString());
     }
 
     /**
@@ -73,7 +73,7 @@ public function assert(mixed $value): BackedEnum
             return $value;
         }
 
-        throw AssertException::withValue($value, $this->toString(), $this->getTrace());
+        throw AssertException::withValue($value, $this->toString());
     }
 
     public function toString(): string

src/Psl/Type/Internal/BoolType.php

@@ -42,7 +42,7 @@ public function coerce(mixed $value): bool
             return true;
         }
 
-        throw CoercionException::withValue($value, $this->toString(), $this->getTrace());
+        throw CoercionException::withValue($value, $this->toString());
     }
 
     /**
@@ -56,7 +56,7 @@ public function assert(mixed $value): bool
             return $value;
         }
 
-        throw AssertException::withValue($value, $this->toString(), $this->getTrace());
+        throw AssertException::withValue($value, $this->toString());
     }
 
     public function toString(): string

src/Psl/Type/Internal/ClassStringType.php

@@ -50,7 +50,7 @@ public function coerce(mixed $value): string
             return $value;
         }
 
-        throw CoercionException::withValue($value, $this->toString(), $this->getTrace());
+        throw CoercionException::withValue($value, $this->toString());
     }
 
     /**
@@ -66,7 +66,7 @@ public function assert(mixed $value): string
             return $value;
         }
 
-        throw AssertException::withValue($value, $this->toString(), $this->getTrace());
+        throw AssertException::withValue($value, $this->toString());
     }
 
     public function toString(): string

src/Psl/Type/Internal/ConvertedType.php

@@ -48,15 +48,29 @@ public function coerce(mixed $value): mixed
             return $value;
         }
 
-        $coercedInput = $this->from->coerce($value);
+        $action = 0;
 
         try {
+            $coercedInput = $this->from->coerce($value);
+            $action++;
             $converted = ($this->converter)($coercedInput);
+            $action++;
+            return $this->into->coerce($converted);
         } catch (Throwable $failure) {
-            throw CoercionException::withConversionFailureOnValue($value, $this->toString(), $this->getTrace(), $failure);
+            throw CoercionException::withValue(
+                $value,
+                match ($action) {
+                    0 => $this->from->toString(),
+                    default => $this->into->toString(),
+                },
+                match ($action) {
+                    0 => PathExpression::coerceInput($value, $this->from->toString()),
+                    1 => PathExpression::convert($coercedInput ?? null, $this->into->toString()),
+                    default => PathExpression::coerceOutput($converted ?? null, $this->into->toString()),
+                },
+                $failure
+            );
         }
-
-        return $this->into->coerce($converted);
     }
 
     /**