scalaz - состав функции - WriterT

Question

Давайте определим Kleisli на \/:

abstract class MyError
case class NumericalError(msg: String) extends MyError

// Either is a Monad with two type parameters: M[A,B] which represent left and right respectively
// Let's create an ad-hoc type
type EEither[+T] = \/[MyError, T]

и одна специальная функция для тестирования:

def safeSqrtEither(t: Double): EEither[Double] =
  safeSqrtOpt(t) match {
    case Some(r) => r.right
    case None => NumericalError("Sqrt on double is not define if _ < 0").left
  }
val kSafeSqrtEither = Kleisli.kleisli( (x: Double) => safeSqrtEither(x) )

Функция композиции работает плавно:

val pipeEither = kSafeSqrtEither >>> kSafeSqrtEither
val r5b = pipeEither2 run 16.0
//which gives r5b: EEither[Double] = \/-(2.0)

Я хотел бы добавить ведение журнала:

type LoggedROCFun[I,O] = I => WriterT[EEither,scalaz.NonEmptyList[String],O]
val sqrtWithLog: LoggedROCFun[Double, Double] =
  (t: Double) =>
    WriterT.put(kSafeSqrtEither(t))(s"squared $t".wrapNel)

который, кажется, имеет желаемое поведение:

val resA = sqrtWithLog(16.0)
// resA: scalaz.WriterT[EEither,scalaz.NonEmptyList[String],Double] = WriterT(\/-((NonEmpty[squared 16.0],4.0)))

Гладкий. Однако я изо всех сил пытаюсь собрать оператора, который:

• объединяет значения в WriterT применение >>>
• цепочки (добавляет) каждый журнал, отслеживая каждый сделанный шаг

Желаемый результат:

val combinedFunction = sqrtWithLog >>> sqrtWithLog
val r = combinedFunction run 16.0
// r: WriterT(\/-((NonEmpty[squared 16.0, squared 4.0],2.0)))

Мой лучший снимок:

def myCompositionOp[I,A,B](f1: LoggedROCFun[I,A])(f2: LoggedROCFun[A,B]): LoggedROCFun[I,B] =
  (x: I) => {
    val e = f1.apply(x)
    val v1: EEither[A] = e.value
    v1 match {
        case Right(v)  => f2(v)
        case Left(err) =>
          val lastLog = e.written
          val v2 = err.left[B]
          WriterT.put(v2)(lastLog)

      }
  }

В вышеизложенном я впервые применяю f1 в xи затем я передаю результат f2, В противном случае я закорачиваю Left, Это неправильно, потому что в случае Right Я сбрасываю предыдущую историю регистрации.

Один последний вопрос

val safeDivWithLog: Kleisli[W, (Double,Double), Double] =
  Kleisli.kleisli[W, (Double, Double), Double]( (t: (Double, Double)) => {
    val (n,d) = t
    WriterT.put(safeDivEither(t))(s"divided $n by $d".wrapNel)
  }
  )
val combinedFunction2 = safeDivWithLog >>> sqrtWithLog
val rAgain = combinedFunction2 run (-10.0,2.0)
// rAgain: W[Double] = WriterT(-\/(NumericalError(Sqrt on double is not define if _ < 0)))

Не уверен, почему журналы не переносятся после переключения конвейера на Left, Это потому что:

• тип MyMonad e w a = ErrorT e (Writer w) a изоморфно (либо e a, w)
• Тип MyMonad e w a = WriterT w (Либо e) a изоморфен Либо r (a, w)

поэтому я перевернул заказ?

Источники: здесь, скаляр, здесь и реальный мир haskell на трансформаторах

Answer 1

Вы очень близки - проблема только в том, что вы похоронили Kleisliпока ты хочешь это снаружи. Ваш LoggedROCFun это просто обычная функция, и Compose Экземпляр для обычных функций требует, чтобы выходные данные первой функции соответствовали типу ввода второй функции. Если вы делаете sqrtWithLog стрелка клеисли будет работать просто отлично

import scalaz._, Scalaz._

abstract class MyError
case class NumericalError(msg: String) extends MyError

type EEither[T] = \/[MyError, T]

def safeSqrtEither(t: Double): EEither[Double] =
  if (t >= 0) math.sqrt(t).right else NumericalError(
    "Sqrt on double is not define if _ < 0"
  ).left

type W[A] = WriterT[EEither, NonEmptyList[String], A]

val sqrtWithLog: Kleisli[W, Double, Double] =
  Kleisli.kleisli[W, Double, Double](t =>
    WriterT.put(safeSqrtEither(t))(s"squared $t".wrapNel)
  )

val combinedFunction = sqrtWithLog >>> sqrtWithLog
val r = combinedFunction run 16.0

Обратите внимание, что я немного изменил ваш код, чтобы сделать его полным рабочим примером.

---

В ответ на ваш комментарий: если вы хотите, чтобы писатель накапливался при сбоях, вам нужно будет изменить порядок Either а также Writer в трансформаторе:

import scalaz._, Scalaz._

abstract class MyError
case class NumericalError(msg: String) extends MyError

type EEither[T] = \/[MyError, T]

def safeSqrtEither(t: Double): EEither[Double] =
  if (t >= 0) math.sqrt(t).right else NumericalError(
    "Sqrt on double is not define if _ < 0"
  ).left

type W[A] = Writer[List[String], A]
type E[A] = EitherT[W, MyError, A]

val sqrtWithLog: Kleisli[E, Double, Double] =
  Kleisli.kleisli[E, Double, Double](t =>
    EitherT[W, MyError, Double](safeSqrtEither(t).set(List(s"squared $t")))
  )

val constNegative1: Kleisli[E, Double, Double] =
  Kleisli.kleisli[E, Double, Double](_ => -1.0.point[E])

val combinedFunction = sqrtWithLog >>> constNegative1 >>> sqrtWithLog

А потом:

scala> combinedFunction.run(16.0).run.written
res9: scalaz.Id.Id[List[String]] = List(squared 16.0, squared -1.0)

Обратите внимание, что это не будет работать с NonEmptyList в писателе, так как вы должны иметь возможность вернуть пустой журнал в случае, например, constNegative1.run(0.0).run.written, Я использовал List, но в реальном коде вы хотели бы тип с менее дорогими добавлениями.