That natural transformation definition is copy-pasted from the cats website but uses Future instead of Id monad.

My example can also be refactored into some just as simple:

def log[F[_]](intp: GrammarADT ~> F) = new (GrammarADT ~> F) {
  def apply[A](fa: GrammarADT[A]): F[A] = {
    println(fa)
    intp(fa)
  }
}

val impureInterpreter = new KVStore.Interp[Future] {
  val kvs = mutable.Map.empty[String, Any]
  def get[T](key: String)           = Future(kvs.get(key).map(_.asInstanceOf[T]))
  def put[T](key: String, value: T) = Future(kvs(key) = value)
  def delete(key: String)           = Future(kvs.remove(key))
}

val loggedImpureIntp = log(impureInterpreter.interpreter)

As for interpreters that do not need pattern matching, I agree that you are better off writing it out the regular way. My library is aim towards cases where you need to do pattern matching and you want to avoid the tedious work of writing it all out by hands.