aptus-core
API
Generated with
aptus-core/aptus/Seq_

Seq_

aptus.`package`.Seq_
final implicit class Seq_[A](val coll: Seq[A]) extends AnyVal

Attributes

Graph
Supertypes
class AnyVal
trait Matchable
class Any

Members list

Value members

Concrete methods

def #@@: String
def @@: String
def IQR(implicit num: Numeric[A]): Double
def assertDistinct(): Seq[A]
def assertDistinctBy[B](f: A => B): Seq[A]
def assertNonEmpty(): Seq[A]
def assertSorted()(implicit ord: Ordering[A]): Seq[A]
def assertSortedBy[B : Ordering](f: A => B): Seq[A]
def containsAllOf(that: Seq[A]): Boolean
def countBySelf: List[(A, Int)]
def data: Data[A]
def debug: Seq[A]
def distinctByAdjacency: Seq[A]
def drop(n: Option[Int]): Seq[A]
def duplicates: Seq[A]
def filterBy[B](p: B => Boolean)(f: A => B): Seq[A]
def filterByNot[B](p: B => Boolean)(f: A => B): Seq[A]
def force: Force[A]
def forceStats(implicit num: Numeric[A]): DoubleStats
def groupByKey[K, V](implicit ev: A <:< (K, V)): Map[K, Seq[V]]
def groupByKeyWithListMap[K, V](implicit ev: A <:< (K, V)): ListMap[K, Seq[V]]
def ifEmptyThenError(msg: String): Seq[A]
def ifOneElement[B](ifOne: A => B, otherwise: (Seq[A]) => B): B
def ifOneElementOpt: Option[A]
def ifOneElementOrElse(errorMessage: (Seq[A]) => Any): A
def initOption: Option[Seq[A]]
def innerJoin[B](that: Seq[B]): InnerJoin[A, B]
def isDisjointWith[B >: A](that: Iterable[B]): Boolean
def isDistinct: Boolean
def isSorted(implicit ev: Ordering[A]): Boolean
def isSortedBy[B : Ordering](f: A => B): Boolean
def join(sep: Separator): String
def join: String
def joinln: String
def joinlnln: String
def jointab: String
def mapAssociateLeft[K](f: A => K): Seq[(K, A)]
def mapAssociateRight[V](f: A => V): Seq[(A, V)]
def mapIf[B <: A](test: Boolean)(f: A => B): Seq[A]
def mapIf[B <: A](pred: A => Boolean)(f: A => B): Seq[A]
def mean(implicit num: Numeric[A]): Double
def median(implicit num: Numeric[A]): Double
def minMax(implicit num: Numeric[A]): (A, A)
def percentile(n: Double)(implicit num: Numeric[A]): Double
def pivot[K, V](implicit ev: A <:< (K, V)): ListMap[V, Seq[K]]

no prior grouping of key/values

no prior grouping of key/values

Attributes

def range[B >: A](implicit cmp: Ordering[B], num: Numeric[B]): B
def requireDistinct(): Seq[A]
def requireDistinctBy[B](f: A => B): Seq[A]
def requireNonEmpty(): Seq[A]
def requireSorted()(implicit ord: Ordering[A]): Seq[A]
def requireSortedBy[B : Ordering](f: A => B): Seq[A]
def roll(n: Int): Seq[A]
def section: String
def section(title: String): String
def section(n: Int)(title: String): String
def section2: String
def section2(title: String): String
def slidingList(n: Int): List[List[A]]
def slidingPairs: List[(A, A)]
def slidingPairsWithNext: Seq[(A, Option[A])]
def slidingPairsWithPrevious: Seq[(Option[A], A)]
def splitAtHead: (A, Seq[A])
def splitAtLast: (Seq[A], A)
def statsOpt(implicit num: Numeric[A]): Option[DoubleStats]
def stdev(implicit num: Numeric[A]): Double
def stdev(mean: Double)(implicit num: Numeric[A]): Double
def systemCall()(implicit ev: A =:= String): String
def systemCallWithErrorRedirection()(implicit ev: A =:= String): String
def tailOption: Option[Seq[A]]
def take(n: Option[Int]): Seq[A]
def toListMap[K, V](implicit ev: A <:< (K, V)): ListMap[K, V]
def toMutableMap[K, V](implicit ev: A <:< (K, V)): HashMap[K, V]
def toOptionalSeq[B](implicit ev: A <:< Option[B]): Option[Seq[B]]
def toTreeMap[K, V](implicit ev: A <:< (K, V), ord: Ordering[K]): TreeMap[K, V]
def zipSameSize[B](that: Seq[B]): Seq[(A, B)]
def zipSameSize[B](that: Seq[B], debug: (Seq[_]) => Any): Seq[(A, B)]
def zipWithIsFirst: Seq[(A, Boolean)]
def zipWithIsLast: Seq[(A, Boolean)]
def zipWithRank: Seq[(A, Rank)]

Concrete fields

val coll: Seq[A]
Generated with