Changing the HaltStrategy.match function signature (#2202)

Co-authored-by: maksim.khramtsov <maksim.khramtsov@btsdigital.kz>

.changeset/real-kangaroos-push.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+The signatures of the `HaltStrategy.match` `StreamHaltStrategy.match` functions have been changed to the generally accepted ones

packages/effect/src/ExecutionStrategy.ts

@@ -106,6 +106,14 @@ export const isParallelN: (self: ExecutionStrategy) => self is ParallelN = inter
  * @category folding
  */
 export const match: {
-  <A>(onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): (self: ExecutionStrategy) => A
-  <A>(self: ExecutionStrategy, onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): A
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }): (self: ExecutionStrategy) => A
+  <A>(self: ExecutionStrategy, options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }): A
 } = internal.match

packages/effect/src/StreamHaltStrategy.ts

@@ -102,10 +102,22 @@ export const isBoth: (self: HaltStrategy) => self is Both = internal.isBoth
 export const isEither: (self: HaltStrategy) => self is Either = internal.isEither
 
 /**
+ * Folds over the specified `HaltStrategy` using the provided case functions.
+ *
  * @since 2.0.0
  * @category folding
  */
 export const match: {
-  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): (self: HaltStrategy) => Z
-  <Z>(self: HaltStrategy, onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z): Z
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): (self: HaltStrategy) => Z
+  <Z>(self: HaltStrategy, options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }): Z
 } = internal.match

packages/effect/src/internal/executionStrategy.ts

@@ -46,27 +46,29 @@ export const isParallelN = (self: ExecutionStrategy.ExecutionStrategy): self is
 
 /** @internal */
 export const match = dual<
-  <A>(
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
-  ) => (self: ExecutionStrategy.ExecutionStrategy) => A,
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }) => (self: ExecutionStrategy.ExecutionStrategy) => A,
   <A>(
     self: ExecutionStrategy.ExecutionStrategy,
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
   ) => A
->(4, (self, onSequential, onParallel, onParallelN) => {
+>(2, (self, options) => {
   switch (self._tag) {
     case OP_SEQUENTIAL: {
-      return onSequential()
+      return options.onSequential()
     }
     case OP_PARALLEL: {
-      return onParallel()
+      return options.onParallel()
     }
     case OP_PARALLEL_N: {
-      return onParallelN(self.parallelism)
+      return options.onParallelN(self.parallelism)
     }
   }
 })

packages/effect/src/internal/stream/haltStrategy.ts

@@ -53,33 +53,42 @@ export const isEither = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.
 
 /** @internal */
 export const match = dual<
-  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z) => (self: HaltStrategy.HaltStrategy) => Z,
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }) => (self: HaltStrategy.HaltStrategy) => Z,
   <Z>(
     self: HaltStrategy.HaltStrategy,
-    onLeft: () => Z,
-    onRight: () => Z,
-    onBoth: () => Z,
-    onEither: () => Z
+    options: {
+      readonly onLeft: () => Z
+      readonly onRight: () => Z
+      readonly onBoth: () => Z
+      readonly onEither: () => Z
+    }
   ) => Z
->(5, <Z>(
+>(2, <Z>(
   self: HaltStrategy.HaltStrategy,
-  onLeft: () => Z,
-  onRight: () => Z,
-  onBoth: () => Z,
-  onEither: () => Z
+  options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }
 ): Z => {
   switch (self._tag) {
     case OpCodes.OP_LEFT: {
-      return onLeft()
+      return options.onLeft()
     }
     case OpCodes.OP_RIGHT: {
-      return onRight()
+      return options.onRight()
     }
     case OpCodes.OP_BOTH: {
-      return onBoth()
+      return options.onBoth()
     }
     case OpCodes.OP_EITHER: {
-      return onEither()
+      return options.onEither()
     }
   }
 })