vic / zio-arrow

Welcome to ZIO Arrow !

Q: What's an Arrow?
A: Arrow is a monoid in a category of strong profunctors

More info here
Join discussions on Discord

ZIO Arrow is an effectful data structure for modeling a highly composable effects. As an example of effect composition, consider the following code:

import zio.{ ZIO }
import zio.arrow.ZArrow._
import zio.console.{ putStrLn }
import zio.arrow.ZArrow

object ArrowMonad extends zio.App {

  // Define plain methods
  val f = (_: Int) + 1
  val g = (_: Int) * 2
  val h = (_: Int) - 3

  // Lift methods to an arrow context
  val arrF = arr(f)
  val arrG = arr(g)
  val arrH = arr(h)

  // Compose arrows to the final arrow
  // No computation is performed, only a composition of ZIO Effects in the Arrow context
  val arrows = List(arrF, arrG, arrH)

  val arrowComposed: ZArrow[Nothing, Int, Int] = arrows.foldLeft(ZArrow.identity[Int])(_ >>> _)

  // Run an effect computation for a composed Arrow
  val prog0 = arrowComposed.run(10)

  // Compose effects in a monadic context
  def monadComposed(din: Int): ZIO[Any, Nothing, Int] =
    for {
      f0 <- ZIO.effectTotal(f)
      g0 <- ZIO.effectTotal(g)
      h0 <- ZIO.effectTotal(h)
    } yield f0.andThen(g0).andThen(h0).apply(din)

  // Run a cmposed Monad effect computation
  val prog1 = monadComposed(10)

  def run(args: List[String]) = (prog0 <*> prog1).flatMap(a => putStrLn(a.toString)).exitCode
}
// (19,19)

Both effects result in the same value. What's different is the performance for such composable effects. Let's look at the decompiled code, obtained with CFR

  Arrow >>>>>> arrowComposed = (ZArrow)MODULE$.arrows().foldLeft((Object)ZArrow$.MODULE$.identity(), (Function2 & Serializable)(x$4, x$5) -> x$4.$greater$greater$greater(x$5));
  
  Monad >>>>>> public ZIO<Object, Nothing$, Object> monadComposed(int din) {return ZIO$.MODULE$.effectTotal((Function0 & Serializable)() -> <br>MODULE$.f()).flatMap((Function1 & Serializable)f0 -> ZIO$.MODULE$.effectTotal((Function0 & Serializable)() -> MODULE$.g()).flatMap((Function1 & Serializable)g0 -> ZIO$.MODULE$.effectTotal((Function0 & Serializable)() -> MODULE$.h()).map((Function1 & Serializable)h0 -> BoxesRunTime.boxToInteger((int)ArrowMonad$.$anonfun$monadComposed$6(f0, g0, din, h0)))));

As we see from a decompiled code, Scala compiler assembles Arrow into a single nice static object and folds a Function2 with and Identity function to obtain the final result. On the other hand, Monad is implemented as a chained computation with flatMap.

Each line in a procedural programming or monadic for context costs six! (6) allocations on JVM plus 3 extra megamorphic dispatches in Functional Programming, according to this talk

Arrow effects cost ZERO! (0) extra allocations and one megamorphic dispatch on JVM.

This is how Arrows became the next big thing in a high performance programming on JVM

Usage

libraryDependencies += "io.github.neurodyne" %% "zio-arrow" % "0.2.1"

Credits

Initial contributors: Wiem Zine El Abidine, John De Goes, Adam Fraser