NESet

Companion object NESet

final class NESet[T] extends AnyVal

A non-empty Set: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.

The purpose of NESet is to allow you to express in a type that a Set is non-empty, thereby eliminating the need for (and potential exception from) a run-time check for non-emptiness. For a non-empty sequence with IndexedSeq performance, see Vector.

Constructing `NESet`s

You can construct a NESet by passing one or more elements to the NESet.apply factory method:

scala> NESet(1, 2, 3)
res0: org.scalactic.anyvals.NESet[Int] = NESet(1, 2, 3)

Alternatively you can cons elements onto the End singleton object, similar to making a Set starting with Nil:

scala> 1 :: 2 :: 3 :: Nil
res0: Set[Int] = Set(1, 2, 3)

scala> 1 :: 2 :: 3 :: End
res1: org.scalactic.NESet[Int] = NESet(1, 2, 3)

Note that although Nil is a Set[Nothing], End is not a NESet[Nothing], because no empty NESet exists. (A non-empty Set is a series of connected links; if you have no links, you have no non-empty Set.)

scala> val nil: Set[Nothing] = Nil
nil: Set[Nothing] = Set()

scala> val nada: NESet[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NESet[Nothing]
       val nada: NESet[Nothing] = End
                                         ^

Working with `NESet`s

NESet does not extend Scala's Seq or Traversable traits because these require that implementations may be empty. For example, if you invoke tail on a Seq that contains just one element, you'll get an empty Seq:

scala> Set(1).tail
res6: Set[Int] = Set()

On the other hand, many useful methods exist on Seq that when invoked on a non-empty Seq are guaranteed to not result in an empty Seq. For convenience, NESet defines a method corresponding to every such Seq method. Here are some examples:

NESet(1, 2, 3).map(_ + 1)                        // Result: NESet(2, 3, 4)
NESet(1).map(_ + 1)                              // Result: NESet(2)
NESet(1, 2, 3).containsSlice(NESet(2, 3)) // Result: true
NESet(1, 2, 3).containsSlice(NESet(3, 4)) // Result: false
NESet(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1

NESet does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NESet to Set is defined in the NESet companion object that will be applied if you attempt to call one of the missing methods. As a result, you can invoke filter on an NESet, even though filter could result in an empty sequence—but the result type will be Set instead of NESet:

NESet(1, 2, 3).filter(_ < 10) // Result: Set(1, 2, 3)
NESet(1, 2, 3).filter(_ > 10) // Result: Set()

You can use NESets in for expressions. The result will be an NESet unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a Set at that point. Here are some examples:

scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

scala> for (i <- NESet(1, 2, 3)) yield i + 1
res0: org.scalactic.anyvals.NESet[Int] = NESet(2, 3, 4)

scala> for (i <- NESet(1, 2, 3) if i < 10) yield i + 1
res1: Set[Int] = Set(2, 3, 4)

scala> for {
     |   i <- NESet(1, 2, 3)
     |   j <- NESet('a', 'b', 'c')
     | } yield (i, j)
res3: org.scalactic.anyvals.NESet[(Int, Char)] =
        NESet((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))

scala> for {
     |   i <- NESet(1, 2, 3) if i < 10
     |   j <- NESet('a', 'b', 'c')
     | } yield (i, j)
res6: Set[(Int, Char)] =
        Set((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))

T: the type of elements contained in this NESet

Linear Supertypes

AnyVal, Any

Ordering

Alphabetic
By Inheritance

Inherited

NESet
AnyVal
Any

Hide All
Show All

Visibility

Public
Protected

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
Any
final def ##: Int
Definition Classes
Any
def +(element: T): NESet[T]
Returns a new NESet with the given element added.
Returns a new NESet with the given element added.
element
the element to add to this NESet
returns
a new NESet consisting of element and all elements of this NESet.
def ++(other: IterableOnce[T]): NESet[T]
Returns a new NESet containing the elements of this NESet followed by the elements of the passed GenTraversableOnce.
Returns a new NESet containing the elements of this NESet followed by the elements of the passed GenTraversableOnce. The element type of the resulting NESet is the most specific superclass encompassing the element types of this NESet and the passed GenTraversableOnce.
other
the GenTraversableOnce to append
returns
a new NESet that contains all the elements of this NESet followed by all elements of other.
def ++[U >: T](other: Vector[U]): NESet[U]
Returns a new NESet containing the elements of this NESet followed by the elements of the passed Vector.
Returns a new NESet containing the elements of this NESet followed by the elements of the passed Vector. The element type of the resulting NESet is the most specific superclass encompassing the element types of this NESet and the passed Vector.
U
the element type of the returned NESet
other
the Vector to append
returns
a new NESet that contains all the elements of this NESet followed by all elements of other.
def ++[U >: T](other: NESet[U]): NESet[U]
Returns a new NESet containing the elements of this NESet followed by the elements of the passed NESet.
Returns a new NESet containing the elements of this NESet followed by the elements of the passed NESet. The element type of the resulting NESet is the most specific superclass encompassing the element types of this and the passed NESet.
U
the element type of the returned NESet
other
the NESet to append
returns
a new NESet that contains all the elements of this NESet followed by all elements of other.
final def ==(arg0: Any): Boolean
Definition Classes
Any
def addString(sb: StringBuilder, start: String, sep: String, end: String): StringBuilder
Appends all elements of this NESet to a string builder using start, end, and separator strings.
Appends all elements of this NESet to a string builder using start, end, and separator strings. The written text will consist of a concatenation of the string start; the result of invoking toString on all elements of this NESet, separated by the string sep; and the string end
sb
the string builder to which elements will be appended
start
the ending string
sep
the separator string
returns
the string builder, sb, to which elements were appended.
def addString(sb: StringBuilder, sep: String): StringBuilder
Appends all elements of this NESet to a string builder using a separator string.
Appends all elements of this NESet to a string builder using a separator string. The written text will consist of a concatenation of the result of invoking toString on of every element of this NESet, separated by the string sep.
sb
the string builder to which elements will be appended
sep
the separator string
returns
the string builder, sb, to which elements were appended.
def addString(sb: StringBuilder): StringBuilder
Appends all elements of this NESet to a string builder.
Appends all elements of this NESet to a string builder. The written text will consist of a concatenation of the result of invoking toString on of every element of this NESet, without any separator string.
sb
the string builder to which elements will be appended
returns
the string builder, sb, to which elements were appended.
def apply(elem: T): Boolean
Check if an element exists at its index in the NESet.
Check if an element exists at its index in the NESet.
returns
true if a element exists in NESet at index idx, where false indicates the element at index idx does not exist.
final def asInstanceOf[T0]: T0
Definition Classes
Any
def collectFirst[U](pf: PartialFunction[T, U]): Option[U]
Finds the first element of this NESet for which the given partial function is defined, if any, and applies the partial function to it.
Finds the first element of this NESet for which the given partial function is defined, if any, and applies the partial function to it.
pf
the partial function
returns
an Option containing pf applied to the first element for which it is defined, or None if the partial function was not defined for any element.
def contains(elem: T): Boolean
Indicates whether this NESet contains a given value as an element.
Indicates whether this NESet contains a given value as an element.
elem
the element to look for
returns
true if this NESet has an element that is equal (as determined by ==) to elem, false otherwise.
def copyToArray[U >: T](arr: Array[U], start: Int, len: Int): Unit
Copies values of this NESet to an array.
Copies values of this NESet to an array. Fills the given array arr with at most len elements of this NESet, beginning at index start. Copying will stop once either the end of the current NESet is reached, the end of the array is reached, or len elements have been copied.
arr
the array to fill
start
the starting index
len
the maximum number of elements to copy
def copyToArray[U >: T](arr: Array[U], start: Int): Unit
Copies values of this NESet to an array.
Copies values of this NESet to an array. Fills the given array arr with values of this NESet, beginning at index start. Copying will stop once either the end of the current NESet is reached, or the end of the array is reached.
arr
the array to fill
start
the starting index
def copyToArray[U >: T](arr: Array[U]): Unit
Copies values of this NESet to an array.
Copies values of this NESet to an array. Fills the given array arr with values of this NESet. Copying will stop once either the end of the current NESet is reached, or the end of the array is reached.
arr
the array to fill
def copyToBuffer[U >: T](buf: Buffer[U]): Unit
Copies all elements of this NESet to a buffer.
Copies all elements of this NESet to a buffer.
buf
the buffer to which elements are copied
def count(p: (T) => Boolean): Int
Counts the number of elements in this NESet that satisfy a predicate.
Counts the number of elements in this NESet that satisfy a predicate.
p
the predicate used to test elements.
returns
the number of elements satisfying the predicate p.
def exists(p: (T) => Boolean): Boolean
Indicates whether a predicate holds for at least one of the elements of this NESet.
Indicates whether a predicate holds for at least one of the elements of this NESet.
p
the predicate used to test elements.
returns
true if the given predicate p holds for some of the elements of this NESet, otherwise false.
def find(p: (T) => Boolean): Option[T]
Finds the first element of this NESet that satisfies the given predicate, if any.
Finds the first element of this NESet that satisfies the given predicate, if any.
p
the predicate used to test elements
returns
an Some containing the first element in this NESet that satisfies p, or None if none exists.
def flatMap[U](f: (T) => NESet[U]): NESet[U]
Builds a new NESet by applying a function to all elements of this NESet and using the elements of the resulting NESets.
Builds a new NESet by applying a function to all elements of this NESet and using the elements of the resulting NESets.
U
the element type of the returned NESet
f
the function to apply to each element.
returns
a new NESet containing elements obtained by applying the given function f to each element of this NESet and concatenating the elements of resulting NESets.
def flatten[B](implicit ev: <:<[T, NESet[B]]): NESet[B]
Converts this NESet of NESets into a NESet formed by the elements of the nested NESets.
Converts this NESet of NESets into a NESet formed by the elements of the nested NESets.
returns
a new NESet resulting from concatenating all nested NESets.
Note
You cannot use this flatten method on a NESet that contains a GenTraversableOnces, because if all the nested GenTraversableOnces were empty, you'd end up with an empty NESet.
def fold[U >: T](z: U)(op: (U, U) => U): U
Folds the elements of this NESet using the specified associative binary operator.
Folds the elements of this NESet using the specified associative binary operator.
The order in which operations are performed on elements is unspecified and may be nondeterministic.
U
a type parameter for the binary operator, a supertype of T.
z
a neutral element for the fold operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for Set concatenation, 0 for addition, or 1 for multiplication.)
op
a binary operator that must be associative
returns
the result of applying fold operator op between all the elements and z
def foldLeft[B](z: B)(op: (B, T) => B): B
Applies a binary operator to a start value and all elements of this NESet, going left to right.
Applies a binary operator to a start value and all elements of this NESet, going left to right.
B
the result type of the binary operator.
z
the start value.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this NESet, going left to right, with the start value, z, on the left:
```
op(...op(op(z, x_1), x_2), ..., x_n)
```
where x₁, ..., x_n are the elements of this NESet.
def foldRight[B](z: B)(op: (T, B) => B): B
Applies a binary operator to all elements of this NESet and a start value, going right to left.
Applies a binary operator to all elements of this NESet and a start value, going right to left.
B
the result of the binary operator
z
the start value
op
the binary operator
returns
the result of inserting op between consecutive elements of this NESet, going right to left, with the start value, z, on the right:
```
op(x_1, op(x_2, ... op(x_n, z)...))
```
where x₁, ..., x_n are the elements of this NESet.
def forall(p: (T) => Boolean): Boolean
Indicates whether a predicate holds for all elements of this NESet.
Indicates whether a predicate holds for all elements of this NESet.
p
the predicate used to test elements.
returns
true if the given predicate p holds for all elements of this NESet, otherwise false.
def foreach(f: (T) => Unit): Unit
Applies a function f to all elements of this NESet.
Applies a function f to all elements of this NESet.
f
the function that is applied for its side-effect to every element. The result of function f is discarded.
def getClass(): Class[_ <: AnyVal]
Definition Classes
AnyVal → Any
def groupBy[K](f: (T) => K): Map[K, NESet[T]]
Partitions this NESet into a map of NESets according to some discriminator function.
Partitions this NESet into a map of NESets according to some discriminator function.
K
the type of keys returned by the discriminator function.
f
the discriminator function.
returns
A map from keys to NESets such that the following invariant holds:
```
(NESet.toSet partition f)(k) = xs filter (x => f(x) == k)
```
That is, every key k is bound to a NESet of those elements x for which f(x) equals k.
def grouped(size: Int): Iterator[NESet[T]]
Partitions elements into fixed size NESets.
Partitions elements into fixed size NESets.
size
the number of elements per group
returns
An iterator producing NESets of size size, except the last will be truncated if the elements don't divide evenly.
def hasDefiniteSize: Boolean
Returns true to indicate this NESet has a definite size, since all NESets are strict collections.
def head: T
Selects the first element of this NESet.
Selects the first element of this NESet.
returns
the first element of this NESet.
def isEmpty: Boolean
Returns false to indicate this NESet, like all NESets, is non-empty.
Returns false to indicate this NESet, like all NESets, is non-empty.
returns
false
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
def isTraversableAgain: Boolean
Returns true to indicate this NESet, like all NESets, can be traversed repeatedly.
Returns true to indicate this NESet, like all NESets, can be traversed repeatedly.
returns
true
def iterator: Iterator[T]
Creates and returns a new iterator over all elements contained in this NESet.
Creates and returns a new iterator over all elements contained in this NESet.
returns
the new iterator
def last: T
Selects the last element of this NESet.
Selects the last element of this NESet.
returns
the last element of this NESet.
def map[U](f: (T) => U): NESet[U]
Builds a new NESet by applying a function to all elements of this NESet.
Builds a new NESet by applying a function to all elements of this NESet.
U
the element type of the returned NESet.
f
the function to apply to each element.
returns
a new NESet resulting from applying the given function f to each element of this NESet and collecting the results.
def max[U >: T](implicit cmp: Ordering[U]): T
Finds the largest element.
Finds the largest element.
returns
the largest element of this NESet.
def maxBy[U](f: (T) => U)(implicit cmp: Ordering[U]): T
Finds the largest result after applying the given function to every element.
Finds the largest result after applying the given function to every element.
returns
the largest result of applying the given function to every element of this NESet.
def min[U >: T](implicit cmp: Ordering[U]): T
Finds the smallest element.
Finds the smallest element.
returns
the smallest element of this NESet.
def minBy[U](f: (T) => U)(implicit cmp: Ordering[U]): T
Finds the smallest result after applying the given function to every element.
Finds the smallest result after applying the given function to every element.
returns
the smallest result of applying the given function to every element of this NESet.
def mkString(start: String, sep: String, end: String): String
Displays all elements of this NESet in a string using start, end, and separator strings.
Displays all elements of this NESet in a string using start, end, and separator strings.
start
the starting string.
sep
the separator string.
end
the ending string.
returns
a string representation of this NESet. The resulting string begins with the string start and ends with the string end. Inside, In the resulting string, the result of invoking toString on all elements of this NESet are separated by the string sep.
def mkString(sep: String): String
Displays all elements of this NESet in a string using a separator string.
Displays all elements of this NESet in a string using a separator string.
sep
the separator string
returns
a string representation of this NESet. In the resulting string, the result of invoking toString on all elements of this NESet are separated by the string sep.
def mkString: String
Displays all elements of this NESet in a string.
Displays all elements of this NESet in a string.
returns
a string representation of this NESet. In the resulting string, the result of invoking toString on all elements of this NESet follow each other without any separator string.
def nonEmpty: Boolean
Returns true to indicate this NESet, like all NESets, is non-empty.
Returns true to indicate this NESet, like all NESets, is non-empty.
returns
true
def product[U >: T](implicit num: Numeric[U]): U
The result of multiplying all the elements of this NESet.
The result of multiplying all the elements of this NESet.
This method can be invoked for any NESet[T] for which an implicit Numeric[T] exists.
returns
the product of all elements
def reduce[U >: T](op: (U, U) => U): U
Reduces the elements of this NESet using the specified associative binary operator.
Reduces the elements of this NESet using the specified associative binary operator.
The order in which operations are performed on elements is unspecified and may be nondeterministic.
U
a type parameter for the binary operator, a supertype of T.
op
a binary operator that must be associative.
returns
the result of applying reduce operator op between all the elements of this NESet.
def reduceLeft[U >: T](op: (U, T) => U): U
Applies a binary operator to all elements of this NESet, going left to right.
Applies a binary operator to all elements of this NESet, going left to right.
U
the result type of the binary operator.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this NESet, going left to right:
```
op(...op(op(x_1, x_2), x_3), ..., x_n)
```
where x₁, ..., x_n are the elements of this NESet.
def reduceLeftOption[U >: T](op: (U, T) => U): Option[U]
Applies a binary operator to all elements of this NESet, going left to right, returning the result in a Some.
Applies a binary operator to all elements of this NESet, going left to right, returning the result in a Some.
U
the result type of the binary operator.
op
the binary operator.
returns
a Some containing the result of reduceLeft(op)
def reduceOption[U >: T](op: (U, U) => U): Option[U]
def reduceRight[U >: T](op: (T, U) => U): U
Applies a binary operator to all elements of this NESet, going right to left.
Applies a binary operator to all elements of this NESet, going right to left.
U
the result of the binary operator
op
the binary operator
returns
the result of inserting op between consecutive elements of this NESet, going right to left:
```
op(x_1, op(x_2, ... op(x_{n-1}, x_n)...))
```
where x₁, ..., x_n are the elements of this NESet.
def reduceRightOption[U >: T](op: (T, U) => U): Option[U]
Applies a binary operator to all elements of this NESet, going right to left, returning the result in a Some.
Applies a binary operator to all elements of this NESet, going right to left, returning the result in a Some.
U
the result of the binary operator
op
the binary operator
returns
a Some containing the result of reduceRight(op)
def sameElements[U >: T](that: NESet[U]): Boolean
Checks if the given NESet contains the same elements in the same order as this NESet.
Checks if the given NESet contains the same elements in the same order as this NESet.
that
the NESet with which to compare
returns
true, if both this and the given NESet contain the same elements in the same order, false otherwise.
def sameElements[U >: T](that: Vector[U]): Boolean
Checks if the given Vector contains the same elements in the same order as this NESet.
Checks if the given Vector contains the same elements in the same order as this NESet.
that
the Vector with which to compare
returns
true, if both this and the given Vector contain the same elements in the same order, false otherwise.
def sameElements[U >: T](that: Iterable[U]): Boolean
Checks if the given Iterable contains the same elements in the same order as this NESet.
Checks if the given Iterable contains the same elements in the same order as this NESet.
that
the Iterable with which to compare
returns
true, if both this NESet and the given Iterable contain the same elements in the same order, false otherwise.
def scan[U >: T](z: U)(op: (U, U) => U): NESet[U]
Computes a prefix scan of the elements of this NESet.
Computes a prefix scan of the elements of this NESet.
U
a type parameter for the binary operator, a supertype of T, and the type of the resulting NESet.
z
a neutral element for the scan operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for Set concatenation, 0 for addition, or 1 for multiplication.)
op
a binary operator that must be associative
returns
a new NESet containing the prefix scan of the elements in this NESet
Note
The neutral element z may be applied more than once. Here are some examples:
NESet(1, 2, 3).scan(0)(_ + _) == NESet(0, 1, 3, 6) NESet(1, 2, 3).scan("z")(_ + _.toString) == NESet("z", "z1", "z12", "z123")
def scanLeft[B](z: B)(op: (B, T) => B): NESet[B]
Produces a NESet containing cumulative results of applying the operator going left to right.
Produces a NESet containing cumulative results of applying the operator going left to right.
Here are some examples:
```
NESet(1, 2, 3).scanLeft(0)(_ + _) == NESet(0, 1, 3, 6)
NESet(1, 2, 3).scanLeft("z")(_ + _) == NESet("z", "z1", "z12", "z123")
```
B
the result type of the binary operator and type of the resulting NESet
z
the start value.
op
the binary operator.
returns
a new NESet containing the intermediate results of inserting op between consecutive elements of this NESet, going left to right, with the start value, z, on the left.
def scanRight[B](z: B)(op: (T, B) => B): NESet[B]
Produces a NESet containing cumulative results of applying the operator going right to left.
Produces a NESet containing cumulative results of applying the operator going right to left.
Here are some examples:
```
NESet(1, 2, 3).scanRight(0)(_ + _) == NESet(6, 5, 3, 0)
NESet(1, 2, 3).scanRight("z")(_ + _) == NESet("123z", "23z", "3z", "z")
```
B
the result of the binary operator and type of the resulting NESet
z
the start value
op
the binary operator
returns
a new NESet containing the intermediate results of inserting op between consecutive elements of this NESet, going right to left, with the start value, z, on the right.
def size: Int
The size of this NESet.
The size of this NESet.
returns
the number of elements in this NESet.
Note
length and size yield the same result, which will be >= 1.
def sliding(size: Int, step: Int): Iterator[NESet[T]]
Groups elements in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.), moving the sliding window by a given step each time.
Groups elements in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.), moving the sliding window by a given step each time.
size
the number of elements per group
step
the distance between the first elements of successive groups
returns
an iterator producing NESets of size size, except the last and the only element will be truncated if there are fewer elements than size.
def sliding(size: Int): Iterator[NESet[T]]
Groups elements in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.)
Groups elements in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.)
size
the number of elements per group
returns
an iterator producing NESets of size size, except the last and the only element will be truncated if there are fewer elements than size.
def stringPrefix: String
Returns "NESet", the prefix of this object's toString representation.
Returns "NESet", the prefix of this object's toString representation.
returns
the string "NESet"
def subsetOf(that: Set[T]): Boolean
def sum[U >: T](implicit num: Numeric[U]): U
The result of summing all the elements of this NESet.
The result of summing all the elements of this NESet.
This method can be invoked for any NESet[T] for which an implicit Numeric[T] exists.
returns
the sum of all elements
def tail: Set[T]
def to[C1](factory: Factory[T, C1]): C1
Converts this NESet into a collection of type Col by copying all elements.
Converts this NESet into a collection of type Col by copying all elements.
C1
the collection type to build.
returns
a new collection containing all elements of this NESet.
def toArray[U >: T](implicit classTag: ClassTag[U]): Array[U]
Converts this NESet to an array.
Converts this NESet to an array.
returns
an array containing all elements of this NESet. A ClassTag must be available for the element type of this NESet.
def toBuffer[U >: T]: Buffer[U]
Converts this NESet to a mutable buffer.
Converts this NESet to a mutable buffer.
returns
a buffer containing all elements of this NESet.
def toIndexedSeq: IndexedSeq[T]
Converts this NESet to an immutable IndexedSeq.
Converts this NESet to an immutable IndexedSeq.
returns
an immutable IndexedSeq containing all elements of this NESet.
def toIterable: Iterable[T]
Converts this NESet to an iterable collection.
Converts this NESet to an iterable collection.
returns
an Iterable containing all elements of this NESet.
def toIterator: Iterator[T]
Returns an Iterator over the elements in this NESet.
Returns an Iterator over the elements in this NESet.
returns
an Iterator containing all elements of this NESet.
def toList: List[T]
Converts this NESet to a set.
Converts this NESet to a set.
returns
a set containing all elements of this NESet.
def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
Converts this NESet to a map.
Converts this NESet to a map.
This method is unavailable unless the elements are members of Tuple2, each ((K, V)) becoming a key-value pair in the map. Duplicate keys will be overwritten by later keys.
returns
a map of type immutable.Map[K, V] containing all key/value pairs of type (K, V) of this NESet.
def toSeq: Seq[T]
Converts this NESet to an immutable IndexedSeq.
Converts this NESet to an immutable IndexedSeq.
returns
an immutable IndexedSeq containing all elements of this NESet.
val toSet: Set[T]
def toString(): String
Returns a string representation of this NESet.
Returns a string representation of this NESet.
returns
the string "NESet" followed by the result of invoking toString on this NESet's elements, surrounded by parentheses.
Definition Classes
NESet → Any
def toVector: Vector[T]
Converts this NESet to a Vector.
Converts this NESet to a Vector.
returns
a Vector containing all elements of this NESet.
def transpose[U](implicit ev: <:<[T, NESet[U]]): NESet[NESet[U]]
def union(that: Set[T])(implicit dummyImplicit: DummyImplicit): NESet[T]
Produces a new NESet that contains all elements of this NESet and also all elements of a given GenSeq.
Produces a new NESet that contains all elements of this NESet and also all elements of a given GenSeq.
NESetX union ys is equivalent to NESetX ++ ys.
Another way to express this is that NESetX union ys computes the order-presevring multi-set union of NESetX and ys. This union method is hence a counter-part of diff and intersect that also work on multi-sets.
that
the Set to add.
returns
a new NESet that contains all elements of this NESet followed by all elements of that GenSeq.
def union(that: NESet[T]): NESet[T]
Produces a new NESet that contains all elements of this NESet and also all elements of a given NESet.
Produces a new NESet that contains all elements of this NESet and also all elements of a given NESet.
NESetX union NESetY is equivalent to NESetX ++ NESetY.
Another way to express this is that NESetX union NESetY computes the order-presevring multi-set union of NESetX and NESetY. This union method is hence a counter-part of diff and intersect that also work on multi-sets.
that
the NESet to add.
returns
a new NESet that contains all elements of this NESet followed by all elements of that.
def union(that: Vector[T]): NESet[T]
Produces a new NESet that contains all elements of this NESet and also all elements of a given Vector.
Produces a new NESet that contains all elements of this NESet and also all elements of a given Vector.
NESetX union everyY is equivalent to NESetX ++ everyY.
Another way to express this is that NESetX union everyY computes the order-presevring multi-set union of NESetX and everyY. This union method is hence a counter-part of diff and intersect that also work on multi-sets.
that
the Vector to add.
returns
a new NESet that contains all elements of this NESet followed by all elements of that Vector.
def unzip[L, R](implicit asPair: (T) => (L, R)): (NESet[L], NESet[R])
Converts this NESet of pairs into two NESets of the first and second half of each pair.
Converts this NESet of pairs into two NESets of the first and second half of each pair.
L
the type of the first half of the element pairs
R
the type of the second half of the element pairs
asPair
an implicit conversion that asserts that the element type of this NESet is a pair.
returns
a pair of NESets, containing the first and second half, respectively, of each element pair of this NESet.
def unzip3[L, M, R](implicit asTriple: (T) => (L, M, R)): (NESet[L], NESet[M], NESet[R])
Converts this NESet of triples into three NESets of the first, second, and and third element of each triple.
Converts this NESet of triples into three NESets of the first, second, and and third element of each triple.
L
the type of the first member of the element triples
M
the type of the second member of the element triples
R
the type of the third member of the element triples
asTriple
an implicit conversion that asserts that the element type of this NESet is a triple.
returns
a triple of NESets, containing the first, second, and third member, respectively, of each element triple of this NESet.
def widen[U >: T]: NESet[U]
def zipAll[O, U >: T](other: Iterable[O], thisElem: U, otherElem: O): NESet[(U, O)]
Returns a NESet formed from this NESet and an iterable collection by combining corresponding elements in pairs.
Returns a NESet formed from this NESet and an iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements will be used to extend the shorter collection to the length of the longer.
other
the Iterable providing the second half of each result pair
thisElem
the element to be used to fill up the result if this NESet is shorter than that Iterable.
otherElem
the element to be used to fill up the result if that Iterable is shorter than this NESet.
returns
a new NESet containing pairs consisting of corresponding elements of this NESet and that. The length of the returned collection is the maximum of the lengths of this NESet and that. If this NESet is shorter than that, thisElem values are used to pad the result. If that is shorter than this NESet, thatElem values are used to pad the result.
def zipWithIndex: NESet[(T, Int)]
Zips this NESet with its indices.
Zips this NESet with its indices.
returns
A new NESet containing pairs consisting of all elements of this NESet paired with their index. Indices start at 0.

Packages

NESet

Companion object NESet

final class NESet[T] extends AnyVal

Constructing `NESet`s

Working with `NESet`s

Value Members

Inherited from AnyVal

Inherited from Any

Ungrouped

Packages

NESet

Companion object NESet

final class NESet[T] extends AnyVal

Constructing NESets

Working with NESets

Value Members

Inherited from AnyVal

Inherited from Any

Ungrouped

NESet

Constructing `NESet`s

Working with `NESet`s