microsite
API
Generated with
microsite/izumi/izumi.fundamentals/izumi.fundamentals.collections/izumi.fundamentals.collections.nonempty/NESet

NESet

izumi.fundamentals.collections.nonempty.NESet
See theNESet companion object
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 NESets ==

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 NESets ==

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))

Type parameters

T

the type of elements contained in this NESet

Attributes

Companion
object
Graph
Supertypes
class AnyVal
trait Matchable
class Any

Members list

Value members

Concrete methods

def +(element: T): NESet[T]

Returns a new NESet with the given element added.

Returns a new NESet with the given element added.

Value parameters

element

the element to add to this NESet

Attributes

Returns

a new NESet consisting of element and all elements of this NESet.

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. The element type of the resulting NESet is the most specific superclass encompassing the element types of this and 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.

Type parameters

U

the element type of the returned NESet

Value parameters

other

the NESet to append

Attributes

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. The element type of the resulting NESet is the most specific superclass encompassing the element types of this NESet and 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.

Type parameters

U

the element type of the returned NESet

Value parameters

other

the Vector to append

Attributes

Returns

a new NESet that contains all the elements of this NESet followed by all elements of other.

def ++(other: IterableOnce[T]): NESet[T]

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.

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.

Value parameters

other

the GenTraversableOnce to append

Attributes

Returns

a new NESet that contains all the elements of this NESet followed by all elements of other.

def addString(sb: StringBuilder): StringBuilder

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.

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.

Value parameters

sb

the string builder to which elements will be appended

Attributes

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. 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.

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.

Value parameters

sb

the string builder to which elements will be appended

sep

the separator string

Attributes

Returns

the string builder, sb, to which elements were appended.

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. 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

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

Value parameters

sb

the string builder to which elements will be appended

sep

the separator string

start

the ending string

Attributes

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.

Attributes

Returns

true if a element exists in NESet at index idx, where false indicates the element at index idx does not exist.

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.

Value parameters

pf

the partial function

Attributes

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.

infix 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.

Value parameters

elem

the element to look for

Attributes

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]): Unit

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.

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.

Value parameters

arr

the array to fill

Attributes

def copyToArray[U >: T](arr: Array[U], start: Int): Unit

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.

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.

Value parameters

arr

the array to fill

start

the starting index

Attributes

def copyToArray[U >: T](arr: Array[U], start: Int, len: Int): Unit

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.

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.

Value parameters

arr

the array to fill

len

the maximum number of elements to copy

start

the starting index

Attributes

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.

Value parameters

buf

the buffer to which elements are copied

Attributes

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.

Value parameters

p

the predicate used to test elements.

Attributes

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.

Value parameters

p

the predicate used to test elements.

Attributes

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.

Value parameters

p

the predicate used to test elements

Attributes

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.

Type parameters

U

the element type of the returned NESet

Value parameters

f

the function to apply to each element.

Attributes

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.

Attributes

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.

Type parameters

U

a type parameter for the binary operator, a supertype of T.

Value parameters

op

a binary operator that must be associative

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.)

Attributes

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.

Type parameters

B

the result type of the binary operator.

Value parameters

op

the binary operator.

z

the start value.

Attributes

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 x1, ..., xn 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.

Type parameters

B

the result of the binary operator

Value parameters

op

the binary operator

z

the start value

Attributes

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 x1, ..., xn 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.

Value parameters

p

the predicate used to test elements.

Attributes

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.

Value parameters

f

the function that is applied for its side-effect to every element. The result of function f is discarded.

Attributes

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.

Type parameters

K

the type of keys returned by the discriminator function.

Value parameters

f

the discriminator function.

Attributes

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.

Value parameters

size

the number of elements per group

Attributes

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.

Returns true to indicate this NESet has a definite size, since all NESets are strict collections.

Attributes

def head: T

Selects the first element of this NESet.

Selects the first element of this NESet.

Attributes

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.

Attributes

Returns

false

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.

Attributes

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.

Attributes

Returns

the new iterator

def last: T

Selects the last element of this NESet.

Selects the last element of this NESet.

Attributes

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.

Type parameters

U

the element type of the returned NESet.

Value parameters

f

the function to apply to each element.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

Returns

the smallest result of applying the given function to every element of this NESet.

def mkString: String

Displays all elements of this NESet in a string.

Displays all elements of this NESet in a string.

Attributes

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 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.

Value parameters

sep

the separator string

Attributes

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(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.

Value parameters

end

the ending string.

sep

the separator string.

start

the starting string.

Attributes

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 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.

Attributes

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.

Attributes

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.

Type parameters

U

a type parameter for the binary operator, a supertype of T.

Value parameters

op

a binary operator that must be associative.

Attributes

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.

Type parameters

U

the result type of the binary operator.

Value parameters

op

the binary operator.

Attributes

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 x1, ..., xn 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.

Type parameters

U

the result type of the binary operator.

Value parameters

op

the binary operator.

Attributes

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.

Type parameters

U

the result of the binary operator

Value parameters

op

the binary operator

Attributes

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 x1, ..., xn 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.

Type parameters

U

the result of the binary operator

Value parameters

op

the binary operator

Attributes

Returns

a Some containing the result of reduceRight(op)

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.

Value parameters

that

the Iterable with which to compare

Attributes

Returns

true, if both this NESet and the given Iterable 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.

Value parameters

that

the Vector with which to compare

Attributes

Returns

true, if both this and the given Vector contain the same elements in the same order, false otherwise.

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.

Value parameters

that

the NESet with which to compare

Attributes

Returns

true, if both this and the given NESet 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.

Type parameters

U

a type parameter for the binary operator, a supertype of T, and the type of the resulting NESet.

Value parameters

op

a binary operator that must be associative

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.)

Attributes

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")

Type parameters

B

the result type of the binary operator and type of the resulting NESet

Value parameters

op

the binary operator.

z

the start value.

Attributes

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")

Type parameters

B

the result of the binary operator and type of the resulting NESet

Value parameters

op

the binary operator

z

the start value

Attributes

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.

Attributes

Returns

the number of elements in this NESet.

Note

length and size yield the same result, which will be >= 1.

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.)

Value parameters

size

the number of elements per group

Attributes

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, 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.

Value parameters

size

the number of elements per group

step

the distance between the first elements of successive groups

Attributes

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.

Attributes

Returns

the string "NESet"

infix 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.

Attributes

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.

Type parameters

C1

the collection type to build.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

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.

Attributes

Returns

an immutable IndexedSeq containing all elements of this NESet.

override def toString: String

Returns a string representation of this NESet.

Returns a string representation of this NESet.

Attributes

Returns

the string "NESet" followed by the result of invoking toString on this NESet's elements, surrounded by parentheses.

Definition Classes
Any
def toVector: Vector[T]

Converts this NESet to a Vector.

Converts this NESet to a Vector.

Attributes

Returns

a Vector containing all elements of this NESet.

def transpose[U](implicit ev: T <:< NESet[U]): NESet[NESet[U]]
infix 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.

Value parameters

that

the Vector to add.

Attributes

Returns

a new NESet that contains all elements of this NESet followed by all elements of that Vector.

infix 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.

Value parameters

that

the NESet to add.

Attributes

Returns

a new NESet that contains all elements of this NESet followed by all elements of that.

infix 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.

Value parameters

that

the Set to add.

Attributes

Returns

a new NESet that contains all elements of this NESet followed by all elements of that GenSeq.

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.

Type parameters

L

the type of the first half of the element pairs

R

the type of the second half of the element pairs

Value parameters

asPair

an implicit conversion that asserts that the element type of this NESet is a pair.

Attributes

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.

Type parameters

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

Value parameters

asTriple

an implicit conversion that asserts that the element type of this NESet is a triple.

Attributes

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. 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.

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.

Value parameters

other

the Iterable providing the second half of each result pair

otherElem

the element to be used to fill up the result if that Iterable is shorter than this NESet.

thisElem

the element to be used to fill up the result if this NESet is shorter than that Iterable.

Attributes

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.

Attributes

Returns

A new NESet containing pairs consisting of all elements of this NESet paired with their index. Indices start at 0.

Concrete fields

val toSet: Set[T]
Generated with