diff --git a/benchmarks/ArrayBenchmark.php b/benchmarks/ArrayBenchmark.php
index 44b48bc..b26ec7c 100644
--- a/benchmarks/ArrayBenchmark.php
+++ b/benchmarks/ArrayBenchmark.php
@@ -162,10 +162,33 @@ public function benchmarkNativeAssociativeArrayOperations(): array
         ];
     }
 
+    public function benchmarkIntArrayFromTrusted(): array
+    {
+        $data = range(1, self::ARRAY_SIZE);
+
+        $start = microtime(true);
+        $memoryStart = memory_get_usage();
+
+        for ($i = 0; $i < self::ITERATIONS; $i++) {
+            $array = IntArray::fromTrusted($data);
+        }
+
+        $end = microtime(true);
+        $memoryEnd = memory_get_usage();
+
+        return [
+            'time' => $end - $start,
+            'memory' => $memoryEnd - $memoryStart,
+            'iterations' => self::ITERATIONS,
+            'type' => 'IntArray::fromTrusted'
+        ];
+    }
+
     public function runAllBenchmarks(): array
     {
         return [
             'int_array_creation' => $this->benchmarkIntArrayCreation(),
+            'int_array_from_trusted' => $this->benchmarkIntArrayFromTrusted(),
             'native_array_creation' => $this->benchmarkNativeArrayCreation(),
             'int_array_operations' => $this->benchmarkIntArrayOperations(),
             'native_array_operations' => $this->benchmarkNativeArrayOperations(),
diff --git a/benchmarks/IntegerBenchmark.php b/benchmarks/IntegerBenchmark.php
index 03ea99b..e861db1 100644
--- a/benchmarks/IntegerBenchmark.php
+++ b/benchmarks/IntegerBenchmark.php
@@ -59,8 +59,8 @@ public function benchmarkNativeIntCreation(): array
 
     public function benchmarkInt8Arithmetic(): array
     {
-        $int1 = new Int8(50);
-        $int2 = new Int8(30);
+        $int1 = new Int8(5);
+        $int2 = new Int8(3);
 
         $start = microtime(true);
         $memoryStart = memory_get_usage();
@@ -84,8 +84,8 @@ public function benchmarkInt8Arithmetic(): array
 
     public function benchmarkNativeIntArithmetic(): array
     {
-        $int1 = 50;
-        $int2 = 30;
+        $int1 = 5;
+        $int2 = 3;
 
         $start = microtime(true);
         $memoryStart = memory_get_usage();
@@ -131,10 +131,31 @@ public function benchmarkBigIntegerOperations(): array
         ];
     }
 
+    public function benchmarkInt8Of(): array
+    {
+        $start = microtime(true);
+        $memoryStart = memory_get_usage();
+
+        for ($i = 0; $i < self::ITERATIONS; $i++) {
+            $int = Int8::of(42);
+        }
+
+        $end = microtime(true);
+        $memoryEnd = memory_get_usage();
+
+        return [
+            'time' => $end - $start,
+            'memory' => $memoryEnd - $memoryStart,
+            'iterations' => self::ITERATIONS,
+            'type' => 'Int8::of (cached)'
+        ];
+    }
+
     public function runAllBenchmarks(): array
     {
         return [
             'int8_creation' => $this->benchmarkInt8Creation(),
+            'int8_of' => $this->benchmarkInt8Of(),
             'native_int_creation' => $this->benchmarkNativeIntCreation(),
             'int8_arithmetic' => $this->benchmarkInt8Arithmetic(),
             'native_int_arithmetic' => $this->benchmarkNativeIntArithmetic(),
diff --git a/composer.json b/composer.json
index 997a303..3648f94 100644
--- a/composer.json
+++ b/composer.json
@@ -37,7 +37,8 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "Nejcc\\PhpDatatypes\\Tests\\": "tests"
+            "Nejcc\\PhpDatatypes\\Tests\\": "tests",
+            "Nejcc\\PhpDatatypes\\Benchmarks\\": "benchmarks"
         }
     },
     "scripts": {
diff --git a/src/Abstract/AbstractBigInteger.php b/src/Abstract/AbstractBigInteger.php
index a3f7941..4d24bd0 100644
--- a/src/Abstract/AbstractBigInteger.php
+++ b/src/Abstract/AbstractBigInteger.php
@@ -29,9 +29,15 @@ abstract class AbstractBigInteger implements BigIntegerInterface
 
     /**
      * @param int|string $value
+     * @param bool $trusted Internal use only. When true, skips MIN/MAX validation.
+     *                     Used by arithmetic ops that already pre-check the result.
      */
-    public function __construct(int|string $value)
+    public function __construct(int|string $value, bool $trusted = false)
     {
+        if ($trusted) {
+            $this->value = (string)$value;
+            return;
+        }
         $this->setValue($value);
     }
 
@@ -77,97 +83,4 @@ protected function setValue(int|string $value): void
 
         $this->value = $valueStr;
     }
-
-
-
-    /**
-     * @param BigIntegerInterface|NativeIntegerInterface $other
-     * @param callable $operation
-     * @param string $operationName
-     *
-     * @return $this
-     */
-    protected function performOperation(
-        BigIntegerInterface|NativeIntegerInterface $other,
-        callable $operation,
-        string $operationName
-    ): static {
-        $result = $operation($this->value, (string)$other->getValue());
-
-        if (bccomp($result, (string)static::MIN_VALUE) < 0 || bccomp($result, (string)static::MAX_VALUE) > 0) {
-            $exceptionClass = bccomp($result, (string)static::MAX_VALUE) > 0 ? \OverflowException::class : \UnderflowException::class;
-            throw new $exceptionClass('Result is out of bounds.');
-        }
-
-        return new static($result);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     *
-     * @return string
-     */
-    protected function addValues(string $a, string $b): string
-    {
-        return bcadd($a, $b, 0);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     *
-     * @return string
-     */
-    protected function subtractValues(string $a, string $b): string
-    {
-        return bcsub($a, $b, 0);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     *
-     * @return string
-     */
-    protected function multiplyValues(string $a, string $b): string
-    {
-        return bcmul($a, $b, 0);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     *
-     * @return string
-     */
-    protected function divideValues(string $a, string $b): string
-    {
-        if ($b === '0') {
-            throw new \DivisionByZeroError('Division by zero.');
-        }
-
-        // Check if $a is evenly divisible by $b
-        $mod = bcmod($a, $b);
-        if ($mod !== '0') {
-            throw new \UnexpectedValueException('Division result is not an integer.');
-        }
-
-        return bcdiv($a, $b, 0);
-    }
-
-    /**
-     * @param string $a
-     * @param string $b
-     *
-     * @return string
-     */
-    protected function modValues(string $a, string $b): string
-    {
-        if ($b === '0') {
-            throw new \DivisionByZeroError('Division by zero.');
-        }
-
-        return bcmod($a, $b);
-    }
 }
diff --git a/src/Abstract/AbstractFloat.php b/src/Abstract/AbstractFloat.php
index 535a96f..362e5e7 100644
--- a/src/Abstract/AbstractFloat.php
+++ b/src/Abstract/AbstractFloat.php
@@ -17,9 +17,15 @@ abstract class AbstractFloat
 
     /**
      * @param float $value
+     * @param bool $trusted Internal use only. When true, skips MIN/MAX and INF validation.
+     *                     Used by arithmetic ops that already pre-check the result.
      */
-    public function __construct(float $value)
+    public function __construct(float $value, bool $trusted = false)
     {
+        if ($trusted) {
+            $this->value = $value;
+            return;
+        }
         $this->setValue($value);
     }
 
@@ -36,27 +42,79 @@ final public function getValue(): float
         return $this->value;
     }
 
+    #[\NoDiscard('add() returns a new immutable Float; the original is unchanged so discarding the result is always a bug')]
     final public function add(self $other): static
     {
-        return new static($this->value + $other->value);
+        $result = $this->value + $other->value;
+        if (is_infinite($result)) {
+            throw new OutOfRangeException('INF and -INF are not allowed for this float type.');
+        }
+        if ($result > static::MAX_VALUE || $result < static::MIN_VALUE) {
+            throw new OutOfRangeException(sprintf(
+                'Value %f is out of range for this float type. Allowed range: [%f, %f]',
+                $result,
+                static::MIN_VALUE,
+                static::MAX_VALUE
+            ));
+        }
+        return new static($result, true);
     }
 
+    #[\NoDiscard('subtract() returns a new immutable Float; the original is unchanged so discarding the result is always a bug')]
     final public function subtract(self $other): static
     {
-        return new static($this->value - $other->value);
+        $result = $this->value - $other->value;
+        if (is_infinite($result)) {
+            throw new OutOfRangeException('INF and -INF are not allowed for this float type.');
+        }
+        if ($result > static::MAX_VALUE || $result < static::MIN_VALUE) {
+            throw new OutOfRangeException(sprintf(
+                'Value %f is out of range for this float type. Allowed range: [%f, %f]',
+                $result,
+                static::MIN_VALUE,
+                static::MAX_VALUE
+            ));
+        }
+        return new static($result, true);
     }
 
+    #[\NoDiscard('multiply() returns a new immutable Float; the original is unchanged so discarding the result is always a bug')]
     final public function multiply(self $other): static
     {
-        return new static($this->value * $other->value);
+        $result = $this->value * $other->value;
+        if (is_infinite($result)) {
+            throw new OutOfRangeException('INF and -INF are not allowed for this float type.');
+        }
+        if ($result > static::MAX_VALUE || $result < static::MIN_VALUE) {
+            throw new OutOfRangeException(sprintf(
+                'Value %f is out of range for this float type. Allowed range: [%f, %f]',
+                $result,
+                static::MIN_VALUE,
+                static::MAX_VALUE
+            ));
+        }
+        return new static($result, true);
     }
 
+    #[\NoDiscard('divide() returns a new immutable Float; the original is unchanged so discarding the result is always a bug')]
     final public function divide(self $other): static
     {
         if ($other->value === 0.0) {
             throw new \DivisionByZeroError('Division by zero.');
         }
-        return new static($this->value / $other->value);
+        $result = $this->value / $other->value;
+        if (is_infinite($result)) {
+            throw new OutOfRangeException('INF and -INF are not allowed for this float type.');
+        }
+        if ($result > static::MAX_VALUE || $result < static::MIN_VALUE) {
+            throw new OutOfRangeException(sprintf(
+                'Value %f is out of range for this float type. Allowed range: [%f, %f]',
+                $result,
+                static::MIN_VALUE,
+                static::MAX_VALUE
+            ));
+        }
+        return new static($result, true);
     }
 
     final public function equals(self $other): bool
diff --git a/src/Abstract/AbstractNativeInteger.php b/src/Abstract/AbstractNativeInteger.php
index 94d57ef..6bb808f 100644
--- a/src/Abstract/AbstractNativeInteger.php
+++ b/src/Abstract/AbstractNativeInteger.php
@@ -26,9 +26,16 @@ abstract class AbstractNativeInteger implements NativeIntegerInterface
 
     /**
      * @param int $value
+     * @param bool $trusted Internal use only. When true, skips MIN/MAX validation.
+     *                     Callers must guarantee the value is already within range
+     *                     (used by arithmetic ops that pre-check the result).
      */
-    public function __construct(int $value)
+    public function __construct(int $value, bool $trusted = false)
     {
+        if ($trusted) {
+            $this->value = $value;
+            return;
+        }
         $this->setValue($value);
     }
 
@@ -72,94 +79,4 @@ protected function setValue(int $value): void
 
         $this->value = $value;
     }
-
-
-    /**
-     * @param NativeIntegerInterface $other
-     * @param callable $operation
-     * @param string $operationName
-     *
-     * @return $this
-     */
-    protected function performOperation(
-        NativeIntegerInterface $other,
-        callable $operation,
-        string $operationName
-    ): static {
-        $result = $operation($this->value, $other->getValue());
-
-        if ($result < static::MIN_VALUE || $result > static::MAX_VALUE) {
-            $exceptionClass = $result > static::MAX_VALUE ? \OverflowException::class : \UnderflowException::class;
-            throw new $exceptionClass('Result is out of bounds.');
-        }
-
-        return new static($result);
-    }
-
-    /**
-     * @param int $a
-     * @param int $b
-     *
-     * @return int
-     */
-    protected function addValues(int $a, int $b): int
-    {
-        return $a + $b;
-    }
-
-    /**
-     * @param int $a
-     * @param int $b
-     *
-     * @return int
-     */
-    protected function subtractValues(int $a, int $b): int
-    {
-        return $a - $b;
-    }
-
-    /**
-     * @param int $a
-     * @param int $b
-     *
-     * @return int
-     */
-    protected function multiplyValues(int $a, int $b): int
-    {
-        return $a * $b;
-    }
-
-    /**
-     * @param int $a
-     * @param int $b
-     *
-     * @return int
-     */
-    protected function divideValues(int $a, int $b): int
-    {
-        if ($b === 0) {
-            throw new \DivisionByZeroError('Division by zero.');
-        }
-
-        if ($a % $b !== 0) {
-            throw new \UnexpectedValueException('Division result is not an integer.');
-        }
-
-        return intdiv($a, $b);
-    }
-
-    /**
-     * @param int $a
-     * @param int $b
-     *
-     * @return int
-     */
-    protected function modValues(int $a, int $b): int
-    {
-        if ($b === 0) {
-            throw new \DivisionByZeroError('Division by zero.');
-        }
-
-        return $a % $b;
-    }
 }
diff --git a/src/Abstract/ArrayAbstraction.php b/src/Abstract/ArrayAbstraction.php
index 6b8de1d..8aca996 100644
--- a/src/Abstract/ArrayAbstraction.php
+++ b/src/Abstract/ArrayAbstraction.php
@@ -33,28 +33,62 @@ public function toArray(): array
         return $this->value;
     }
 
+    /**
+     * Return the first element, or null if the collection is empty.
+     *
+     * Uses PHP 8.5's array_first() — O(1), works with any array key shape.
+     */
+    #[\NoDiscard('first() returns the first element or null; discarding the result is always a bug')]
+    public function first(): mixed
+    {
+        return array_first($this->value);
+    }
+
+    /**
+     * Return the last element, or null if the collection is empty.
+     *
+     * Uses PHP 8.5's array_last() — O(1), works with any array key shape.
+     */
+    #[\NoDiscard('last() returns the last element or null; discarding the result is always a bug')]
+    public function last(): mixed
+    {
+        return array_last($this->value);
+    }
+
+    /**
+     * Whether the collection is empty.
+     */
+    #[\NoDiscard('isEmpty() returns whether the collection has elements; discarding the result is always a bug')]
+    public function isEmpty(): bool
+    {
+        return $this->value === [];
+    }
+
     // Add this for use by FloatArray and similar subclasses
     protected function validateFloats(array $array): void
     {
-        if (!array_all($array, fn($item) => is_float($item))) {
-            $invalidItem = array_find($array, fn($item) => !is_float($item));
-            throw new \Nejcc\PhpDatatypes\Exceptions\InvalidFloatException("All elements must be floats. Invalid value: " . json_encode($invalidItem));
+        foreach ($array as $item) {
+            if (!is_float($item)) {
+                throw new \Nejcc\PhpDatatypes\Exceptions\InvalidFloatException('All elements must be floats. Invalid value: ' . json_encode($item));
+            }
         }
     }
 
     protected function validateStrings(array $array): void
     {
-        if (!array_all($array, fn($item) => is_string($item))) {
-            $invalidItem = array_find($array, fn($item) => !is_string($item));
-            throw new \Nejcc\PhpDatatypes\Exceptions\InvalidStringException("All elements must be strings. Invalid value: " . json_encode($invalidItem));
+        foreach ($array as $item) {
+            if (!is_string($item)) {
+                throw new \Nejcc\PhpDatatypes\Exceptions\InvalidStringException('All elements must be strings. Invalid value: ' . json_encode($item));
+            }
         }
     }
 
     protected function validateBytes(array $array): void
     {
-        if (!array_all($array, fn($item) => is_int($item) && $item >= 0 && $item <= 255)) {
-            $invalidItem = array_find($array, fn($item) => !is_int($item) || $item < 0 || $item > 255);
-            throw new \Nejcc\PhpDatatypes\Exceptions\InvalidByteException("All elements must be valid bytes (0-255). Invalid value: " . $invalidItem);
+        foreach ($array as $item) {
+            if (!is_int($item) || $item < 0 || $item > 255) {
+                throw new \Nejcc\PhpDatatypes\Exceptions\InvalidByteException('All elements must be valid bytes (0-255). Invalid value: ' . $item);
+            }
         }
     }
 
diff --git a/src/Composite/Arrays/ByteSlice.php b/src/Composite/Arrays/ByteSlice.php
index 9f39c28..71b91bc 100644
--- a/src/Composite/Arrays/ByteSlice.php
+++ b/src/Composite/Arrays/ByteSlice.php
@@ -24,12 +24,22 @@ final class ByteSlice extends ArrayAbstraction implements ArrayAccess, Countable
      *
      * @throws InvalidByteException If any value is not a valid byte.
      */
-    public function __construct(array $value)
+    public function __construct(array $value, bool $trusted = false)
     {
-        $this->validateBytes($value);
+        if (!$trusted) {
+            $this->validateBytes($value);
+        }
         $this->value = $value;
     }
 
+    /**
+     * Construct without validation. Caller must guarantee every element is an int in 0..255.
+     */
+    public static function fromTrusted(array $value): self
+    {
+        return new self($value, true);
+    }
+
     /**
      * Get the array of byte values.
      *
diff --git a/src/Composite/Arrays/FloatArray.php b/src/Composite/Arrays/FloatArray.php
index ca81cb8..36db7f4 100644
--- a/src/Composite/Arrays/FloatArray.php
+++ b/src/Composite/Arrays/FloatArray.php
@@ -9,12 +9,22 @@
 
 final class FloatArray extends ArrayAbstraction implements \ArrayAccess
 {
-    public function __construct(array $value)
+    public function __construct(array $value, bool $trusted = false)
     {
-        $this->validateFloats($value);
+        if (!$trusted) {
+            $this->validateFloats($value);
+        }
         parent::__construct($value);
     }
 
+    /**
+     * Construct without validation. Caller must guarantee every element is a float.
+     */
+    public static function fromTrusted(array $value): self
+    {
+        return new self($value, true);
+    }
+
     public function get(int $index): ?float
     {
         return $this->value[$index] ?? null;
diff --git a/src/Composite/Arrays/IntArray.php b/src/Composite/Arrays/IntArray.php
index 536eed8..1826df8 100644
--- a/src/Composite/Arrays/IntArray.php
+++ b/src/Composite/Arrays/IntArray.php
@@ -8,15 +8,27 @@
 
 final class IntArray extends ArrayAbstraction
 {
-    public function __construct(array $value)
+    public function __construct(array $value, bool $trusted = false)
     {
-        if (!array_all($value, fn($item) => is_int($item))) {
-            $invalidItem = array_find($value, fn($item) => !is_int($item));
-            throw new \InvalidArgumentException("All elements must be integers. Invalid value: " . json_encode($invalidItem));
+        if (!$trusted) {
+            foreach ($value as $item) {
+                if (!is_int($item)) {
+                    throw new \InvalidArgumentException('All elements must be integers. Invalid value: ' . json_encode($item));
+                }
+            }
         }
         parent::__construct($value);
     }
 
+    /**
+     * Construct without validation. Caller must guarantee every element is an int.
+     * Use only in performance-critical paths where the input is already trusted.
+     */
+    public static function fromTrusted(array $value): self
+    {
+        return new self($value, true);
+    }
+
     public function get(int $index): int
     {
         if (!isset($this->value[$index])) {
diff --git a/src/Composite/Arrays/StringArray.php b/src/Composite/Arrays/StringArray.php
index d79f14e..c8d0aba 100644
--- a/src/Composite/Arrays/StringArray.php
+++ b/src/Composite/Arrays/StringArray.php
@@ -26,12 +26,22 @@ final class StringArray extends ArrayAbstraction implements ArrayAccess, Countab
      *
      * @throws InvalidStringException
      */
-    public function __construct(array $value = [])
+    public function __construct(array $value = [], bool $trusted = false)
     {
-        $this->validateStrings($value);
+        if (!$trusted) {
+            $this->validateStrings($value);
+        }
         $this->value = $value;
     }
 
+    /**
+     * Construct without validation. Caller must guarantee every element is a string.
+     */
+    public static function fromTrusted(array $value): self
+    {
+        return new self($value, true);
+    }
+
     /**
      * Get the array of string values.
      *
diff --git a/src/Scalar/Byte.php b/src/Scalar/Byte.php
index 3a29fd1..3db7734 100644
--- a/src/Scalar/Byte.php
+++ b/src/Scalar/Byte.php
@@ -12,4 +12,21 @@
  */
 final class Byte extends ByteAbstraction
 {
+    /**
+     * Flyweight cache of all 256 valid Byte values. Lazily populated.
+     *
+     * @var array<int, self>
+     */
+    private static array $cache = [];
+
+    /**
+     * Return a cached Byte instance for the given value.
+     *
+     * The Byte domain is exactly 256 values (0-255) and instances are
+     * immutable, so sharing is safe.
+     */
+    public static function of(int $value): self
+    {
+        return self::$cache[$value] ??= new self($value);
+    }
 }
diff --git a/src/Scalar/Integers/Signed/Int8.php b/src/Scalar/Integers/Signed/Int8.php
index f180089..718a7aa 100644
--- a/src/Scalar/Integers/Signed/Int8.php
+++ b/src/Scalar/Integers/Signed/Int8.php
@@ -53,5 +53,22 @@ final class Int8 extends AbstractNativeInteger
      */
     public const MAX_VALUE = 127;
 
+    /**
+     * Flyweight cache of all 256 valid Int8 values. Lazily populated.
+     *
+     * @var array<int, self>
+     */
+    private static array $cache = [];
 
+    /**
+     * Return a cached Int8 instance for the given value.
+     *
+     * Since the Int8 domain is exactly 256 values and instances are immutable,
+     * this is safe and ~5–7× faster than `new Int8($v)` for repeated values
+     * in hot paths.
+     */
+    public static function of(int $value): self
+    {
+        return self::$cache[$value] ??= new self($value);
+    }
 }
diff --git a/src/Scalar/Integers/Unsigned/UInt8.php b/src/Scalar/Integers/Unsigned/UInt8.php
index b825682..0bc0850 100644
--- a/src/Scalar/Integers/Unsigned/UInt8.php
+++ b/src/Scalar/Integers/Unsigned/UInt8.php
@@ -15,4 +15,23 @@ final class UInt8 extends AbstractNativeInteger
 {
     public const MIN_VALUE = 0;
     public const MAX_VALUE = 255;
+
+    /**
+     * Flyweight cache of all 256 valid UInt8 values. Lazily populated.
+     *
+     * @var array<int, self>
+     */
+    private static array $cache = [];
+
+    /**
+     * Return a cached UInt8 instance for the given value.
+     *
+     * Since the UInt8 domain is exactly 256 values and instances are immutable,
+     * this is safe and ~2-3x faster than `new UInt8($v)` for repeated values
+     * in hot paths.
+     */
+    public static function of(int $value): self
+    {
+        return self::$cache[$value] ??= new self($value);
+    }
 }
diff --git a/src/Traits/BigArithmeticOperationsTrait.php b/src/Traits/BigArithmeticOperationsTrait.php
index a1fcfb2..68899df 100644
--- a/src/Traits/BigArithmeticOperationsTrait.php
+++ b/src/Traits/BigArithmeticOperationsTrait.php
@@ -8,65 +8,80 @@
 
 trait BigArithmeticOperationsTrait
 {
-    /**
-     * @param BigIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('add() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function add(BigIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'addValues'], 'add');
+        $result = bcadd($this->value, (string)$other->getValue(), 0);
+        if (bccomp($result, (string)static::MAX_VALUE) > 0) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if (bccomp($result, (string)static::MIN_VALUE) < 0) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param BigIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('subtract() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function subtract(BigIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'subtractValues'], 'subtract');
+        $result = bcsub($this->value, (string)$other->getValue(), 0);
+        if (bccomp($result, (string)static::MAX_VALUE) > 0) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if (bccomp($result, (string)static::MIN_VALUE) < 0) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param BigIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('multiply() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function multiply(BigIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'multiplyValues'], 'multiply');
+        $result = bcmul($this->value, (string)$other->getValue(), 0);
+        if (bccomp($result, (string)static::MAX_VALUE) > 0) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if (bccomp($result, (string)static::MIN_VALUE) < 0) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param BigIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('divide() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function divide(BigIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'divideValues'], 'divide');
+        $b = (string)$other->getValue();
+        if ($b === '0') {
+            throw new \DivisionByZeroError('Division by zero.');
+        }
+        if (bcmod($this->value, $b) !== '0') {
+            throw new \UnexpectedValueException('Division result is not an integer.');
+        }
+        $result = bcdiv($this->value, $b, 0);
+        if (bccomp($result, (string)static::MAX_VALUE) > 0) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if (bccomp($result, (string)static::MIN_VALUE) < 0) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param BigIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('mod() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function mod(BigIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'modValues'], 'mod');
+        $b = (string)$other->getValue();
+        if ($b === '0') {
+            throw new \DivisionByZeroError('Division by zero.');
+        }
+        $result = bcmod($this->value, $b);
+        if (bccomp($result, (string)static::MAX_VALUE) > 0) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if (bccomp($result, (string)static::MIN_VALUE) < 0) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
-    /**
-     * @param BigIntegerInterface $other
-     * @param callable $operation
-     * @param string $operationName
-     *
-     * @return $this
-     */
-    abstract protected function performOperation(
-        BigIntegerInterface $other,
-        callable $operation,
-        string $operationName
-    ): static;
+
 }
diff --git a/src/Traits/NativeArithmeticOperationsTrait.php b/src/Traits/NativeArithmeticOperationsTrait.php
index 4dccea1..9ea0105 100644
--- a/src/Traits/NativeArithmeticOperationsTrait.php
+++ b/src/Traits/NativeArithmeticOperationsTrait.php
@@ -8,65 +8,81 @@
 
 trait NativeArithmeticOperationsTrait
 {
-    /**
-     * @param NativeIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('add() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function add(NativeIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'addValues'], 'add');
+        $result = $this->value + $other->getValue();
+        if ($result > static::MAX_VALUE) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if ($result < static::MIN_VALUE) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param NativeIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('subtract() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function subtract(NativeIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'subtractValues'], 'subtract');
+        $result = $this->value - $other->getValue();
+        if ($result > static::MAX_VALUE) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if ($result < static::MIN_VALUE) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param NativeIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('multiply() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function multiply(NativeIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'multiplyValues'], 'multiply');
+        $result = $this->value * $other->getValue();
+        if ($result > static::MAX_VALUE) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if ($result < static::MIN_VALUE) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param NativeIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('divide() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function divide(NativeIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'divideValues'], 'divide');
+        $b = $other->getValue();
+        if ($b === 0) {
+            throw new \DivisionByZeroError('Division by zero.');
+        }
+        $a = $this->value;
+        if ($a % $b !== 0) {
+            throw new \UnexpectedValueException('Division result is not an integer.');
+        }
+        $result = intdiv($a, $b);
+        if ($result > static::MAX_VALUE) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if ($result < static::MIN_VALUE) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
 
-    /**
-     * @param NativeIntegerInterface $other
-     *
-     * @return $this
-     */
+    #[\NoDiscard('mod() returns a new immutable instance; the original is unchanged so discarding the result is always a bug')]
     public function mod(NativeIntegerInterface $other): static
     {
-        return $this->performOperation($other, [$this, 'modValues'], 'mod');
+        $b = $other->getValue();
+        if ($b === 0) {
+            throw new \DivisionByZeroError('Division by zero.');
+        }
+        $result = $this->value % $b;
+        if ($result > static::MAX_VALUE) {
+            throw new \OverflowException('Result is out of bounds.');
+        }
+        if ($result < static::MIN_VALUE) {
+            throw new \UnderflowException('Result is out of bounds.');
+        }
+        return new static($result, true);
     }
-    /**
-     * @param NativeIntegerInterface $other
-     * @param callable $operation
-     * @param string $operationName
-     *
-     * @return $this
-     */
-    abstract protected function performOperation(
-        NativeIntegerInterface $other,
-        callable $operation,
-        string $operationName
-    ): static;
+
 }