Scala Standard Library 2.13.1 - scala.collection.LazyZip2 (original) (raw)

final class LazyZip2[+El1, +El2, C1] extends AnyRef

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. LazyZip2
2. AnyRef
3. Any

Implicitly

1. by lazyZip2ToIterable

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Visibility

1. Public
2. Protected

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  final def ++[B >: A](suffix: IterableOnce[B]): View[B]
5.  def ->[B](y: B): (LazyZip2[El1, El2, C1], B)
6.  final def ==(arg0: Any): Boolean
7.  final def addString(b: mutable.StringBuilder): mutable.StringBuilder
8.  final def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder
9.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
10.  final def asInstanceOf[T0]: T0
11.  def clone(): AnyRef
12.  def collect[B](pf: PartialFunction[(El1, El2), B]): View[B]
13.  def collectFirst[B](pf: PartialFunction[(El1, El2), B]): Option[B]
14.  def concat[B >: A](suffix: IterableOnce[B]): View[B]
15.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
16.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
17.  def copyToArray[B >: A](xs: Array[B]): Int
18.  def corresponds[B](that: IterableOnce[B])(p: ((El1, El2), B) => Boolean): Boolean
19.  def count(p: ((El1, El2)) => Boolean): Int
20.  def drop(n: Int): View[(El1, El2)]
21.  def dropRight(n: Int): View[(El1, El2)]
22.  def dropWhile(p: ((El1, El2)) => Boolean): View[(El1, El2)]
23.  def empty: View[(El1, El2)]
24.  def ensuring(cond: (LazyZip2[El1, El2, C1]) => Boolean, msg: => Any): LazyZip2[El1, El2, C1]
25.  def ensuring(cond: (LazyZip2[El1, El2, C1]) => Boolean): LazyZip2[El1, El2, C1]
26.  def ensuring(cond: Boolean, msg: => Any): LazyZip2[El1, El2, C1]
27.  def ensuring(cond: Boolean): LazyZip2[El1, El2, C1]
28.  final def eq(arg0: AnyRef): Boolean
29.  def equals(arg0: AnyRef): Boolean
30.  def exists(p: (El1, El2) => Boolean): Boolean
31.  def filter[C](p: (El1, El2) => Boolean)(implicit bf: BuildFrom[C1, (El1, El2), C]): C
32.  def filterNot(pred: ((El1, El2)) => Boolean): View[(El1, El2)]
33.  def finalize(): Unit
34.  def find(p: ((El1, El2)) => Boolean): Option[(El1, El2)]
35.  def flatMap[B, C](f: (El1, El2) => Iterable[B])(implicit bf: BuildFrom[C1, B, C]): C
36.  def flatten[B](implicit asIterable: ((El1, El2)) => IterableOnce[B]): View[B]
37.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
38.  def foldLeft[B](z: B)(op: (B, (El1, El2)) => B): B
39.  def foldRight[B](z: B)(op: ((El1, El2), B) => B): B
40.  def forall(p: (El1, El2) => Boolean): Boolean
41.  def foreach[U](f: (El1, El2) => U): Unit
42.  def formatted(fmtstr: String): String
43.  final def getClass(): Class[_ <: AnyRef]
44.  def groupBy[K](f: ((El1, El2)) => K): immutable.Map[K, View[(El1, El2)]]
45.  def groupMap[K, B](key: ((El1, El2)) => K)(f: ((El1, El2)) => B): immutable.Map[K, View[B]]
46.  def groupMapReduce[K, B](key: ((El1, El2)) => K)(f: ((El1, El2)) => B)(reduce: (B, B) => B): immutable.Map[K, B]
47.  def grouped(size: Int): Iterator[View[(El1, El2)]]
48.  def hashCode(): Int
49.  def head: (El1, El2)
50.  def headOption: Option[(El1, El2)]
51.  def init: View[(El1, El2)]
52.  def inits: Iterator[View[(El1, El2)]]
53.  def isEmpty: Boolean
54.  final def isInstanceOf[T0]: Boolean
55.  def isTraversableAgain: Boolean
56.  def iterableFactory: IterableFactory[View]
57.  def iterator: Iterator[(El1, El2)]
58.  def knownSize: Int
59.  def last: (El1, El2)
60.  def lastOption: Option[(El1, El2)]
61.  def lazyZip[B](that: Iterable[B]): LazyZip3[El1, El2, B, C1]
62.  def map[B, C](f: (El1, El2) => B)(implicit bf: BuildFrom[C1, B, C]): C
63.  def max[B >: A](implicit ord: math.Ordering[B]): (El1, El2)
64.  def maxBy[B](f: ((El1, El2)) => B)(implicit cmp: math.Ordering[B]): (El1, El2)
65.  def maxByOption[B](f: ((El1, El2)) => B)(implicit cmp: math.Ordering[B]): Option[(El1, El2)]
66.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[(El1, El2)]
67.  def min[B >: A](implicit ord: math.Ordering[B]): (El1, El2)
68.  def minBy[B](f: ((El1, El2)) => B)(implicit cmp: math.Ordering[B]): (El1, El2)
69.  def minByOption[B](f: ((El1, El2)) => B)(implicit cmp: math.Ordering[B]): Option[(El1, El2)]
70.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[(El1, El2)]
71.  final def mkString: String
72.  final def mkString(sep: String): String
73.  final def mkString(start: String, sep: String, end: String): String
74.  final def ne(arg0: AnyRef): Boolean
75.  def nonEmpty: Boolean
76.  final def notify(): Unit
77.  final def notifyAll(): Unit
78.  def partition(p: ((El1, El2)) => Boolean): (View[(El1, El2)], View[(El1, El2)])
79.  def partitionMap[A1, A2](f: ((El1, El2)) => Either[A1, A2]): (View[A1], View[A2])
80.  def product[B >: A](implicit num: math.Numeric[B]): B
81.  def reduce[B >: A](op: (B, B) => B): B
82.  def reduceLeft[B >: A](op: (B, (El1, El2)) => B): B
83.  def reduceLeftOption[B >: A](op: (B, (El1, El2)) => B): Option[B]
84.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
85.  def reduceRight[B >: A](op: ((El1, El2), B) => B): B
86.  def reduceRightOption[B >: A](op: ((El1, El2), B) => B): Option[B]
87.  def scan[B >: A](z: B)(op: (B, B) => B): View[B]
88.  def scanLeft[B](z: B)(op: (B, (El1, El2)) => B): View[B]
89.  def scanRight[B](z: B)(op: ((El1, El2), B) => B): View[B]
90.  def size: Int
91.  def sizeCompare(that: Iterable[_]): Int
92.  def sizeCompare(otherSize: Int): Int
93.  final def sizeIs: SizeCompareOps
94.  def slice(from: Int, until: Int): View[(El1, El2)]
95.  def sliding(size: Int, step: Int): Iterator[View[(El1, El2)]]
96.  def sliding(size: Int): Iterator[View[(El1, El2)]]
97.  def span(p: ((El1, El2)) => Boolean): (View[(El1, El2)], View[(El1, El2)])
98.  def splitAt(n: Int): (View[(El1, El2)], View[(El1, El2)])
99.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[(El1, El2), S]): S
100.  def sum[B >: A](implicit num: math.Numeric[B]): B
101.  final def synchronized[T0](arg0: => T0): T0
102.  def tail: View[(El1, El2)]
103.  def tails: Iterator[View[(El1, El2)]]
104.  def take(n: Int): View[(El1, El2)]
105.  def takeRight(n: Int): View[(El1, El2)]
106.  def takeWhile(p: ((El1, El2)) => Boolean): View[(El1, El2)]
107.  def tapEach[U](f: ((El1, El2)) => U): View[(El1, El2)]
108.  def to[C1](factory: Factory[(El1, El2), C1]): C1
109.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
110.  final def toBuffer[B >: A]: Buffer[B]
111.  def toIndexedSeq: immutable.IndexedSeq[(El1, El2)]
112.  final def toIterable: View[(El1, El2)]
113.  def toList: immutable.List[(El1, El2)]
114.  def toMap[K, V](implicit ev: <:<[(El1, El2), (K, V)]): immutable.Map[K, V]
115.  def toSeq: immutable.Seq[(El1, El2)]
116.  def toSet[B >: A]: immutable.Set[B]
117.  def toString(): String
118.  def toVector: immutable.Vector[(El1, El2)]
119.  def transpose[B](implicit asIterable: ((El1, El2)) => Iterable[B]): View[View[B]]
120.  def unzip[A1, A2](implicit asPair: ((El1, El2)) => (A1, A2)): (View[A1], View[A2])
121.  def unzip3[A1, A2, A3](implicit asTriple: ((El1, El2)) => (A1, A2, A3)): (View[A1], View[A2], View[A3])
122.  def view: View[(El1, El2)]
123.  final def wait(): Unit
124.  final def wait(arg0: Long, arg1: Int): Unit
125.  final def wait(arg0: Long): Unit
126.  def withFilter(p: ((El1, El2)) => Boolean): WithFilter[(El1, El2), [_]View[_]]
127.  def zip[B](that: IterableOnce[B]): View[((El1, El2), B)]
128.  def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): View[(A1, B)]
129.  def zipWithIndex: View[((El1, El2), Int)]

Shadowed Implicit Value Members

1.  def exists(p: ((El1, El2)) => Boolean): Boolean
2.  def filter(pred: ((El1, El2)) => Boolean): View[(El1, El2)]
3.  def flatMap[B](f: ((El1, El2)) => IterableOnce[B]): View[B]
4.  def forall(p: ((El1, El2)) => Boolean): Boolean
5.  def foreach[U](f: ((El1, El2)) => U): Unit
6.  def lazyZip[B]: ([B](that: Iterable[B])scala.collection.LazyZip2[(El1, El2),B,_1.type]) forSome {val _1: View[(El1, El2)]}
7.  def map[B](f: ((El1, El2)) => B): View[B]
8.  def toString(): String

Deprecated Value Members

1.  def ++:[B >: A](that: IterableOnce[B]): View[B]
2.  final def /:[B](z: B)(op: (B, (El1, El2)) => B): B
3.  final def :\[B](z: B)(op: ((El1, El2), B) => B): B
4.  def aggregate[B](z: => B)(seqop: (B, (El1, El2)) => B, combop: (B, B) => B): B
5.  def companion: IterableFactory[[_]View[_]]
6.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
7.  def force: IndexedSeq[(El1, El2)]
8.  def hasDefiniteSize: Boolean
9.  final def repr: View[(El1, El2)]
10.  def seq: View[(El1, El2)]
11.  final def toIterator: Iterator[(El1, El2)]
12.  final def toStream: immutable.Stream[(El1, El2)]
13.  final def toTraversable: Traversable[(El1, El2)]
14.  def view(from: Int, until: Int): View[(El1, El2)]
15.  def →[B](y: B): (LazyZip2[El1, El2, C1], B)

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion lazyZip2ToIterable fromLazyZip2[El1, El2, C1] to View[(El1, El2)]

Inherited by implicit conversion any2stringadd fromLazyZip2[El1, El2, C1] to any2stringadd[LazyZip2[El1, El2, C1]]

Inherited by implicit conversion StringFormat fromLazyZip2[El1, El2, C1] to StringFormat[LazyZip2[El1, El2, C1]]

Inherited by implicit conversion Ensuring fromLazyZip2[El1, El2, C1] to Ensuring[LazyZip2[El1, El2, C1]]

Inherited by implicit conversion ArrowAssoc fromLazyZip2[El1, El2, C1] to ArrowAssoc[LazyZip2[El1, El2, C1]]

Ungrouped