[String] add types to all arguments

nicolas-grekas · nicolas-grekas · commit b995c211729a · 2021-05-28T10:10:10.000+02:00
diff --git a/AbstractString.php b/AbstractString.php
@@ -95,12 +95,16 @@ public static function wrap(array $values): array
      *
      * @return static
      */
-    public function after($needle, bool $includeNeedle = false, int $offset = 0): self
+    public function after(string|iterable $needle, bool $includeNeedle = false, int $offset = 0): self
     {
         $str = clone $this;
         $i = \PHP_INT_MAX;
 
-        foreach ((array) $needle as $n) {
+        if (\is_string($needle)) {
+            $needle = [$needle];
+        }
+
+        foreach ($needle as $n) {
             $n = (string) $n;
             $j = $this->indexOf($n, $offset);
 
@@ -126,12 +130,16 @@ public function after($needle, bool $includeNeedle = false, int $offset = 0): se
      *
      * @return static
      */
-    public function afterLast($needle, bool $includeNeedle = false, int $offset = 0): self
+    public function afterLast(string|iterable $needle, bool $includeNeedle = false, int $offset = 0): self
     {
         $str = clone $this;
         $i = null;
 
-        foreach ((array) $needle as $n) {
+        if (\is_string($needle)) {
+            $needle = [$needle];
+        }
+
+        foreach ($needle as $n) {
             $n = (string) $n;
             $j = $this->indexOfLast($n, $offset);
 
@@ -162,12 +170,16 @@ abstract public function append(string ...$suffix): self;
      *
      * @return static
      */
-    public function before($needle, bool $includeNeedle = false, int $offset = 0): self
+    public function before(string|iterable $needle, bool $includeNeedle = false, int $offset = 0): self
     {
         $str = clone $this;
         $i = \PHP_INT_MAX;
 
-        foreach ((array) $needle as $n) {
+        if (\is_string($needle)) {
+            $needle = [$needle];
+        }
+
+        foreach ($needle as $n) {
             $n = (string) $n;
             $j = $this->indexOf($n, $offset);
 
@@ -193,12 +205,16 @@ public function before($needle, bool $includeNeedle = false, int $offset = 0): s
      *
      * @return static
      */
-    public function beforeLast($needle, bool $includeNeedle = false, int $offset = 0): self
+    public function beforeLast(string|iterable $needle, bool $includeNeedle = false, int $offset = 0): self
     {
         $str = clone $this;
         $i = null;
 
-        foreach ((array) $needle as $n) {
+        if (\is_string($needle)) {
+            $needle = [$needle];
+        }
+
+        foreach ($needle as $n) {
             $n = (string) $n;
             $j = $this->indexOfLast($n, $offset);
 
@@ -253,17 +269,17 @@ public function collapseWhitespace(): self
     /**
      * @param string|string[] $needle
      */
-    public function containsAny($needle): bool
+    public function containsAny(string|iterable $needle): bool
     {
         return null !== $this->indexOf($needle);
     }
 
     /**
      * @param string|string[] $suffix
      */
-    public function endsWith($suffix): bool
+    public function endsWith(string|iterable $suffix): bool
     {
-        if (!\is_array($suffix) && !$suffix instanceof \Traversable) {
+        if (\is_string($suffix)) {
             throw new \TypeError(sprintf('Method "%s()" must be overridden by class "%s" to deal with non-iterable values.', __FUNCTION__, static::class));
         }
 
@@ -316,9 +332,9 @@ public function ensureStart(string $prefix): self
     /**
      * @param string|string[] $string
      */
-    public function equalsTo($string): bool
+    public function equalsTo(string|iterable $string): bool
     {
-        if (!\is_array($string) && !$string instanceof \Traversable) {
+        if (\is_string($string)) {
             throw new \TypeError(sprintf('Method "%s()" must be overridden by class "%s" to deal with non-iterable values.', __FUNCTION__, static::class));
         }
 
@@ -350,9 +366,9 @@ public function ignoreCase(): self
     /**
      * @param string|string[] $needle
      */
-    public function indexOf($needle, int $offset = 0): ?int
+    public function indexOf(string|iterable $needle, int $offset = 0): ?int
     {
-        if (!\is_array($needle) && !$needle instanceof \Traversable) {
+        if (\is_string($needle)) {
             throw new \TypeError(sprintf('Method "%s()" must be overridden by class "%s" to deal with non-iterable values.', __FUNCTION__, static::class));
         }
 
@@ -372,9 +388,9 @@ public function indexOf($needle, int $offset = 0): ?int
     /**
      * @param string|string[] $needle
      */
-    public function indexOfLast($needle, int $offset = 0): ?int
+    public function indexOfLast(string|iterable $needle, int $offset = 0): ?int
     {
-        if (!\is_array($needle) && !$needle instanceof \Traversable) {
+        if (\is_string($needle)) {
             throw new \TypeError(sprintf('Method "%s()" must be overridden by class "%s" to deal with non-iterable values.', __FUNCTION__, static::class));
         }
 
@@ -467,7 +483,7 @@ abstract public function replace(string $from, string $to): self;
      *
      * @return static
      */
-    abstract public function replaceMatches(string $fromRegexp, $to): self;
+    abstract public function replaceMatches(string $fromRegexp, string|callable $to): self;
 
     /**
      * @return static
@@ -540,9 +556,9 @@ public function split(string $delimiter, int $limit = null, int $flags = null):
     /**
      * @param string|string[] $prefix
      */
-    public function startsWith($prefix): bool
+    public function startsWith(string|iterable $prefix): bool
     {
-        if (!\is_array($prefix) && !$prefix instanceof \Traversable) {
+        if (\is_string($prefix)) {
             throw new \TypeError(sprintf('Method "%s()" must be overridden by class "%s" to deal with non-iterable values.', __FUNCTION__, static::class));
         }
 
diff --git a/AbstractUnicodeString.php b/AbstractUnicodeString.php
@@ -303,7 +303,7 @@ public function padStart(int $length, string $padStr = ' '): parent
         return $this->pad($length, $pad, \STR_PAD_LEFT);
     }
 
-    public function replaceMatches(string $fromRegexp, $to): parent
+    public function replaceMatches(string $fromRegexp, string|callable $to): parent
     {
         if ($this->ignoreCase) {
             $fromRegexp .= 'i';
diff --git a/ByteString.php b/ByteString.php
@@ -129,27 +129,23 @@ public function chunk(int $length = 1): array
         return $chunks;
     }
 
-    public function endsWith($suffix): bool
+    public function endsWith(string|iterable|AbstractString $suffix): bool
     {
-        if ($suffix instanceof parent) {
+        if ($suffix instanceof AbstractString) {
             $suffix = $suffix->string;
-        } elseif (\is_array($suffix) || $suffix instanceof \Traversable) {
+        } elseif (!\is_string($suffix)) {
             return parent::endsWith($suffix);
-        } else {
-            $suffix = (string) $suffix;
         }
 
         return '' !== $suffix && \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix), null, $this->ignoreCase);
     }
 
-    public function equalsTo($string): bool
+    public function equalsTo(string|iterable|AbstractString $string): bool
     {
-        if ($string instanceof parent) {
+        if ($string instanceof AbstractString) {
             $string = $string->string;
-        } elseif (\is_array($string) || $string instanceof \Traversable) {
+        } elseif (!\is_string($string)) {
             return parent::equalsTo($string);
-        } else {
-            $string = (string) $string;
         }
 
         if ('' !== $string && $this->ignoreCase) {
@@ -167,14 +163,12 @@ public function folded(): parent
         return $str;
     }
 
-    public function indexOf($needle, int $offset = 0): ?int
+    public function indexOf(string|iterable|AbstractString $needle, int $offset = 0): ?int
     {
-        if ($needle instanceof parent) {
+        if ($needle instanceof AbstractString) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
+        } elseif (!\is_string($needle)) {
             return parent::indexOf($needle, $offset);
-        } else {
-            $needle = (string) $needle;
         }
 
         if ('' === $needle) {
@@ -186,14 +180,12 @@ public function indexOf($needle, int $offset = 0): ?int
         return false === $i ? null : $i;
     }
 
-    public function indexOfLast($needle, int $offset = 0): ?int
+    public function indexOfLast(string|iterable|AbstractString $needle, int $offset = 0): ?int
     {
-        if ($needle instanceof parent) {
+        if ($needle instanceof AbstractString) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
+        } elseif (!\is_string($needle)) {
             return parent::indexOfLast($needle, $offset);
-        } else {
-            $needle = (string) $needle;
         }
 
         if ('' === $needle) {
@@ -305,7 +297,7 @@ public function replace(string $from, string $to): parent
         return $str;
     }
 
-    public function replaceMatches(string $fromRegexp, $to): parent
+    public function replaceMatches(string $fromRegexp, string|callable $to): parent
     {
         if ($this->ignoreCase) {
             $fromRegexp .= 'i';
@@ -404,9 +396,9 @@ public function split(string $delimiter, int $limit = null, int $flags = null):
         return $chunks;
     }
 
-    public function startsWith($prefix): bool
+    public function startsWith(string|iterable|AbstractString $prefix): bool
     {
-        if ($prefix instanceof parent) {
+        if ($prefix instanceof AbstractString) {
             $prefix = $prefix->string;
         } elseif (!\is_string($prefix)) {
             return parent::startsWith($prefix);
diff --git a/CodePointString.php b/CodePointString.php
@@ -80,14 +80,12 @@ public function codePointsAt(int $offset): array
         return '' === $str->string ? [] : [mb_ord($str->string, 'UTF-8')];
     }
 
-    public function endsWith($suffix): bool
+    public function endsWith(string|iterable|AbstractString $suffix): bool
     {
         if ($suffix instanceof AbstractString) {
             $suffix = $suffix->string;
-        } elseif (\is_array($suffix) || $suffix instanceof \Traversable) {
+        } elseif (!\is_string($suffix)) {
             return parent::endsWith($suffix);
-        } else {
-            $suffix = (string) $suffix;
         }
 
         if ('' === $suffix || !preg_match('//u', $suffix)) {
@@ -101,14 +99,12 @@ public function endsWith($suffix): bool
         return \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix));
     }
 
-    public function equalsTo($string): bool
+    public function equalsTo(string|iterable|AbstractString $string): bool
     {
         if ($string instanceof AbstractString) {
             $string = $string->string;
-        } elseif (\is_array($string) || $string instanceof \Traversable) {
+        } elseif (!\is_string($string)) {
             return parent::equalsTo($string);
-        } else {
-            $string = (string) $string;
         }
 
         if ('' !== $string && $this->ignoreCase) {
@@ -118,14 +114,12 @@ public function equalsTo($string): bool
         return $string === $this->string;
     }
 
-    public function indexOf($needle, int $offset = 0): ?int
+    public function indexOf(string|iterable|AbstractString $needle, int $offset = 0): ?int
     {
         if ($needle instanceof AbstractString) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
+        } elseif (!\is_string($needle)) {
             return parent::indexOf($needle, $offset);
-        } else {
-            $needle = (string) $needle;
         }
 
         if ('' === $needle) {
@@ -137,14 +131,12 @@ public function indexOf($needle, int $offset = 0): ?int
         return false === $i ? null : $i;
     }
 
-    public function indexOfLast($needle, int $offset = 0): ?int
+    public function indexOfLast(string|iterable|AbstractString $needle, int $offset = 0): ?int
     {
         if ($needle instanceof AbstractString) {
             $needle = $needle->string;
-        } elseif (\is_array($needle) || $needle instanceof \Traversable) {
+        } elseif (!\is_string($needle)) {
             return parent::indexOfLast($needle, $offset);
-        } else {
-            $needle = (string) $needle;
         }
 
         if ('' === $needle) {
@@ -247,14 +239,12 @@ public function split(string $delimiter, int $limit = null, int $flags = null):
         return $chunks;
     }
 
-    public function startsWith($prefix): bool
+    public function startsWith(string|iterable|AbstractString $prefix): bool
     {
         if ($prefix instanceof AbstractString) {
             $prefix = $prefix->string;
-        } elseif (\is_array($prefix) || $prefix instanceof \Traversable) {
+        } elseif (!\is_string($prefix)) {
             return parent::startsWith($prefix);
-        } else {
-            $prefix = (string) $prefix;
         }
 
         if ('' === $prefix || !preg_match('//u', $prefix)) {
diff --git a/LazyString.php b/LazyString.php
@@ -25,10 +25,10 @@ class LazyString implements \Stringable, \JsonSerializable
      *
      * @return static
      */
-    public static function fromCallable($callback, ...$arguments): self
+    public static function fromCallable(callable|array $callback, mixed ...$arguments): self
     {
-        if (!\is_callable($callback) && !(\is_array($callback) && isset($callback[0]) && $callback[0] instanceof \Closure && 2 >= \count($callback))) {
-            throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a callable or a [Closure, method] lazy-callable, "%s" given.', __METHOD__, get_debug_type($callback)));
+        if (\is_array($callback) && !\is_callable($callback) && !(($callback[0] ?? null) instanceof \Closure || 2 < \count($callback))) {
+            throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a callable or a [Closure, method] lazy-callable, "%s" given.', __METHOD__, '['.implode(', ', array_map('get_debug_type', $callback)).']'));
         }
 
         $lazyString = new static();
@@ -50,16 +50,10 @@ public static function fromCallable($callback, ...$arguments): self
     }
 
     /**
-     * @param string|int|float|bool|\Stringable $value
-     *
      * @return static
      */
-    public static function fromStringable($value): self
+    public static function fromStringable(string|int|float|bool|\Stringable $value): self
     {
-        if (!self::isStringable($value)) {
-            throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a scalar or a stringable object, "%s" given.', __METHOD__, get_debug_type($value)));
-        }
-
         if (\is_object($value)) {
             return static::fromCallable([$value, '__toString']);
         }
@@ -73,19 +67,17 @@ public static function fromStringable($value): self
     /**
      * Tells whether the provided value can be cast to string.
      */
-    final public static function isStringable($value): bool
+    final public static function isStringable(mixed $value): bool
     {
-        return \is_string($value) || $value instanceof self || (\is_object($value) ? method_exists($value, '__toString') : is_scalar($value));
+        return \is_string($value) || $value instanceof \Stringable || is_scalar($value);
     }
 
     /**
      * Casts scalars and stringable objects to strings.
      *
-     * @param object|string|int|float|bool $value
-     *
      * @throws \TypeError When the provided value is not stringable
      */
-    final public static function resolve($value): string
+    final public static function resolve(\Stringable|string|int|float|bool $value): string
     {
         return $value;
     }
diff --git a/Slugger/AsciiSlugger.php b/Slugger/AsciiSlugger.php
diff --git a/UnicodeString.php b/UnicodeString.php

Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ public function padStart(int $length, string $padStr = ' '): parent`
`303`	`303`	`return $this->pad($length, $pad, \STR_PAD_LEFT);`
`304`	`304`	`}`
`305`	`305`
`306`		`- public function replaceMatches(string $fromRegexp, $to): parent`
	`306`	`+ public function replaceMatches(string $fromRegexp, string\|callable $to): parent`
`307`	`307`	`{`
`308`	`308`	`if ($this->ignoreCase) {`
`309`	`309`	`$fromRegexp .= 'i';`
Original file line number	Diff line number	Diff line change
`@@ -129,27 +129,23 @@ public function chunk(int $length = 1): array`
`129`	`129`	`return $chunks;`
`130`	`130`	`}`
`131`	`131`
`132`		`- public function endsWith($suffix): bool`
	`132`	`+ public function endsWith(string\|iterable\|AbstractString $suffix): bool`
`133`	`133`	`{`
`134`		`- if ($suffix instanceof parent) {`
	`134`	`+ if ($suffix instanceof AbstractString) {`
`135`	`135`	`$suffix = $suffix->string;`
`136`		`- } elseif (\is_array($suffix) \|\| $suffix instanceof \Traversable) {`
	`136`	`+ } elseif (!\is_string($suffix)) {`
`137`	`137`	`return parent::endsWith($suffix);`
`138`		`- } else {`
`139`		`- $suffix = (string) $suffix;`
`140`	`138`	`}`
`141`	`139`
`142`	`140`	`return '' !== $suffix && \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix), null, $this->ignoreCase);`
`143`	`141`	`}`
`144`	`142`
`145`		`- public function equalsTo($string): bool`
	`143`	`+ public function equalsTo(string\|iterable\|AbstractString $string): bool`
`146`	`144`	`{`
`147`		`- if ($string instanceof parent) {`
	`145`	`+ if ($string instanceof AbstractString) {`
`148`	`146`	`$string = $string->string;`
`149`		`- } elseif (\is_array($string) \|\| $string instanceof \Traversable) {`
	`147`	`+ } elseif (!\is_string($string)) {`
`150`	`148`	`return parent::equalsTo($string);`
`151`		`- } else {`
`152`		`- $string = (string) $string;`
`153`	`149`	`}`
`154`	`150`
`155`	`151`	`if ('' !== $string && $this->ignoreCase) {`
`@@ -167,14 +163,12 @@ public function folded(): parent`
`167`	`163`	`return $str;`
`168`	`164`	`}`
`169`	`165`
`170`		`- public function indexOf($needle, int $offset = 0): ?int`
	`166`	`+ public function indexOf(string\|iterable\|AbstractString $needle, int $offset = 0): ?int`
`171`	`167`	`{`
`172`		`- if ($needle instanceof parent) {`
	`168`	`+ if ($needle instanceof AbstractString) {`
`173`	`169`	`$needle = $needle->string;`
`174`		`- } elseif (\is_array($needle) \|\| $needle instanceof \Traversable) {`
	`170`	`+ } elseif (!\is_string($needle)) {`
`175`	`171`	`return parent::indexOf($needle, $offset);`
`176`		`- } else {`
`177`		`- $needle = (string) $needle;`
`178`	`172`	`}`
`179`	`173`
`180`	`174`	`if ('' === $needle) {`
`@@ -186,14 +180,12 @@ public function indexOf($needle, int $offset = 0): ?int`
`186`	`180`	`return false === $i ? null : $i;`
`187`	`181`	`}`
`188`	`182`
`189`		`- public function indexOfLast($needle, int $offset = 0): ?int`
	`183`	`+ public function indexOfLast(string\|iterable\|AbstractString $needle, int $offset = 0): ?int`
`190`	`184`	`{`
`191`		`- if ($needle instanceof parent) {`
	`185`	`+ if ($needle instanceof AbstractString) {`
`192`	`186`	`$needle = $needle->string;`
`193`		`- } elseif (\is_array($needle) \|\| $needle instanceof \Traversable) {`
	`187`	`+ } elseif (!\is_string($needle)) {`
`194`	`188`	`return parent::indexOfLast($needle, $offset);`
`195`		`- } else {`
`196`		`- $needle = (string) $needle;`
`197`	`189`	`}`
`198`	`190`
`199`	`191`	`if ('' === $needle) {`
`@@ -305,7 +297,7 @@ public function replace(string $from, string $to): parent`
`305`	`297`	`return $str;`
`306`	`298`	`}`
`307`	`299`
`308`		`- public function replaceMatches(string $fromRegexp, $to): parent`
	`300`	`+ public function replaceMatches(string $fromRegexp, string\|callable $to): parent`
`309`	`301`	`{`
`310`	`302`	`if ($this->ignoreCase) {`
`311`	`303`	`$fromRegexp .= 'i';`
`@@ -404,9 +396,9 @@ public function split(string $delimiter, int $limit = null, int $flags = null):`
`404`	`396`	`return $chunks;`
`405`	`397`	`}`
`406`	`398`
`407`		`- public function startsWith($prefix): bool`
	`399`	`+ public function startsWith(string\|iterable\|AbstractString $prefix): bool`
`408`	`400`	`{`
`409`		`- if ($prefix instanceof parent) {`
	`401`	`+ if ($prefix instanceof AbstractString) {`
`410`	`402`	`$prefix = $prefix->string;`
`411`	`403`	`} elseif (!\is_string($prefix)) {`
`412`	`404`	`return parent::startsWith($prefix);`
Original file line number	Diff line number	Diff line change
`@@ -80,14 +80,12 @@ public function codePointsAt(int $offset): array`
`80`	`80`	`return '' === $str->string ? [] : [mb_ord($str->string, 'UTF-8')];`
`81`	`81`	`}`
`82`	`82`
`83`		`- public function endsWith($suffix): bool`
	`83`	`+ public function endsWith(string\|iterable\|AbstractString $suffix): bool`
`84`	`84`	`{`
`85`	`85`	`if ($suffix instanceof AbstractString) {`
`86`	`86`	`$suffix = $suffix->string;`
`87`		`- } elseif (\is_array($suffix) \|\| $suffix instanceof \Traversable) {`
	`87`	`+ } elseif (!\is_string($suffix)) {`
`88`	`88`	`return parent::endsWith($suffix);`
`89`		`- } else {`
`90`		`- $suffix = (string) $suffix;`
`91`	`89`	`}`
`92`	`90`
`93`	`91`	`if ('' === $suffix \|\| !preg_match('//u', $suffix)) {`
`@@ -101,14 +99,12 @@ public function endsWith($suffix): bool`
`101`	`99`	`return \strlen($this->string) >= \strlen($suffix) && 0 === substr_compare($this->string, $suffix, -\strlen($suffix));`
`102`	`100`	`}`
`103`	`101`
`104`		`- public function equalsTo($string): bool`
	`102`	`+ public function equalsTo(string\|iterable\|AbstractString $string): bool`
`105`	`103`	`{`
`106`	`104`	`if ($string instanceof AbstractString) {`
`107`	`105`	`$string = $string->string;`
`108`		`- } elseif (\is_array($string) \|\| $string instanceof \Traversable) {`
	`106`	`+ } elseif (!\is_string($string)) {`
`109`	`107`	`return parent::equalsTo($string);`
`110`		`- } else {`
`111`		`- $string = (string) $string;`
`112`	`108`	`}`
`113`	`109`
`114`	`110`	`if ('' !== $string && $this->ignoreCase) {`
`@@ -118,14 +114,12 @@ public function equalsTo($string): bool`
`118`	`114`	`return $string === $this->string;`
`119`	`115`	`}`
`120`	`116`
`121`		`- public function indexOf($needle, int $offset = 0): ?int`
	`117`	`+ public function indexOf(string\|iterable\|AbstractString $needle, int $offset = 0): ?int`
`122`	`118`	`{`
`123`	`119`	`if ($needle instanceof AbstractString) {`
`124`	`120`	`$needle = $needle->string;`
`125`		`- } elseif (\is_array($needle) \|\| $needle instanceof \Traversable) {`
	`121`	`+ } elseif (!\is_string($needle)) {`
`126`	`122`	`return parent::indexOf($needle, $offset);`
`127`		`- } else {`
`128`		`- $needle = (string) $needle;`
`129`	`123`	`}`
`130`	`124`
`131`	`125`	`if ('' === $needle) {`
`@@ -137,14 +131,12 @@ public function indexOf($needle, int $offset = 0): ?int`
`137`	`131`	`return false === $i ? null : $i;`
`138`	`132`	`}`
`139`	`133`
`140`		`- public function indexOfLast($needle, int $offset = 0): ?int`
	`134`	`+ public function indexOfLast(string\|iterable\|AbstractString $needle, int $offset = 0): ?int`
`141`	`135`	`{`
`142`	`136`	`if ($needle instanceof AbstractString) {`
`143`	`137`	`$needle = $needle->string;`
`144`		`- } elseif (\is_array($needle) \|\| $needle instanceof \Traversable) {`
	`138`	`+ } elseif (!\is_string($needle)) {`
`145`	`139`	`return parent::indexOfLast($needle, $offset);`
`146`		`- } else {`
`147`		`- $needle = (string) $needle;`
`148`	`140`	`}`
`149`	`141`
`150`	`142`	`if ('' === $needle) {`
`@@ -247,14 +239,12 @@ public function split(string $delimiter, int $limit = null, int $flags = null):`
`247`	`239`	`return $chunks;`
`248`	`240`	`}`
`249`	`241`
`250`		`- public function startsWith($prefix): bool`
	`242`	`+ public function startsWith(string\|iterable\|AbstractString $prefix): bool`
`251`	`243`	`{`
`252`	`244`	`if ($prefix instanceof AbstractString) {`
`253`	`245`	`$prefix = $prefix->string;`
`254`		`- } elseif (\is_array($prefix) \|\| $prefix instanceof \Traversable) {`
	`246`	`+ } elseif (!\is_string($prefix)) {`
`255`	`247`	`return parent::startsWith($prefix);`
`256`		`- } else {`
`257`		`- $prefix = (string) $prefix;`
`258`	`248`	`}`
`259`	`249`
`260`	`250`	`if ('' === $prefix \|\| !preg_match('//u', $prefix)) {`
Original file line number	Diff line number	Diff line change
`@@ -25,10 +25,10 @@ class LazyString implements \Stringable, \JsonSerializable`
`25`	`25`	`*`
`26`	`26`	`* @return static`
`27`	`27`	`*/`
`28`		`- public static function fromCallable($callback, ...$arguments): self`
	`28`	`+ public static function fromCallable(callable\|array $callback, mixed ...$arguments): self`
`29`	`29`	`{`
`30`		`- if (!\is_callable($callback) && !(\is_array($callback) && isset($callback[0]) && $callback[0] instanceof \Closure && 2 >= \count($callback))) {`
`31`		`- throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a callable or a [Closure, method] lazy-callable, "%s" given.', __METHOD__, get_debug_type($callback)));`
	`30`	`+ if (\is_array($callback) && !\is_callable($callback) && !(($callback[0] ?? null) instanceof \Closure \|\| 2 < \count($callback))) {`
	`31`	`+ throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a callable or a [Closure, method] lazy-callable, "%s" given.', __METHOD__, '['.implode(', ', array_map('get_debug_type', $callback)).']'));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`$lazyString = new static();`
`@@ -50,16 +50,10 @@ public static function fromCallable($callback, ...$arguments): self`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`/**`
`53`		`- * @param string\|int\|float\|bool\|\Stringable $value`
`54`		`- *`
`55`	`53`	`* @return static`
`56`	`54`	`*/`
`57`		`- public static function fromStringable($value): self`
	`55`	`+ public static function fromStringable(string\|int\|float\|bool\|\Stringable $value): self`
`58`	`56`	`{`
`59`		`- if (!self::isStringable($value)) {`
`60`		`- throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be a scalar or a stringable object, "%s" given.', __METHOD__, get_debug_type($value)));`
`61`		`- }`
`62`		`-`
`63`	`57`	`if (\is_object($value)) {`
`64`	`58`	`return static::fromCallable([$value, '__toString']);`
`65`	`59`	`}`
`@@ -73,19 +67,17 @@ public static function fromStringable($value): self`
`73`	`67`	`/**`
`74`	`68`	`* Tells whether the provided value can be cast to string.`
`75`	`69`	`*/`
`76`		`- final public static function isStringable($value): bool`
	`70`	`+ final public static function isStringable(mixed $value): bool`
`77`	`71`	`{`
`78`		`- return \is_string($value) \|\| $value instanceof self \|\| (\is_object($value) ? method_exists($value, '__toString') : is_scalar($value));`
	`72`	`+ return \is_string($value) \|\| $value instanceof \Stringable \|\| is_scalar($value);`
`79`	`73`	`}`
`80`	`74`
`81`	`75`	`/**`
`82`	`76`	`* Casts scalars and stringable objects to strings.`
`83`	`77`	`*`
`84`		`- * @param object\|string\|int\|float\|bool $value`
`85`		`- *`
`86`	`78`	`* @throws \TypeError When the provided value is not stringable`
`87`	`79`	`*/`
`88`		`- final public static function resolve($value): string`
	`80`	`+ final public static function resolve(\Stringable\|string\|int\|float\|bool $value): string`
`89`	`81`	`{`
`90`	`82`	`return $value;`
`91`	`83`	`}`