implicit final class Seq_[A] extends AnyVal
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Seq_
- AnyVal
- Any
- Hide All
- Show All
Visibility
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- Any
-
final
def
##(): Int
- Definition Classes
- Any
- def #@@: String
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- Any
- def @@: String
- def IQR(implicit num: Numeric[A]): Double
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- 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](f: (A) ⇒ B)(implicit arg0: Ordering[B]): Seq[A]
- val coll: Seq[A]
- def containsAllOf(that: Seq[A]): Boolean
- def countBySelf: List[(A, Int)]
- def data: Data[A]
-
def
debug: Seq[A]
- Annotations
- @fordevonly( message = ... )
- 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
getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- 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
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isSorted(implicit ev: Ordering[A]): Boolean
- def isSortedBy[B](f: (A) ⇒ B)(implicit arg0: Ordering[B]): Boolean
- def join: String
- def join(sep: aptus.Separator): 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](pred: (A) ⇒ Boolean)(f: (A) ⇒ B): Seq[A]
- def mapIf[B <: A](test: 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
- 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](f: (A) ⇒ B)(implicit arg0: Ordering[B]): Seq[A]
- def roll(n: Int): Seq[A]
- def section(n: Int)(title: String): String
- def section(title: String): String
- def section: String
- def section2(title: String): String
- def section2: 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(mean: Double)(implicit num: Numeric[A]): Double
- def stdev(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
toString(): String
- Definition Classes
- Any
- def toTreeMap[K, V](implicit ev: <:<[A, (K, V)], ord: Ordering[K]): TreeMap[K, V]
- def writeFileLines(path: aptus.FilePath): aptus.FilePath
- def zipSameSize[B](that: Seq[B], debug: (Seq[_]) ⇒ Any): Seq[(A, B)]
- def zipSameSize[B](that: Seq[B]): Seq[(A, B)]
- def zipWithIsFirst: Seq[(A, Boolean)]
- def zipWithIsLast: Seq[(A, Boolean)]
- def zipWithRank: Seq[(A, aptus.Rank)]