# _use

trait _Use[A] extends _aggregate[A] with _calculate[A] with _evaluate[A] with _metadata[A] with _print[A] with _process[A] with _read[A] with _transform[A]

### Stream Consumption Interface

Once a single stream consumption method is invoked, the stream object should generally be discarded. The only exceptions are methods defined in _metadata and _read interfaces.

Source
__.scala
trait _toTuple
trait _toScala
trait _toJava
trait _toString
trait _process
trait _print
trait _evaluate
class java.lang.Object
trait scala.Matchable
class Any
object Stream

## Def

inline def average(using v: Math.Average[A]): A

Average

Average

Computes average

For empty Stream returns zero value

``````   (10 <> 15).stream.map(_.toFloat).average  // Returns 12.5
``````

Note: average is available for types providing given Math.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Inherited from
_calculate
Source
_calculate.scala
inline def averageFew[B,C,D,E,F](fb: A => Opt[B], fc: A => Opt[C], fd: A => Opt[D], fe: A => Opt[E], ff: A => Opt[F])(using nb: Math.Average[B], nc: Math.Average[C], nd: Math.Average[D], ne: Math.Average[E], nf: Math.Average[F]): (B, C) | (B, C, D) | (B, C, D, E) | (B, C, D, E, F)

Multi average

Multi average

Simultaneously computes up to 5 average values for properties specified by functions

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

``````   (1 <> 1000).stream.averageFew(_ * 10F, _ * 100F).tp  // Prints (5005, 50050)

val (first, second, third) = (1 <> 1000).stream.averageFew(v => v.toDouble, _ * 10.0, _ * 100.0)

first.tp     // Prints 500.5
second.tp    // Prints 5005.0
third.tp     // Prints 50050.0
``````

Note: Averages areavailable for types providing given Stream.Custom.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Inherited from
_calculate
Source
_calculate.scala
inline def averageOpt(using v: Math.Average[A]): Opt[A]

Average option

Average option

Computes average or returns void option for empty stream

``````   (10 <> 15).stream.map(_.toFloat).averageOpt  // Returns Opt(12.5)
``````

Note: averageOpt is available for types providing given Math.Average implementations, which are by default Double, Float and opaque numerals based on Double and Float

Inherited from
_calculate
Source
_calculate.scala
inline def contains(value: A): Boolean

Value check

Value check

Returns true if stream contains given value.

Inherited from
_evaluate
Source
_evaluate.scala
inline def containsSequence(seq: Stream[A]): Boolean

Sequence check

Sequence check

Returns true if stream contains given sequence of values.

Inherited from
_evaluate
Source
_evaluate.scala
inline def count(f: A => Boolean): Int

Conditional count

Conditional count

Counts all stream elements, which satisfy given predicate

Inherited from
_evaluate
Source
_evaluate.scala
inline def count: Int

All count

All count

Counts all stream elements

Inherited from
_evaluate
Source
_evaluate.scala
inline def countAndTime: (Int, Time.Length)

Count and time

Count and time

Returns all elements count and Time.Length it took to pump the stream

``````  val (cnt,time) = (1 <> 1000).stream.peek(_ => J.sleep(1.Millis)).countAndTime

("" + cnt + " elements processed in " + time.tag).tp

// Output
1000 elements processed in 1.488880500 sec
``````
Inherited from
_evaluate
Source
_evaluate.scala
inline def countFew[B,C,D,E,F](f1: A => Boolean, f2: A => Boolean, f3: A => Boolean, f4: A => Boolean, f5: A => Boolean): (Int, Int) | (Int, Int, Int) | (Int, Int, Int, Int) | (Int, Int, Int, Int, Int)

Multi count

Multi count

Simultaneously counts values for up to 5 different predicates

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

``````val (large, odd, even) = (1 <>> 1000).stream.countFew(_ > 100, _ % 2 == 0, _ % 2 == 1)

large.tp    // Prints 899
odd.tp      // Prints 499
even.tp     // Prints 500
``````
Inherited from
_evaluate
Source
_evaluate.scala
inline def docTree

Doc Tree description

Doc Tree description

Returns a tree describing all stream trasformations

``````('a' <> 'z').stream
.map(_.toInt)
.take(_ % 2 == 0)
.docTree.tp

// Output
scalqa.lang.int.g.Stream\$TakeStream\$2@4ds1{raw=Int}
scalqa.lang.char.z.stream.map\$Ints@j38c{raw=Int,fromRaw=Char,size=26}
scalqa.lang.char.Z\$Stream_fromRange@gw1k{raw=Char,size=26,from=a,step=1}
``````
Inherited from
Source
inline def drain: Unit

Pump stream out

Pump stream out

Fetches and discards all stream elements

This operation can be usefull for side effects built into streaming pipeline

`````` ('A' <> 'C').stream.peek(_.tp).drain

// Output
A
B
C
``````
Inherited from
_process
Source
_process.scala
inline def equalsSequence(v: Stream[A]): Boolean

Equal check

Equal check

Iterates both streams and compares all corresponding elements

Returns `true` if all are equal, `false`` otherwise

Inherited from
_evaluate
Source
_evaluate.scala
inline def equalsSequenceResult(v: Stream[A]): Result[true]

Equal check

Equal check

Iterates both streams and compares all corresponding elements

When first not equal pair is found, the problem result is returned

If all elements are equal, Result[true] is returned

``````(0 <> 10).stream.equalsAllResult(0 <> 10).tp
// Prints: Result(true)

(0 <> 10).stream.equalsAllResult(0 <>> 10).tp
// Prints: Result(Problem(Second stream has less elements))

((0 <> 5).stream + 7 + 8).equalsAllResult(0 <> 10).tp
// Prints: Result(Problem(Fail at index 6: 7 != 6))
``````

Note: The returned problem contains message with basic description

Inherited from
_evaluate
Source
_evaluate.scala
inline def exists(f: A => Boolean): Boolean

Exists check

Exists check

Returns true if there is an elemnet satisfying given predicate

Inherited from
_evaluate
Source
_evaluate.scala
inline def find(f: A => Boolean): A

Find value

Find value

Finds the first value accepted by given predicate

`````` (1 <> 1000).stream.find(_ > 100).tp  // Prints 101
``````

Note: If value is not found find fails, use findOpt in most cases

Inherited from
_evaluate
Source
_evaluate.scala
inline def findOpt(f: A => Boolean): Opt[A]

Optional find value

Optional find value

Finds the first value accepted by given predicate or returns void option if not found

``````(1 <> 1000).stream.findOpt(_ > 100).tp   // Prints Opt(101)

(1 <> 10).stream.findOpt(_ > 100).tp     // Prints Opt(VOID)
``````
Inherited from
_evaluate
Source
_evaluate.scala
inline def findPositionOpt(f: A => Boolean): Int.Opt

Find index

Find index

Optionally returns index for the first element satisfying the predicate or Int.Opt(VOID) if none found

``````  (50 <> 500).stream.findPositionOpt(_ == 400)  // Retuns Int.Opt(350)
``````
Inherited from
_evaluate
Source
_evaluate.scala

Find start index

Find start index

Optionally returns index where given stream value sequence matches current stream values

Inherited from
_evaluate
Source
_evaluate.scala
inline def FOLD(start: A)(f: (A, A) => A): A

Heavy Fold

Heavy Fold

Folds elements with a binary function

FOLD is functionally equivalent to fold, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Inherited from
_aggregate
Source
_aggregate.scala
inline def fold(start: A)(f: (A, A) => A): A

Fold

Fold

Folds elements with a binary function

``````    // Calculate sum of first 1000 Ints

(1 <> 1000).stream.fold(0)(_ + _) // Returns 500500
``````
Value Params
f

binary function to fold elements with

start

Inherited from
_aggregate
Source
_aggregate.scala
inline def FOLD_AS[B](start: B)(f: (B, A) => B): B

Heavy Fold and convert

Heavy Fold and convert

Folds and converts elements with a binary function

FOLD_AS is functionally equivalent to foldAs, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Inherited from
_aggregate
Source
_aggregate.scala
inline def foldAs[B](start: B)(f: (B, A) => B): B

Fold and convert

Fold and convert

Folds and converts elements with a binary function

``````    // Calculate sum of first 1000 Ints

(1 <> 1000).stream.foldAs(0L)(_ + _) // Returns 500500
``````
Value Params
f

binary function to fold elements with Note. When folding AnyRef stream as a primitive value, there will be value boxing. Use FOLD_AS instead, which will be perfectly specialized.

start

Inherited from
_aggregate
Source
_aggregate.scala
inline def FOREACH[U](f: A => U): Unit

Heavy process stream

Heavy process stream

Applies given function to each stream element

FOREACH is functionally equivalent to foreach, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Inherited from
_process
Source
_process.scala
inline def foreach[U](f: A => U): Unit

Process stream

Process stream

Applies given function to each stream element

`````` ('A' <> 'C').stream.foreach(_.tp)

// Output
A
B
C
``````
Inherited from
_process
Source
_process.scala
inline def foreachIndexed[U](f: (Int, A) => U, start: Int): Unit

For each indexed

For each indexed

Calls given function with counter

`````` ('A' <> 'C').stream.foreachIndexed((i,v) => "Element " + i + " = " + v tp(), 1)

// Output
Element 1 = A
Element 2 = B
Element 3 = C
``````
Value Params
start

starting value for indexing

Inherited from
_process
Source
_process.scala
inline def fornil[U](f: => U): Unit

Run for nonexistent value

Run for nonexistent value

Runs given function only if stream is empty.

This operation is rarely useful and is provided for consistency.

Use peekEmpty instead, it can be combined with other processing

Inherited from
_process
Source
_process.scala
inline def isEvery(f: A => Boolean): Boolean

Forall check

Forall check

Returns true if every single element satisfies the given predicate

Inherited from
_evaluate
Source
_evaluate.scala
inline def iterator: scala.collection.Iterator[A]

Iterator view

Iterator view

Wraps current stream as `scala.collection.Iterator`

Inherited from
_toScala
Source
_toScala.scala
inline def last: A

Last element

Last element

Returns the last stream element

Fails if empty

Inherited from
_evaluate
Source
_evaluate.scala
inline def lastOpt: Opt[A]

Last element

Last element

Optionally returns the last element or Opt(VOID)

Inherited from
_evaluate
Source
_evaluate.scala
inline def makeString(separator: String)(using t: Any.Def.Tag[A]): String

Convert to String

Convert to String

The result is a concatenation of all elements with given separator

``````   ('a' <> 'j').stream.makeString("")            // Returns abcdefghij

('a' <> 'j').stream.makeString("|")           // Returns a|b|c|d|e|f|g|h|i|j

``````
Inherited from
_toString
Source
_toString.scala
inline def max(using o: Ordering[A]): A

Maximum

Maximum

Computes maximum value

Fails for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def maxBy[B](f: A => B)(using o: Ordering[B]): A

Maximum by property

Maximum by property

Computes maximum value based on given function

Fails for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def maxByOpt(f: A => B)(using o: Ordering[B]): Opt[A]

Optional maximum by property

Optional maximum by property

Computes maximum value based on given function or returns void option for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def maxOpt(using o: Ordering[A]): Opt[A]

Optional maximum

Optional maximum

Computes maximum value or returns void option for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def min(using o: Ordering[A]): A

Minimum

Minimum

Computes minimum value

Fails for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def minBy[B](f: A => B)(using o: Ordering[B]): A

Minimum by property

Minimum by property

Computes minimum value based on given function

Fails for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def minByOpt(f: A => B)(using o: Ordering[B]): Opt[A]

Optional minimum by property

Optional minimum by property

Computes minimum value based on given function or returns void option for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def minOpt(using o: Ordering[A]): Opt[A]

Optional minimum

Optional minimum

Computes minimum value or returns void option for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def pack(using s: Specialized[A]): s.Pack

Pack elements

Pack elements

Returns stream elements as Pack

Inherited from
_toCollections
Source
_toCollections.scala
inline def printId(using t: Any.Def.Tag[A]): Unit

Print to console with row id

Print to console with row id

Same as regular print, but with added first column identifying the object

``````
('A' <> 'F').stream.map(v => (v.Int, v)).print

// Output
----------------- -- --
Id                _1 _2
----------------- -- --
scala.Tuple2@dzkr 65 A
scala.Tuple2@zn1  66 B
scala.Tuple2@71j3 67 C
scala.Tuple2@562u 68 D
scala.Tuple2@c8tt 69 E
scala.Tuple2@p0m8 70 F
----------------- -- --
``````
Inherited from
_print
Source
_print.scala
inline def process[U,W](foreachFun: A => U, fornilFun: => W): Unit

Process elements or empty case

Process elements or empty case

Applies given function to each stream element or runs second function when stream is empty

`````` ('A' <>> 'A').stream.process(_.tp, "Empty".tp)

// Output
Empty
``````
Inherited from
_process
Source
_process.scala
inline def range(using o: Ordering[A]): Range[A]

Range

Range

Computes value range

Fails for empty streams

Inherited from
_calculate
Source
_calculate.scala
inline def rangeOpt(using o: Ordering[A]): Opt[Range[A]]

Optional range

Optional range

Computes value value or returns void option for empty streams

Inherited from
_calculate
Source
_calculate.scala

Next element

Next element

Delivers next stream element

`````` val s : Stream[Char] = 'A' <> 'Z'

``````

Note: If stream is empty, read will fail. So, use a safer readOpt in most cases

Inherited from
Source

Next optional element

Next optional element

Delivers next stream element or void option if stream is empty

`````` val s : Stream[Char] = 'A' <> 'C'

``````
Inherited from
Source
inline def readStream(cnt: Int): Stream[A] & Able.Size

Immediatelly removes given number of elements from current stream and returns them as a new stream

`````` val s : Stream[Int] = 1 <> 12

s.readStream(3).tp  // Prints Stream(1, 2, 3)
s.readStream(4).tp  // Prints Stream(4, 5, 6, 7)
s.readStream(7).tp  // Prints Stream(8, 9, 10, 11, 12)
``````

Note: If requested number of elements is not available, the number returned is less (0 if empty)

Inherited from
Source
inline def reduce(f: (A, A) => A): A

Reduce

Reduce

Folds elements with a binary function

``````   // Calculate sum of first 1000 Ints

(1 <> 1000).stream.reduce(_ + _) // Returns 500500
``````

Note. Threre is no default value, and if stream is empty, operation fails. Use reduceOpt as safer option

Value Params
f

binary function to fold elements with

Inherited from
_aggregate
Source
_aggregate.scala
inline def REDUCE(f: (A, A) => A): A

Heavy reduce

Heavy reduce

Folds elements with a binary function

REDUCE is functionally equivalent to reduce, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Inherited from
_aggregate
Source
_aggregate.scala
inline def REDUCE_OPT(f: (A, A) => A): Opt[A]

Heavy optional reduce

Heavy optional reduce

Folds elements with a binary function

REDUCE_OPT is functionally equivalent to reduceOpt, but is fully inlined. It makes compiled code larger, but guarantees the best possible performance on large streams.

Inherited from
_aggregate
Source
_aggregate.scala
inline def reduceOpt(f: (A, A) => A): Opt[A]

Optional reduce

Optional reduce

Folds elements with a binary function or returns empty option when stream is empty

``````    // Calculate sum of first 1000 Ints

(1 <> 1000).stream.reduceOpt(_ + _) // Returns Opt(500500)
``````
Value Params
f

binary function to fold elements with

Inherited from
_aggregate
Source
_aggregate.scala
inline def sizeLongOpt

Optional long size

Optional long size

Many streams can return their current element count. If the information is not available, void option is returned

``````var s = (Int.min.Long <> Int.max.toLong).stream

s.sizeLongOpt.tp    // Prints Long.Opt(4294967296)

s = s.take(_ > 10)  // static sizing is lost

s.sizeLongOpt.tp    // Prints Long.Opt(VOID)
``````
Inherited from
Source
inline def sizeOpt

Optional size

Optional size

Many streams can return their current element count. If the information is not available, void option is returned

Note: If size is known, but exceeds integer range, void option is returned. For theses cases use sizeLongOpt

`````` var s = ('a' <> 'z').stream

s.sizeOpt.tp         // Prints Int.Opt(26)

s = s.take(_ > 10)   // static sizing is lost

s.sizeOpt.tp         // Prints Int.Opt(VOID)
``````
Inherited from
Source
inline def startsWithSequence(v: Stream[A]): Boolean

Equal start check

Equal start check

Checks if starting elements of two streams (to a point where one stream ends) are equal

Inherited from
_evaluate
Source
_evaluate.scala
inline def startsWithSequenceResult(v: Stream[A]): Result[true]

Equal start check

Equal start check

Checks if starting elements of two streams (to a point where one stream ends) are equal

``````(0 <> 10).stream.equalsStartResult(0 <> 1000).tp
// Prints: Result(true)

(0 <> 1000).stream.equalsStartResult(0 <> 10).tp
// Prints: Result(true)

((0 <> 5).stream + 7 + 8).equalsStartResult(0 <> 10).tp
// Prints: Result(Problem(Fail at index 6: 7 != 6))
``````

Note: The returned problem result contains message with basic description

Inherited from
_evaluate
Source
_evaluate.scala
inline def sum(using v: Math.Sum[A]): A

Sum

Sum

Calculates sum of all values

For empty stream returns zero

``````    (1 <> 1000).stream.sum.tp // Prints 500500
``````
Inherited from
_calculate
Source
_calculate.scala
inline def sumFew[B,C,D,E,F](fb: A => Opt[B], fc: A => Opt[C], fd: A => Opt[D], fe: A => Opt[E], ff: A => Opt[F])(using nb: Math.Sum[B], nc: Math.Sum[C], nd: Math.Sum[D], ne: Math.Sum[E], nf: Math.Sum[F]): (B, C) | (B, C, D) | (B, C, D, E) | (B, C, D, E, F)

Multi sum

Multi sum

Simultaneously computes up to 5 sum values for properties specified by given functions

Returns tuple of appropriate size with values corresponding to the given mappings

For empty Stream returned tuple will hold zeros

`````` (1 <> 1000).stream.sumFew(_ * 10, _ * 100).tp  // Prints (5005000, 50050000)

val (first, second, third) = (1 <> 1000).stream.sumFew(v => v, _ * 10, _ * 100)

first.tp     // Prints 500500
second.tp    // Prints 5005000
third.tp     // Prints 50050000
``````
Inherited from
_calculate
Source
_calculate.scala
inline def sumOpt(using v: Math.Sum[A]): Opt[A]

Optional sum

Optional sum

Calculates sum of all values or returns void option for empty streams

``````    (1 <> 1000).stream.sumOpt.tp // Prints Opt(500500)
``````
Inherited from
_calculate
Source
_calculate.scala
inline def toArray(using t: scala.reflect.ClassTag[A], s: Specialized[A]): s.Array

Convert to Array

Convert to Array

Returns stream elements as Array

`````` val a : Array[Int] =  (1 <> 10).stream.toArray
``````
Inherited from
_toCollections
Source
_toCollections.scala
inline def toBuffer(using s: Specialized[A]): s.Buffer

Convert to Buffer

Convert to Buffer

Returns stream elements as Buffer

Inherited from
_toCollections
Source
_toCollections.scala
inline def toIdx(using s: Specialized[A]): s.Idx

Convert to Idx

Convert to Idx

Returns stream elements as Idx

Inherited from
_toCollections
Source
_toCollections.scala
inline def toJavaIterator: java.util.Iterator[A]

Convert to Java Iterator

Convert to Java Iterator

Wraps current stream as `java.util.Iterator`

Inherited from
_toJava
Source
_toJava.scala
inline def toJavaList: java.util.List[A]

Convert to Java List

Convert to Java List

Returns stream elements as `java.util.List`

Inherited from
_toJava
Source
_toJava.scala
inline def toJavaSpliterator(splitSize: Int): java.util.Spliterator[A]

Convert to Java Spliterator

Convert to Java Spliterator

Wraps current stream as `java.util.Spliterator`

Inherited from
_toJava
Source
_toJava.scala
inline def toJavaStream(parallel: Boolean): java.util.stream.Stream[A]

Convert to Java Stream

Convert to Java Stream

Wraps current stream as `java.util.stream.Stream`

Inherited from
_toJava
Source
_toJava.scala
inline def toList: scala.collection.immutable.List[A]

Convert to List

Convert to List

Returns stream elements as `scala.collection.immutable.List`

Inherited from
_toScala
Source
_toScala.scala
inline def toLookup[KEY, VALUE](using KEY: Specialized[KEY]): KEY.Lookup[VALUE]

Convert to Lookup

Convert to Lookup

Note. This operation is only available for streams holding tuples, like (KEY,VALUE)

Converts a stream of tuples to Lookup

``````val intLookup : Lookup[Int,Char] = ('A' <> 'F').stream.zipKey(_.toInt).toLookup

intLookup.pairStream.tp   // Prints Stream((69,E), (70,F), (65,A), (66,B), (67,C), (68,D))

val charLookup : Lookup[Char,Int] = ('A' <> 'F').stream.zipValue(_.toInt).toLookup

charLookup.pairStream.tp   // Prints Stream((E,69), (F,70), (A,65), (B,66), (C,67), (D,68))
``````
Inherited from
_toCollections
Source
_toCollections.scala
inline def toLookupBy[KEY](f: A => KEY)(using KEY: Specialized[KEY]): KEY.Lookup[A]

Convert to Lookup

Convert to Lookup

Converts stream to a Lookup collection, where key is created with provided function

``````val intLookup : Lookup[Int,Char] = ('A' <> 'F').stream.toLookupBy(_.toInt)

intLookup.pairStream.tp   // Prints Stream((69,E), (70,F), (65,A), (66,B), (67,C), (68,D))
``````
Inherited from
_toCollections
Source
_toCollections.scala
inline def toMap[KEY, VALUE]: scala.collection.immutable.Map[KEY, VALUE]

Convert to scala.Map

Convert to scala.Map

Note. This operation is only available for streams holding tuples, like (KEY,VALUE)

Converts a stream of tuples to scala.Map

Inherited from
_toScala
Source
_toScala.scala
inline def toMapBy[B](f: A => B): scala.collection.immutable.Map[B, A]

Convert to scala.Map

Convert to scala.Map

Converts stream to scala.Map, where key is created with provided function

Inherited from
_toScala
Source
_toScala.scala
inline def toProduct: scala.Product

Convert to Product

Convert to Product

Returns stream elements as `scala.Product`

Inherited from
_toScala
Source
_toScala.scala
inline def toSeq: scala.collection.immutable.IndexedSeq[A]

Convert to Seq

Convert to Seq

Returns stream elements as `scala.collection.immutable.IndexedSeq`

Inherited from
_toScala
Source
_toScala.scala
inline def toSet(using s: Specialized[A]): s.Set

Convert to unique collection

Convert to unique collection

Returns stream elements as Set

Inherited from
_toCollections
Source
_toCollections.scala
inline def toText(using t: Any.Def.Tag[A]): String

Elements as multi-line String

Elements as multi-line String

Returns all elements as String formatted table

If elements implement Able.Doc, each 'doc' property value is placed in a different column

If elements implement `scala.Product` (like all Tuples), each Product element is placed in a different column

``````  ('a' <> 'e').stream.map(v => (v + "1", v + "2", v + "3", v + "4", v + "5")).toText.tp

// Output
-- -- -- -- --
?  ?  ?  ?  ?
-- -- -- -- --
a1 a2 a3 a4 a5
b1 b2 b3 b4 b5
c1 c2 c3 c4 c5
d1 d2 d3 d4 d5
e1 e2 e3 e4 e5
-- -- -- -- --
``````
Inherited from
_toString
Source
_toString.scala
inline def toVector: scala.collection.immutable.Vector[A]

Convert to Vector

Convert to Vector

Returns stream elements as `scala.collection.immutable.Vector`

Inherited from
_toScala
Source
_toScala.scala
inline def tuple10: (A, A, A, A, A, A, A, A, A, A)

Convert to Tuple10

Convert to Tuple10

If Stream has less then 10 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple11: (A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple11

Convert to Tuple11

If Stream has less then 11 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple12: (A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple12

Convert to Tuple12

If Stream has less then 12 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple13: (A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple13

Convert to Tuple13

If Stream has less then 13 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple14: (A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple14

Convert to Tuple14

If Stream has less then 14 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple15: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple15

Convert to Tuple15

If Stream has less then 15 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple16: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple16

Convert to Tuple16

If Stream has less then 16 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple17: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple17

Convert to Tuple17

If Stream has less then 17 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple18: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple18

Convert to Tuple18

If Stream has less then 18 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple19: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple19

Convert to Tuple19

If Stream has less then 19 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple2: (A, A)

Convert to Tuple2

Convert to Tuple2

If Stream has less then 2 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple20: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple20

Convert to Tuple20

If Stream has less then 20 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple21: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple21

Convert to Tuple21

If Stream has less then 21 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple22: (A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)

Convert to Tuple22

Convert to Tuple22

If Stream has less then 22 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple3: (A, A, A)

Convert to Tuple3

Convert to Tuple3

If Stream has less then 3 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple4: (A, A, A, A)

Convert to Tuple4

Convert to Tuple4

If Stream has less then 4 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple5: (A, A, A, A, A)

Convert to Tuple5

Convert to Tuple5

If Stream has less then 5 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple6: (A, A, A, A, A, A)

Convert to Tuple6

Convert to Tuple6

If Stream has less then 6 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple7: (A, A, A, A, A, A, A)

Convert to Tuple7

Convert to Tuple7

If Stream has less then 7 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple8: (A, A, A, A, A, A, A, A)

Convert to Tuple8

Convert to Tuple8

If Stream has less then 8 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala
inline def tuple9: (A, A, A, A, A, A, A, A, A)

Convert to Tuple9

Convert to Tuple9

If Stream has less then 9 elements, the operation will fail.

Inherited from
_toTuple
Source
_toTuple.scala