estou a usarcats FreeMonad. Aqui está uma versão simplificada da á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))
}

Um dos intérpretes será um invólucro em torno de uma biblioteca de terceiros, chamadaClient aqui qual a suaget A assinatura do método é semelhante a:

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

Minha pergunta é como posso codificar esse requisito na minha implementação?

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)
        }
}

Eu tentei coisas como a introdução de limites para o meuapply (gostarapply[A <: Resource : Format : Definition]) que não funcionou.

Eu entendi aquiloFunctionK é transformar valores de tipos ordenados de primeira ordem, mas existe alguma maneira em que eu possa codificar os requisitos do parâmetro type?

Pretendo usá-lo 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)