org.scalactic.anyvals.NonEmptyArray.scala Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2001-2013 Artima, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.scalactic.anyvals
import scala.annotation.unchecked.{ uncheckedVariance => uV }
import scala.collection.GenIterable
import scala.collection.GenSeq
import scala.collection.GenTraversableOnce
import scala.collection.generic.CanBuildFrom
import scala.collection.mutable.Buffer
import scala.reflect.ClassTag
import scala.collection.immutable
import scala.collection.mutable.ArrayBuffer
import org.scalactic.Every
// Can't be a LinearSeq[T] because Builder would be able to create an empty one.
/**
* 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))
*
*
* @tparam T the type of elements contained in this NonEmptyArray
*/
final class NonEmptyArray[T] private (val toArray: Array[T]) extends AnyVal {
/**
* Returns a new NonEmptyArray containing the elements of this NonEmptyArray followed by the elements of the passed NonEmptyArray.
* The element type of the resulting NonEmptyArray is the most specific superclass encompassing the element types of this and the passed NonEmptyArray.
*
* @tparam U the element type of the returned NonEmptyArray
* @param other the NonEmptyArray to append
* @return a new NonEmptyList that contains all the elements of this NonEmptyList followed by all elements of other.
*/
def ++[U >: T](other: NonEmptyArray[U])(implicit classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray((toArray ++ other.toArray).toArray)
/**
* Returns a new NonEmptyArray containing the elements of this NonEmptyArray followed by the elements of the passed Every.
* The element type of the resulting NonEmptyArray is the most specific superclass encompassing the element types of this NonEmptyArray and the passed Every.
*
* @tparam U the element type of the returned NonEmptyArray
* @param other the Every to append
* @return a new NonEmptyArray that contains all the elements of this NonEmptyArray followed by all elements of other.
*/
def ++[U >: T](other: Every[U])(implicit classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray((toArray ++ other).toArray)
// TODO: Have I added these extra ++, etc. methods to Every that take a NonEmptyList?
/**
* Returns a new NonEmptyArray containing the elements of this NonEmptyArray followed by the elements of the passed GenTraversableOnce.
* The element type of the resulting NonEmptyArray is the most specific superclass encompassing the element types of this NonEmptyArray
* and the passed GenTraversableOnce.
*
* @tparam U the element type of the returned NonEmptyArray
* @param other the GenTraversableOnce to append
* @return a new NonEmptyArray that contains all the elements of this NonEmptyArray followed by all elements of other.
*/
def ++[U >: T](other: org.scalactic.ColCompatHelper.IterableOnce[U])(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
new NonEmptyArray((toArray ++ other.toStream).toArray)
/**
* Returns a new NonEmptyArray with the given element prepended.
*
*
* Note that :-ending operators are right associative. A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.
*
*
* @param element the element to prepend to this NonEmptyArray
* @return a new NonEmptyArray consisting of element followed by all elements of this NonEmptyArray.
*/
final def +:[U >: T](element: U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray(element +: toArray)
/**
* Returns a new NonEmptyArray with the given element appended.
*
*
* Note a mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.
*
*
* @param element the element to append to this NonEmptyArray
* @return a new NonEmptyArray consisting of all elements of this NonEmptyArray followed by element.
*/
def :+[U >: T](element: U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray(toArray :+ element)
/**
* Appends all elements of this NonEmptyArray to a string builder. The written text will consist of a concatenation of the result of invoking toString
* on of every element of this NonEmptyArray, without any separator string.
*
* @param sb the string builder to which elements will be appended
* @return the string builder, sb, to which elements were appended.
*/
final def addString(sb: StringBuilder): StringBuilder = toArray.addString(sb)
/**
* Appends all elements of this NonEmptyArray 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 NonEmptyArray, separated by the string sep.
*
* @param sb the string builder to which elements will be appended
* @param sep the separator string
* @return the string builder, sb, to which elements were appended.
*/
final def addString(sb: StringBuilder, sep: String): StringBuilder = toArray.addString(sb, sep)
/**
* Appends all elements of this NonEmptyArray 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 NonEmptyArray,
* separated by the string sep; and the string end
*
* @param sb the string builder to which elements will be appended
* @param start the starting string
* @param sep the separator string
* @param start the ending string
* @return the string builder, sb, to which elements were appended.
*/
final def addString(sb: StringBuilder, start: String, sep: String, end: String): StringBuilder = toArray.addString(sb, start, sep, end)
/**
* Selects an element by its index in the NonEmptyArray.
*
* @return the element of this NonEmptyArray at index idx, where 0 indicates the first element.
*/
final def apply(idx: Int): T = toArray(idx)
/**
* Finds the first element of this NonEmptyArray for which the given partial function is defined, if any, and applies the partial function to it.
*
* @param pf the partial function
* @return 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.
*/
final def collectFirst[U](pf: PartialFunction[T, U])(implicit classTagOfU: ClassTag[U]): Option[U] = toArray.collectFirst(pf)
/**
* Indicates whether this NonEmptyArray contains a given value as an element.
*
* @param elem the element to look for
* @return true if this NonEmptyArray has an element that is equal (as determined by ==) to elem, false otherwise.
*/
final def contains(elem: T): Boolean = toArray.contains(elem)
/**
* Indicates whether this NonEmptyArray contains a given GenSeq as a slice.
*
* @param that the GenSeq slice to look for
* @return true if this NonEmptyArray contains a slice with the same elements as that, otherwise false.
*/
final def containsSlice[B](that: GenSeq[B]): Boolean = toArray.containsSlice(that)
/**
* Indicates whether this NonEmptyArray contains a given Every as a slice.
*
* @param that the Every slice to look for
* @return true if this NonEmptyArray contains a slice with the same elements as that, otherwise false.
*/
final def containsSlice[B](that: Every[B]): Boolean = toArray.containsSlice(that.toVector)
/**
* Indicates whether this NonEmptyArray contains a given NonEmptyArray as a slice.
*
* @param that the NonEmptyArray slice to look for
* @return true if this NonEmptyArray contains a slice with the same elements as that, otherwise false.
*/
final def containsSlice[B](that: NonEmptyArray[B]): Boolean = toArray.containsSlice(that.toArray)
/**
* Copies values of this NonEmptyArray to an array. Fills the given array arr with values of this NonEmptyArray. Copying
* will stop once either the end of the current NonEmptyArray is reached, or the end of the array is reached.
*
* @param arr the array to fill
*/
final def copyToArray[U >: T](arr: Array[U]): Unit = toArray.copyToArray(arr, 0)
/**
* Copies values of this NonEmptyArray to an array. Fills the given array arr with values of this NonEmptyArray, beginning at
* index start. Copying will stop once either the end of the current NonEmptyArray is reached, or the end of the array is reached.
*
* @param arr the array to fill
* @param start the starting index
*/
final def copyToArray[U >: T](arr: Array[U], start: Int): Unit = toArray.copyToArray(arr, start)
/**
* Copies values of this NonEmptyArray to an array. Fills the given array arr with at most len elements of this NonEmptyArray, beginning at
* index start. Copying will stop once either the end of the current NonEmptyArray is reached, the end of the array is reached, or
* len elements have been copied.
*
* @param arr the array to fill
* @param start the starting index
* @param len the maximum number of elements to copy
*/
final def copyToArray[U >: T](arr: Array[U], start: Int, len: Int): Unit = toArray.copyToArray(arr, start, len)
/**
* Copies all elements of this NonEmptyArray to a buffer.
*
* @param buf the buffer to which elements are copied
*/
final def copyToBuffer[U >: T](buf: Buffer[U]): Unit = toArray.copyToBuffer(buf)
/**
* Indicates whether every element of this NonEmptyArray relates to the corresponding element of a given GenSeq by satisfying a given predicate.
*
* @tparam B the type of the elements of that
* @param that the GenSeq to compare for correspondence
* @param p the predicate, which relates elements from this NonEmptyArray and the passed GenSeq
* @return true if this NonEmptyArray and the passed GenSeq have the same length and p(x, y) is true
* for all corresponding elements x of this NonEmptyArray and y of that, otherwise false.
*/
final def corresponds[B](that: GenSeq[B])(p: (T, B) => Boolean): Boolean = toArray.corresponds(that)(p)
/**
* Indicates whether every element of this NonEmptyArray relates to the corresponding element of a given Every by satisfying a given predicate.
*
* @tparam B the type of the elements of that
* @param that the Every to compare for correspondence
* @param p the predicate, which relates elements from this NonEmptyArray and the passed Every
* @return true if this NonEmptyArray and the passed Every have the same length and p(x, y) is true
* for all corresponding elements x of this NonEmptyArray and y of that, otherwise false.
*/
final def corresponds[B](that: Every[B])(p: (T, B) => Boolean): Boolean = toArray.corresponds(that.toVector)(p)
/**
* Indicates whether every element of this NonEmptyArray relates to the corresponding element of a given NonEmptyArray by satisfying a given predicate.
*
* @tparam B the type of the elements of that
* @param that the NonEmptyArray to compare for correspondence
* @param p the predicate, which relates elements from this and the passed NonEmptyArray
* @return true if this and the passed NonEmptyArray have the same length and p(x, y) is true
* for all corresponding elements x of this NonEmptyArray and y of that, otherwise false.
*/
final def corresponds[B](that: NonEmptyArray[B])(p: (T, B) => Boolean): Boolean = toArray.corresponds(that.toArray)(p)
/**
* Counts the number of elements in this NonEmptyArray that satisfy a predicate.
*
* @param p the predicate used to test elements.
* @return the number of elements satisfying the predicate p.
*/
final def count(p: T => Boolean): Int = toArray.count(p)
/**
* Builds a new NonEmptyArray from this NonEmptyArray without any duplicate elements.
*
* @return A new NonEmptyArray that contains the first occurrence of every element of this NonEmptyArray.
*/
final def distinct: NonEmptyArray[T] = new NonEmptyArray(toArray.distinct)
/**
* Indicates whether this NonEmptyArray ends with the given GenSeq.
*
* @param that the sequence to test
* @return true if this NonEmptyArray has that as a suffix, false otherwise.
*/
final def endsWith[B](that: GenSeq[B]): Boolean = toArray.endsWith(that)
/**
* Indicates whether this NonEmptyArray ends with the given Every.
*
* @param that the Every to test
* @return true if this NonEmptyArray has that as a suffix, false otherwise.
*/
final def endsWith[B](that: Every[B]): Boolean = toArray.endsWith(that.toVector)
// TODO: Search for that: Every in here and add a that: NonEmptyArray in Every.
/**
* Indicates whether this NonEmptyArray ends with the given NonEmptyArray.
*
* @param that the NonEmptyArray to test
* @return true if this NonEmptyArray has that as a suffix, false otherwise.
*/
final def endsWith[B](that: NonEmptyArray[B]): Boolean = toArray.endsWith(that.toArray.toSeq)
/*
override def equals(o: Any): Boolean =
o match {
case nonEmptyArray: NonEmptyArray[_] => toArray == nonEmptyArray.toArray
case _ => false
}
*/
/**
* Indicates whether a predicate holds for at least one of the elements of this NonEmptyArray.
*
* @param the predicate used to test elements.
* @return true if the given predicate p holds for some of the elements of this NonEmptyArray, otherwise false.
*/
final def exists(p: T => Boolean): Boolean = toArray.exists(p)
/**
* Finds the first element of this NonEmptyArray that satisfies the given predicate, if any.
*
* @param p the predicate used to test elements
* @return an Some containing the first element in this NonEmptyArray that satisfies p, or None if none exists.
*/
final def find(p: T => Boolean): Option[T] = toArray.find(p)
/**
* Builds a new NonEmptyArray by applying a function to all elements of this NonEmptyArray and using the elements of the resulting NonEmptyArrays.
*
* @tparam U the element type of the returned NonEmptyArray
* @param f the function to apply to each element.
* @return a new NonEmptyArray containing elements obtained by applying the given function f to each element of this NonEmptyArray and concatenating
* the elements of resulting NonEmptyArrays.
*/
final def flatMap[U](f: T => NonEmptyArray[U])(implicit classTag: ClassTag[U]): NonEmptyArray[U] = {
val buf = new ArrayBuffer[U]
for (ele <- toArray)
buf ++= f(ele).toArray
new NonEmptyArray(buf.toArray)
}
/**
* Converts this NonEmptyArray of NonEmptyArrays into a NonEmptyArray
* formed by the elements of the nested NonEmptyArrays.
*
*
* Note: You cannot use this flatten method on a NonEmptyArray that contains a GenTraversableOnces, because
* if all the nested GenTraversableOnces were empty, you'd end up with an empty NonEmptyArray.
*
*
* @tparm B the type of the elements of each nested NonEmptyArray
* @return a new NonEmptyArray resulting from concatenating all nested NonEmptyArrays.
*/
final def flatten[B](implicit ev: T <:< NonEmptyArray[B], classTag: ClassTag[B]): NonEmptyArray[B] = flatMap(ev)
/**
* Folds the elements of this NonEmptyArray using the specified associative binary operator.
*
*
* The order in which operations are performed on elements is unspecified and may be nondeterministic.
*
*
* @tparam U a type parameter for the binary operator, a supertype of T.
* @param 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 list concatenation,
* 0 for addition, or 1 for multiplication.)
* @param op a binary operator that must be associative
* @return the result of applying fold operator op between all the elements and z
*/
final def fold[U >: T](z: U)(op: (U, U) => U): U = toArray.fold(z)(op)
/**
* Applies a binary operator to a start value and all elements of this NonEmptyArray, going left to right.
*
* @tparam B the result type of the binary operator.
* @param z the start value.
* @param op the binary operator.
* @return the result of inserting op between consecutive elements of this NonEmptyArray, 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 NonEmptyArray.
*
*/
final def foldLeft[B](z: B)(op: (B, T) => B): B = toArray.foldLeft(z)(op)
/**
* Applies a binary operator to all elements of this NonEmptyArray and a start value, going right to left.
*
* @tparam B the result of the binary operator
* @param z the start value
* @param op the binary operator
* @return the result of inserting op between consecutive elements of this NonEmptyArray, 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 NonEmptyArray.
*
*/
final def foldRight[B](z: B)(op: (T, B) => B): B = toArray.foldRight(z)(op)
/**
* Indicates whether a predicate holds for all elements of this NonEmptyArray.
*
* @param p the predicate used to test elements.
* @return true if the given predicate p holds for all elements of this NonEmptyArray, otherwise false.
*/
final def forall(p: T => Boolean): Boolean = toArray.forall(p)
/**
* Applies a function f to all elements of this NonEmptyArray.
*
* @param f the function that is applied for its side-effect to every element. The result of function f is discarded.
*/
final def foreach(f: T => Unit): Unit = toArray.foreach(f)
//def arrayToNonEmptyArray(array: Array[T]): NonEmptyArray[T] = new NonEmptyArray[T](array)
/**
* Partitions this NonEmptyArray into a map of NonEmptyArrays according to some discriminator function.
*
* @tparam K the type of keys returned by the discriminator function.
* @param f the discriminator function.
* @return A map from keys to NonEmptyArrays such that the following invariant holds:
*
*
* (nonEmptyArray.toArray partition f)(k) = xs filter (x => f(x) == k)
*
*
*
* That is, every key k is bound to a NonEmptyArray of those elements x for which f(x) equals k.
*
*/
final def groupBy[K](f: T => K)(implicit classTag: ClassTag[T]): Map[K, NonEmptyArray[T]] = {
val mapKToArray = toArray.toList.groupBy(f) // toList and implicit ClassTag is required to compile in scala 2.10.
(mapKToArray.mapValues{ list => new NonEmptyArray(list.toArray) }).toMap
}
/**
* Partitions elements into fixed size NonEmptyArrays.
*
* @param size the number of elements per group
* @return An iterator producing NonEmptyArrays of size size, except the last will be truncated if the elements don't divide evenly.
*/
final def grouped(size: Int)(implicit classTag: ClassTag[T]): Iterator[NonEmptyArray[T]] = {
val itOfArray = toArray.toList.grouped(size) // toList and implicit ClassTag is required to compile in scala 2.10.
itOfArray.map { list => new NonEmptyArray(list.toArray) }
}
/**
* Returns true to indicate this NonEmptyArray has a definite size, since all NonEmptyArrays are strict collections.
*/
final def hasDefiniteSize: Boolean = true
// override def hashCode: Int = toArray.hashCode
/**
* Selects the first element of this NonEmptyArray.
*
* @return the first element of this NonEmptyArray.
*/
final def head: T = toArray.head
// Methods like headOption I can't get rid of because of the implicit conversion to GenTraversable.
// Users can call any of the methods I've left out on a NonEmptyArray, and get whatever Array would return
// for that method call. Eventually I'll probably implement them all to save the implicit conversion.
/**
* Selects the first element of this NonEmptyArray and returns it wrapped in a Some.
*
* @return the first element of this NonEmptyArray, wrapped in a Some.
*/
final def headOption: Option[T] = toArray.headOption
/**
* Finds index of first occurrence of some value in this NonEmptyArray.
*
* @param elem the element value to search for.
* @return the index of the first element of this NonEmptyArray that is equal (as determined by ==) to elem,
* or -1, if none exists.
*/
final def indexOf(elem: T): Int = toArray.indexOf(elem, 0)
/**
* Finds index of first occurrence of some value in this NonEmptyArray after or at some start index.
*
* @param elem the element value to search for.
* @param from the start index
* @return the index >= from of the first element of this NonEmptyArray that is equal (as determined by ==) to elem,
* or -1, if none exists.
*/
final def indexOf(elem: T, from: Int): Int = toArray.indexOf(elem, from)
/**
* Finds first index where this NonEmptyArray contains a given GenSeq as a slice.
*
* @param that the GenSeq defining the slice to look for
* @return the first index at which the elements of this NonEmptyArray starting at that index match the elements of
* GenSeq that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: GenSeq[U]): Int = toArray.indexOfSlice(that)
/**
* Finds first index after or at a start index where this NonEmptyArray contains a given GenSeq as a slice.
*
* @param that the GenSeq defining the slice to look for
* @param from the start index
* @return the first index >= from at which the elements of this NonEmptyArray starting at that index match the elements of
* GenSeq that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: GenSeq[U], from: Int): Int = toArray.indexOfSlice(that, from)
/**
* Finds first index where this NonEmptyArray contains a given Every as a slice.
*
* @param that the Every defining the slice to look for
* @return the first index such that the elements of this NonEmptyArray starting at this index match the elements of
* Every that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: Every[U]): Int = toArray.indexOfSlice(that.toVector)
/**
* Finds first index where this NonEmptyArray contains a given NonEmptyArray as a slice.
*
* @param that the NonEmptyArray defining the slice to look for
* @return the first index such that the elements of this NonEmptyArray starting at this index match the elements of
* NonEmptyArray that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: NonEmptyArray[U]): Int = toArray.indexOfSlice(that.toArray)
/**
* Finds first index after or at a start index where this NonEmptyArray contains a given Every as a slice.
*
* @param that the Every defining the slice to look for
* @param from the start index
* @return the first index >= from such that the elements of this NonEmptyArray starting at this index match the elements of
* Every that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: Every[U], from: Int): Int = toArray.indexOfSlice(that.toVector, from)
/**
* Finds first index after or at a start index where this NonEmptyArray contains a given NonEmptyArray as a slice.
*
* @param that the NonEmptyArray defining the slice to look for
* @param from the start index
* @return the first index >= from such that the elements of this NonEmptyArray starting at this index match the elements of
* NonEmptyArray that, or -1 of no such subsequence exists.
*/
final def indexOfSlice[U >: T](that: NonEmptyArray[U], from: Int): Int = toArray.indexOfSlice(that.toArray, from)
/**
* Finds index of the first element satisfying some predicate.
*
* @param p the predicate used to test elements.
* @return the index of the first element of this NonEmptyArray that satisfies the predicate p,
* or -1, if none exists.
*/
final def indexWhere(p: T => Boolean): Int = toArray.indexWhere(p)
/**
* Finds index of the first element satisfying some predicate after or at some start index.
*
* @param p the predicate used to test elements.
* @param from the start index
* @return the index >= from of the first element of this NonEmptyArray that satisfies the predicate p,
* or -1, if none exists.
*/
final def indexWhere(p: T => Boolean, from: Int): Int = toArray.indexWhere(p, from)
/**
* Produces the range of all indices of this NonEmptyArray.
*
* @return a Range value from 0 to one less than the length of this NonEmptyArray.
*/
final def indices: Range = toArray.indices
/**
* Tests whether this NonEmptyArray contains given index.
*
* @param idx the index to test
* @return true if this NonEmptyArray contains an element at position idx, false otherwise.
*/
final def isDefinedAt(idx: Int): Boolean = toArray.isDefinedAt(idx)
/**
* Returns false to indicate this NonEmptyArray, like all NonEmptyArrays, is non-empty.
*
* @return false
*/
final def isEmpty: Boolean = false
/**
* Returns true to indicate this NonEmptyArray, like all NonEmptyArrays, can be traversed repeatedly.
*
* @return true
*/
final def isTraversableAgain: Boolean = true
/**
* Creates and returns a new iterator over all elements contained in this NonEmptyArray.
*
* @return the new iterator
*/
final def iterator: Iterator[T] = toArray.iterator
/**
* Selects the last element of this NonEmptyArray.
*
* @return the last element of this NonEmptyArray.
*/
final def last: T = toArray.last
/**
* Finds the index of the last occurrence of some value in this NonEmptyArray.
*
* @param elem the element value to search for.
* @return the index of the last element of this NonEmptyArray that is equal (as determined by ==) to elem,
* or -1, if none exists.
*/
final def lastIndexOf(elem: T): Int = toArray.lastIndexOf(elem)
/**
* Finds the index of the last occurrence of some value in this NonEmptyArray before or at a given end index.
*
* @param elem the element value to search for.
* @param end the end index.
* @return the index >= end of the last element of this NonEmptyArray that is equal (as determined by ==)
* to elem, or -1, if none exists.
*/
final def lastIndexOf(elem: T, end: Int): Int = toArray.lastIndexOf(elem, end)
/**
* Finds the last index where this NonEmptyArray contains a given GenSeq as a slice.
*
* @param that the GenSeq defining the slice to look for
* @return the last index at which the elements of this NonEmptyArray starting at that index match the elements of
* GenSeq that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: GenSeq[U]): Int = toArray.lastIndexOfSlice(that)
/**
* Finds the last index before or at a given end index where this NonEmptyArray contains a given GenSeq as a slice.
*
* @param that the GenSeq defining the slice to look for
* @param end the end index
* @return the last index >= end at which the elements of this NonEmptyArray starting at that index match the elements of
* GenSeq that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: GenSeq[U], end: Int): Int = toArray.lastIndexOfSlice(that, end)
/**
* Finds the last index where this NonEmptyArray contains a given Every as a slice.
*
* @param that the Every defining the slice to look for
* @return the last index at which the elements of this NonEmptyArray starting at that index match the elements of
* Every that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: Every[U]): Int = toArray.lastIndexOfSlice(that.toVector)
/**
* Finds the last index where this NonEmptyArray contains a given NonEmptyArray as a slice.
*
* @param that the NonEmptyArray defining the slice to look for
* @return the last index at which the elements of this NonEmptyArray starting at that index match the elements of
* NonEmptyArray that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: NonEmptyArray[U]): Int = toArray.lastIndexOfSlice(that.toArray)
/**
* Finds the last index before or at a given end index where this NonEmptyArray contains a given Every as a slice.
*
* @param that the Every defining the slice to look for
* @param end the end index
* @return the last index >= end at which the elements of this NonEmptyArray starting at that index match the elements of
* Every that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: Every[U], end: Int): Int = toArray.lastIndexOfSlice(that.toVector, end)
/**
* Finds the last index before or at a given end index where this NonEmptyArray contains a given NonEmptyArray as a slice.
*
* @param that the NonEmptyArray defining the slice to look for
* @param end the end index
* @return the last index >= end at which the elements of this NonEmptyArray starting at that index match the elements of
* NonEmptyArray that, or -1 of no such subsequence exists.
*/
final def lastIndexOfSlice[U >: T](that: NonEmptyArray[U], end: Int): Int = toArray.lastIndexOfSlice(that.toArray, end)
/**
* Finds index of last element satisfying some predicate.
*
* @param p the predicate used to test elements.
* @return the index of the last element of this NonEmptyArray that satisfies the predicate p, or -1, if none exists.
*/
final def lastIndexWhere(p: T => Boolean): Int = toArray.lastIndexWhere(p)
/**
* Finds index of last element satisfying some predicate before or at given end index.
*
* @param p the predicate used to test elements.
* @param end the end index
* @return the index >= end of the last element of this NonEmptyArray that satisfies the predicate p,
* or -1, if none exists.
*/
final def lastIndexWhere(p: T => Boolean, end: Int): Int = toArray.lastIndexWhere(p, end)
/**
* Returns the last element of this NonEmptyArray, wrapped in a Some.
*
* @return the last element, wrapped in a Some.
*/
final def lastOption: Option[T] = toArray.lastOption // Will always return a Some
/**
* The length of this NonEmptyArray.
*
*
* Note: length and size yield the same result, which will be >= 1.
*
*
* @return the number of elements in this NonEmptyArray.
*/
final def length: Int = toArray.length
/**
* Compares the length of this NonEmptyArray to a test value.
*
* @param len the test value that gets compared with the length.
* @return a value x where
*
*
* x < 0 if this.length < len
* x == 0 if this.length == len
* x > 0 if this.length > len
*
*/
final def lengthCompare(len: Int): Int = toArray.lengthCompare(len)
/**
* Builds a new NonEmptyArray by applying a function to all elements of this NonEmptyArray.
*
* @tparam U the element type of the returned NonEmptyArray.
* @param f the function to apply to each element.
* @return a new NonEmptyArray resulting from applying the given function f to each element of this NonEmptyArray and collecting the results.
*/
final def map[U](f: T => U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
new NonEmptyArray(toArray.map(f).toArray)
/**
* Finds the largest element.
*
* @return the largest element of this NonEmptyArray.
*/
final def max[U >: T](implicit cmp: Ordering[U]): T = toArray.max(cmp)
/**
* Finds the largest result after applying the given function to every element.
*
* @return the largest result of applying the given function to every element of this NonEmptyArray.
*/
final def maxBy[U](f: T => U)(implicit cmp: Ordering[U]): T = toArray.maxBy(f)(cmp)
/**
* Finds the smallest element.
*
* @return the smallest element of this NonEmptyArray.
*/
final def min[U >: T](implicit cmp: Ordering[U]): T = toArray.min(cmp)
/**
* Finds the smallest result after applying the given function to every element.
*
* @return the smallest result of applying the given function to every element of this NonEmptyArray.
*/
final def minBy[U](f: T => U)(implicit cmp: Ordering[U]): T = toArray.minBy(f)(cmp)
/**
* Displays all elements of this NonEmptyArray in a string.
*
* @return a string representation of this NonEmptyArray. In the resulting string, the result of invoking toString on all elements of this
* NonEmptyArray follow each other without any separator string.
*/
final def mkString: String = toArray.mkString
/**
* Displays all elements of this NonEmptyArray in a string using a separator string.
*
* @param sep the separator string
* @return a string representation of this NonEmptyArray. In the resulting string, the result of invoking toString on all elements of this
* NonEmptyArray are separated by the string sep.
*/
final def mkString(sep: String): String = toArray.mkString(sep)
/**
* Displays all elements of this NonEmptyArray in a string using start, end, and separator strings.
*
* @param start the starting string.
* @param sep the separator string.
* @param end the ending string.
* @return a string representation of this NonEmptyArray. 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 NonEmptyArray are
* separated by the string sep.
*/
final def mkString(start: String, sep: String, end: String): String = toArray.mkString(start, sep, end)
/**
* Returns true to indicate this NonEmptyArray, like all NonEmptyArrays, is non-empty.
*
* @return true
*/
final def nonEmpty: Boolean = true
/**
* A copy of this NonEmptyArray with an element value appended until a given target length is reached.
*
* @param len the target length
* @param elem he padding value
* @return a new NonEmptyArray consisting of all elements of this NonEmptyArray followed by the minimal number of occurrences
* of elem so that the resulting NonEmptyArray has a length of at least len.
*/
final def padTo[U >: T](len: Int, elem: U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
new NonEmptyArray(toArray.padTo(len, elem).toArray)
/**
* Produces a new NonEmptyArray where a slice of elements in this NonEmptyArray is replaced by another NonEmptyArray
*
* @param from the index of the first replaced element
* @param that the NonEmptyArray whose elements should replace a slice in this NonEmptyArray
* @param replaced the number of elements to drop in the original NonEmptyArray
*/
final def patch[U >: T](from: Int, that: NonEmptyArray[U], replaced: Int)(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
new NonEmptyArray(toArray.toVector.patch(from, that.toVector, replaced).toArray) // Current version of toArray.patch seems to be buggy in Scala 2.13.0 scala-js, we may try to remove it when newer version of scala/scala-js is available.
/**
* Iterates over distinct permutations.
*
*
* Here's an example:
*
*
*
* NonEmptyArray('a', 'b', 'b').permutations.toArray = Array(NonEmptyArray(a, b, b), NonEmptyArray(b, a, b), NonEmptyArray(b, b, a))
*
*
* @return an iterator that traverses the distinct permutations of this NonEmptyArray.
*/
final def permutations(implicit classTag: ClassTag[T]): Iterator[NonEmptyArray[T]] = {
val it = toArray.toList.permutations // toList and implicit ClassTag is required to compile in scala 2.10.
it map { list => new NonEmptyArray(list.toArray) }
}
/**
* Returns the length of the longest prefix whose elements all satisfy some predicate.
*
* @param p the predicate used to test elements.
* @return the length of the longest prefix of this NonEmptyArray such that every element
* of the segment satisfies the predicate p.
*/
final def prefixLength(p: T => Boolean): Int = toArray.prefixLength(p)
/**
* The result of multiplying all the elements of this NonEmptyArray.
*
*
* This method can be invoked for any NonEmptyArray[T] for which an implicit Numeric[T] exists.
*
*
* @return the product of all elements
*/
final def product[U >: T](implicit num: Numeric[U]): U = toArray.product(num)
/**
* Reduces the elements of this NonEmptyArray using the specified associative binary operator.
*
*
* The order in which operations are performed on elements is unspecified and may be nondeterministic.
*
*
* @tparam U a type parameter for the binary operator, a supertype of T.
* @param op a binary operator that must be associative.
* @return the result of applying reduce operator op between all the elements of this NonEmptyArray.
*/
final def reduce[U >: T](op: (U, U) => U): U = toArray.reduce(op)
/**
* Applies a binary operator to all elements of this NonEmptyArray, going left to right.
*
* @tparam U the result type of the binary operator.
* @param op the binary operator.
* @return the result of inserting op between consecutive elements of this NonEmptyArray, going left to right:
*
*
* op(...op(op(x_1, x_2), x_3), ..., x_n)
*
*
*
* where x1, ..., xn are the elements of this NonEmptyArray.
*
*/
final def reduceLeft[U >: T](op: (U, T) => U): U = toArray.reduceLeft(op)
/**
* Applies a binary operator to all elements of this NonEmptyArray, going left to right, returning the result in a Some.
*
* @tparam U the result type of the binary operator.
* @param op the binary operator.
* @return a Some containing the result of reduceLeft(op)
*
*/
final def reduceLeftOption[U >: T](op: (U, T) => U): Option[U] = toArray.reduceLeftOption(op)
final def reduceOption[U >: T](op: (U, U) => U): Option[U] = toArray.reduceOption(op)
/**
* Applies a binary operator to all elements of this NonEmptyArray, going right to left.
*
* @tparam U the result of the binary operator
* @param op the binary operator
* @return the result of inserting op between consecutive elements of this NonEmptyArray, going right to left:
*
*
* op(x_1, op(x_2, ... op(x_{n-1}, x_n)...))
*
*
*
* where x1, ..., xn are the elements of this NonEmptyArray.
*
*/
final def reduceRight[U >: T](op: (T, U) => U): U = toArray.reduceRight(op)
/**
* Applies a binary operator to all elements of this NonEmptyArray, going right to left, returning the result in a Some.
*
* @tparam U the result of the binary operator
* @param op the binary operator
* @return a Some containing the result of reduceRight(op)
*/
final def reduceRightOption[U >: T](op: (T, U) => U): Option[U] = toArray.reduceRightOption(op)
/**
* Returns new NonEmptyArray with elements in reverse order.
*
* @return a new NonEmptyArray with all elements of this NonEmptyArray in reversed order.
*/
final def reverse: NonEmptyArray[T] =
new NonEmptyArray(toArray.reverse)
/**
* An iterator yielding elements in reverse order.
*
*
* Note: nonEmptyArray.reverseIterator is the same as nonEmptyArray.reverse.iterator, but might be more efficient.
*
*
* @return an iterator yielding the elements of this NonEmptyArray in reversed order
*/
final def reverseIterator: Iterator[T] = toArray.reverseIterator
/**
* Builds a new NonEmptyArray by applying a function to all elements of this NonEmptyArray and collecting the results in reverse order.
*
*
* Note: nonEmptyArray.reverseMap(f) is the same as nonEmptyArray.reverse.map(f), but might be more efficient.
*
*
* @tparam U the element type of the returned NonEmptyArray.
* @param f the function to apply to each element.
* @return a new NonEmptyArray resulting from applying the given function f to each element of this NonEmptyArray
* and collecting the results in reverse order.
*/
final def reverseMap[U](f: T => U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
new NonEmptyArray(toArray.reverseMap(f).toArray)
/**
* Checks if the given GenIterable contains the same elements in the same order as this NonEmptyArray.
*
* @param that the GenIterable with which to compare
* @return true, if both this NonEmptyArray and the given GenIterable contain the same elements
* in the same order, false otherwise.
*/
final def sameElements[U >: T](that: GenIterable[U]): Boolean = toArray.sameElements(that)
/**
* Checks if the given Every contains the same elements in the same order as this NonEmptyArray.
*
* @param that the Every with which to compare
* @return true, if both this and the given Every contain the same elements
* in the same order, false otherwise.
*/
final def sameElements[U >: T](that: Every[U]): Boolean = toArray.sameElements(that.toVector)
/**
* Checks if the given NonEmptyArray contains the same elements in the same order as this NonEmptyArray.
*
* @param that the NonEmptyArray with which to compare
* @return true, if both this and the given NonEmptyArray contain the same elements
* in the same order, false otherwise.
*/
final def sameElements[U >: T](that: NonEmptyArray[U]): Boolean = toArray.sameElements(that.toArray)
/**
* Computes a prefix scan of the elements of this NonEmptyArray.
*
*
* Note: The neutral element z may be applied more than once.
*
*
*
* Here are some examples:
*
*
*
* NonEmptyArray(1, 2, 3).scan(0)(_ + _) == NonEmptyArray(0, 1, 3, 6)
* NonEmptyArray(1, 2, 3).scan("z")(_ + _.toString) == NonEmptyArray("z", "z1", "z12", "z123")
*
*
* @tparam U a type parameter for the binary operator, a supertype of T, and the type of the resulting NonEmptyArray.
* @param 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 list concatenation,
* 0 for addition, or 1 for multiplication.)
* @param op a binary operator that must be associative
* @return a new NonEmptyArray containing the prefix scan of the elements in this NonEmptyArray
*/
final def scan[U >: T](z: U)(op: (U, U) => U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray(toArray.scan(z)(op).toArray)
/**
* Produces a NonEmptyArray containing cumulative results of applying the operator going left to right.
*
*
* Here are some examples:
*
*
*
* NonEmptyArray(1, 2, 3).scanLeft(0)(_ + _) == NonEmptyArray(0, 1, 3, 6)
* NonEmptyArray(1, 2, 3).scanLeft("z")(_ + _) == NonEmptyArray("z", "z1", "z12", "z123")
*
*
* @tparam B the result type of the binary operator and type of the resulting NonEmptyArray
* @param z the start value.
* @param op the binary operator.
* @return a new NonEmptyArray containing the intermediate results of inserting op between consecutive elements of this NonEmptyArray,
* going left to right, with the start value, z, on the left.
*/
final def scanLeft[B](z: B)(op: (B, T) => B)(implicit classTag: ClassTag[B]): NonEmptyArray[B] = new NonEmptyArray(toArray.scanLeft(z)(op).toArray)
/**
* Produces a NonEmptyArray containing cumulative results of applying the operator going right to left.
*
*
* Here are some examples:
*
*
*
* NonEmptyArray(1, 2, 3).scanRight(0)(_ + _) == NonEmptyArray(6, 5, 3, 0)
* NonEmptyArray(1, 2, 3).scanRight("z")(_ + _) == NonEmptyArray("123z", "23z", "3z", "z")
*
*
* @tparam B the result of the binary operator and type of the resulting NonEmptyArray
* @param z the start value
* @param op the binary operator
* @return a new NonEmptyArray containing the intermediate results of inserting op between consecutive elements of this NonEmptyArray,
* going right to left, with the start value, z, on the right.
*/
final def scanRight[B](z: B)(op: (T, B) => B)(implicit classTag: ClassTag[B]): NonEmptyArray[B] = new NonEmptyArray(toArray.scanRight(z)(op).toArray)
/**
* Computes length of longest segment whose elements all satisfy some predicate.
*
* @param p the predicate used to test elements.
* @param from the index where the search starts.
* @param the length of the longest segment of this NonEmptyArray starting from index from such that every element of the
* segment satisfies the predicate p.
*/
final def segmentLength(p: T => Boolean, from: Int): Int = toArray.segmentLength(p, from)
/**
* Groups elements in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.)
*
* @param size the number of elements per group
* @return an iterator producing NonEmptyArrays of size size, except the last and the only element will be truncated
* if there are fewer elements than size.
*/
final def sliding(size: Int)(implicit classTag: ClassTag[T]): Iterator[NonEmptyArray[T]] = toArray.toList.sliding(size).map(l => new NonEmptyArray(l.toArray)) // toList and implicit ClassTag is required to compile in scala 2.10.
/**
* 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.
*
* @param size the number of elements per group
* @param step the distance between the first elements of successive groups
* @return an iterator producing NonEmptyArrays of size size, except the last and the only element will be truncated
* if there are fewer elements than size.
*/
final def sliding(size: Int, step: Int)(implicit classTag: ClassTag[T]): Iterator[NonEmptyArray[T]] = toArray.toList.sliding(size, step).map(l => new NonEmptyArray(l.toArray)) // toList and implicit ClassTag is required to compile in scala 2.10.
/**
* The size of this NonEmptyArray.
*
*
* Note: length and size yield the same result, which will be >= 1.
*
*
* @return the number of elements in this NonEmptyArray.
*/
final def size: Int = toArray.size
/**
* Sorts this NonEmptyArray according to the Ordering of the result of applying the given function to every element.
*
* @tparam U the target type of the transformation f, and the type where the Ordering ord is defined.
* @param f the transformation function mapping elements to some other domain U.
* @param ord the ordering assumed on domain U.
* @return a NonEmptyArray consisting of the elements of this NonEmptyArray sorted according to the Ordering where
* x < y if ord.lt(f(x), f(y)).
*/
final def sortBy[U](f: T => U)(implicit ord: Ordering[U]): NonEmptyArray[T] = new NonEmptyArray(toArray.sortBy(f))
/**
* Sorts this NonEmptyArray according to a comparison function.
*
*
* The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the
* sorted NonEmptyArray as in the original.
*
*
* @param the comparison function that tests whether its first argument precedes its second argument in the desired ordering.
* @return a NonEmptyArray consisting of the elements of this NonEmptyArray sorted according to the comparison function lt.
*/
final def sortWith(lt: (T, T) => Boolean): NonEmptyArray[T] = new NonEmptyArray(toArray.sortWith(lt))
/**
* Sorts this NonEmptyArray according to an Ordering.
*
*
* The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the
* sorted NonEmptyArray as in the original.
*
*
* @param ord the Ordering to be used to compare elements.
* @param the comparison function that tests whether its first argument precedes its second argument in the desired ordering.
* @return a NonEmptyArray consisting of the elements of this NonEmptyArray sorted according to the comparison function lt.
*/
final def sorted[U >: T](implicit ord: Ordering[U], classTag: ClassTag[U]): NonEmptyArray[U] = new NonEmptyArray(toArray.sorted(ord).toArray)
/**
* Indicates whether this NonEmptyArray starts with the given GenSeq.
*
* @param that the GenSeq slice to look for in this NonEmptyArray
* @return true if this NonEmptyArray has that as a prefix, false otherwise.
*/
final def startsWith[B](that: GenSeq[B]): Boolean = toArray.startsWith(that)
/**
* Indicates whether this NonEmptyArray starts with the given GenSeq at the given index.
*
* @param that the GenSeq slice to look for in this NonEmptyArray
* @param offset the index at which this NonEmptyArray is searched.
* @return true if this NonEmptyArray has that as a slice at the index offset, false otherwise.
*/
final def startsWith[B](that: GenSeq[B], offset: Int): Boolean = toArray.startsWith(that, offset)
/**
* Indicates whether this NonEmptyArray starts with the given Every.
*
* @param that the Every to test
* @return true if this collection has that as a prefix, false otherwise.
*/
final def startsWith[B](that: Every[B]): Boolean = toArray.startsWith(that.toVector)
/**
* Indicates whether this NonEmptyArray starts with the given NonEmptyArray.
*
* @param that the NonEmptyArray to test
* @return true if this collection has that as a prefix, false otherwise.
*/
final def startsWith[B](that: NonEmptyArray[B]): Boolean = toArray.startsWith(that.toArray.toSeq)
/**
* Indicates whether this NonEmptyArray starts with the given Every at the given index.
*
* @param that the Every slice to look for in this NonEmptyArray
* @param offset the index at which this NonEmptyArray is searched.
* @return true if this NonEmptyArray has that as a slice at the index offset, false otherwise.
*/
final def startsWith[B](that: Every[B], offset: Int): Boolean = toArray.startsWith(that.toVector, offset)
/**
* Indicates whether this NonEmptyArray starts with the given NonEmptyArray at the given index.
*
* @param that the NonEmptyArray slice to look for in this NonEmptyArray
* @param offset the index at which this NonEmptyArray is searched.
* @return true if this NonEmptyArray has that as a slice at the index offset, false otherwise.
*/
final def startsWith[B](that: NonEmptyArray[B], offset: Int): Boolean = toArray.startsWith(that.toArray.toSeq, offset)
/**
* Returns "NonEmptyArray", the prefix of this object's toString representation.
*
* @return the string "NonEmptyArray"
*/
def stringPrefix: String = "NonEmptyArray"
/**
* The result of summing all the elements of this NonEmptyArray.
*
*
* This method can be invoked for any NonEmptyArray[T] for which an implicit Numeric[T] exists.
*
*
* @return the sum of all elements
*/
final def sum[U >: T](implicit num: Numeric[U]): U = toArray.sum(num)
import scala.language.higherKinds
/**
* Converts this NonEmptyArray to a list.
*
* @return a list containing all elements of this NonEmptyArray. A ClassTag must be available for the element type of this NonEmptyArray.
*/
final def toList[U >: T]: List[U] = toArray.toList
/**
* Converts this NonEmptyArray to a Vector.
*
* @return a Vector containing all elements of this NonEmptyArray.
*/
final def toVector: Vector[T] = toArray.toVector
/**
* Converts this NonEmptyArray to a mutable buffer.
*
* @return a buffer containing all elements of this NonEmptyArray.
*/
final def toBuffer[U >: T]: Buffer[U] = toArray.toBuffer
/**
* Converts this NonEmptyArray to an immutable IndexedSeq.
*
* @return an immutable IndexedSeq containing all elements of this NonEmptyArray.
*/
final def toIndexedSeq: collection.immutable.IndexedSeq[T] = toArray.toVector
/**
* Converts this NonEmptyArray to an iterable collection.
*
* @return an Iterable containing all elements of this NonEmptyArray.
*/
final def toIterable: Iterable[T] = toArray.toIterable
/**
* Returns an Iterator over the elements in this NonEmptyArray.
*
* @return an Iterator containing all elements of this NonEmptyArray.
*/
final def toIterator: Iterator[T] = toArray.toIterator
/**
* Converts this NonEmptyArray to a list.
*
* @return a list containing all elements of this NonEmptyArray.
*/
// final def toArray: Array[T] = toArray
/**
* Converts this NonEmptyArray 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.
*
*
* @return a map of type immutable.Map[K, V] containing all key/value pairs of type (K, V) of this NonEmptyArray.
*/
final def toMap[K, V](implicit ev: T <:< (K, V)): Map[K, V] = toArray.toMap
/**
* Converts this NonEmptyArray to an immutable IndexedSeq.
*
* @return an immutable IndexedSeq containing all elements of this NonEmptyArray.
*/
final def toSeq: collection.immutable.Seq[T] = toArray.toList
/**
* Converts this NonEmptyArray to a set.
*
* @return a set containing all elements of this NonEmptyArray.
*/
final def toSet[U >: T]: Set[U] = toArray.toSet
/**
* Converts this NonEmptyArray to a stream.
*
* @return a stream containing all elements of this NonEmptyArray.
*/
final def toStream: Stream[T] = toArray.toStream
/**
* Returns a string representation of this NonEmptyArray.
*
* @return the string "NonEmptyArray" followed by the result of invoking toString on
* this NonEmptyArray's elements, surrounded by parentheses.
*/
override def toString: String = "NonEmptyArray(" + toArray.mkString(", ") + ")"
final def transpose[U](implicit ev: T <:< NonEmptyArray[U], classTag: ClassTag[U]): NonEmptyArray[NonEmptyArray[U]] = {
val asArrays = toArray.map(ev)
val list = asArrays.toList.transpose // toList and implicit ClassTag is required to compile in scala 2.10.
new NonEmptyArray(list.map(l => new NonEmptyArray(l.toArray)).toArray)
}
/**
* Converts this NonEmptyArray of pairs into two NonEmptyArrays of the first and second half of each pair.
*
* @tparam L the type of the first half of the element pairs
* @tparam R the type of the second half of the element pairs
* @param asPair an implicit conversion that asserts that the element type of this NonEmptyArray is a pair.
* @return a pair of NonEmptyArrays, containing the first and second half, respectively, of each element pair of this NonEmptyArray.
*/
final def unzip[L, R](implicit asPair: T => (L, R), classTagL: ClassTag[L], classTagR: ClassTag[R]): (NonEmptyArray[L], NonEmptyArray[R]) = {
val unzipped = toArray.unzip
(new NonEmptyArray(unzipped._1.toArray), new NonEmptyArray(unzipped._2.toArray))
}
/**
* Converts this NonEmptyArray of triples into three NonEmptyArrays of the first, second, and and third element of each triple.
*
* @tparam L the type of the first member of the element triples
* @tparam R the type of the second member of the element triples
* @tparam R the type of the third member of the element triples
* @param asTriple an implicit conversion that asserts that the element type of this NonEmptyArray is a triple.
* @return a triple of NonEmptyArrays, containing the first, second, and third member, respectively, of each element triple of this NonEmptyArray.
*/
final def unzip3[L, M, R](implicit asTriple: T => (L, M, R), classTagL: ClassTag[L], classTagM: ClassTag[M], classTagR: ClassTag[R]): (NonEmptyArray[L], NonEmptyArray[M], NonEmptyArray[R]) = {
val unzipped = toArray.unzip3
(new NonEmptyArray(unzipped._1.toArray), new NonEmptyArray(unzipped._2.toArray), new NonEmptyArray(unzipped._3.toArray))
}
/**
* A copy of this NonEmptyArray with one single replaced element.
*
* @param idx the position of the replacement
* @param elem the replacing element
* @throws IndexOutOfBoundsException if the passed index is greater than or equal to the length of this NonEmptyArray
* @return a copy of this NonEmptyArray with the element at position idx replaced by elem.
*/
final def updated[U >: T](idx: Int, elem: U)(implicit classTag: ClassTag[U]): NonEmptyArray[U] =
try new NonEmptyArray(toArray.updated(idx, elem).toArray)
catch { case _: UnsupportedOperationException => throw new IndexOutOfBoundsException(idx.toString) } // This is needed for 2.10 support. Can drop after.
// Because 2.11 throws IndexOutOfBoundsException.
/**
* Returns a NonEmptyArray formed from this NonEmptyArray 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.
*
* @tparm O the type of the second half of the returned pairs
* @tparm U the type of the first half of the returned pairs
* @param other the Iterable providing the second half of each result pair
* @param thisElem the element to be used to fill up the result if this NonEmptyArray is shorter than that Iterable.
* @param thatElem the element to be used to fill up the result if that Iterable is shorter than this NonEmptyArray.
* @return a new NonEmptyArray containing pairs consisting of corresponding elements of this NonEmptyArray and that. The
* length of the returned collection is the maximum of the lengths of this NonEmptyArray and that. If this NonEmptyArray
* is shorter than that, thisElem values are used to pad the result. If that is shorter than this
* NonEmptyArray, thatElem values are used to pad the result.
*/
final def zipAll[O, U >: T](other: collection.Iterable[O], thisElem: U, otherElem: O): NonEmptyArray[(U, O)] =
new NonEmptyArray(toArray.zipAll(other, thisElem, otherElem))
/**
* Zips this NonEmptyArray with its indices.
*
* @return A new NonEmptyArray containing pairs consisting of all elements of this NonEmptyArray paired with their index. Indices start at 0.
*/
final def zipWithIndex: NonEmptyArray[(T, Int)] = new NonEmptyArray(toArray.zipWithIndex)
}
/**
* Companion object for class NonEmptyArray.
*/
object NonEmptyArray {
/**
* Constructs a new NonEmptyArray given at least one element.
*
* @tparam T the type of the element contained in the new NonEmptyArray
* @param firstElement the first element (with index 0) contained in this NonEmptyArray
* @param otherElements a varargs of zero or more other elements (with index 1, 2, 3, ...) contained in this NonEmptyArray
*/
def apply[T](firstElement: T, otherElements: T*)(implicit classTag: ClassTag[T]): NonEmptyArray[T] = new NonEmptyArray((Array.empty[T] :+ firstElement) ++ otherElements)
/**
* Variable argument extractor for NonEmptyArrays.
*
* @param nonEmptyArray: the NonEmptyArray containing the elements to extract
* @return an Seq containing this NonEmptyArrays elements, wrapped in a Some
*/
def unapplySeq[T](nonEmptyArray: NonEmptyArray[T]): Option[Seq[T]] = Some(nonEmptyArray.toArray)
/*
// TODO: Figure out how to get case NonEmptyArray() to not compile
def unapplySeq[T](nonEmptyArray: NonEmptyArray[T]): Option[(T, Seq[T])] = Some(nonEmptyArray.head, nonEmptyArray.tail)
*/
/**
* Optionally construct a NonEmptyArray containing the elements, if any, of a given GenSeq.
*
* @param seq the GenSeq with which to construct a NonEmptyArray
* @return a NonEmptyArray containing the elements of the given GenSeq, if non-empty, wrapped in
* a Some; else None if the GenSeq is empty
*/
def from[T](seq: GenSeq[T])(implicit classTag: ClassTag[T]): Option[NonEmptyArray[T]] =
seq.headOption match {
case None => None
case Some(first) => Some(new NonEmptyArray((Array.empty[T] :+ first) ++ seq.tail))
}
import scala.language.implicitConversions
/**
* Implicit conversion from NonEmptyArray to Array.
*
*
* One use case for this implicit conversion is to enable GenSeq[NonEmptyArray]s to be flattened.
* Here's an example:
*
*
*
* scala> Vector(NonEmptyArray(1, 2, 3), NonEmptyArray(3, 4), NonEmptyArray(5, 6, 7, 8)).flatten
* res0: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 3, 4, 5, 6, 7, 8)
*
*
* @param nonEmptyArray the NonEmptyArray to convert to a Array
* @return a Array containing the elements, in order, of this NonEmptyArray
*/
implicit def nonEmptyArrayToArray[E](nonEmptyArray: NonEmptyArray[E]): Array[E] = nonEmptyArray.toArray
//implicit def nonEmptyArrayToTraversable[E](nonEmptyArray: NonEmptyArray[E]): Traversable[E] = nonEmptyArray.toTraversable
implicit def nonEmptyArrayToIterable[E](nonEmptyArray: NonEmptyArray[E]): Iterable[E] = nonEmptyArray.toIterable
implicit def nonEmptyArrayToPartialFunction[E](nonEmptyArray: NonEmptyArray[E]): PartialFunction[Int, E] =
new PartialFunction[Int, E] {
def apply(idx: Int): E = nonEmptyArray(idx)
def isDefinedAt(idx: Int): Boolean = nonEmptyArray.isDefinedAt(idx)
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy