Eu já havia pensado que parte do objetivo da implementação era evitar esse mesmo problema, então talvez eu esteja fazendo algo obviamente idiota?

Aqui está um 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: Eu percebo que isso é bobagem :) Na prática, minha classe de comando possui muitos comandos, e eu tenho um comando que executa esse mesmo loop ... basicamente, pesquise algum estado, se verdadeiro abortar, se falso, continue esperando.

Eu quero evitar o estouro de pilha que isso causa ... PENSEI que isso já era um trampolim, mas acho que preciso fazê-lo manualmente novamente? Existe uma maneira limpa de fazê-lo dentro da maneira livre de pensar em mônada?

Atualizar:

Pensando mais sobre isso, acho que a questão não é o sono Free Monad, mas o Id.Id que nós nos ligamos à avaliação ... então tentei algo como:

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

Mas o problema disso é que ele avaliará apenas uma etapa. Idealmente, eu gostaria que o runFC bloqueasse até que alguma condição fosse satisfeita (ou, nesse caso, faça um loop para sempre até que eu a mate, mas sem um estouro de pilha)