Anteriormente había pensado que parte del objetivo de la implementación era evitar este mismo problema, ¿entonces tal vez estoy haciendo algo obviamente tonto?

Aquí hay un código:

    // Stack overflow
import scalaz._

sealed trait Command[T]
case class Wait(ms: Long) extends Command[Unit]

case object Evaluator extends (Command ~> Id.Id) {
  override def apply[T](cmd: Command[T]) = cmd match {
    case Wait(t)  => Thread.sleep(t)
  }
}

object Api {
  def sleep(ms: Long): Free.FreeC[Command, Unit] = Free.liftFC(Wait(ms))
}

val sleep: Free.FreeC[Command, Unit] =
  Api.sleep(1).flatMap { _ => sleep }

Free.runFC(sleep)(Evaluator)

Nota: Me doy cuenta de que esto es una tontería :) En la práctica, mi clase de comando tiene muchos comandos, y tengo un comando que hace este mismo ciclo ... básicamente, sondea algún estado, si es verdadero, si es falso, sigue esperando.

Quiero evitar el desbordamiento de la pila que esto causa ... PENSÉ que esto ya estaba en el trampolín, pero supongo que necesito hacerlo manualmente nuevamente. ¿Hay una manera limpia de hacerlo dentro de la forma de pensar de la mónada libre?

Actualizar:

Pensando más en esto, creo que el problema no es la mónada libre del sueño, sino la identificación.

case object Evaluator2 extends (Command ~> ({ type t[x] = Free[Id.Id, x] })#t) {
  override def apply[T](cmd: Command[T]) = cmd match {
    case Wait(t)  => Thread.sleep(t); Free.liftF[Id.Id, Unit](())
  }
}

Free.runFC[Command, ({ type t[x] = Free[Id.Id, x] })#t, Unit](sleep)(Evaluator2)(Free.freeMonad[Id.Id])

Pero el problema con esto es que solo evaluará un paso. Idealmente, me gustaría que runFC se bloquee hasta que se cumpla alguna condición (o en este caso, que se repita para siempre hasta que la mate, pero sin un desbordamiento de pila)