Parameters

code.data.CollectingFlowStream.TYPEA

subClasses

superClasses

Any

code.data.FlowStream

java.io.Serializable

java.lang.Object

scala.Equals

scala.Function1

scala.PartialFunction

scala.Serializable

scala.collection.AbstractIterable

scala.collection.AbstractSeq

scala.collection.AbstractTraversable

scala.collection.GenIterable

scala.collection.GenIterableLike

scala.collection.GenSeq

scala.collection.GenSeqLike

scala.collection.GenTraversable

scala.collection.GenTraversableLike

scala.collection.GenTraversableOnce

scala.collection.Iterable

scala.collection.IterableLike

scala.collection.LinearSeq

scala.collection.LinearSeqLike

scala.collection.LinearSeqOptimized

scala.collection.Parallelizable

scala.collection.Seq

scala.collection.SeqLike

scala.collection.Traversable

scala.collection.TraversableLike

scala.collection.TraversableOnce

scala.collection.generic.FilterMonadic

scala.collection.generic.GenericTraversableTemplate

scala.collection.generic.HasNewBuilder

Js Constructors

new code_data_EagerFlowStream(
    i // scala.collection.Iterator[code.data.EagerFlowStream.TYPEA]
)

new code_data_EagerFlowStream(
    t // scala.collection.Traversable[code.data.EagerFlowStream.TYPEA]
)

new code_data_EagerFlowStream(
    l // scala.collection.immutable.List[code.data.EagerFlowStream.TYPEA]
)

ApplyMethods

Methods

$bang$eq(x$1:Any):boolean

$colon$bslash(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

$colon$plus(elem:code.data.EagerFlowStream.TYPEB):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

$colon$plus(elem:scala.collection.SeqLike.B, bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

$div$colon(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

$eq$eq(x$1:Any):boolean

$hash$colon$colon(hd:code.data.EagerFlowStream.TYPEA):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

$hash$colon$colon$colon(prefix:code.data.FlowStream[code.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

$hash$colon$colon$colon(prefix:scala.collection.immutable.Stream[code.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

$hash$hash():int

$init$():Unit

$plus$colon(elem:code.data.EagerFlowStream.TYPEB):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

$plus$colon(elem:scala.collection.SeqLike.B, bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

$plus$plus(that:scala.collection.GenTraversableOnce[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

$plus$plus(that:scala.collection.GenTraversableOnce[scala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

$plus$plus$colon(that:scala.collection.TraversableOnce[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

$plus$plus$colon(that:scala.collection.Traversable[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

$plus$plus$colon(that:scala.collection.TraversableOnce[scala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

$plus$plus$colon(that:scala.collection.Traversable[scala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

addString(b:scala.collection.mutable.StringBuilder):scala.collection.mutable.StringBuilder

addString(b:scala.collection.mutable.StringBuilder, sep:java.lang.String):scala.collection.mutable.StringBuilder

addString(b:scala.collection.mutable.StringBuilder, start:java.lang.String, sep:java.lang.String, end:java.lang.String):scala.collection.mutable.StringBuilder

aggregate(z:Unknown Nothing, seqop:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB], combop:scala.Function2[code.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

andThen(k:scala.Function1[code.data.EagerFlowStream.Ccode.data.EagerFlowStream.TYPEA]):scala.PartialFunction[code.data.EagerFlowStream.Cint]

append(rest:Unknown Nothing):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

apply(n:int):code.data.EagerFlowStream.TYPEA

applyOrElse(x:code.data.EagerFlowStream.TYPEA1, default:scala.Function1[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEB1]):code.data.EagerFlowStream.TYPEB1

asInstanceOf():scala.Any.T0

canEqual(that:Any):boolean

collect(pf:scala.PartialFunction[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

collect(pf:scala.PartialFunction[scala.collection.TraversableLike.Ascala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

collectFirst(pf:scala.PartialFunction[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB]):scala.Option[code.data.EagerFlowStream.TYPEB]

collecting():code.data.CollectingFlowStream[code.data.EagerFlowStream.TYPEA]

combinations(n:int):scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

companion():scala.collection.generic.GenericCompanion[code.data.FlowStream]

compose(g:scala.Function1[code.data.EagerFlowStream.Cint]):scala.Function1[code.data.EagerFlowStream.Ccode.data.EagerFlowStream.TYPEA]

contains(elem:code.data.EagerFlowStream.TYPEA1):boolean

containsSlice(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):boolean

copyToArray(xs:Array[code.data.EagerFlowStream.TYPEB]):Unit

copyToArray(xs:Array[scala.collection.TraversableOnce.B], start:int):Unit

copyToArray(xs:Array[code.data.EagerFlowStream.TYPEB], start:int, len:int):Unit

copyToBuffer(dest:scala.collection.mutable.Buffer[code.data.EagerFlowStream.TYPEB]):Unit

corresponds(that:scala.collection.GenSeq[scala.collection.LinearSeqLike.B], p:scala.Function2[booleanscala.collection.LinearSeqLike.Ascala.collection.LinearSeqLike.B]):boolean

count(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):int

diff(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

distinct():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

drop(n:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

dropRight(n:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

dropWhile(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

eager():code.data.EagerFlowStream[code.data.EagerFlowStream.TYPEA]

endsWith(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):boolean

eq(x$1:java.lang.Object):boolean

equals(that:Any):boolean

exists(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):boolean

filter(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

filterNot(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

find(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):scala.Option[code.data.EagerFlowStream.TYPEA]

flatMap(f:scala.Function1[code.data.EagerFlowStream.TYPEAscala.collection.GenTraversableOnce[code.data.EagerFlowStream.TYPEB]]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

flatMap(f:scala.Function1[code.data.FlowStream.TYPEAscala.collection.GenTraversableOnce[code.data.FlowStream.TYPEB]], unusedCanBuild:Any):code.data.FlowStream[code.data.FlowStream.TYPEB]

flatMap(f:scala.Function1[scala.collection.GenTraversableOnce[scala.collection.TraversableLike.B]scala.collection.TraversableLike.A], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

flatten(asTraversable:scala.Function1[code.data.EagerFlowStream.TYPEAscala.collection.GenTraversableOnce[code.data.EagerFlowStream.TYPEB]]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

fold(z:code.data.EagerFlowStream.TYPEA1, op:scala.Function2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1]):code.data.EagerFlowStream.TYPEA1

foldLeft(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

foldRight(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

forall(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):boolean

force():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

foreach(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.U]):Unit

forgetful():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

genericBuilder():scala.collection.mutable.Builder[code.data.EagerFlowStream.TYPEBcode.data.FlowStream[code.data.EagerFlowStream.TYPEB]]

getClass():java.lang.Class[Any]

groupBy(f:scala.Function1[code.data.EagerFlowStream.Kcode.data.EagerFlowStream.TYPEA]):scala.collection.immutable.Map[code.data.EagerFlowStream.Kcode.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

grouped(size:int):scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

hasDefiniteSize():boolean

hashCode():int

head():code.data.EagerFlowStream.TYPEA

headOption():scala.Option[code.data.EagerFlowStream.TYPEA]

indexOf(elem:code.data.EagerFlowStream.TYPEB):int

indexOf(elem:code.data.EagerFlowStream.TYPEB, from:int):int

indexOfSlice(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):int

indexOfSlice(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB], from:int):int

indexWhere(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):int

indexWhere(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA], from:int):int

indices():scala.collection.immutable.Range

init():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

inits():scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

intersect(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

isDefinedAt(x:int):boolean

isEmpty():boolean

isInstanceOf():boolean

isTraversableAgain():boolean

iterator():scala.collection.Iterator[code.data.EagerFlowStream.TYPEA]

last():code.data.EagerFlowStream.TYPEA

lastIndexOf(elem:code.data.EagerFlowStream.TYPEB):int

lastIndexOf(elem:code.data.EagerFlowStream.TYPEB, end:int):int

lastIndexOfSlice(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):int

lastIndexOfSlice(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB], end:int):int

lastIndexWhere(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):int

lastIndexWhere(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA], end:int):int

lastOption():scala.Option[code.data.EagerFlowStream.TYPEA]

length():int

lengthCompare(len:int):int

lift():scala.Function1[intscala.Option[code.data.EagerFlowStream.TYPEA]]

map(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

map(f:scala.Function1[code.data.FlowStream.TYPEAcode.data.FlowStream.TYPEB], unusedCanBuild:Any):code.data.FlowStream[code.data.FlowStream.TYPEB]

map(f:scala.Function1[scala.collection.TraversableLike.Ascala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

max(cmp:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEA

maxBy(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB], cmp:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEA

min(cmp:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEA

minBy(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB], cmp:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEA

mkString():java.lang.String

mkString(sep:java.lang.String):java.lang.String

mkString(start:java.lang.String, sep:java.lang.String, end:java.lang.String):java.lang.String

ne(x$1:java.lang.Object):boolean

nonEmpty():boolean

notify():Unit

notifyAll():Unit

orElse(that:scala.PartialFunction[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEB1]):scala.PartialFunction[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEB1]

padTo(len:int, elem:code.data.EagerFlowStream.TYPEB):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

padTo(len:int, elem:scala.collection.SeqLike.B, bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

par():scala.collection.parallel.immutable.ParSeq[code.data.EagerFlowStream.TYPEA]

parFlatMap(ts:scala.collection.parallel.TaskSupport, f:scala.Function1[code.data.EagerFlowStream.TYPEAscala.collection.GenTraversableOnce[code.data.EagerFlowStream.TYPEB]], parallelism:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

partition(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):scala.Tuple2[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

patch(from:int, that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEA], replaced:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

patch(from:int, patch:scala.collection.GenSeq[scala.collection.SeqLike.B], replaced:int, bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

permutations():scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

prefixLength(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):int

print():Unit

print(sep:java.lang.String):Unit

product(num:scala.math.Numeric[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

recreate(newIter:scala.collection.Iterator[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

recreate(newL:scala.collection.immutable.List[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

recreate(outer:scala.collection.Traversable[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

recreateWithItems(items:Unknown Nothing):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

reduce(op:scala.Function2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1]):code.data.EagerFlowStream.TYPEA1

reduceLeft(op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

reduceLeftOption(op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):scala.Option[code.data.EagerFlowStream.TYPEB]

reduceOption(op:scala.Function2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA1]):scala.Option[code.data.EagerFlowStream.TYPEA1]

reduceRight(op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

reduceRightOption(op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):scala.Option[code.data.EagerFlowStream.TYPEB]

repr():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

reverse():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

reverseIterator():scala.collection.Iterator[code.data.EagerFlowStream.TYPEA]

reverseMap(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

reverseMap(f:scala.Function1[scala.collection.SeqLike.Ascala.collection.SeqLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

runWith(action:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.U]):scala.Function1[booleanint]

sameElements(that:scala.collection.GenIterable[code.data.EagerFlowStream.TYPEB]):boolean

scan(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

scan(z:scala.collection.TraversableLike.B, op:scala.Function2[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Bscala.collection.TraversableLike.B], cbf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

scanLeft(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

scanLeft(z:scala.collection.TraversableLike.B, op:scala.Function2[scala.collection.TraversableLike.Ascala.collection.TraversableLike.Bscala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

scanRight(z:code.data.EagerFlowStream.TYPEB, op:scala.Function2[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEBcode.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEB]

scanRight(z:scala.collection.TraversableLike.B, op:scala.Function2[scala.collection.TraversableLike.Ascala.collection.TraversableLike.Bscala.collection.TraversableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.TraversableLike.Bscala.collection.TraversableLike.Reprscala.collection.TraversableLike.That]):scala.collection.TraversableLike.That

segmentLength(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA], from:int):int

seq():scala.collection.LinearSeq[code.data.EagerFlowStream.TYPEA]

size():int

slice(from:int, until:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

sliding(size:int):scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

sliding(size:int, step:int):scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

sortBy(f:scala.Function1[code.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEB], ord:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

sortWith(lt:scala.Function2[booleancode.data.EagerFlowStream.TYPEAcode.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

sorted(ord:scala.math.Ordering[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

span(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):scala.Tuple2[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

splitAt(n:int):scala.Tuple2[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

startsWith(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB]):boolean

startsWith(that:scala.collection.GenSeq[code.data.EagerFlowStream.TYPEB], offset:int):boolean

stringPrefix():java.lang.String

sum(num:scala.math.Numeric[code.data.EagerFlowStream.TYPEB]):code.data.EagerFlowStream.TYPEB

synchronized(x$1:java.lang.Object.T0):java.lang.Object.T0

tail():code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

tails():scala.collection.Iterator[code.data.FlowStream[code.data.EagerFlowStream.TYPEA]]

take(n:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

takeRight(n:int):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

takeWhile(p:scala.Function1[booleancode.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

to(cbf:scala.collection.generic.CanBuildFrom[scala.Nothingscala.collection.TraversableLike.Ascala.collection.TraversableLike.Col[scala.collection.TraversableLike.A]]):scala.collection.TraversableLike.Col[scala.collection.TraversableLike.A]

toArray(evidence:scala.reflect.ClassTag[code.data.EagerFlowStream.TYPEB]):Array[code.data.EagerFlowStream.TYPEB]

toBuffer():scala.collection.mutable.Buffer[code.data.EagerFlowStream.TYPEB]

toIndexedSeq():scala.collection.immutable.IndexedSeq[scala.collection.TraversableOnce.A]

toIterable():scala.collection.Iterable[code.data.EagerFlowStream.TYPEA]

toIterator():scala.collection.Iterator[scala.collection.IterableLike.A]

toList():scala.collection.immutable.List[code.data.EagerFlowStream.TYPEA]

toMap(ev:scala.Predef$$less$colon$less[scala.Tuple2[scala.collection.TraversableOnce.Tscala.collection.TraversableOnce.U]scala.collection.TraversableOnce.A]):scala.collection.immutable.Map[scala.collection.TraversableOnce.Tscala.collection.TraversableOnce.U]

toParArray():scala.collection.parallel.mutable.ParArray[code.data.EagerFlowStream.TYPEA]

toSeq():scala.collection.Seq[code.data.EagerFlowStream.TYPEA]

toSet():scala.collection.immutable.Set[code.data.EagerFlowStream.TYPEB]

toStream():scala.collection.immutable.Stream[code.data.EagerFlowStream.TYPEA]

toString():java.lang.String

toTraversable():scala.collection.Traversable[scala.collection.TraversableLike.A]

toVector():scala.collection.immutable.Vector[code.data.EagerFlowStream.TYPEA]

transpose(asTraversable:scala.Function1[code.data.EagerFlowStream.TYPEAscala.collection.GenTraversableOnce[code.data.EagerFlowStream.TYPEB]]):code.data.FlowStream[code.data.FlowStream[code.data.EagerFlowStream.TYPEB]]

union(that:scala.collection.Seq[code.data.EagerFlowStream.TYPEA]):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

union(that:scala.collection.GenSeq[scala.collection.SeqLike.B], bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

unzip(asPair:scala.Function1[code.data.EagerFlowStream.TYPEAscala.Tuple2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA2]]):scala.Tuple2[code.data.FlowStream[code.data.EagerFlowStream.TYPEA1]code.data.FlowStream[code.data.EagerFlowStream.TYPEA2]]

unzip3(asTriple:scala.Function1[code.data.EagerFlowStream.TYPEAscala.Tuple3[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEA2code.data.EagerFlowStream.TYPEA3]]):scala.Tuple3[code.data.FlowStream[code.data.EagerFlowStream.TYPEA1]code.data.FlowStream[code.data.EagerFlowStream.TYPEA2]code.data.FlowStream[code.data.EagerFlowStream.TYPEA3]]

updated(index:int, elem:code.data.EagerFlowStream.TYPEA):code.data.FlowStream[code.data.EagerFlowStream.TYPEA]

updated(index:int, elem:scala.collection.SeqLike.B, bf:scala.collection.generic.CanBuildFrom[scala.collection.SeqLike.Bscala.collection.SeqLike.Reprscala.collection.SeqLike.That]):scala.collection.SeqLike.That

view():scala.collection.SeqLike.<refinement>

view(from:int, until:int):scala.collection.SeqView[scala.collection.SeqLike.Ascala.collection.SeqLike.Repr]

wait():Unit

wait(x$1:long):Unit

wait(x$1:long, x$2:int):Unit

withFilter(p:scala.Function1[booleanscala.collection.TraversableLike.A]):scala.collection.generic.FilterMonadic[scala.collection.TraversableLike.Ascala.collection.TraversableLike.Repr]

zip(that:scala.collection.GenIterable[code.data.EagerFlowStream.TYPEB]):code.data.FlowStream[scala.Tuple2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEB]]

zip(that:scala.collection.GenIterable[scala.collection.IterableLike.B], bf:scala.collection.generic.CanBuildFrom[scala.Tuple2[scala.collection.IterableLike.A1scala.collection.IterableLike.B]scala.collection.IterableLike.Reprscala.collection.IterableLike.That]):scala.collection.IterableLike.That

zipAll(that:scala.collection.Iterable[code.data.EagerFlowStream.TYPEB], thisElem:code.data.EagerFlowStream.TYPEA1, thatElem:code.data.EagerFlowStream.TYPEB):code.data.FlowStream[scala.Tuple2[code.data.EagerFlowStream.TYPEA1code.data.EagerFlowStream.TYPEB]]

zipAll(that:scala.collection.GenIterable[scala.collection.IterableLike.B], thisElem:scala.collection.IterableLike.A1, thatElem:scala.collection.IterableLike.B, bf:scala.collection.generic.CanBuildFrom[scala.Tuple2[scala.collection.IterableLike.A1scala.collection.IterableLike.B]scala.collection.IterableLike.Reprscala.collection.IterableLike.That]):scala.collection.IterableLike.That

zipWithIndex():code.data.FlowStream[scala.Tuple2[code.data.EagerFlowStream.TYPEA1int]]

zipWithIndex(bf:scala.collection.generic.CanBuildFrom[scala.Tuple2[intscala.collection.IterableLike.A1]scala.collection.IterableLike.Reprscala.collection.IterableLike.That]):scala.collection.IterableLike.That