A non-empty array: an ordered, mutable, non-empty collection of elements with IndexedSeq
performance characteristics.
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
.
NonEmptyList
s 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 ^
NonEmptyList
s 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 NonEmptyList
s 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))
the type of elements contained in this NonEmptyList
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
.
NonEmptyMap
s 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")
NonEmptyMap
s 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 NonEmptyMap
s 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")
the type of key contained in this NonEmptyMap
the type of value contained in this NonEmptyMap
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
.
NonEmptySet
s 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 ^
NonEmptySet
s 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 NonEmptySet
s 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))
the type of elements contained in this NonEmptySet
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
.
NonEmptyString
s 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 ^
NonEmptyString
s 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 NonEmptyString
s 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))
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
.
NonEmptyVector
s 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 ^
NonEmptyVector
s 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 NonEmptyVector
s 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))
the type of elements contained in this NonEmptyVector
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
Companion object for class NonEmptyArray
.
Companion object for class NonEmptyArray
.
Companion object for class NonEmptyList
.
Companion object for class NonEmptyList
.
Companion object for class NonEmptyMap
.
Companion object for class NonEmptyMap
.
Companion object for class NonEmptySet
.
Companion object for class NonEmptySet
.
Companion object for class NonEmptyString
.
Companion object for class NonEmptyString
.
Companion object for class NonEmptyVector
.
Companion object for class NonEmptyVector
.
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 anArray
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 withIndexedSeq
performance, seeEvery
.Constructing
NonEmptyArray
sYou can construct a
NonEmptyArray
by passing one or more elements to theNonEmptyArray.apply
factory method:Working with
NonEmptyArray
sNonEmptyArray
does not extend Scala'sSeq
orTraversable
traits because these require that implementations may be empty. For example, if you invoketail
on aSeq
that contains just one element, you'll get an emptySeq
:On the other hand, many useful methods exist on
Seq
that when invoked on a non-emptySeq
are guaranteed to not result in an emptySeq
. For convenience,NonEmptyArray
defines a method corresponding to every suchSeq
method. Here are some examples:NonEmptyArray
does not currently define any methods corresponding toSeq
methods that could result in an emptySeq
. However, an implicit converison fromNonEmptyArray
toArray
is defined in theNonEmptyArray
companion object that will be applied if you attempt to call one of the missing methods. As a result, you can invokefilter
on anNonEmptyArray
, even thoughfilter
could result in an empty sequence—but the result type will beArray
instead ofNonEmptyArray
:You can use
NonEmptyArray
s infor
expressions. The result will be anNonEmptyArray
unless you use a filter (anif
clause). Because filters are desugared to invocations offilter
, the result type will switch to aArray
at that point. Here are some examples:the type of elements contained in this
NonEmptyArray