Scalaz повторяет: «Поднимает» EnumeratorT для соответствия «IterateeT» для «большей» монады

445

Если у меня есть EnumeratorTи соответствующий, IterateeTя могу запустить их вместе:

val en: EnumeratorT[String, Task] = EnumeratorT.enumList(List("a", "b", "c"))
val it: IterateeT[String, Task, Int] = IterateeT.length

(it &= en).run : Task[Int]

Если монада перечислителя "больше", чем монада итерируемого, я могу использовать upили, в более общем смысле, Hoist"поднять" итератора для сопоставления:

val en: EnumeratorT[String, Task] = ...
val it: IterateeT[String, Id, Int] = ...

val liftedIt = IterateeT.IterateeTMonadTrans[String].hoist(
  implicitly[Task |>=| Id]).apply(it)
(liftedIt &= en).run: Task[Int]

Но что мне делать, если итеративная монада "больше", чем монада перечислителя?

val en: EnumeratorT[String, Id] = ...
val it: IterateeT[String, Task, Int] = ...

it &= ???

Кажется , нет ни одного Hoistпримера EnumeratorT, ни какого-либо очевидного метода «подъема».

— LMM
источник

+1 за аккуратный вопрос, но я не уверен, что это возможно в общем случае, так как на Enumeratorсамом деле это просто обертка вокруг a StepT => IterateeT, которая предполагает, что вам нужно «уйти в отставку» от StepT[E, BigMonad, A].

— Трэвис Браун

Да, я обнаружил это, когда попытался реализовать это напрямую. Но логически это Enumeratorпросто эффективный источник, верно? Такое чувство, что я должен быть в состоянии использовать то, что может поставить Aдля снабжения Task[A].

— LMM

Я не знаю достаточно о Scala, чтобы предложить ответ, но не могли бы вы определить свой собственный тип и предоставить механизм подъема для него ?

— Роб

Нет, это совсем не одно и то же, это другой вид "подъема".

— LMM

@TravisBrown есть щедрость на это прямо сейчас, если вы хотите, чтобы написать это.

— Аарон Холл

В обычном кодировании перечислитель по сути является StepT[E, F, ?] ~> F[StepT[E, F, ?]]. Если вы попытаетесь написать универсальный метод, преобразующий этот тип в Step[E, G, ?] ~> G[Step[E, G, ?]]данное F ~> G, вы быстро столкнетесь с проблемой: вам нужно «опустить» a Step[E, G, A]доStep[E, F, A] , чтобы иметь возможность применить исходный перечислитель.

Scalaz также предоставляет альтернативную кодировку перечислителя, которая выглядит следующим образом:

trait EnumeratorP[E, F[_]] {
  def apply[G[_]: Monad](f: F ~> G): EnumeratorT[E, G]
}

Этот подход позволяет нам определять перечислитель, который конкретно определяет необходимые эффекты, но его можно «поднять» для работы с потребителями, которым требуется более широкий контекст. Мы можем изменить ваш пример для использования EnumeratorP(и более новый подход к естественному преобразованию, а не старый частичный порядок монад):

import scalaz._, Scalaz._, iteratee._, concurrent.Task

def enum: EnumeratorP[String, Id] = ???
def iter: IterateeT[String, Task, Int] = ???

val toTask = new (Id ~> Task) { def apply[A](a: A): Task[A] = Task(a) }

Теперь мы можем составить два, как это:

scala> def result = (iter &= enum(toTask)).run
result: scalaz.concurrent.Task[Int]

EnumeratorPявляется монадическим (если Fэто аппликативно), а EnumeratorPобъект компаньона предоставляет некоторые функции , чтобы помочь с определением счетчиков , которые очень похожи на те , на EnumeratorT-ТАХ empty, perform, enumPStreamи т.д. Я думаю , там должен быть EnumeratorTслучаями , которые не могут быть реализованы с использованием EnumeratorPкодирование, но с верхней части моей головы , я не уверен , что они будут выглядеть.

— Трэвис Браун
источник