Package

anyvals

Permalink

package anyvals

Visibility

Public
All

Type Members

final class NonEmptyArray[T] extends AnyVal

A non-empty array: an ordered, mutable, non-empty collection of elements with IndexedSeq performance characteristics.
A non-empty array: an ordered, mutable, non-empty collection of elements with IndexedSeq performance characteristics.
The purpose of NonEmptyArray is to allow you to express in a type that an Array is non-empty, thereby eliminating the need for (and potential exception from) a run-time check for non-emptiness. For a non-empty immutable sequence with IndexedSeq performance, see Every.
Constructing NonEmptyArrays
You can construct a NonEmptyArray by passing one or more elements to the NonEmptyArray.apply factory method:
```
scala> NonEmptyArray(1, 2, 3)
res0: org.scalactic.anyvals.NonEmptyArray[Int] = NonEmptyArray(1, 2, 3)
```
Working with NonEmptyArrays
NonEmptyArray 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> Array(1).tail
res6: Array[Int] = Array()
```
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, NonEmptyArray defines a method corresponding to every such Seq method. Here are some examples:
```
NonEmptyArray(1, 2, 3).map(_ + 1)                        // Result: NonEmptyArray(2, 3, 4)
NonEmptyArray(1).map(_ + 1)                              // Result: NonEmptyArray(2)
NonEmptyArray(1, 2, 3).containsSlice(NonEmptyArray(2, 3)) // Result: true
NonEmptyArray(1, 2, 3).containsSlice(NonEmptyArray(3, 4)) // Result: false
NonEmptyArray(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1
```
NonEmptyArray does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NonEmptyArray to Array is defined in the NonEmptyArray 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 NonEmptyArray, even though filter could result in an empty sequence—but the result type will be Array instead of NonEmptyArray:
```
NonEmptyArray(1, 2, 3).filter(_ < 10) // Result: Array(1, 2, 3)
NonEmptyArray(1, 2, 3).filter(_ > 10) // Result: Array()
```
You can use NonEmptyArrays in for expressions. The result will be an NonEmptyArray unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a Array at that point. Here are some examples:
```
scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

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

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

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

scala> for {
     |   i <- NonEmptyArray(1, 2, 3) if i < 10
     |   j <- NonEmptyArray('a', 'b', 'c')
     | } yield (i, j)
res6: Array[(Int, Char)] =
        Array((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 NonEmptyArray
final class NonEmptyList[+T] extends AnyVal

A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
The purpose of NonEmptyList is to allow you to express in a type that a List 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 Every.
Constructing NonEmptyLists
You can construct a NonEmptyList by passing one or more elements to the NonEmptyList.apply factory method:
```
scala> NonEmptyList(1, 2, 3)
res0: org.scalactic.anyvals.NonEmptyList[Int] = NonEmptyList(1, 2, 3)
```
Alternatively you can cons elements onto the End singleton object, similar to making a List starting with Nil:
```
scala> 1 :: 2 :: 3 :: Nil
res0: List[Int] = List(1, 2, 3)

scala> 1 :: 2 :: 3 :: End
res1: org.scalactic.NonEmptyList[Int] = NonEmptyList(1, 2, 3)
```
Note that although Nil is a List[Nothing], End is not a NonEmptyList[Nothing], because no empty NonEmptyList exists. (A non-empty list is a series of connected links; if you have no links, you have no non-empty list.)
```
scala> val nil: List[Nothing] = Nil
nil: List[Nothing] = List()

scala> val nada: NonEmptyList[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NonEmptyList[Nothing]
       val nada: NonEmptyList[Nothing] = End
                                         ^
```
Working with NonEmptyLists
NonEmptyList 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> List(1).tail
res6: List[Int] = List()
```
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, NonEmptyList defines a method corresponding to every such Seq method. Here are some examples:
```
NonEmptyList(1, 2, 3).map(_ + 1)                        // Result: NonEmptyList(2, 3, 4)
NonEmptyList(1).map(_ + 1)                              // Result: NonEmptyList(2)
NonEmptyList(1, 2, 3).containsSlice(NonEmptyList(2, 3)) // Result: true
NonEmptyList(1, 2, 3).containsSlice(NonEmptyList(3, 4)) // Result: false
NonEmptyList(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1
```
NonEmptyList does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NonEmptyList to List is defined in the NonEmptyList 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 NonEmptyList, even though filter could result in an empty sequence—but the result type will be List instead of NonEmptyList:
```
NonEmptyList(1, 2, 3).filter(_ < 10) // Result: List(1, 2, 3)
NonEmptyList(1, 2, 3).filter(_ > 10) // Result: List()
```
You can use NonEmptyLists in for expressions. The result will be an NonEmptyList unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a List at that point. Here are some examples:
```
scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

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

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

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

scala> for {
     |   i <- NonEmptyList(1, 2, 3) if i < 10
     |   j <- NonEmptyList('a', 'b', 'c')
     | } yield (i, j)
res6: List[(Int, Char)] =
        List((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 NonEmptyList
final class NonEmptyMap[K, +V] extends AnyVal

A non-empty map: an ordered, immutable, non-empty collection of key-value tuples with LinearSeq performance characteristics.
A non-empty map: an ordered, immutable, non-empty collection of key-value tuples with LinearSeq performance characteristics.
The purpose of NonEmptyMap is to allow you to express in a type that a Map 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 Every.
Constructing NonEmptyMaps
You can construct a NonEmptyMap by passing one or more elements to the NonEmptyMap.apply factory method:
```
scala> NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three")
res0: org.scalactic.anyvals.NonEmptyMap[Int, String] = NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three")
```
Working with NonEmptyMaps
NonEmptyMap does not extend Scala's Map 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> Map(1 -> "one").tail
res6: Map[Int] = Map()
```
On the other hand, many useful methods exist on Map that when invoked on a non-empty Seq are guaranteed to not result in an empty Map. For convenience, NonEmptyMap defines a method corresponding to every such Map method. Here are an example:
```
NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three").map(t => (t._1 + 1, t._2))                        // Result: NonEmptyMap(2 -> "one", 3 -> "two", 4 -> "three")
```
NonEmptyMap does not currently define any methods corresponding to Map methods that could result in an empty Map. However, an implicit converison from NonEmptyMap to Map is defined in the NonEmptyMap 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 NonEmptyMap, even though filter could result in an empty map—but the result type will be Map instead of NonEmptyMap:
```
NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three").filter(_._1 < 10) // Result: Map(1 -> "one", 2 -> "two", 3 -> "three")
NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three").filter(_._ 1> 10) // Result: Map()
```
You can use NonEmptyMaps in for expressions. The result will be an NonEmptyMap unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a Map at that point. Here are some examples:
```
scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

scala> for ((i, j) <- NonEmptyMap(1 -> "one", 2 -> "two", 3 -> "three")) yield (i + 1, j)
res0: org.scalactic.anyvals.NonEmptyMap[Int, String] = NonEmptyMap(2 -> "one", 3 -> "two", 4 -> "three")

scala> for ((i, j) <- NonEmptyMap(1, 2, 3) if i < 10) yield (i + 1, j)
res1: Map[Int, String] = Map(2 -> "one", 3 -> "two", 4 -> "three")
```
K
the type of key contained in this NonEmptyMap
V
the type of value contained in this NonEmptyMap
final class NonEmptySet[T] extends AnyVal

A non-empty Set: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
A non-empty Set: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
The purpose of NonEmptySet 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 Every.
Constructing NonEmptySets
You can construct a NonEmptySet by passing one or more elements to the NonEmptySet.apply factory method:
```
scala> NonEmptySet(1, 2, 3)
res0: org.scalactic.anyvals.NonEmptySet[Int] = NonEmptySet(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.NonEmptySet[Int] = NonEmptySet(1, 2, 3)
```
Note that although Nil is a Set[Nothing], End is not a NonEmptySet[Nothing], because no empty NonEmptySet 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: NonEmptySet[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NonEmptySet[Nothing]
       val nada: NonEmptySet[Nothing] = End
                                         ^
```
Working with NonEmptySets
NonEmptySet 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, NonEmptySet defines a method corresponding to every such Seq method. Here are some examples:
```
NonEmptySet(1, 2, 3).map(_ + 1)                        // Result: NonEmptySet(2, 3, 4)
NonEmptySet(1).map(_ + 1)                              // Result: NonEmptySet(2)
NonEmptySet(1, 2, 3).containsSlice(NonEmptySet(2, 3)) // Result: true
NonEmptySet(1, 2, 3).containsSlice(NonEmptySet(3, 4)) // Result: false
NonEmptySet(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1
```
NonEmptySet does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NonEmptySet to Set is defined in the NonEmptySet 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 NonEmptySet, even though filter could result in an empty sequence—but the result type will be Set instead of NonEmptySet:
```
NonEmptySet(1, 2, 3).filter(_ < 10) // Result: Set(1, 2, 3)
NonEmptySet(1, 2, 3).filter(_ > 10) // Result: Set()
```
You can use NonEmptySets in for expressions. The result will be an NonEmptySet 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 <- NonEmptySet(1, 2, 3)) yield i + 1
res0: org.scalactic.anyvals.NonEmptySet[Int] = NonEmptySet(2, 3, 4)

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

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

scala> for {
     |   i <- NonEmptySet(1, 2, 3) if i < 10
     |   j <- NonEmptySet('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 NonEmptySet
final class NonEmptyString extends AnyVal

A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
The purpose of NonEmptyString is to allow you to express in a type that a String 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 Every.
Constructing NonEmptyStrings
You can construct a NonEmptyString by passing one or more elements to the NonEmptyString.apply factory method:
```
scala> NonEmptyString(1, 2, 3)
res0: org.scalactic.anyvals.NonEmptyString[Int] = NonEmptyString(1, 2, 3)
```
Alternatively you can cons elements onto the End singleton object, similar to making a String starting with Nil:
```
scala> 1 :: 2 :: 3 :: Nil
res0: String[Int] = String(1, 2, 3)

scala> 1 :: 2 :: 3 :: End
res1: org.scalactic.NonEmptyString[Int] = NonEmptyString(1, 2, 3)
```
Note that although Nil is a String[Nothing], End is not a NonEmptyString[Nothing], because no empty NonEmptyString exists. (A non-empty list is a series of connected links; if you have no links, you have no non-empty list.)
```
scala> val nil: String[Nothing] = Nil
nil: String[Nothing] = String()

scala> val nada: NonEmptyString[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NonEmptyString[Nothing]
       val nada: NonEmptyString[Nothing] = End
                                         ^
```
Working with NonEmptyStrings
NonEmptyString 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> String(1).tail
res6: String[Int] = String()
```
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, NonEmptyString defines a method corresponding to every such Seq method. Here are some examples:
```
NonEmptyString(1, 2, 3).map(_ + 1)                        // Result: NonEmptyString(2, 3, 4)
NonEmptyString(1).map(_ + 1)                              // Result: NonEmptyString(2)
NonEmptyString(1, 2, 3).containsSlice(NonEmptyString(2, 3)) // Result: true
NonEmptyString(1, 2, 3).containsSlice(NonEmptyString(3, 4)) // Result: false
NonEmptyString(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1
```
NonEmptyString does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NonEmptyString to String is defined in the NonEmptyString 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 NonEmptyString, even though filter could result in an empty sequence—but the result type will be String instead of NonEmptyString:
```
NonEmptyString(1, 2, 3).filter(_ < 10) // Result: String(1, 2, 3)
NonEmptyString(1, 2, 3).filter(_ > 10) // Result: String()
```
You can use NonEmptyStrings in for expressions. The result will be an NonEmptyString unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a String at that point. Here are some examples:
```
scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

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

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

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

scala> for {
     |   i <- NonEmptyString(1, 2, 3) if i < 10
     |   j <- NonEmptyString('a', 'b', 'c')
     | } yield (i, j)
res6: String[(Int, Char)] =
        String((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))
```
final class NonEmptyVector[+T] extends AnyVal

A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.
The purpose of NonEmptyVector is to allow you to express in a type that a Vector 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 Every.
Constructing NonEmptyVectors
You can construct a NonEmptyVector by passing one or more elements to the NonEmptyVector.apply factory method:
```
scala> NonEmptyVector(1, 2, 3)
res0: org.scalactic.anyvals.NonEmptyVector[Int] = NonEmptyVector(1, 2, 3)
```
Alternatively you can cons elements onto the End singleton object, similar to making a Vector starting with Nil:
```
scala> 1 :: 2 :: 3 :: Nil
res0: Vector[Int] = Vector(1, 2, 3)

scala> 1 :: 2 :: 3 :: End
res1: org.scalactic.NonEmptyVector[Int] = NonEmptyVector(1, 2, 3)
```
Note that although Nil is a Vector[Nothing], End is not a NonEmptyVector[Nothing], because no empty NonEmptyVector exists. (A non-empty list is a series of connected links; if you have no links, you have no non-empty list.)
```
scala> val nil: Vector[Nothing] = Nil
nil: Vector[Nothing] = Vector()

scala> val nada: NonEmptyVector[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NonEmptyVector[Nothing]
       val nada: NonEmptyVector[Nothing] = End
                                         ^
```
Working with NonEmptyVectors
NonEmptyVector 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> Vector(1).tail
res6: Vector[Int] = Vector()
```
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, NonEmptyVector defines a method corresponding to every such Seq method. Here are some examples:
```
NonEmptyVector(1, 2, 3).map(_ + 1)                        // Result: NonEmptyVector(2, 3, 4)
NonEmptyVector(1).map(_ + 1)                              // Result: NonEmptyVector(2)
NonEmptyVector(1, 2, 3).containsSlice(NonEmptyVector(2, 3)) // Result: true
NonEmptyVector(1, 2, 3).containsSlice(NonEmptyVector(3, 4)) // Result: false
NonEmptyVector(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1
```
NonEmptyVector does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NonEmptyVector to Vector is defined in the NonEmptyVector 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 NonEmptyVector, even though filter could result in an empty sequence—but the result type will be Vector instead of NonEmptyVector:
```
NonEmptyVector(1, 2, 3).filter(_ < 10) // Result: Vector(1, 2, 3)
NonEmptyVector(1, 2, 3).filter(_ > 10) // Result: Vector()
```
You can use NonEmptyVectors in for expressions. The result will be an NonEmptyVector unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a Vector at that point. Here are some examples:
```
scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

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

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

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

scala> for {
     |   i <- NonEmptyVector(1, 2, 3) if i < 10
     |   j <- NonEmptyVector('a', 'b', 'c')
     | } yield (i, j)
res6: Vector[(Int, Char)] =
        Vector((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 NonEmptyVector

Value Members

object End

Object that can be used as an endpoint for NonEmptyList construction expressions that use the cons (::) operator.
Object that can be used as an endpoint for NonEmptyList construction expressions that use the cons (::) operator.
Here's an example:
```
scala> 1 :: 2 :: 3 :: End
res0: org.scalactic.NonEmptyList[Int] = NonEmptyList(1, 2, 3)
```
Note that unlike Nil, which is an instance of List[Nothing], End is not an instance of NonEmptyList[Nothing], because there is no empty NonEmptyList:
```
scala> Nil.isInstanceOf[List[_]]
res0: Boolean = true

scala> End.isInstanceOf[NonEmptyList[_]]
res1: Boolean = false
```
object NonEmptyArray

Companion object for class NonEmptyArray.
Companion object for class NonEmptyArray.
object NonEmptyList

Companion object for class NonEmptyList.
Companion object for class NonEmptyList.
object NonEmptyMap

Companion object for class NonEmptyMap.
Companion object for class NonEmptyMap.
object NonEmptySet

Companion object for class NonEmptySet.
Companion object for class NonEmptySet.
object NonEmptyString

Companion object for class NonEmptyString.
Companion object for class NonEmptyString.
object NonEmptyVector

Companion object for class NonEmptyVector.
Companion object for class NonEmptyVector.

Ungrouped