Estoy usandocats FreeMonad. Aquí hay una versión simplificada del álgebra:

sealed trait Op[A]

object Op {
    final case class Get[T](name: String) extends Op[T]

    type OpF[A] = Free[Op, A]

    def get[T](name: String): OpF[T] = liftF[Op, T](Get[T](name))
}

Uno de los intérpretes será un contenedor alrededor de una biblioteca de terceros, llamadaClient aquí que esget La firma del método es similar a:

class Client {
    def get[O <: Resource](name: String)
        (implicit f: Format[O], d: Definition[O]): Future[O] = ???
}

Mi pregunta es ¿cómo puedo codificar ese requisito en mi implementación?

class FutureOp extends (Op ~> Future) {
    val client = new Client()

    def apply[A](fa: Op[A]): Future[A] =
        fa match {
            case Get(name: String) =>
                client.get[A](name)
        }
}

Intenté cosas como introducir límites a miapply (me gustaapply[A <: Resource : Format : Definition]) que no funcionó.

Entiendo queFunctionK es transformar valores de tipos de primer orden, pero ¿hay alguna forma de codificar los requisitos del parámetro de tipo?

Tengo la intención de usarlo como:

def run[F[_]: Monad, A](intp: Op ~> F, op: OpF[A]): F[A] = op.foldMap(intp)

val p: Op.OpF[Foo] = Op.get[Foo]("foo")

val i = new FutureOp()

run(i, d)