Merge pull request #41 from rcardin/38-add-a-ziporaccumulate-variant-that-accumulates-on-a-custom-type

Add a ziporaccumulate variant that accumulates on a custom type

Author: rcardin

src/main/scala/in/rcard/raise4s/Fold.scala

@@ -1,7 +1,5 @@
 package in.rcard.raise4s
 
-import scala.annotation.targetName
-
 private[raise4s] def _mapOrAccumulate[Error, A, B](iterable: Iterable[A])(
     transform: Raise[Error] ?=> A => B
 )(using r: Raise[List[Error]]): List[B] =
@@ -23,7 +21,7 @@ private[raise4s] def _mapOrAccumulate[Error, A, B](
 )(
     transform: Raise[Error] ?=> A => B
 )(using r: Raise[Error]): List[B] =
-  var errors  = collection.mutable.ArrayBuffer.empty[Error]
+  val errors  = collection.mutable.ArrayBuffer.empty[Error]
   val results = collection.mutable.ArrayBuffer.empty[B]
   iterable.foreach(a =>
     Raise.fold(
@@ -94,3 +92,48 @@ private[raise4s] def _zipOrAccumulate[Error, A, B, C, D, E, F, G, H, I, J](
   if errors.isEmpty then block(a, b, c, d, e, f, g, h, i)
   else r.raise(errors.toList)
 }
+
+private[raise4s] def _zipOrAccumulate[Error, A, B, C, D, E, F, G, H, I, J](
+    combine: (Error, Error) => Error
+)(
+    action1: Raise[Error] ?=> A,
+    action2: Raise[Error] ?=> B,
+    action3: Raise[Error] ?=> C,
+    action4: Raise[Error] ?=> D,
+    action5: Raise[Error] ?=> E,
+    action6: Raise[Error] ?=> F,
+    action7: Raise[Error] ?=> G,
+    action8: Raise[Error] ?=> H,
+    action9: Raise[Error] ?=> I
+)(block: (A, B, C, D, E, F, G, H, I) => J)(using r: Raise[Error]): J = {
+  val errors = collection.mutable.ArrayBuffer.empty[Error]
+  val a: A = Raise.recover(action1) { newError =>
+    errors += newError; null.asInstanceOf[A]
+  }
+  val b: B = Raise.recover(action2) { newError =>
+    errors += newError; null.asInstanceOf[B]
+  }
+  val c: C = Raise.recover(action3) { newError =>
+    errors += newError; null.asInstanceOf[C]
+  }
+  val d: D = Raise.recover(action4) { newError =>
+    errors += newError; null.asInstanceOf[D]
+  }
+  val e: E = Raise.recover(action5) { newError =>
+    errors += newError; null.asInstanceOf[E]
+  }
+  val f: F = Raise.recover(action6) { newError =>
+    errors += newError; null.asInstanceOf[F]
+  }
+  val g: G = Raise.recover(action7) { newError =>
+    errors += newError; null.asInstanceOf[G]
+  }
+  val h: H = Raise.recover(action8) { newError =>
+    errors += newError; null.asInstanceOf[H]
+  }
+  val i: I = Raise.recover(action9) { newError =>
+    errors += newError; null.asInstanceOf[I]
+  }
+  if errors.isEmpty then block(a, b, c, d, e, f, g, h, i)
+  else r.raise(errors.reduce(combine))
+}