Add sequenceT function

Author: klimick

src/Fp/Functions/Collection/Sequence.php

@@ -70,6 +70,20 @@ function sequenceEither(iterable $collection): Either
     return TraverseEitherOperation::id($collection)->map(asArray(...));
 }
 
+/**
+ * Varargs version of {@see sequenceEither()}.
+ *
+ * @template E
+ * @template TVI
+ *
+ * @param Either<E, TVI> | Closure(): Either<E, TVI> ...$items
+ * @return Either<E, list<TVI>>
+ */
+function sequenceEitherT(Either|Closure ...$items): Either
+{
+    return TraverseEitherOperation::id($items)->map(asList(...));
+}
+
 /**
  * Same as {@see sequenceEither()} but accumulates all left errors.
  *

src/Fp/Psalm/Hook/FunctionReturnTypeProvider/SequenceEitherFunctionReturnTypeProvider.php

@@ -4,8 +4,11 @@
 
 namespace Fp\Psalm\Hook\FunctionReturnTypeProvider;
 
+use Fp\Collections\ArrayList;
+use Fp\Collections\NonEmptyArrayList;
 use Fp\Collections\NonEmptyHashMap;
 use Fp\Functional\Either\Either;
+use Fp\Functional\Option\Option;
 use Fp\Psalm\Util\Sequence\GetEitherTypeParam;
 use Fp\PsalmToolkit\Toolkit\CallArg;
 use Fp\PsalmToolkit\Toolkit\PsalmApi;
@@ -18,21 +21,23 @@
 
 use function Fp\Callable\ctor;
 use function Fp\Collection\sequenceOptionT;
+use function Fp\Evidence\of;
+use function Fp\Evidence\proveTrue;
 
 final class SequenceEitherFunctionReturnTypeProvider implements FunctionReturnTypeProviderInterface
 {
     public static function getFunctionIds(): array
     {
         return [
             strtolower('Fp\Collection\sequenceEither'),
+            strtolower('Fp\Collection\sequenceEitherT'),
         ];
     }
 
     public static function getFunctionReturnType(FunctionReturnTypeProviderEvent $event): ?Union
     {
-        return PsalmApi::$args->getCallArgs($event)
-            ->flatMap(fn($args) => $args->head())
-            ->flatMap(fn(CallArg $arg) => PsalmApi::$types->asSingleAtomicOf(TKeyedArray::class, $arg->type))
+        return self::getInputTypeFromSequenceEither($event)
+            ->orElse(fn() => self::getInputTypeFromSequenceEitherT($event))
             ->flatMap(fn(TKeyedArray $types) => sequenceOptionT(
                 fn() => NonEmptyHashMap::collectNonEmpty($types->properties)
                     ->traverseOption(GetEitherTypeParam::left(...))
@@ -56,4 +61,29 @@ public static function getFunctionReturnType(FunctionReturnTypeProviderEvent $ev
             ->map(ctor(Union::class))
             ->get();
     }
+
+    /**
+     * @return Option<TKeyedArray>
+     */
+    private static function getInputTypeFromSequenceEither(FunctionReturnTypeProviderEvent $event): Option
+    {
+        return proveTrue(strtolower('Fp\Collection\sequenceEither') === $event->getFunctionId())
+            ->flatMap(fn() => PsalmApi::$args->getCallArgs($event))
+            ->flatMap(fn($args) => $args->head())
+            ->flatMap(fn(CallArg $arg) => PsalmApi::$types->asSingleAtomic($arg->type))
+            ->flatMap(of(TKeyedArray::class));
+    }
+
+    /**
+     * @return Option<TKeyedArray>
+     */
+    private static function getInputTypeFromSequenceEitherT(FunctionReturnTypeProviderEvent $event): Option
+    {
+        return proveTrue(strtolower('Fp\Collection\sequenceEitherT') === $event->getFunctionId())
+            ->flatMap(fn() => PsalmApi::$args->getCallArgs($event))
+            ->flatMap(fn(ArrayList $args) => $args->toNonEmptyArrayList())
+            ->map(fn(NonEmptyArrayList $args) => new TKeyedArray(
+                $args->map(fn(CallArg $arg) => $arg->type)->toNonEmptyList(),
+            ));
+    }
 }

tests/Static/Plugin/SequenceEitherPluginStaticTest.php

@@ -11,6 +11,7 @@
 use function Fp\Collection\at;
 use function Fp\Collection\sequenceEither;
 use function Fp\Collection\sequenceEitherAcc;
+use function Fp\Collection\sequenceEitherT;
 use function Fp\Evidence\proveInt;
 use function Fp\Evidence\proveNonEmptyString;
 use function Fp\Evidence\proveString;
@@ -133,6 +134,22 @@ public function sequenceAccWithNonEmptyArray(array $list): Either
         return sequenceEitherAcc($list);
     }
 
+    /**
+     * @param array<string, mixed> $data
+     * @return Either<InvalidArgumentException, array{non-empty-string, int}>
+     */
+    public function sequenceEitherT(array $data): Either
+    {
+        return sequenceEitherT(
+            at($data, 'name')
+                ->flatMap(proveNonEmptyString(...))
+                ->toRight(fn() => new InvalidArgumentException()),
+            at($data, 'age')
+                ->flatMap(proveInt(...))
+                ->toRight(fn() => new InvalidArgumentException()),
+        );
+    }
+
     /**
      * @return Either<
      *     array{
@@ -146,7 +163,7 @@ public function sequenceAccWithNonEmptyArray(array $list): Either
      *     array{
      *         name: non-empty-string,
      *         age: int,
-     *         address?: array{
+     *         address: array{
      *             postcode: int,
      *             city: non-empty-string
      *         }