org.scalautils.Every.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest_2.11.0-RC2 Show documentation
ScalaTest is a free, open-source testing toolkit for Scala and Java programmers.
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.scalautils

import scala.collection.immutable
import scala.collection.mutable.ArrayBuffer
import scala.collection.GenTraversableOnce
import scala.reflect.ClassTag
import scala.collection.mutable.Buffer
import scala.collection.GenSeq
import scala.collection.GenIterable
import scala.collection.generic.CanBuildFrom
import Every.fromNonEmptyVector
import scala.annotation.unchecked.{ uncheckedVariance => uV }

// Can't be an IndexedSeq[T] because Builder would be able to create an empty one.
/**
 * An ordered, immutable, non-empty collection of elements.
 *
 * 
 * Class Every has two and only two subtypes: One and Many.
 * A One contains exactly one element. A Many contains two or more elements. Thus no way exists for an
 * Every to contain zero elements.
 * 
 *
 * Constructing Everys
 *
 * 
 * You can construct an Every by passing one or more elements to the Every.apply factory method:
 * 
 *
 *  * Every(1)
 * Every(1, 2)
 * Every(1, 2, 3)
 * 
 *
 * 
 * Alternatively you can pass one element to the One.apply factory method, or two or more elements to 
 * Many.apply:
 * 
 *
 *  * One(1)
 * Many(1, 3)
 * Many(1, 2, 3)
 * 
 *
 * Working with Everys
 *
 * 
 * Every 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, Every defines a method corresponding to every such Seq
 * method. Here are some examples:
 * 
 * 
 *  * Many(1, 2, 3).map(_ + 1)                  // Result: Many(2, 3, 4)
 * One(1).map(_ + 1)                         // Result: One(2)
 * Every(1, 2, 3).containsSlice(Every(2, 3)) // Result: true
 * Every(1, 2, 3).containsSlice(Every(3, 4)) // Result: false
 * Every(-1, -2, 3, 4, 5).minBy(_.abs)       // Result: -1
 * 
 *
 * 
 * Every does not currently define any methods corresponding to Seq methods that could result in
 * an empty Seq. However, an implicit converison from Every to collection.immutable.IndexedSeq
 * is defined in the Every 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 Every, even though filter could result
 * in an empty sequence—but the result type will be collection.immutable.IndexedSeq instead of Every:
 * 
 *
 *  * Every(1, 2, 3).filter(_ < 10) // Result: Vector(1, 2, 3)
 * Every(1, 2, 3).filter(_ > 10) // Result: Vector()
 * 
 * 
 *
 * 
 * You can use Everys in for expressions. The result will be an Every unless
 * you use a filter (an if clause). Because filters are desugared to invocations of filter, the
 * result type will switch to a collection.immutable.IndexedSeq at that point. Here are some examples:
 * 
 * 
 *  * scala> import org.scalautils._
 * import org.scalautils._
 *
 * scala> for (i <- Every(1, 2, 3)) yield i + 1
 * res0: org.scalautils.Every[Int] = Many(2, 3, 4)
 *
 * scala> for (i <- Every(1, 2, 3) if i < 10) yield i + 1
 * res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 3, 4)
 *
 * scala> for {
 *      |   i <- Every(1, 2, 3)
 *      |   j <- Every('a', 'b', 'c')
 *      | } yield (i, j)
 * res3: org.scalautils.Every[(Int, Char)] =
 *         Many((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))
 *
 * scala> for {
 *      |   i <- Every(1, 2, 3) if i < 10
 *      |   j <- Every('a', 'b', 'c')
 *      | } yield (i, j)
 * res6: scala.collection.immutable.IndexedSeq[(Int, Char)] =
 *         Vector((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))
 * 
 *
 * Motivation for Everys
 *
 * 
 * Although Every is a general-purpose, non-empty ordered collection, it was motivated by the desire to enable easy
 * accumulation of errors in Ors. For examples of Every used in that use case, see the
 * Accumulating errors with Or section in the main documentation for Or.
 * 
 *
 * @tparam T the type of elements contained in this Every
 */
sealed abstract class Every[+T] protected (underlying: Vector[T]) extends PartialFunction[Int, T] {

/*
  private def this(firstElement: T, otherElements: T*) = this(Vector(firstElement) ++ otherElements)
*/

  /**
   * Returns a new Many containing the elements of this Every followed by the elements of the passed Every.
   * The element type of the resulting Many is the most specific superclass encompassing the element types of this and the passed Every.
   *
   * @tparam U the element type of the returned Many
   * @param other the Every to append
   * @return a new Many that contains all the elements of this Every followed by all elements of other.
   */
  def ++[U >: T](other: Every[U]): Many[U]

  /**
   * Returns a new Many containing the elements of this Every followed by the elements of the passed GenTraversableOnce.
   * The element type of the resulting Many is the most specific superclass encompassing the element types of this Every
   * and the passed GenTraversableOnce.
   *
   * @tparam U the element type of the returned Many
   * @param other the Every to append
   * @return a new Many that contains all the elements of this Every followed by all elements of other.
   */
  def ++[U >: T](other: GenTraversableOnce[U]): Every[U]

  /**
   * Fold left: applies a binary operator to a start value, z, and all elements of this Every, going left to right.
   *
   * 
   * Note: /: is alternate syntax for the foldLeft method; z /: every is the
   * same as every foldLeft z.
   * 
   *
   * @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 Every, going left to right, with the start value,
   *     z, on the left:
   *
   *    * op(...op(op(z, x_1), x_2), ..., x_n)
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */
  final def /:[B](z: B)(op: (B, T) => B): B = underlying./:(z)(op)

  /**
   * Fold right: applies a binary operator to all elements of this Every and a start value, going right to left.
   *
   * 
   * Note: :\ is alternate syntax for the foldRight method; every :\ z is the same
   * as every foldRight z.
   * 
   *
   * @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 Every, going right to left, with the start value,
   *     z, on the right:
   *
   *    * op(x_1, op(x_2, ... op(x_n, z)...))
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */
  final def :\[B](z: B)(op: (T, B) => B): B = underlying.:\(z)(op)

  /**
   * Returns a new Every 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 Every
   * @return a new Every consisting of element followed by all elements of this Every.
   */
  final def +:[U >: T](element: U): Many[U] = Many(element, underlying.head, underlying.tail: _*)

  /**
   * Returns a new Every 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 Every
   * @return a new Every consisting of all elements of this Every followed by element.
   */
  def :+[U >: T](element: U): Many[U]

  /**
   * Appends all elements of this Every to a string builder. The written text will consist of a concatenation of the result of invoking toString
   * on of every element of this Every, 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 = underlying.addString(sb)

  /**
   * Appends all elements of this Every 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 Every, 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 = underlying.addString(sb, sep)

  /**
   * Appends all elements of this Every 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 Every,
   * 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 = underlying.addString(sb, start, sep, end)

  /**
   * Selects an element by its index in the Every.
   *
   * @return the element of this Every at index idx, where 0 indicates the first element.
   */
  final def apply(idx: Int): T = underlying(idx)

  /**
   * Finds the first element of the Every 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]): Option[U] = underlying.collectFirst(pf)

  /**
   * Indicates whether this Every contains a given value as an element.
   *
   * @param elem the element to look for
   * @return true if this Every has an element that is equal (as determined by ==) to elem, false otherwise. 
   */ 
  final def contains(elem: Any): Boolean = underlying.contains(elem)

  /**
   * Indicates whether this Every contains a given GenSeq as a slice.
   *
   * @param that the GenSeq slice to look for
   * @return true if this Every contains a slice with the same elements as that, otherwise false.
   */
  final def containsSlice[B](that: GenSeq[B]): Boolean = underlying.containsSlice(that)

  /**
   * Indicates whether this Every contains a given Every as a slice.
   *
   * @param that the Every slice to look for
   * @return true if this Every contains a slice with the same elements as that, otherwise false.
   */
  final def containsSlice[B](that: Every[B]): Boolean = underlying.containsSlice(that.toVector)

  /**
   * Copies values of this Every to an array. Fills the given array arr with values of this Every. Copying
   * will stop once either the end of the current Every 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 = underlying.copyToArray(arr)

  /**
   * Copies values of this Every to an array. Fills the given array arr with values of this Every, beginning at
   * index start. Copying will stop once either the end of the current Every 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 = underlying.copyToArray(arr, start)

  /**
   * Copies values of this Every to an array. Fills the given array arr with at most len elements of this Every, beginning at
   * index start. Copying will stop once either the end of the current Every 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 = underlying.copyToArray(arr, start, len)

  /**
   * Copies all elements of this Every to a buffer. 
   *
   * @param buf the buffer to which elements are copied
   */
  final def copyToBuffer[U >: T](buf: Buffer[U]): Unit = underlying.copyToBuffer(buf)

  /**
   * Indicates whether every element of this Every 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 Every and the passed GenSeq
   * @return true if this Every and the passed GenSeq have the same length and p(x, y) is true
   *     for all corresponding elements x of this Every and y of that, otherwise false.
   */
  final def corresponds[B](that: GenSeq[B])(p: (T, B) => Boolean): Boolean = underlying.corresponds(that)(p)

  /**
   * Indicates whether every element of this Every 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 and the passed Every
   * @return true if this and the passed Every have the same length and p(x, y) is true
   *     for all corresponding elements x of this Every and y of that, otherwise false.
   */
  final def corresponds[B](that: Every[B])(p: (T, B) => Boolean): Boolean = underlying.corresponds(that.toVector)(p)

  /**
   * Counts the number of elements in the Every 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 = underlying.count(p)

  /**
   * Builds a new Every from this Every without any duplicate elements.
   *
   * @return A new Every that contains the first occurrence of every element of this Every. 
   */
  final def distinct: Every[T] = {
    val eles = underlying.distinct
    val head = eles.head
    val tail = eles.tail
    if (tail.isEmpty) One(head) else Many(head, tail.head, tail.tail: _*)
  }

  /**
   * Indicates whether this Every ends with the given GenSeq.
   *
   * @param the sequence to test
   * @return true if this Every has that as a suffix, false otherwise. 
   */
  final def endsWith[B](that: GenSeq[B]): Boolean = underlying.endsWith(that)

  /**
   * Indicates whether this Every ends with the given Every.
   *
   * @param the sequence to test
   * @return true if this Every has that as a suffix, false otherwise. 
   */
  final def endsWith[B](that: Every[B]): Boolean = underlying.endsWith(that.toVector)

  /**
   * Indicates whether a predicate holds for at least one of the elements of this Every.
   *
   * @param the predicate used to test elements.
   * @return true if the given predicate p holds for some of the elements of this Every, otherwise false. 
   */
  final def exists(p: T => Boolean): Boolean = underlying.exists(p)

  /**
   * Finds the first element of this Every that satisfies the given predicate, if any.
   *
   * @param p the predicate used to test elements
   * @return an Some containing the first element in this Every that satisfies p, or None if none exists. 
   */
  final def find(p: T => Boolean): Option[T] = underlying.find(p)

  /**
   * Builds a new Every by applying a function to all elements of this Every and using the elements of the resulting Everys.
   *
   * @tparam U the element type of the returned Every
   * @param f the function to apply to each element.
   * @return a new Every containing elements obtained by applying the given function f to each element of this Every and concatenating
   *    the elements of resulting Everys. 
   */
  final def flatMap[U](f: T => Every[U]): Every[U] = {
    val buf = new ArrayBuffer[U]
    for (ele <- underlying)
      buf ++= f(ele).toVector
    val vec = buf.toVector
    Every(vec.head, vec.tail: _*)
  }

  /**
   * Converts this Every of Everys into an Every
   * formed by the elements of the nested Everys.
   *
   * 
   * Note: You cannot use this flatten method on an Every that contains a GenTraversableOnces, because 
   * if all the nested GenTraversableOnces were empty, you'd end up with an empty Every.
   * 
   *
   * @tparm B the type of the elements of each nested Every
   * @return a new Every resulting from concatenating all nested Everys.
   */
  final def flatten[B](implicit ev: T <:< Every[B]): Every[B] = flatMap(ev)

  /**
   * Folds the elements of this Every 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 = underlying.fold(z)(op)

  /**
   * Applies a binary operator to a start value and all elements of this Every, 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 Every, going left to right, with the start value,
   *     z, on the left:
   *
   *    * op(...op(op(z, x_1), x_2), ..., x_n)
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */ 
  final def foldLeft[B](z: B)(op: (B, T) => B): B = underlying.foldLeft(z)(op)

  /**
   * Applies a binary operator to all elements of this Every 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 Every, going right to left, with the start value,
   *     z, on the right:
   *
   *    * op(x_1, op(x_2, ... op(x_n, z)...))
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */
  final def foldRight[B](z: B)(op: (T, B) => B): B = underlying.foldRight(z)(op)

  /**
   * Indicates whether a predicate holds for all elements of this Every.
   *
   * @param p the predicate used to test elements.
   * @return true if the given predicate p holds for all elements of this Every, otherwise false. 
   */
  final def forall(p: T => Boolean): Boolean = underlying.forall(p)

  /**
   * Applies a function f to all elements of this Every.
   *
   * @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 = underlying.foreach(f)

  /**
   * Partitions this Every into a map of Everys 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 Everys such that the following invariant holds:
   *
   *    * (every.toVector partition f)(k) = xs filter (x => f(x) == k)
   * 
   *
   * 
   * That is, every key k is bound to an Every of those elements x for which f(x) equals k.
   * 
   */
  final def groupBy[K](f: T => K): Map[K, Every[T]] = {
    val mapKToVec = underlying.groupBy(f)
    mapKToVec.mapValues { vec => Every(vec.head, vec.tail: _*) }
  }

  /**
   * Partitions elements into fixed size Everys.
   *
   * @param size the number of elements per group
   * @return An iterator producing Everys of size size, except the last will be truncated if the elements don't divide evenly. 
   */
  final def grouped(size: Int): Iterator[Every[T]] = {
    val itOfVec = underlying.grouped(size)
    itOfVec.map { vec => Every(vec.head, vec.tail: _*) }
  }

  /**
   * Returns true to indicate this Every has a definite size, since all Everys are strict collections.
   */
  final def hasDefiniteSize: Boolean = true

  /**
   * Selects the first element of this Every. 
   *
   * @return the first element of this Every.
   */
  final def head: T = underlying.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 an Every, and get whatever Vector would return
  // for that method call. Eventually I'll probably implement them all to save the implicit conversion.

  /**
   * Selects the first element of this Every and returns it wrapped in a Some. 
   *
   * @return the first element of this Every, wrapped in a Some.
   */
  final def headOption: Option[T] = underlying.headOption

  /**
   * Finds index of first occurrence of some value in this Every.
   *
   * @param elem the element value to search for. 
   * @return the index of the first element of this Every that is equal (as determined by ==) to elem,
   *     or -1, if none exists.
   */
  final def indexOf[U >: T](elem: U): Int = underlying.indexOf(elem)

  /**
   * Finds index of first occurrence of some value in this Every 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 Every that is equal (as determined by ==) to elem,
   *     or -1, if none exists.
   */
  final def indexOf[U >: T](elem: U, from: Int): Int = underlying.indexOf(elem, from)

  /**
   * Finds first index where this Every 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 Every 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 = underlying.indexOfSlice(that)

  /**
   * Finds first index after or at a start index where this Every 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 Every 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 = underlying.indexOfSlice(that, from)

  /**
   * Finds first index where this Every 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 Every 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 = underlying.indexOfSlice(that.toVector)

  /**
   * Finds first index after or at a start index where this Every 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 Every 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 = underlying.indexOfSlice(that.toVector, 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 Every that satisfies the predicate p,
   *     or -1, if none exists.
   */ 
  final def indexWhere(p: T => Boolean): Int = underlying.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 Every that satisfies the predicate p,
   *     or -1, if none exists.
   */ 
  final def indexWhere(p: T => Boolean, from: Int): Int = underlying.indexWhere(p, from)

  /**
   * Produces the range of all indices of this Every. 
   *
   * @return a Range value from 0 to one less than the length of this Every. 
   */
  final def indices: Range = underlying.indices

  /**
   * Tests whether this Every contains given index.
   *
   * @param idx the index to test
   * @return true if this Every contains an element at position idx, false otherwise. 
   */
  final def isDefinedAt(idx: Int): Boolean = underlying.isDefinedAt(idx)

  /**
   * Returns false to indicate this Every, like all Everys, is non-empty.
   *
   * @return false
   */
  final def isEmpty: Boolean = false

  /**
   * Returns true to indicate this Every, like all Everys, can be traversed repeatedly.
   *
   * @return true
   */
  final def isTraversableAgain: Boolean = true

  /**
   * Creates and returns a new iterator over all elements contained in this Every.
   *
   * @return the new iterator
   */
  final def iterator: Iterator[T] = underlying.iterator

  /**
   * Selects the last element of this Every. 
   *
   * @return the last element of this Every.
   */
  final def last: T = underlying.last

  /**
   * Finds the index of the last occurrence of some value in this Every.
   *
   * @param elem the element value to search for.
   * @return the index of the last element of this Every that is equal (as determined by ==) to elem,
   *     or -1, if none exists.
   */
  final def lastIndexOf[U >: T](elem: U): Int = underlying.lastIndexOf(elem)

  /**
   * Finds the index of the last occurrence of some value in this Every 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 Every that is equal (as determined by ==)
   *     to elem, or -1, if none exists.
   */
  final def lastIndexOf[U >: T](elem: U, end: Int): Int = underlying.lastIndexOf(elem, end)

  /**
   * Finds the last index where this Every 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 Every 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 = underlying.lastIndexOfSlice(that)

  /**
   * Finds the last index before or at a given end index where this Every 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 Every 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 = underlying.lastIndexOfSlice(that, end)

  /**
   * Finds the last index where this Every 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 Every 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 = underlying.lastIndexOfSlice(that.toVector)

  /**
   * Finds the last index before or at a given end index where this Every 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 Every 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 = underlying.lastIndexOfSlice(that.toVector, 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 Every that satisfies the predicate p, or -1, if none exists. 
   */
  final def lastIndexWhere(p: T => Boolean): Int = underlying.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 Every that satisfies the predicate p,
   *     or -1, if none exists. 
   */
  final def lastIndexWhere(p: T => Boolean, end: Int): Int = underlying.lastIndexWhere(p, end)

  /**
   * Returns the last element of this Every, wrapped in a Some. 
   *
   * @return the last element, wrapped in a Some. 
   */
  final def lastOption: Option[T] = underlying.lastOption // Will always return a Some

  /**
   * The length of this Every.
   *
   * 
   * Note: length and size yield the same result, which will be >= 1. 
   * 
   *
   * @return the number of elements in this Every. 
   */
  final def length: Int = underlying.length

  /**
   * Compares the length of this Every 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 = underlying.lengthCompare(len)

  /**
   * Builds a new Every by applying a function to all elements of this Every.
   *
   * @tparam U the element type of the returned Every.
   * @param f the function to apply to each element. 
   * @return a new Every resulting from applying the given function f to each element of this Every and collecting the results. 
   */
  final def map[U](f: T => U): Every[U] = {
    val vec = underlying.map(f)
    Every(vec.head, vec.tail: _*)
  }

  /**
   * Finds the largest element.
   *
   * @return the largest element of this Every. 
   */
  final def max[U >: T](implicit cmp: Ordering[U]): T = underlying.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 Every. 
   */
  final def maxBy[U](f: T => U)(implicit cmp: Ordering[U]): T = underlying.maxBy(f)(cmp)

  /**
   * Finds the smallest element.
   *
   * @return the smallest element of this Every. 
   */
  final def min[U >: T](implicit cmp: Ordering[U]): T = underlying.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 Every. 
   */
  final def minBy[U](f: T => U)(implicit cmp: Ordering[U]): T = underlying.minBy(f)(cmp)

  /**
   * Displays all elements of this Every in a string. 
   *
   * @return a string representation of this Every. In the resulting string, the result of invoking toString on all elements of this
   *     Every follow each other without any separator string. 
   */
  final def mkString: String = underlying.mkString

  /**
   * Displays all elements of this Every in a string using a separator string. 
   *
   * @param sep the separator string
   * @return a string representation of this Every. In the resulting string, the result of invoking toString on all elements of this
   *     Every are separated by the string sep. 
   */
  final def mkString(sep: String): String = underlying.mkString(sep)

  /**
   * Displays all elements of this Every 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 Every. 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 Every are
   *     separated by the string sep. 
   */
  final def mkString(start: String, sep: String, end: String): String = underlying.mkString(start, sep, end)

  /**
   * Returns true to indicate this Every, like all Everys, is non-empty.
   *
   * @return true
   */
  final def nonEmpty: Boolean = true

  /**
   * A copy of this Every 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 Every consisting of all elements of this Every followed by the minimal number of occurrences
   *     of elem so that the resulting Every has a length of at least len. 
   */
  final def padTo[U >: T](len: Int, elem: U): Every[U] = {
    val vec = underlying.padTo(len, elem)
    Every(vec.head, vec.tail: _*)
  }

  /**
   * Produces a new Every where a slice of elements in this Every is replaced by another Every
   *
   * @param from the index of the first replaced element 
   * @param that the Every whose elements should replace a slice in this Every
   * @param replaced the number of elements to drop in the original Every
   */
  final def patch[U >: T](from: Int, that: Every[U], replaced: Int): Every[U] = {
    val vec = underlying.patch(from, that.toVector, replaced)
    Every(vec.head, vec.tail: _*)
  }

  /**
   * Iterates over distinct permutations. 
   *
   * 
   * Here's an example:
   * 
   *
   *    * Every('a', 'b', 'b').permutations.toList = Iterator(Many(a, b, b), Many(b, a, b), Many(b, b, a))
   * 
   *
   * @return an iterator which traverses the distinct permutations of this Every.
   */
  final def permutations: Iterator[Every[T]] = {
    val it = underlying.permutations
    it map { v => Every(v.head, v.tail: _*) }
  }

  /**
   * 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 Every such that every element
   *     of the segment satisfies the predicate p. 
   */
  final def prefixLength(p: T => Boolean): Int = underlying.prefixLength(p)

  /**
   * The result of multiplying all the elements of this Every.
   *
   * 
   * This method can be invoked for any Every[T] for which an implicit Numeric[T] exists.
   * 
   *
   * @return the product of all elements
   */
  final def product[U >: T](implicit num: Numeric[U]): U = underlying.product(num)

  /**
   * Reduces the elements of this Every 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 Every.
   */
  final def reduce[U >: T](op: (U, U) => U): U = underlying.reduce(op)

  /**
   * Applies a binary operator to all elements of this Every, 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 Every, going left to right:
   *
   *    * op(...op(op(x_1, x_2), x_3), ..., x_n)
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */
  final def reduceLeft[U >: T](op: (U, T) => U): U = underlying.reduceLeft(op)

  /**
   * Applies a binary operator to all elements of this Every, 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] = underlying.reduceLeftOption(op)

  final def reduceOption[U >: T](op: (U, U) => U): Option[U] = underlying.reduceOption(op)

  /**
   * Applies a binary operator to all elements of this Every, 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 Every, going right to left:
   *
   *    * op(x_1, op(x_2, ... op(x_{n-1}, x_n)...))
   * 
   *
   * 
   * where x₁, ..., x_n are the elements of this Every. 
   * 
   */
  final def reduceRight[U >: T](op: (T, U) => U): U = underlying.reduceRight(op)

  /**
   * Applies a binary operator to all elements of this Every, 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] = underlying.reduceRightOption(op)

  /**
   * Returns new Every wih elements in reverse order.
   *
   * @return a new Every with all elements of this Every in reversed order. 
   */
  final def reverse: Every[T] = {
    val vec = underlying.reverse
    Every(vec.head, vec.tail: _*)
  }

  /**
   * An iterator yielding elements in reverse order.
   *
   * 
   * Note: every.reverseIterator is the same as every.reverse.iterator, but might be more efficient. 
   * 
   *
   * @return an iterator yielding the elements of this Every in reversed order 
   */
  final def reverseIterator: Iterator[T] = underlying.reverseIterator

  /**
   * Builds a new Every by applying a function to all elements of this Every and collecting the results in reverse order.
   *
   * 
   * Note: every.reverseMap(f) is the same as every.reverse.map(f), but might be more efficient. 
   * 
   *
   * @tparam U the element type of the returned Every.
   * @param f the function to apply to each element. 
   * @return a new Every resulting from applying the given function f to each element of this Every
   *     and collecting the results in reverse order. 
   */
  final def reverseMap[U](f: T => U): Every[U] = {
    val vec = underlying.reverseMap(f)
    Every(vec.head, vec.tail: _*)
  }

  /**
   * Checks if the given GenIterable contains the same elements in the same order as this Every.
   *
   * @param that the GenIterable with which to compare
   * @return true, if both this Every and the given GenIterable contain the same elements
   *     in the same order, false otherwise. 
   */
  final def sameElements[U >: T](that: GenIterable[U]): Boolean = underlying.sameElements(that)

  /**
   * Checks if the given Every contains the same elements in the same order as this Every.
   *
   * @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 = underlying.sameElements(that.toVector)

  /**
   * Computes a prefix scan of the elements of this Every.
   *
   * 
   * Note: The neutral element z may be applied more than once. 
   * 
   *
   * 
   * Here are some examples:
   * 
   *
   *    * Every(1, 2, 3).scan(0)(_ + _) == Every(0, 1, 3, 6)
   * Every(1, 2, 3).scan("z")(_ + _.toString) == Every("z", "z1", "z12", "z123")
   * 
   *
   * @tparam U a type parameter for the binary operator, a supertype of T, and the type of the resulting Every.
   * @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 Every containing the prefix scan of the elements in this Every 
   */
  final def scan[U >: T](z: U)(op: (U, U) => U): Every[U] = Every.from(underlying.scan(z)(op)).get

  /**
   * Produces an Every containing cumulative results of applying the operator going left to right.
   *
   * 
   * Here are some examples:
   * 
   *
   *    * Every(1, 2, 3).scanLeft(0)(_ + _) == Every(0, 1, 3, 6)
   * Every(1, 2, 3).scanLeft("z")(_ + _) == Every("z", "z1", "z12", "z123")
   * 
   *
   * @tparam B the result type of the binary operator and type of the resulting Every
   * @param z the start value.
   * @param op the binary operator.
   * @return a new Every containing the intermediate results of inserting op between consecutive elements of this Every,
   *     going left to right, with the start value, z, on the left.
   */ 
  final def scanLeft[B](z: B)(op: (B, T) => B): Every[B] = Every.from(underlying.scanLeft(z)(op)).get

  /**
   * Produces an Every containing cumulative results of applying the operator going right to left.
   *
   * 
   * Here are some examples:
   * 
   *
   *    * Every(1, 2, 3).scanRight(0)(_ + _) == Every(6, 5, 3, 0)
   * Every(1, 2, 3).scanRight("z")(_ + _) == Every("123z", "23z", "3z", "z")
   * 
   *
   * @tparam B the result of the binary operator and type of the resulting Every
   * @param z the start value
   * @param op the binary operator
   * @return a new Every containing the intermediate results of inserting op between consecutive elements of this Every,
   *     going right to left, with the start value, z, on the right.
   */
  final def scanRight[B](z: B)(op: (T, B) => B): Every[B] = Every.from(underlying.scanRight(z)(op)).get

  /**
   * 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 Every starting from index from such that every element of the
   *     segment satisfies the predicate p. 
   */
  final def segmentLength(p: T => Boolean, from: Int): Int = underlying.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 Everys 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): Iterator[Every[T]] = underlying.sliding(size).map(fromNonEmptyVector(_))

  /**
   * 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 Everys 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): Iterator[Every[T]] = underlying.sliding(size, step).map(fromNonEmptyVector(_))

  /**
   * The size of this Every.
   *
   * 
   * Note: length and size yield the same result, which will be >= 1. 
   * 
   *
   * @return the number of elements in this Every. 
   */
  final def size: Int = underlying.size

  /**
   * Sorts this Every 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 Every consisting of the elements of this Every sorted according to the Ordering where
   *    x < y if ord.lt(f(x), f(y)). 
   */
  final def sortBy[U](f: T => U)(implicit ord: math.Ordering[U]): Every[T] = fromNonEmptyVector(underlying.sortBy(f))

  /**
   * Sorts this Every 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 Every as in the original. 
   * 
   *
   * @param the comparison function that tests whether its first argument precedes its second argument in the desired ordering.
   * @return an Every consisting of the elements of this Every sorted according to the comparison function lt.
   */
  final def sortWith(lt: (T, T) => Boolean): Every[T] = fromNonEmptyVector(underlying.sortWith(lt))

  /**
   * Sorts this Every 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 Every 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 an Every consisting of the elements of this Every sorted according to the comparison function lt.
   */
  final def sorted[U >: T](implicit ord: math.Ordering[U]): Every[U] = fromNonEmptyVector(underlying.sorted(ord))

  /**
   * Indicates whether this Every starts with the given GenSeq. 
   *
   * @param that the GenSeq slice to look for in this Every
   * @return true if this Every has that as a prefix, false otherwise.
   */
  final def startsWith[B](that: GenSeq[B]): Boolean = underlying.startsWith(that)

  /**
   * Indicates whether this Every starts with the given GenSeq at the given index. 
   *
   * @param that the GenSeq slice to look for in this Every
   * @param offset the index at which this Every is searched.
   * @return true if this Every has that as a slice at the index offset, false otherwise.
   */
  final def startsWith[B](that: GenSeq[B], offset: Int): Boolean = underlying.startsWith(that, offset)

  /**
   * Indicates whether this Every 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 = underlying.startsWith(that.toVector)

  /**
   * Indicates whether this Every starts with the given Every at the given index. 
   *
   * @param that the Every slice to look for in this Every
   * @param offset the index at which this Every is searched.
   * @return true if this Every has that as a slice at the index offset, false otherwise.
   */
  final def startsWith[B](that: Every[B], offset: Int): Boolean = underlying.startsWith(that.toVector, offset)

  /**
   * The prefix of this object's toString representation.
   *
   * @return a string representation which starts the result of toString applied to this Every, which will be "One"
   * if this Every is a One, or "Many" if it is a Many.
   */
  def stringPrefix: String

  /**
   * The result of summing all the elements of this Every.
   *
   * 
   * This method can be invoked for any Every[T] for which an implicit Numeric[T] exists.
   * 
   *
   * @return the sum of all elements
   */
  final def sum[U >: T](implicit num: Numeric[U]): U = underlying.sum(num)

  import scala.language.higherKinds

  /**
   * Converts this Every into a collection of type Col by copying all elements.
   *
   * @tparam Col the collection type to build.
   * @return a new collection containing all elements of this Every. 
   */
  final def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T @uV]]): Col[T @uV] = underlying.to[Col](cbf)

  /**
   * Converts this Every to an array.
   *
   * @return an array containing all elements of this Every. A ClassTag must be available for the element type of this Every. 
   */ 
  final def toArray[U >: T](implicit classTag: ClassTag[U]): Array[U] = underlying.toArray

  /**
   * Converts this Every to a Vector.
   *
   * @return a Vector containing all elements of this Every. 
   */ 
  final def toVector: Vector[T] = underlying

  /**
   * Converts this Every to a mutable buffer.
   *
   * @return a buffer containing all elements of this Every. 
   */ 
  final def toBuffer[U >: T]: Buffer[U] = underlying.toBuffer

  /**
   * Converts this Every to an immutable IndexedSeq.
   *
   * @return an immutable IndexedSeq containing all elements of this Every. 
   */ 
  final def toIndexedSeq: collection.immutable.IndexedSeq[T] = underlying

  /**
   * Converts this Every to an iterable collection.
   *
   * @return an Iterable containing all elements of this Every. 
   */ 
  final def toIterable: Iterable[T] = underlying.toIterable

  /**
   * Returns an Iterator over the elements in this Every.
   *
   * @return an Iterator containing all elements of this Every. 
   */ 
  final def toIterator: Iterator[T] = underlying.toIterator

  /**
   * Converts this Every to a list.
   *
   * @return a list containing all elements of this Every. 
   */ 
  final def toList: List[T] = underlying.toList

  /**
   * Converts this Every 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 Every. 
   */ 
  final def toMap[K, V](implicit ev: T <:< (K, V)): Map[K, V] = underlying.toMap

  /**
   * Converts this Every to an immutable IndexedSeq.
   *
   * @return an immutable IndexedSeq containing all elements of this Every.
   */ 
  final def toSeq: collection.immutable.Seq[T] = underlying

  /**
   * Converts this Every to a set.
   *
   * @return a set containing all elements of this Every. 
   */ 
  final def toSet[U >: T]: Set[U] = underlying.toSet

  /**
   * Converts this Every to a stream.
   *
   * @return a stream containing all elements of this Every. 
   */ 
  final def toStream: Stream[T] = underlying.toStream

  /**
   * Converts this Every to an unspecified Traversable.
   *
   * @return a Traversable containing all elements of this Every. 
   */ 
  final def toTraversable: Traversable[T] = underlying.toTraversable

  final def transpose[U](implicit ev: T <:< Every[U]): Every[Every[U]] = {
    val asVecs = underlying.map(ev)
    val vec = asVecs.transpose
    fromNonEmptyVector(vec map fromNonEmptyVector)
  }

  /**
   * Produces a new Every that contains all elements of this Every and also all elements of a given Every.
   *
   * 
   * everyX union everyY is equivalent to everyX ++ everyY.
   * 
   *
   * 
   * Another way to express this is that everyX union everyY computes the order-presevring multi-set union
   * of everyX and everyY. This union method is hence a counter-part of diff and intersect that
   * also work on multi-sets.
   * 
   *
   * @param that the Every to add.
   * @return a new Every that contains all elements of this Every followed by all elements of that.
   */
  final def union[U >: T](that: Every[U]): Every[U] = fromNonEmptyVector(underlying union that.toVector)

  /**
   * Produces a new Every that contains all elements of this Every and also all elements of a given GenSeq.
   *
   * 
   * everyX union ys is equivalent to everyX ++ ys.
   * 
   *
   * 
   * Another way to express this is that everyX union ys computes the order-presevring multi-set union
   * of everyX and ys. This union method is hence a counter-part of diff and intersect that
   * also work on multi-sets.
   * 
   *
   * @param that the GenSeq to add.
   * @return a new Every that contains all elements of this Every followed by all elements of that GenSeq.
   */
  final def union[U >: T](that: GenSeq[U])(implicit cbf: CanBuildFrom[Vector[T], U, Vector[U]]): Every[U] = fromNonEmptyVector(underlying.union(that)(cbf))

  /**
   * Converts this Every of pairs into two Everys 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 Every is a pair.
   * @return a pair of Everys, containing the first and second half, respectively, of each element pair of this Every. 
   */
  final def unzip[L, R](implicit asPair: T => (L, R)): (Every[L], Every[R]) = {
    val unzipped = underlying.unzip
    (fromNonEmptyVector(unzipped._1), fromNonEmptyVector(unzipped._2))
  }

  /**
   * Converts this Every of triples into three Everys 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 Every is a triple.
   * @return a triple of Everys, containing the first, second, and third member, respectively, of each element triple of this Every. 
   */
  final def unzip3[L, M, R](implicit asTriple: T => (L, M, R)): (Every[L], Every[M], Every[R]) = {
    val unzipped = underlying.unzip3
    (fromNonEmptyVector(unzipped._1), fromNonEmptyVector(unzipped._2), fromNonEmptyVector(unzipped._3))
  }

  /**
   * A copy of this Every with one single replaced element.
   *
   * @param idx the position of the replacement
   * @param elem the replacing element
   * @return a copy of this Every with the element at position idx replaced by elem. 
   */
  final def updated[U >: T](idx: Int, elem: U): Every[U] = fromNonEmptyVector(underlying.updated(idx, elem))

  /**
   * Returns an Every formed from this Every 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 Every is shorter than that Iterable.
   * @param thatElem the element to be used to fill up the result if that Iterable is shorter than this Every.
   * @return a new Every containing pairs consisting of corresponding elements of this Every and that. The
   *     length of the returned collection is the maximum of the lengths of this Every and that. If this Every
   *     is shorter than that, thisElem values are used to pad the result. If that is shorter than this
   *     Every, thatElem values are used to pad the result. 
   */
  final def zipAll[O, U >: T](other: collection.Iterable[O], thisElem: U, otherElem: O): Every[(U, O)] =
    Every.from(underlying.zipAll(other, thisElem, otherElem)).get

  /**
   * Zips this Every  with its indices.
   *
   * @return A new Every containing pairs consisting of all elements of this Every paired with their index. Indices start at 0.
   */
  final def zipWithIndex: Every[(T, Int)] = fromNonEmptyVector(underlying.zipWithIndex)
}

/**
 * Companion object for abstract class Every.
 */
object Every {

  /**
   * Constructs a new Every given at least one element.
   *
   * @tparam T the type of the element contained in the new Every
   * @param firstElement the first element (with index 0) contained in this Every
   * @param otherElements a varargs of zero or more other elements (with index 1, 2, 3, ...) contained in this Every
   */
  def apply[T](firstElement: T, otherElements: T*): Every[T] = 
    if (otherElements.isEmpty) One(firstElement) else Many(firstElement, otherElements.head, otherElements.tail: _*)

  /**
   * Variable argument extractor for Everys.
   *
   * @param every: the Every containing the elements to extract
   * @return an Seq containing this Everys elements, wrapped in a Some 
   */
  def unapplySeq[T](every: Every[T]): Option[Seq[T]] = Some(every.toVector)

/*
  // TODO: Figure out how to get case Every() to not compile
  def unapplySeq[T](every: Every[T]): Option[(T, Seq[T])] = Some(every.head, every.tail)
*/

  /**
   * Optionally construct an Every containing the elements, if any, of a given GenSeq.
   *
   * @param seq the GenSeq with which to construct an Every
   * @return an Every 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]): Option[Every[T]] =
    seq.headOption match {
      case None => None
      case Some(first) =>
        seq.tail.headOption match {
          case None => Some(One(first))
          case Some(second) => Some(Many(first, second, seq.tail.tail.seq: _*)) 
        }
    }

  import scala.language.implicitConversions

  // Can be flattened: Vector(Every(1, 2, 3), Every(1, 2, 3)).flatten shouldBe Vector(1, 2, 3, 1, 2, 3)
  /**
   * Implicit conversion from Every to immutable IndexedSeq.
   *
   * 
   * One use case for this implicit conversion is to enable GenSeq[Every]s to be flattened.
   * Here's an example:
   * 
   *
   *    * scala> Vector(Every(1, 2, 3), Every(3, 4), Every(5, 6, 7, 8)).flatten
   * res0: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 3, 4, 5, 6, 7, 8)
   * 
   *
   * @param every the Every to convert to a GenTraversableOnce
   * @return an immutable IndexedSeq containing the elements, in order, of this Every
   */
  implicit def everyToGenTraversableOnce[E](every: Every[E]): scala.collection.immutable.IndexedSeq[E] = every.toVector

  private def fromNonEmptyVector[E](vec: Vector[E]): Every[E] = Every(vec.head, vec.tail: _*)
}

/**
 * An Every that contains exactly one element.
 *
 * 
 * For more information and examples, see the main documentation for superclass Every.
 * 
 *
 * @tparam T the type of the element contained in this One
 * @param loneElement the lone element contained in this One
 */
final case class One[+T](loneElement: T) extends Every[T](Vector(loneElement)) {

  /**
   * Returns this One with the type widened to Every.
   *
   * @return this One as an Every
   */
  def asEvery: Every[T] = this
  def ++[U >: T](other: Every[U]): Many[U] = Many(loneElement, other.toVector.head, other.toVector.tail: _*)
  def ++[U >: T](other: GenTraversableOnce[U]): Every[U] =
    if (other.isEmpty) this else Many(loneElement, other.toVector.head, other.toVector.tail: _*)
  def :+[U >: T](element: U): Many[U] = Many(loneElement, element)

  /**
   * Returns "One", the prefix of this object's toString representation.
   *
   * @return the string "One"
   */
  def stringPrefix: String = "One"

  /**
   * Returns a string representation of this One.
   *
   * @return the string "One" followed by the result of invoking toString on
   *   this One's lone element, surrounded by parentheses.
   */
  override def toString: String = "One(" + loneElement + ")"
}

/**
 * An Every that contains two or more elements.
 *
 * 
 * For more information and examples, see the main documentation for superclass Every.
 * 
 *
 * @tparam T the type of the element contained in this Many
 * @param firstElement the first element (with index 0) contained in this Many
 * @param secondElement the second element (with index 1) contained in this Many
 * @param otherElements a varargs of zero or more other elements (with index 2, 3, ...) contained in this Many
 */
final case class Many[+T](firstElement: T, secondElement: T, otherElements: T*) extends Every[T](firstElement +: secondElement +: Vector(otherElements: _*)) {

  /**
   * Returns this Many with the type widened to Every.
   *
   * @return this Many as an Every
   */
  def asEvery: Every[T] = this
  def ++[U >: T](other: Every[U]): Many[U] = Many(firstElement, secondElement, (otherElements.toVector ++ other.toVector): _*)
  def ++[U >: T](other: GenTraversableOnce[U]): Every[U] =
    if (other.isEmpty) this else Many(firstElement, secondElement, otherElements ++ other.toVector: _*)
  def :+[U >: T](element: U): Many[U] = Many(firstElement, secondElement, (otherElements :+ element): _*)

  /**
   * Returns "Many", the prefix of this object's toString representation.
   *
   * @return the string "Many"
   */
  def stringPrefix: String = "Many"

  /**
   * Returns a string representation of this Many.
   *
   * @return the string "Many" followed by the result of invoking toString on
   *   this Many's elements, surrounded by parentheses.
   */
  override def toString: String = "Many(" + toVector.mkString(", ") + ")"
}
org.scalautils.Every.scala Maven / Gradle / Ivy

Constructing `Every`s

Working with `Every`s

Motivation for `Every`s
