scalaz Iteratees da Scala Iterator
Domanda
Ho modificato il codice qui sotto come credo mi era stato combinando l'IterV oggetti in modo non corretto in cima al problema iter.next
.
sto sperimentando Iteratee
in scalaz e sto chiedendo perché il seguente non funziona. Ecco quello che ho:
import scalaz._
import Scalaz._
import IterV._
implicit val iteratorEnumerator = new Enumerator[Iterator] {
def apply[E,A](iter: Iterator[E], i: IterV[E,A]): IterV[E,A] =
if (iter.isEmpty) i
else i.fold(done = (acc,input) => i,
cont = k => apply(iter, k(El(iter.next))))
}
/* probably incorrect
val iter = Iterator(1,2,3)
println("peek(iter) " + peek(iter).run)
println("peek(iter) " + peek(iter).run)
*/
def peekpeek[E]: IterV[E, (Option[E],Option[E])] =
for (a <- peek; b <- peek) yield (a,b)
def peekheadpeek[E]: IterV[E, (Option[E],Option[E],Option[E])] =
for (a <- peek; b <- head; c <- peek) yield (a,b,c)
peekpeek(Iterator(1,2,3,4)).run
peekheadpeek(Iterator(1,2,3,4)).run
Questo restituisce:
res0: (Option[Int], Option[Int]) = (Some(1),Some(2))
res1: (Option[Int], Option[Int], Option[Int]) = (Some(1),Some(2),Some(3))
Dove mi aspettavo (Some(1),Some(1))
e (Some(1),Some(1),Some(2))
.
ho il sospetto che questo ha a che fare con effettuazione iter.next
essere lato. Qual è il modo migliore per affrontare questo?
Per fare un confronto, questo prese direttamente dagli esempi di codice sorgente dal sito scalaz funzioni correttamente:
implicit val StreamEnumerator = new Enumerator[Stream] {
def apply[E, A](e: Stream[E], i: IterV[E, A]): IterV[E, A] = e match {
case Stream() => i
case x #:: xs => i.fold(done = (_, _) => i,
cont = k => apply(xs, k(El(x))))
}
}
Soluzione
penso di aver capito questo. Sembrava essere principalmente a causa El
utilizzando un parametro per nome, che ricalcola iter.next
- e come ho inizialmente chiamato il calcolo in modo non corretto con due diversi peek(iter).run
. Ho riscritto l'enumeratore primo iter.next
assegnare ad un val (ed anche reso ricorsivo coda nel processo):
implicit val iteratorEnumerator = new Enumerator[Iterator] {
@annotation.tailrec
def apply[E,A](iter: Iterator[E], i: IterV[E,A]): IterV[E,A] = i match {
case _ if iter.isEmpty => i
case Done(acc, input) => i
case Cont(k) =>
val x = iter.next
apply(iter, k(El(x)))
}
}
Quindi:
def peekpeek[A] =
for (a1 <- peek[A]; a2 <- peek[A]) yield (a1,a2)
def peekheadpeek[A] =
for (a1 <- peek[A]; a2 <- head[A]; a3 <- peek[A]) yield (a1,a2,a3)
def headpeekhead[A] =
for (a1 <- head[A]; a2 <- peek[A]; a3 <- head[A]) yield (a1,a2,a3)
peekpeek(Iterator(1,2,3)).run
peekheadpeek(Iterator(1,2,3)).run
headpeekhead(Iterator(1,2,3)).run
length(Iterator.from(1).take(1000000)).run
restituirebbe questo:
res13: (Option[Int], Option[Int]) = (Some(1),Some(1))
res14: (Option[Int], Option[Int], Option[Int]) = (Some(1),Some(1),Some(2))
res15: (Option[Int], Option[Int], Option[Int]) = (Some(1),Some(2),Some(2))
res16: Int = 1000000
Altri suggerimenti
Hai ragione su iter.next causare effetti collaterali. Credo che la questione si riduce a ciò che è la differenza tra un flusso e un iteratore. Questa domanda ha informazioni pertinenti.
Iteratees sono pigri. Gli effetti collaterali (iteratore) e la pigrizia non si mescolano. Forse questo farà la cosa giusta:
implicit val iteratorEnumerator = new Enumerator[Iterator] {
def apply[E,A](iter: Iterator[E], i: IterV[E,A]): IterV[E,A] =
iter.foldRight(i)((x, y) =>
y.fold(done = (acc, input) => y,
cont = k => apply(iter, k(El(x))))
)
}
Poi di nuovo, forse no. Solo la fonte di foldRight saprà. Gli effetti collaterali sono così.
È possibile evitare gli effetti collaterali con la creazione di un iteratore usa e getta di dimensioni uno:
implicit val iteratorEnumerator = new Enumerator[Iterator] {
def apply[E,A](iter: Iterator[E], i: IterV[E,A]): IterV[E,A] =
if (iter.isEmpty) i
else i.fold(done = (acc,input) => i,
cont = k => apply(iter, k(El(iter.take(1).next))))
}