Как использовать бесплатную монаду с Future[M[_]]

Абстрактный тип данных Ops определяет алгебру для выборки и сохранения нескольких Record. Он описывает две операции, но это единственное, что должна делать алгебра. То, как на самом деле выполняются операции, не должно иметь никакого значения для Fetch и Store, единственная полезная вещь, которую вы ожидаете, это соответственно List[Record] и List[Response].

Делая ожидаемый тип результата Fetch и Store Future[List[Record]]], вы ограничиваете возможности интерпретации этой алгебры. Возможно, в ваших тестах вы не хотите асинхронно подключаться к веб-сервису или базе данных и просто хотите протестировать с помощью Map[Int, Result] или Vector[Result], но теперь вам необходимо вернуть Future, что делает тесты более сложными, чем они могли бы быть.

Но сказать, что вам не нужен ETL[Future[List[Record]]], не решить ваш вопрос: вы используете асинхронные библиотеки и, вероятно, хотите вернуть некоторые Future.

Начиная с вашей первой реализации:

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import cats.implicits._
import cats.free.Free

type Record = String
type Response = String

sealed trait EtlOp[T]
case class Fetch(offset: Int, amount: Int) extends EtlOp[List[Record]]
case class Store(recs: List[Record]) extends EtlOp[List[Response]]

type ETL[A] = Free[EtlOp, A]

def fetch(offset: Int, amount: Int): ETL[List[Record]] = 
  Free.liftF(Fetch(offset, amount))
def store(recs: List[Record]): ETL[List[Response]] = 
  Free.liftF(Store(recs))

def fetchStore(offset: Int, amount: Int): ETL[List[Response]] =
  fetch(offset, amount).flatMap(store)

Но теперь у нас все еще нет Futures ? Это работа нашего переводчика:

import cats.~>

val interpretFutureDumb: EtlOp ~> Future = new (EtlOp ~> Future) {
  def apply[A](op: EtlOp[A]): Future[A] = op match {
    case Store(records) => 
      Future.successful(records.map(rec => s"Resp($rec)"))
      // store in DB, send to webservice, ...
    case Fetch(offset, amount) =>
      Future.successful(List.fill(amount)(offset.toString))
      // get from DB, from webservice, ...
  }
}

С помощью этого интерпретатора (где, конечно, вы бы заменили Future.successful(...) чем-то более полезным) мы можем получить наш Future[List[Response]] :

val responses: Future[List[Response]] = 
  fetchStore(1, 5).foldMap(interpretFutureDumb)

val records: Future[List[Record]] = 
  fetch(2, 4).foldMap(interpretFutureDumb)

responses.foreach(println)
// List(Resp(1), Resp(1), Resp(1), Resp(1), Resp(1))
records.foreach(println)
// List(2, 2, 2, 2)

Но мы все еще можем создать другой интерпретатор, который не возвращает Future :

import scala.collection.mutable.ListBuffer
import cats.Id

val interpretSync: EtlOp ~> Id = new (EtlOp ~> Id) {
  val records: ListBuffer[Record] = ListBuffer()
  def apply[A](op: EtlOp[A]): Id[A] = op match {
    case Store(recs) => 
      records ++= recs
      records.toList
    case Fetch(offset, amount) =>
      records.drop(offset).take(amount).toList
  }
}

val etlResponse: ETL[List[Response]] =
  for { 
    _       <- store(List("a", "b", "c", "d"))
    records <- fetch(1, 2)
    resp    <- store(records)
  } yield resp

val responses2: List[Response] = etlResponse.foldMap(interpretSync)
// List(a, b, c, d, b, c)