A couple of shortcut methods on Func

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.
@@ -65,7 +66,7 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
      * @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 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))
 
     /**
@@ -200,9 +225,9 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
    *
    * @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](())
     }
 
@@ -251,14 +276,14 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
    */
   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](()))
       }
 
@@ -300,7 +325,7 @@ abstract class MonadicalEitherArrow[E <: Throwable] {
   /**
    * 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))
 
   /**