A couple of shortcut methods on Func

build.sbt

@@ -1,5 +1,6 @@
 import de.heikoseeberger.sbtheader.License
-import sbtcrossproject.crossProject
+import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._
+import sbtcrossproject.CrossPlugin.autoImport.crossProject
 
 name := "codec"
 
@@ -13,7 +14,7 @@ val scalaV = scalaVersion := "2.12.8"
 
 val commons = Seq(
   scalaV,
-  crossScalaVersions := Seq(scalaVersion.value, "2.13.0"),
+  //crossScalaVersions := Seq(scalaVersion.value, "2.13.0-RC1"),
   version                   := "0.0.5",
   fork in Test              := true,
   parallelExecution in Test := false,
@@ -30,18 +31,19 @@ val commons = Seq(
 
 commons
 
-val kindProjector = addCompilerPlugin("org.typelevel" % "kind-projector" % "0.10.3" cross CrossVersion.binary)
+val kindProjector = addCompilerPlugin("org.typelevel" % "kind-projector" % "0.10.0" cross CrossVersion.binary)
 
-val Cats1V = "2.0.0-RC1"
+val Cats1V = "1.6.0"
 val ScodecBitsV = "1.1.10"
-val CirceV = "0.12.0-RC2"
+val CirceV = "0.11.1"
 val ShapelessV = "2.3.+"
 
 val chill = "com.twitter" %% "chill" % "0.9.3"
 
 val ScalatestV = "3.0.5"
 
-val ScalacheckV = "1.14.0"
+// Note that cats-laws 1.5 are compiled against scalacheck 1.13, and scalacheck-shapeless should also not introduce the upgrade
+val ScalacheckV = "1.13.5"
 
 val protobuf = Seq(
   PB.targets in Compile := Seq(
@@ -64,7 +66,7 @@ lazy val `codec-core` = crossProject(JVMPlatform, JSPlatform)
     libraryDependencies ++= Seq(
       "org.typelevel"              %%% "cats-core"                 % Cats1V,
       "org.typelevel"              %%% "cats-testkit"              % Cats1V % Test,
-      "com.github.alexarchambault" %%% "scalacheck-shapeless_1.13" % "1.2.3" % Test,
+      "com.github.alexarchambault" %%% "scalacheck-shapeless_1.13" % "1.1.8" % Test,
       "org.scalacheck"             %%% "scalacheck"                % ScalacheckV % Test,
       "org.scalatest"              %%% "scalatest"                 % ScalatestV % Test
     )

core/src/main/scala/fluence/codec/MonadicalEitherArrow.scala

@@ -49,6 +49,7 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
    * @tparam B Successful result type
    */
   abstract class Func[A, B] {
+    f ⇒
 
     /**
      * Run the func on input, using the given monad.
@@ -63,9 +64,9 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
      *
      * @param input Input
      * @param F All internal maps and composes, as well as errors, are to be executed with this MonadError.
-      *          Error type should be a supertype for this arrow's error E.
+     *          Error type should be a supertype for this arrow's error E.
      */
-    def runF[F[_]](input: A)(implicit F: MonadError[F, EE] forSome {type EE >: E}): F[B] =
+    def runF[F[_]](input: A)(implicit F: MonadError[F, EE] forSome { type EE >: E }): F[B] =
       runEither(input).flatMap(F.fromEither)
 
     /**
@@ -76,13 +77,37 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
      */
     def apply[F[_]: Monad](input: A): EitherT[F, E, B]
 
+    /**
+     * Shortcut for function composition
+     *
+     * @param other Other function to run after
+     * @tparam C Resulting input type
+     * @return Composed function
+     */
+    def on[C](other: Func[C, A]): Func[C, B] =
+      catsMonadicalEitherArrowChoice.compose(this, other)
+
+    /**
+     * Convert this Func into another one, lifting the error
+     *
+     * @param m Another instance of MonadicalEitherArrow
+     * @param convertE Convert error
+     * @tparam EE Error type
+     * @return Converted function
+     */
+    def to[EE <: Throwable](m: MonadicalEitherArrow[EE])(implicit convertE: E ⇒ EE): m.Func[A, B] =
+      new m.Func[A, B] {
+        override def apply[F[_]: Monad](input: A): EitherT[F, EE, B] =
+          f[F](input).leftMap(convertE)
+      }
+
     /**
      * Converts this Func to Kleisli, using MonadError to execute upon and to lift errors into.
      *
      * @param F All internal maps and composes, as well as errors, are to be executed with this MonadError.
      *           Error type should be a supertype for this arrow's error E.
      */
-    def toKleisli[F[_]](implicit F: MonadError[F, EE] forSome {type EE >: E}): Kleisli[F, A, B] =
+    def toKleisli[F[_]](implicit F: MonadError[F, EE] forSome { type EE >: E }): Kleisli[F, A, B] =
       Kleisli(input ⇒ runF[F](input))
 
     /**
@@ -97,11 +122,11 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
     }
 
     /**
-      * Picks a point from the arrow, using the initial element (Unit) on the left.
+     * Picks a point from the arrow, using the initial element (Unit) on the left.
-      *
+     *
-      * @param input Point to pick
+     * @param input Point to pick
-      * @return Picked point
+     * @return Picked point
-      */
+     */
     def pointAt(input: A): Point[B] =
       catsMonadicalEitherArrowChoice.lmap(this)(_ ⇒ input)
   }
@@ -187,22 +212,22 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
   }
 
   /**
-    * Check a condition, lifted with a Func.
+   * Check a condition, lifted with a Func.
-    *
+   *
-    * @param error Error to produce when condition is not met
+   * @param error Error to produce when condition is not met
-    * @return Func that takes boolean, checks it, and returns Unit or fails with given error
+   * @return Func that takes boolean, checks it, and returns Unit or fails with given error
-    */
+   */
   def cond(error: ⇒ E): Func[Boolean, Unit] =
     liftFuncEither(Either.cond(_, (), error))
 
   /**
-    * Lift a function which returns a Func arrow with Unit on the left side.
+   * Lift a function which returns a Func arrow with Unit on the left side.
-    *
+   *
-    * @param f Function to lift
+   * @param f Function to lift
-    */
+   */
-  def liftFuncPoint[A, B](f: A ⇒ Point[B]): Func[A,B] =
+  def liftFuncPoint[A, B](f: A ⇒ Point[B]): Func[A, B] =
-    new Func[A,B]{
+    new Func[A, B] {
-      override def apply[F[_] : Monad](input: A): EitherT[F, E, B] =
+      override def apply[F[_]: Monad](input: A): EitherT[F, E, B] =
         f(input).apply[F](())
     }
 
@@ -240,25 +265,25 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
   }
 
   /**
-    * Point type maps from Unit to a particular value of A, so it's just a lazy Func.
+   * Point type maps from Unit to a particular value of A, so it's just a lazy Func.
-    *
+   *
-    * @tparam A Output value type
+   * @tparam A Output value type
-    */
+   */
   type Point[A] = Func[Unit, A]
 
   /**
-    * Point must obey MonadErrorLaws
+   * Point must obey MonadErrorLaws
-    */
+   */
   implicit object catsMonadicalEitherPointMonad extends MonadError[Point, E] {
     override def flatMap[A, B](fa: Point[A])(f: A ⇒ Point[B]): Point[B] =
-      new Func[Unit, B]{
+      new Func[Unit, B] {
-        override def apply[F[_] : Monad](input: Unit): EitherT[F, E, B] =
+        override def apply[F[_]: Monad](input: Unit): EitherT[F, E, B] =
           fa[F](()).flatMap(f(_).apply[F](()))
       }
 
     override def tailRecM[A, B](a: A)(f: A ⇒ Point[Either[A, B]]): Point[B] =
-      new Func[Unit, B]{
+      new Func[Unit, B] {
-        override def apply[F[_] : Monad](input: Unit): EitherT[F, E, B] =
+        override def apply[F[_]: Monad](input: Unit): EitherT[F, E, B] =
           Monad[EitherT[F, E, ?]].tailRecM(a)(f(_).apply[F](()))
       }
 
@@ -266,8 +291,8 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
       liftFuncEither(_ ⇒ Left(e))
 
     override def handleErrorWith[A](fa: Point[A])(f: E ⇒ Point[A]): Point[A] =
-      new Func[Unit, A]{
+      new Func[Unit, A] {
-        override def apply[F[_] : Monad](input: Unit): EitherT[F, E, A] =
+        override def apply[F[_]: Monad](input: Unit): EitherT[F, E, A] =
           fa[F](()).leftFlatMap(e ⇒ f(e).apply[F](()))
       }
 
@@ -298,9 +323,9 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
     Bijection(liftFuncEither(direct), liftFuncEither(inverse))
 
   /**
-    * Lifts point functions into Bijection.
+   * Lifts point functions into Bijection.
-    */
+   */
-  def liftPointB[A,B](direct: A ⇒ Point[B], inverse: B ⇒ Point[A]): Bijection[A,B] =
+  def liftPointB[A, B](direct: A ⇒ Point[B], inverse: B ⇒ Point[A]): Bijection[A, B] =
     Bijection(liftFuncPoint(direct), liftFuncPoint(inverse))
 
   /**

kryo/src/main/scala/fluence/codec/kryo/KryoCodecs.scala

@@ -101,6 +101,8 @@ object KryoCodecs {
     /**
      * Build a new instance of KryoCodecs with the given poolSize and F effect
      * @param poolSize Kryo pool size
+     * @param F ApplicativeError for catching serialization errors
+     * @tparam F Effect type
      * @return Configured instance of KryoCodecs
      */
     def build(

project/plugins.sbt

@@ -1,19 +1,21 @@
-addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.0.3")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.0.0")
 
-addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.25")
+addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.20")
 
 addSbtPlugin("de.heikoseeberger" % "sbt-header" % "5.2.0")
 
-addSbtPlugin("com.thesamet" % "sbt-protoc" % "0.99.23")
+addSbtPlugin("com.thesamet" % "sbt-protoc" % "0.99.20")
 
-addSbtPlugin("org.scala-js"       % "sbt-scalajs"              % "0.6.28")
+addSbtPlugin("org.scala-js"       % "sbt-scalajs"              % "0.6.27")
-addSbtPlugin("org.portable-scala" % "sbt-crossproject"         % "0.6.1")
+addSbtPlugin("org.portable-scala" % "sbt-crossproject"         % "0.6.0")
-addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "0.6.1")
+addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "0.6.0")
 
-addSbtPlugin("ch.epfl.scala" % "sbt-scalajs-bundler" % "0.15.0")
+addSbtPlugin("ch.epfl.scala" % "sbt-scalajs-bundler" % "0.14.0")
 
 addSbtPlugin("net.virtual-void" % "sbt-dependency-graph" % "0.9.2")
 
-libraryDependencies += "com.thesamet.scalapb" %% "compilerplugin" % "0.9.0"
+addSbtPlugin("com.lihaoyi" % "workbench" % "0.4.1")
+
+libraryDependencies += "com.thesamet.scalapb" %% "compilerplugin" % "0.8.4"
 
 addSbtPlugin("org.foundweekends" % "sbt-bintray" % "0.5.4")