Sequencing

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
implicit def convertEqualityToArraySequencing[E](equality: Equality[E]): Sequencing[Array[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type Array[E].
Implicit conversion that converts an Equality of type E into Sequencing of type Array[E]. This is required to support the explicit Equality syntax, for example:
```
(Array("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[Array[String]].
E
type of elements in the Array
equality
Equality of type E
returns
Sequencing of type Array[E]
implicit def convertEqualityToEverySequencing[E](equality: Equality[E]): Sequencing[Every[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type Every[E].
Implicit conversion that converts an Equality of type E into Sequencing of type Every[E]. This is required to support the explicit Equality syntax, for example:
```
(Every("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[Every[String]].
E
type of elements in the Every
equality
Equality of type E
returns
Sequencing of type Every[E]
implicit def convertEqualityToGenSeqSequencing[E, SEQ[e] <: GenSeq[e]](equality: Equality[E]): Sequencing[SEQ[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type SEQ[E], where SEQ is a subtype of scala.collection.GenSeq.
Implicit conversion that converts an Equality of type E into Sequencing of type SEQ[E], where SEQ is a subtype of scala.collection.GenSeq. This is required to support the explicit Equality syntax, for example:
```
(List("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[List[String]].
E
type of elements in the scala.collection.GenSeq
SEQ
subtype of scala.collection.GenSeq
equality
Equality of type E
returns
Sequencing of type SEQ[E]
implicit def convertEqualityToJavaListSequencing[E, JLIST[e] <: List[e]](equality: Equality[E]): Sequencing[JLIST[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type JLIST[E], where JLIST is a subtype of java.util.List.
Implicit conversion that converts an Equality of type E into Sequencing of type JLIST[E], where JLIST is a subtype of java.util.List. This is required to support the explicit Equality syntax, for example:
```
val javaList = new java.util.ArrayList[String]()
javaList.add("hi", "he")
(javaList should contain ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[java.util.ArrayList[String]].
E
type of elements in the java.util.List
JLIST
subtype of java.util.List
equality
Equality of type E
returns
Sequencing of type JLIST[E]
implicit def convertEqualityToJavaSortedMapSequencing[K, V, JMAP[k, v] <: SortedMap[k, v]](equality: Equality[java.util.Map.Entry[K, V]]): Sequencing[JMAP[K, V]]

Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Sequencing of type JMAP[K, V], where JMAP is a subtype of java.util.SortedMap.
Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Sequencing of type JMAP[K, V], where JMAP is a subtype of java.util.SortedMap. This is required to support the explicit Equality syntax, for example:
```
val javaMap = new java.util.TreeMap[Int, String]()
javaMap.put(1, "one")
// lowerCased needs to be implemented as Normalization[java.util.Map.Entry[K, V]]
(javaMap should contain inOrderOnly (Entry(1, "ONE"))) (after being lowerCased)
```
(after being lowerCased) will returns an java.util.Map.Entry[Int, String] and this implicit conversion will convert it into Aggregating[java.util.TreeMap[Int, String]].
K
the type of the key in the java.util.SortedMap
V
the type of the value in the java.util.SortedMap
JMAP
subtype of java.util.SortedMap
equality
Equality of type java.util.Map.Entry[K, V]
returns
Sequencing of type JMAP[K, V]
implicit def convertEqualityToJavaSortedSetSequencing[E, JSET[e] <: SortedSet[e]](equality: Equality[E]): Sequencing[JSET[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type JSET[E], where JSET is a subtype of java.util.SortedSet.
Implicit conversion that converts an Equality of type E into Sequencing of type JSET[E], where JSET is a subtype of java.util.SortedSet. This is required to support the explicit Equality syntax, for example:
```
val javaSet = new java.util.TreeSet[String]()
javaSet.add("hi", "he")
(javaSet should contain inOrderOnly ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[java.util.TreeSet[String]].
E
type of elements in the java.util.List
JSET
subtype of java.util.List
equality
Equality of type E
returns
Sequencing of type JLIST[E]
implicit def convertEqualityToSortedMapSequencing[K, V, MAP[k, v] <: SortedMap[k, v]](equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

Implicit conversion that converts an Equality of type (K, V) into Sequencing of type MAP[K, V], where MAP is a subtype of scala.collection.SortedMap.
Implicit conversion that converts an Equality of type (K, V) into Sequencing of type MAP[K, V], where MAP is a subtype of scala.collection.SortedMap. This is required to support the explicit Equality syntax, for example:
```
// lowerCased needs to be implemented as Normalization[(K, V)]
(SortedMap("hi" -> "hi", "he" -> "he") should contain inOrderOnly ("HI" -> "HI", "HE" -> "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[SortedMap[String, String]].
K
the type of the key in the scala.collection.SortedMap
V
the type of the value in the scala.collection.SortedMap
MAP
subtype of scala.collection.SortedMap
equality
Equality of type (K, V)
returns
Sequencing of type MAP[K, V]
implicit def convertEqualityToSortedSetSequencing[E, SET[e] <: SortedSet[e]](equality: Equality[E]): Sequencing[SET[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type SET[E], where SET is a subtype of scala.collection.SortedSet.
Implicit conversion that converts an Equality of type E into Sequencing of type SET[E], where SET is a subtype of scala.collection.SortedSet. This is required to support the explicit Equality syntax, for example:
```
(SortedSet("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Sequencing[SortedSet[String]].
E
type of elements in the scala.collection.SortedSet
SET
subtype of scala.collection.SortedSet
equality
Equality of type E
returns
Sequencing of type SET[E]
implicit def convertEqualityToStringSequencing(equality: Equality[Char]): Sequencing[String]

Implicit conversion that converts an Equality of type Char into Sequencing of type String.
Implicit conversion that converts an Equality of type Char into Sequencing of type String. This is required to support the explicit Equality syntax, for example:
```
// lowerCased needs to be implemented as Normalization[Char]
("hi hello" should contain inOrderOnly ('E')) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[Char] and this implicit conversion will convert it into Sequencing[String].
equality
Equality of type Char
returns
Sequencing of type String
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def sequencingNatureOfArray[E](implicit equality: Equality[E]): Sequencing[Array[E]]

Implicit to support Sequencing nature of Array.
Implicit to support Sequencing nature of Array.
E
the type of the element in the Array
equality
Equality type class that is used to check equality of element in the Array
returns
Sequencing[Array[E]] that supports Array in relevant contain syntax
implicit def sequencingNatureOfEvery[E](implicit equality: Equality[E]): Sequencing[Every[E]]

Implicit to support Sequencing nature of Every.
Implicit to support Sequencing nature of Every.
E
the type of the element in the Every
equality
Equality type class that is used to check equality of element in the Every
returns
Sequencing[Every[E]] that supports Every in relevant contain syntax
implicit def sequencingNatureOfGenSeq[E, SEQ[e] <: GenSeq[e]](implicit equality: Equality[E]): Sequencing[SEQ[E]]

Implicit to support Sequencing nature of scala.collection.GenSeq.
Implicit to support Sequencing nature of scala.collection.GenSeq.
E
the type of the element in the scala.collection.GenSeq
SEQ
any subtype of scala.collection.GenSeq
equality
Equality type class that is used to check equality of element in the scala.collection.GenSeq
returns
Sequencing[SEQ[E]] that supports scala.collection.GenSeq in relevant contain syntax
implicit def sequencingNatureOfJavaList[E, JLIST[e] <: List[e]](implicit equality: Equality[E]): Sequencing[JLIST[E]]

Implicit to support Sequencing nature of java.util.List.
Implicit to support Sequencing nature of java.util.List.
E
the type of the element in the java.util.List
JLIST
any subtype of java.util.List
equality
Equality type class that is used to check equality of element in the java.util.List
returns
Sequencing[JLIST[E]] that supports java.util.List in relevant contain syntax
implicit def sequencingNatureOfJavaSortedMap[K, V, JMAP[k, v] <: SortedMap[k, v]](implicit equality: Equality[java.util.Map.Entry[K, V]]): Sequencing[JMAP[K, V]]

Implicit to support Sequencing nature of java.util.SortedMap.
Implicit to support Sequencing nature of java.util.SortedMap.
K
the type of the key in the java.util.SortedMap
V
the type of the value in the java.util.SortedMap
JMAP
any subtype of java.util.SortedMap
equality
Equality type class that is used to check equality of entry in the java.util.SortedMap
returns
Sequencing[JMAP[K, V]] that supports java.util.SortedMap in relevant contain syntax
implicit def sequencingNatureOfJavaSortedSet[E, JSET[e] <: SortedSet[e]](implicit equality: Equality[E]): Sequencing[JSET[E]]

Implicit to support Sequencing nature of java.util.SortedSet.
Implicit to support Sequencing nature of java.util.SortedSet.
E
the type of the element in the java.util.SortedSet
JSET
any subtype of java.util.SortedSet
equality
Equality type class that is used to check equality of element in the java.util.SortedSet
returns
Sequencing[JSET[E]] that supports java.util.SortedSet in relevant contain syntax
implicit def sequencingNatureOfSortedMap[K, V, MAP[k, v] <: SortedMap[k, v]](implicit equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

Implicit to support Sequencing nature of scala.collection.SortedMap.
Implicit to support Sequencing nature of scala.collection.SortedMap.
K
the type of the key in the scala.collection.SortedMap
V
the type of the value in the scala.collection.SortedMap
MAP
any subtype of scala.collection.SortedMap
equality
Equality type class that is used to check equality of element in the scala.collection.SortedMap
returns
Sequencing[MAP[K, V]] that supports scala.collection.SortedMap in relevant contain syntax
implicit def sequencingNatureOfSortedSet[E, SET[e] <: SortedSet[e]](implicit equality: Equality[E]): Sequencing[SET[E]]

Implicit to support Sequencing nature of scala.collection.SortedSet.
Implicit to support Sequencing nature of scala.collection.SortedSet.
E
the type of the element in the scala.collection.SortedSet
SET
any subtype of scala.collection.SortedSet
equality
Equality type class that is used to check equality of element in the scala.collection.SortedSet
returns
Sequencing[SET[E]] that supports scala.collection.SortedSet in relevant contain syntax
implicit def sequencingNatureOfString(implicit equality: Equality[Char]): Sequencing[String]

Implicit to support Sequencing nature of String.
Implicit to support Sequencing nature of String.
equality
Equality type class that is used to check equality of Char in the String
returns
Sequencing[String] that supports String in relevant contain syntax
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()

object Sequencing

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def convertEqualityToArraySequencing[E](equality: Equality[E]): Sequencing[Array[E]]

implicit def convertEqualityToEverySequencing[E](equality: Equality[E]): Sequencing[Every[E]]

implicit def convertEqualityToGenSeqSequencing[E, SEQ[e] <: GenSeq[e]](equality: Equality[E]): Sequencing[SEQ[E]]

implicit def convertEqualityToJavaListSequencing[E, JLIST[e] <: List[e]](equality: Equality[E]): Sequencing[JLIST[E]]

implicit def convertEqualityToJavaSortedMapSequencing[K, V, JMAP[k, v] <: SortedMap[k, v]](equality: Equality[java.util.Map.Entry[K, V]]): Sequencing[JMAP[K, V]]

implicit def convertEqualityToJavaSortedSetSequencing[E, JSET[e] <: SortedSet[e]](equality: Equality[E]): Sequencing[JSET[E]]

implicit def convertEqualityToSortedMapSequencing[K, V, MAP[k, v] <: SortedMap[k, v]](equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

implicit def convertEqualityToSortedSetSequencing[E, SET[e] <: SortedSet[e]](equality: Equality[E]): Sequencing[SET[E]]

implicit def convertEqualityToStringSequencing(equality: Equality[Char]): Sequencing[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def sequencingNatureOfArray[E](implicit equality: Equality[E]): Sequencing[Array[E]]

implicit def sequencingNatureOfEvery[E](implicit equality: Equality[E]): Sequencing[Every[E]]

implicit def sequencingNatureOfGenSeq[E, SEQ[e] <: GenSeq[e]](implicit equality: Equality[E]): Sequencing[SEQ[E]]

implicit def sequencingNatureOfJavaList[E, JLIST[e] <: List[e]](implicit equality: Equality[E]): Sequencing[JLIST[E]]

implicit def sequencingNatureOfJavaSortedMap[K, V, JMAP[k, v] <: SortedMap[k, v]](implicit equality: Equality[java.util.Map.Entry[K, V]]): Sequencing[JMAP[K, V]]

implicit def sequencingNatureOfJavaSortedSet[E, JSET[e] <: SortedSet[e]](implicit equality: Equality[E]): Sequencing[JSET[E]]

implicit def sequencingNatureOfSortedMap[K, V, MAP[k, v] <: SortedMap[k, v]](implicit equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

implicit def sequencingNatureOfSortedSet[E, SET[e] <: SortedSet[e]](implicit equality: Equality[E]): Sequencing[SET[E]]

implicit def sequencingNatureOfString(implicit equality: Equality[Char]): Sequencing[String]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped