vhutov

Decoder[FailedMessage].inj[Messages]

vhutov

implicit class InjectableFunctor[F[_], A](fa: F[A]) {
  def inj[B](implicit F: Functor[F], I: Inject[A, B]): F[B] = {
    fa.map(I.inj) 
  }
}

vhutov

Decoder[FailureResponse].map(Inject[FailedResponse, Messages].inj)

vhutov

Decoder[FailedResponse].map(m ⇒ Right(Left(m))

vhutov

type Messages = SuccessResposne :=: FailedResponse :+: QuotaRequest

vhutov

type A = Int :+: String :+: Double
type B = (Int :+: (String :+: Double))
type C = Either[Int, Either[String, Double]]

// A === B === C

vhutov

type :+:[A, B] = Either[A, B]

vhutov

abstract class Inject[A, B] {
  def inj: A ⇒ B
  def prj: B ⇒ Option[A]
}

vhutov

import cats.Inject

type B = Either[Int, Either[String, Double]]

val i = Inject[Int, B].inj(1)       // Left(1)
val s = Inject[String, B].inj("hi") // Right(Left(hi))
val d = Inject[Double, B].inj(1.0)  // Right(Right(1.0))

Inject[String, B].prj(i) // None
Inject[String, B].prj(s) // Some(hi)

vhutov

import io.circe.{Encoder, Decoder}
import cats.effect.Concurrent
import cats.syntax.either._

case class JmsMessage[T](value: T, metadata: Metadata)

class JmsParentController[
  F[_]            : Concurrent,
  Request         : Encoder,
  SuccessResponse : Decoder,