object functions
Collection of iterateees
- Alphabetic
- By Inheritance
- functions
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- implicit final class IterOps[E, F[_], A] extends AnyVal
- type ResumableIter[E, F[_], A] = IterateeT[E, F, (A, IterateeT[E, F, _])]
- class ResumableIterIterator[E, A] extends Iterator[A]
Only possible to work on IO as it allows us to exit the monad
- type ResumableIterList[E, F[_], A] = IterateeT[E, F, (Iterable[A], IterateeT[E, F, _])]
- type ResumableIterListStep[E, F[_], A] = StepT[E, F, (Iterable[A], IterateeT[E, F, _])]
- type ResumableStep[E, F[_], A] = StepT[E, F, (A, IterateeT[E, F, _])]
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def appendTo[F[_]](to: Appendable)(implicit F: Applicative[F]): IterateeT[CharSequence, F, CharSequence]
Append to an appendable, always returns Done for a line, cont for everything else TODO - should it be a pair including the appendable?
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def dropWhile[E, F[_]](f: (E) => Boolean)(implicit F: Monad[F]): IterateeT[E, F, Option[E]]
drop while iteratee, returning the possibly remaining data
- def dropWhileM[E, F[_]](f: (E) => F[Boolean])(implicit F: Monad[F]): IterateeT[E, F, Option[E]]
Same as dropWhile but captures the Monad in F
- def enumToMany[E, F[_], A, R](dest: ResumableIter[A, F, R])(toMany: ResumableIter[E, F, EphemeralStream[A]])(implicit F: Monad[F]): ResumableIter[E, F, R]
Takes Input[E] converts via toMany to an EphemeralStream[A].
Takes Input[E] converts via toMany to an EphemeralStream[A]. This in turn is fed to the destination iteratee. The inputs can be 1 -> Many, Many -> 1, or indeed 1 -> 1.
The callers must take care of what kind of continnuation Iteratee is returned in a Done.
If the dest returns EOF, the toMany is in turn called with EOF for any needed resource control processing.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def evalWith[FROM, F[_], TO](f: (FROM) => TO)(implicit F: Applicative[F]): IterateeT[FROM, F, TO]
Calls the function param with the fed data and returns its result - consider Scalaz 7 map directly rather than composing
- def extract[E, F[_], A](iter: ResumableIter[E, F, A])(implicit F: Monad[F]): F[Option[A]]
Extract the Some(value) from a Done or None if it was not Done.
- def extractCont[E, F[_], A](iter: ResumableIter[E, F, A])(implicit F: Monad[F]): ResumableIter[E, F, A]
Extract the continuation from a Done
- def extractContFromDoneOrCont[E, F[_], A](iter: ResumableIter[E, F, A])(implicit F: Monad[F]): ResumableIter[E, F, A]
Extract the continuation from a Done, or the continuation itself
- def extractContS[E, F[_], A](s: ResumableStep[E, F, A])(implicit F: Monad[F]): ResumableIter[E, F, A]
Extract the continuation from a Done
- def extractS[E, F[_], A](iter: ResumableStep[E, F, A])(implicit F: Monad[F]): Option[A]
Extract the Some(value) from a Done or None if it was not Done.
- def filter[E, F[_]](f: (E) => Boolean)(implicit F: Monad[F]): IterateeT[E, F, Iterable[E]]
filter iteratee, greedily taking all content until eof
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def find[E, F[_]](f: (E) => Boolean)(implicit F: Monad[F]): IterateeT[E, F, Option[E]]
"find" iteratee, finds Some(first) or None
- def flatMap[E, F[_], A, B](itr: IterateeT[E, F, A])(f: (A) => IterateeT[E, F, B])(implicit F: Monad[F]): IterateeT[E, F, B]
Based on Scalaz 7 flatMap but exposes the monad through the f parameter
- def foldI[E, F[_], A](f: (E, A) => A)(init: A, stopOn: (A) => Boolean = (_: A) => true)(implicit F: Monad[F]): ResumableIter[E, F, A]
Stepwise fold, each element is evaluated but each one is returned as a result+resumable iter.
- def foldIM[E, F[_], A](f: (E, A) => F[A])(init: A, stopOn: (A) => Boolean = (_: A) => true)(implicit F: Monad[F]): ResumableIter[E, F, A]
Stepwise fold but the result of f is bound to F
- def foldOnDone[E, F[_], A, ACC](e: => EnumeratorT[E, F])(initAcc: ACC, initResumable: ResumableIter[E, F, A])(f: (ACC, A) => ACC)(implicit F: Monad[F]): F[ACC]
Folds over the Iteratee with Cont or Done and Empty, returning with Done and EOF.
Folds over the Iteratee with Cont or Done and Empty, returning with Done and EOF. If there is a ping pong on enumerator -> Cont -> enumerator then we'll of course get an infinite loop.
foldI returns a ResumableIter that performs a fold until a done, this folds over the enumerator to return a value.
combine with onDone to get through chunks of data.
- def foldOnDoneIter[E, F[_], A, ACC](initAcc: ACC, initIter: ResumableIter[E, F, A])(f: (ACC, A) => ACC)(implicit F: Monad[F]): IterateeT[E, F, ACC]
Enumeratee that folds over the Iteratee with Cont or Done and Empty, returning with Done and EOF.
Enumeratee that folds over the Iteratee with Cont or Done and Empty, returning with Done and EOF.
Converts ResumableIters on Done via a fold, returning Done only when receiving EOF from the initIter.
NB - This can be thought of the reverse of toResumableIter but also accumulating.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def isDone[E, F[_], A](iter: IterateeT[E, F, A])(implicit F: Monad[F]): F[Boolean]
Helper to identify dones
- def isDoneS[E, F[_], A](step: StepT[E, F, A])(implicit F: Monad[F]): Boolean
- def isEOF[E, F[_], A](iter: IterateeT[E, F, A])(implicit F: Monad[F]): F[Boolean]
Helper for done and eof
- def isEOFS[E, F[_], A](step: StepT[E, F, A])(implicit F: Monad[F]): Boolean
Helper for done and eof
- def isEmpty[E, F[_], A](iter: IterateeT[E, F, A])(implicit F: Monad[F]): F[Boolean]
Helper for done and empty
- def isEmptyS[E, F[_], A](step: StepT[E, F, A])(implicit F: Monad[F]): Boolean
Helper for done and empty
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isResumableEOF[E, F[_], A](iter: ResumableIter[E, F, A])(implicit F: Monad[F]): F[Boolean]
is this iteratee actually "empty"
- def isResumableEOFS[E, F[_], A](s: ResumableStep[E, F, A]): Boolean
- def iteratorEnumerator[E, F[_]](iter: Iterator[E])(implicit f: Monad[F]): EnumeratorT[E, F]
Taken from huynhjl's answer on StackOverflow, just abstracting the type to allow for better implicit inference
Taken from huynhjl's answer on StackOverflow, just abstracting the type to allow for better implicit inference
def iteratorEnumerator[E](iter: Iterator[E]) = new EnumeratorT[E, Trampoline] { override def apply[A]: StepT[E, Trampoline, A] => IterateeT[E, Trampoline, A] = { case step if iter.isEmpty => iterateeT[E, Trampoline, A](Free.point(step)) case step @ Done(acc, input) => iterateeT[E, Trampoline, A](Free.point(step)) case step @ Cont(k) => val x : E = iter.next
k(Element(x)) >>== { s => s.mapContOr(_ => sys.error("diverging iteratee"), apply(s)) } } }
- def mapTo[E, F[_], A](f: (E) => Input[EphemeralStream[A]])(implicit F: Applicative[F]): IterateeT[E, F, EphemeralStream[A]]
Maps a given input to a function returning a Input[EphemeralStream].
Maps a given input to a function returning a Input[EphemeralStream]. If the Input is El it returns it, if EOF empty and continues on empty.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def onDone[E, F[_], A](originalList: List[ResumableIter[E, F, A]])(implicit F: Monad[F]): ResumableIterList[E, F, A]
onDone, iterates over the list of iteratees applying the element, when the resulting list contains a Done then the list of Dones is returned.
onDone, iterates over the list of iteratees applying the element, when the resulting list contains a Done then the list of Dones is returned.
One can use tuples or pattern matching to discern which of the original lists iteratees have matched.
Due to the return type of this iteratee all items in the list must return the same type and must return both an A and an IterV with the same interface to continue with the next and maintain state.
In the case of EOF, an empty list is returned
- def repeatUntil[E, F[_], A](init: A)(f: (A) => A)(stopOn: (A) => Boolean)(implicit F: Monad[F]): F[(A, ResumableIter[A, F, A])]
Repeating fold on done, calling f with the result to accumulate with side effects, stopping when stopOn is true and returns the accumulated value continuation iteratee pair.
- def repeatUntilM[E, F[_], A](init: A)(f: (A) => F[A])(stopOn: (A) => Boolean)(implicit F: Monad[F]): F[(A, ResumableIter[A, F, A])]
Repeating fold on done, calling f with the result to accumulate with side effects, stopping when stopOn is true and returns the accumulated value continuation iteratee pair.
- def resumableEOF[E, F[_], A](input: A = null)(implicit F: Applicative[F]): ResumableIter[E, F, A]
marks a continuation resumableiter as actually being EOF - i.e.
marks a continuation resumableiter as actually being EOF - i.e. don't attempt to evaluate it
- def resumableEOFDone[E, F[_], A](input: A)(implicit F: Applicative[F]): ResumableStep[E, F, A]
- def runningCount[E, F[_]](implicit F: Monad[F]): ResumableIter[E, F, Long]
keeps a running count of each element, probably not of much use unless combined but acts as a good poc for ResumableIter
- def sum[T, F[_]](implicit n: Numeric[T], F: Applicative[F]): IterateeT[T, F, T]
Sums an iteratee up, consider using the Scalaz IterateeT monadic sum instead
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toResumableIter[E, F[_], A](oiter: IterateeT[E, F, A])(implicit F: Monad[F]): ResumableIter[E, F, A]
Converts a normal IterV[E,A] to a ResumableIter.
Converts a normal IterV[E,A] to a ResumableIter.
Does so by folding over the iter once for an input and when its Done starting again with the original iter. This is close to restarting the iter on a new "stream", otherwise all attempts to keep the Cont will be made.
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def withIter[E, A](e: EnumeratorT[E, IO])(initResumable: ResumableIter[E, IO, A]): ResumableIterIterator[E, A]
Converts the iteratee/enumerator/source triple into a Iterator.
Converts the iteratee/enumerator/source triple into a Iterator. This is only possible in IO given the ability to exit the monad _and_ trampoline.
For most uses iterate is a better option
Deprecated Value Members
- def enumerateeMap[E, F[_], A, R](target: IterateeT[A, F, R])(f: (E) => A)(implicit F: Monad[F]): IterateeT[E, F, R]
Enumeratee that converts input 1:1 String => Int, enumerator Iterator[String] but IterV[Int, Int]
Enumeratee that converts input 1:1 String => Int, enumerator Iterator[String] but IterV[Int, Int]
- Annotations
- @deprecated
- Deprecated
(Since version 0.6.0-M5) Use Scalaz 7 IterateeT.contramap