Настройка композиции Future, Either и Writer в Scalaz

Question

Это продолжение моего предыдущего вопроса: секвенирование Scalaz WriterT и Either с помощью for-yield

Следующий блок кода является примером последовательности Future, Either а также Writer с использованием EitherT а также WriterT монадные трансформаторы; Следующий вопрос о том, как тонко изменить поведение этого стека трансформаторов.

import scalaz._, Scalaz._

class Example[F[_], L] (val logFn: (String) => L)(implicit val f: Monad[F], l: Monoid[L])
{
  type T = Throwable
  type EF[α] = EitherT[F, T, α]
  type WEF[α] = WriterT[EF, L, α]

  private def unreliableInt (i: Int): T Either Int = new java.util.Random ().nextBoolean match {
    case false => Right (i)
    case true => Left (new Exception (":-("))
  }

  private def fn (i: Int): WEF[Int] = WriterT.put[EF, L, Int](EitherT.fromEither[F, T, Int](f.point (unreliableInt (i))))(l.zero)

  private def log (msg: String): WEF[Unit] = WriterT.put[EF, L, Unit](EitherT.right[F, T, Unit](f.point (())))(logFn (msg))

  private def foo (): WEF[Int] = for {
    _ <- log ("Start")
    x <- fn (18)
    _ <- log ("Middle")
    y <- fn (42)
    _ <- log ("End")
  } yield x + y

  def bar (): F[(Option[Int], L)] = {
    val barWEF: WEF[Int] = foo ()

    // Pull out the logs.
    val logsEF: EF[L] = barWEF.written
    val logsF: F[L] = logsEF.toEither.map {
      case Right (x) => x
      case Left (e) => logFn(s"Not the logs we are looking for ${e.getMessage}")
    }

    // Pull out the value.
    val resEF: EF[Int] = barWEF.value
    val resF: F[Option[Int]] = resEF.run.map {
      case \/- (r) => r.some
      case -\/ (ex) => None
    }

    for {
      logs <- logsF
      response <- resF
    } yield (response, logs)
  }
}

object Program
{
  def main (args : Array[String]) = {
    import scala.concurrent._
    import scala.concurrent.duration._
    import ExecutionContext.Implicits.global

    type L = List[String]
    type F[α] = Future[α]

    implicit val l: Monoid[L] = new Monoid[L] { def zero = Nil; def append (f1: L, f2: => L) = f1 ::: f2 }
    implicit val f: Monad[F] = scalaz.std.scalaFuture.futureInstance

    def createLog (s: String) = s :: Nil
    val example = new Example[F, L] (createLog)
    val result = Await.result (example.bar (), 5 seconds)
    println ("Context logs attached:" + result._2.foldLeft ("") { (a, x) => a + "\n$ " + s"$x"})
    println ("Result:" + result._1)
  }
}

Функция foo не ведет себя так, как мне нужно; функция bar и main Функция иллюстрирует проблему.

Желаемое поведение таково, что main всегда будет печатать один из следующих результатов:

Context logs attached:
$ Start
Result:None

или же

Context logs attached:
$ Start
$ Middle
Result:None

или же

Context logs attached:
$ Start
$ Middle
$ End
Result:Some(60)

main Однако функция никогда не должна печатать следующее:

Context logs attached:
$ Not the logs we are looking for :-(
Result:None

Но это именно то, что он делает. Когда оба fn1 а также fn2 успешны, foo ведет себя как требуется и main распечатывает все журналы. Если один или оба fn1 или же fn2 вернуть Left функция bar не возвращает журналы, а main продолжает печатать только исключение. Там нет никакого способа увидеть, как далеко это зашло в журналах.

Кажется, что этот конкретный стек трансформаторов ведет себя так, что если когда-либо будет -\/ в последовательности контекст регистрации просто отображается...

Глядя на код Scalaz для WriterT это выглядит, вероятно, так:

final case class WriterT[F[_], W, A](run: F[(W, A)])

WriterT это класс дела, единственным членом которого является run, Что касается этого примера run кортеж нашего контекста регистрации (A) и наш результат, оба завернутые в одно и то же EitherT (F). W а также A в данных связаны типом, поэтому либо они оба находятся внутри левого, либо оба находятся внутри правого.

Я могу предположить, что мне нужна настроенная версия WriterT который ведет себя немного по-другому, храня свои данные примерно так, предоставляя доступ к части записи только внутри нового Applicative[F].point:

final case class WriterT[F[_], W, A](wF: F[W], vF:F[A]) {
  def run: F[(W, A)] = for {
    w <- wF
    v <- vF
  } yield (w, v)
}

Хотя я не совсем уверен, создаю ли я WriterT Тип класса будет рекомендуемым подходом к решению этой проблемы и достижению желаемого поведения.

Какие у меня варианты?

Answer 1

Эта статья: Составление монадических эффектов объясняет проблему.

Так...

type MyMonad e w a = ErrorT e (Writer w) А изоморфен (Either e a, w)

type MyMonad e w a = WriterT w (Either e) a изоморфен Either r (a, w)

Переупорядочение стека монадных трансформаторов следующим образом решает проблему:

import scalaz._, Scalaz._

class Example[F[_], L] (val logFn: (String) => L)(implicit val f: Monad[F], l: Monoid[L])
{
  type T = Throwable
  type WF[α] = WriterT[F, L, α]
  type EWF[α] = EitherT[WF, T, α]

  private def unreliableInt (i: Int): T Either Int = {
    new java.util.Random ().nextBoolean match {
      case false => Right (i)
      case true => Left (new Exception (":-("))
    }
  }

  private def fn (i: Int): EWF[Int] = unreliableInt (i) match {
    case Left (left) => EitherT.left [WF, T, Int] (WriterT.put[F, L, T] (f.point (left))(l.zero))
    case Right (right) => EitherT.right [WF, T, Int] (WriterT.put[F, L, Int] (f.point (right))(l.zero))
  }

  private def log (msg: String): EWF[Unit] = { EitherT.right[WF, T, Unit](WriterT.put[F, L, Unit] (f.point (()))(logFn (msg))) }

  private def foo (): EWF[Int] = for {
    a <- log ("Start")
    x <- fn (18)
    b <- log ("Middle")
    y <- fn (42)
    c <- log ("End")
  } yield x + y

  def bar (): F[(Option[Int], L)] = {
    val barEWF: EWF[Int] = foo ()

    // Pull out the logs.
    val logsF: F[L] = barEWF.run.written

    // Pull out the value.
    val resF: F[Option[Int]] = barEWF.run.value.map {
      case \/- (r) => r.some
      case -\/ (ex) => None
    }

    for {
      logs <- logsF
      response <- resF
    } yield (response, logs)
  }
}

object Program
{
  def main (args : Array[String]) = {
    import scala.concurrent._
    import scala.concurrent.duration._
    import ExecutionContext.Implicits.global

    type L = List[String]
    type F[α] = Future[α]

    implicit val l: Monoid[L] = new Monoid[L] { def zero = Nil; def append (f1: L, f2: => L) = f1 ::: f2 }
    implicit val f: Monad[F] = scalaz.std.scalaFuture.futureInstance

    def createLog (s: String) = s :: Nil
    val example = new Example[F, L] (createLog)
    val result = Await.result (example.bar (), 5 seconds)
    println ("Context logs attached:" + result._2.foldLeft ("") { (a, x) => a + "\n$ " + s"$x"})
    println ("Result:" + result._1)
  }
}