ZArrow is a functional programming library built to be used with the ZIO ecosystem.

The library implements the type ZArrow[I, R, E, O]. Each instance of ZArrow describes an effectful mapping from I to O. Specifically, it maps any I to a ZIO[R, E, O], which is a computation that requires an R and either succeeds with an O, fails with an E, or dies.

While ZIO provides features to simplify working with effects, this library aims to further simplify working with effectful mappings. It offers a set of factory methods to lift compatible values into a ZArrow, which can then be transformed using a comprehensive set of operators (e.g., imap, map, flatMap, combine, etc.).

A ZIO[R, E, A] can be thought of as a function R => Either[E, A] where R, called the environment, is passed implicitly (given/implicit parameter).

On the other hand, a ZArrow[I, R, E, O] can be thought of as a function I => R => Either[E, O] where I is passed explicitly and R is passed implicitly.

Another way to look at a ZArrow[I, R, E, O] is to think about it as a ZIO[R, E, O] to which another input channel I was added.

To use ZArrow in your Scala project, add the following dependencies to your build.sbt:

libraryDependencies += "dev.zio" %% "zio" % zioVersion
libraryDependencies += "be.broij" %% "zarrow" % zArrowVersion

We provide an overview of the utilities this library offer. Each method mentioned in the following sections is fully documented in the source code. For further information, please refer to that documentation.

One can create a ZArrow from scratch using:

• ZArrow.unit
• ZArrow.identity

One can lift compatible values into a ZArrow using the following factory methods:

• ZArrow.succeed
• ZArrow.attempt
• ZArrow.fromZIO
• ZArrow.fromZIOAttempt

Each ZArrow[I, R, E, O] has an apply method that allows to compute the ZIO[R, E, O] a value of type I is mapped to. There are also some variants of the apply method that map collections of values sequentially. Finally, the par methods map collections of values in parallel.

One can transform a ZArrow using a variety of operators:

• combine (or <*>)
• combinePar (or <&>)
• zip
• zipPar
• first
• second
• andThen (or >>>)
• compose (or <<<)
• errorAndThen
• errorCompose
• catchAll
• catchAllCause
• mapZIO
• map
• mapAttempt
• mapError
• mapErrorAttempt
• mapBoth
• imap
• imapAttempt
• flatMap (or >>=)
• flatMapError
• flatMapBoth
• withFilter
• swapInputs
• swapOutputs
• filterFirst
• filterSecond