OpenStrat
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
OpenStrat/ostrat/Sequ

Sequ

ostrat.Sequ
trait Sequ[+A] extends SeqNoName[A]

This the base trait for all efficient sequence collections based on Array like classes, Arrays, ArrayBuffers etc. The final classes compile time wrap the platform Array and buffer classes. So currently there are just two classes for each type A, An ArrImut that wraps a standard immutable Array to produce an immutable array, and a ArrBuff that wraps an ArrayBuffer. Currently this just in a standard ArrayBuffer. Where A is a compound value types or an AnyVal type.

Attributes

Graph
Supertypes
trait SeqNoName[A]
trait SeqLike[A]
class Any
Known subtypes
trait Arr[A]
trait ArrNoParam[A]
class AnyArr
class BoolArr
class CharArr
class DblArr
class FloatArr
class IntArr
class LongArr
class StrArr
trait ValueNArr[A]
trait DblNArr[A]
trait Dbl1Arr[A]
class Angles
trait Dbl2Arr[A]
class MyDbl2s
class Pt2Arr
class Vec2MArr
class Vec2s
trait Dbl3Arr[A]
class Pt3Arr
class PtM3Arr
trait Dbl4Arr[A]
trait LineSegLikeDbl4Arr[VT, A]
trait Dbl5Arr[A]
trait Dbl6Arr[A]
trait LineSegLikeDbl6Arr[VT, A]
trait Dbl7Arr[A]
trait LineSegLikeDblNArr[VT, A]
trait IntNArr[A]
trait Int1Arr[A]
class Colours
class HStepArr
class HVDirnArr
class SqDirnArr
trait Int2Arr[A]
class HCenArr
class HCoordArr
class HSideArr
class HVertArr
class SqCens
class SqVertArr
trait Int3Arr[A]
trait Int4Arr[A]
trait Int5Arr[A]
trait Int6Arr[A]
trait LongNArr[A]
trait Long1Arr[A]
trait ArrayDblArr[A]
class MultipleArr[A]
class OptRefArr[A]
trait PairArr[A1, A1Arr, A2, A]
trait PairNoA1PramArr[A1, A1Arr, A2, A]
trait ArrayIntBackedPairArr[A1, ArrA1, A2, A]
trait SeqLikeIntNPairArr[A1E, A1, ArrA1, A2, A]
trait PolygonLikeIntNPairArr[A1V, A1, ArrA1, A2, A]
trait DblNPairArr[A1, ArrA1, A2, A]
trait Dbl2PairArr[A1, ArrA1, A2, A]
trait PointDbl2PairArr[A1, ArrA1, A2, A]
class Pt2PairArr[A2]
class LatLongPairArr[A2]
trait Dbl3PairArr[A1, ArrA1, A2, A]
trait PointDbl3PairArr[A1, ArrA1, A2, A]
class PtM3PairArr[A2]
trait Dbl4PairArr[A1, ArrA1, A2, A]
trait LineSegLikeDbl4PairArr[VT, A1, ArrA1, A2, A]
class LineSegPairArr[A2]
trait LineSegLikeDblNPairArr[VT, A1, ArrA1, A2, A]
trait PointDblNPairArr[A1, ArrA1, A2, A]
trait IntNPairArr[A1, ArrA1, A2, A]
trait Int1PairArr[A1, ArrA1, A2, A]
class HStepPairArr[A2]
trait Int2PairArr[A1, ArrA1, A2, A]
class HCenPairArr[A2]
trait Int3PairArr[A1, ArrA1, A2, A]
class HCenStepPairArr[A2]
trait Int4PairArr[A1, ArrA1, A2, A]
trait LineSegLikeInt4PairArr[VT, A1, ArrA1, A2, A]
trait LineSegLikeIntNPairArr[VT, A1, ArrA1, A2, A]
trait SeqLikePairArr[A1E, A1, A1Arr, A2, A]
trait SeqLikeDblNPairArr[A1E, A1, A1Arr, A2, A]
trait PolygonLikeDblNPairArr[A1V, A1, ArrA1, A2, A]
trait PolygonLikeDbl2PairArr[A1V, A1, ArrA1, A2, A]
class PolygonPairArr[A2]
trait PolygonLikePairArr[A1V, A1, A1Arr, A2, A]
class StrPairArr[A2]
trait LineSegLikePairArr[VT, A1, ArrA1, A2, A]
trait PointPairArr[A1, ArrA1, A2, A]
class RPairArr[A1, A2]
class RArr[A]
trait LineSegLikeArr[VT, A]
trait Buff[A]
class AnyBuff
trait ArrayDblBuff[A]
trait ArrayIntBuff[A]
class DblBuff
class FloatBuff
class IntBuff
class LongBuff
class MultipleBuff[A]
trait PairBuff[B1, B2, B]
trait DblNPairBuff[B1, B2, B]
trait Dbl2PairBuff[A1, A2, A]
class Pt2PairBuff[A2]
class LatLongPairBuff[B2]
trait Dbl3PairBuff[B1, B2, B]
class PtM3PairBuff[B2]
trait Dbl4PairBuff[B1, B2, B]
class LineSegPairBuff[B2]
trait IntNPairBuff[B1, B2, B]
trait Int1PairBuff[A1, A2, A]
class HStepPairBuff[A2]
trait Int2PairBuff[A1, A2, A]
class HCenPairBuff[B2]
trait Int3PairBuff[A1, A2, A]
trait Int4PairBuff[B1, B2, B]
class RPairBuff[B1, B2]
trait SeqLikePairBuff[A1E, A1, A2, A]
trait SeqLikeDblNPairBuff[B1E, B1, B2, B]
class PolygonPairBuff[A2]
trait SeqLikeIntNPairBuff[B1E, B1, B2, B]
trait LineSegLikePairBuff[VT, B1, B2, B]
class RBuff[A]
trait ValueNBuff[A]
trait DblNBuff[A]
trait Dbl2Buff[B]
class MinesBuff
class BuffVec2
class Pt2Buff
class Vec2MBuff
trait Dbl3Buff[A]
class Pt3Buff
class PtM3Buff
trait Dbl4Buff[A]
trait Dbl5Buff[A]
trait Dbl6Buff[A]
trait IntNBuff[A]
trait Int1Buff[A]
class HStepBuff
trait Int2Buff[A]
class HCenBuff
class HSideBuff
class HVertBuff
class SqCenBuff
trait Int3Buff[A]
trait Int4Buff[A]
trait Int5Buff[A]
trait Int6Buff[A]
trait LongNBuff[A]
trait Long1Buff[A, ArrA]

Members list

Concise view

Type members

Types

type ThisT <: Sequ[A]

The final type of this object.

The final type of this object.

Attributes

Value members

Abstract methods

def apply(index: Int): A

Accesses the defining sequence element by a 0 based index.

Accesses the defining sequence element by a 0 based index.

Attributes

def length: Int

The length of this Sequence. This will have the same value as the dataLength property inherited from SeqLike[A].

The length of this Sequence. This will have the same value as the dataLength property inherited from SeqLike[A].

Attributes

Concrete methods

def collect[B, BB <: Arr[B]](pf: PartialFunction[A, B])(implicit ev: ArrMapBuilder[B, BB]): BB

Collects values of B by applying partial function to only those elements of A, for which the PartialFunction is defined.

Collects values of B by applying partial function to only those elements of A, for which the PartialFunction is defined.

Attributes

def contains[A1 >: A](elem: A1): Boolean

Returns true if this sequence contains a value equal to the parameter value. The passed vvalue for equivlence testing an be a super type of the collection type.

Returns true if this sequence contains a value equal to the parameter value. The passed vvalue for equivlence testing an be a super type of the collection type.

Attributes

def cycleGet(index: Int): A

Applies an index to this ArrayLike collection which cycles back to element 0, when it reaches the end of the collection. Accepts even negative integers as an index value without throwing an exception.

Applies an index to this ArrayLike collection which cycles back to element 0, when it reaches the end of the collection. Accepts even negative integers as an index value without throwing an exception.

Attributes

def eMap[B, ArrB <: Arr[B]](f: A => EMon[B])(implicit ev: ArrMapBuilder[B, ArrB]): EMon[ArrB]
def eMapList[B](f: A => EMon[B]): EMon[List[B]]
override def elemsStr: String

The element String allows the composition of toString for the whole collection. The syntax of the output will be reworked.

The element String allows the composition of toString for the whole collection. The syntax of the output will be reworked.

Attributes

Definition Classes
def empty: Boolean

Is this sequence empty?

Is this sequence empty?

Attributes

def exists(f: A => Boolean): Boolean

Tests if the condition exists for any element of this sequence.

Tests if the condition exists for any element of this sequence.

Attributes

def existsCount(f: A => Boolean): Int

Counts the number of elements that fulfil the condition A => Boolean

Counts the number of elements that fulfil the condition A => Boolean

Attributes

def fMax[B](defaultValue: B)(f: A => B)(implicit cmp: Ordering[B]): B

Gives the maximum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Gives the maximum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Attributes

def fMin[B](defaultValue: B)(f: A => B)(implicit cmp: Ordering[B]): B

Gives the minimum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Gives the minimum value of type B, produced by applying the function from A to B on each element of this collection, or the default value if the collection is empty.

Attributes

def filter[ArrA <: Arr[A]](f: A => Boolean)(implicit ev: ArrMapBuilder[A, ArrA]): ArrA
def filterNot[ArrA <: Arr[A]](f: A => Boolean)(implicit ev: ArrMapBuilder[A, ArrA]): ArrA
def filterToList(f: A => Boolean): List[A]
def find(f: A => Boolean): Option[A]

Tries to find te first element of this sequence conforming to the predicate.

Tries to find te first element of this sequence conforming to the predicate.

Attributes

def flatMap[ArrB <: Arr[_]](f: A => ArrB)(implicit ev: ArrFlatBuilder[ArrB]): ArrB

Specialised flatMap to a Arr.

Specialised flatMap to a Arr.

Attributes

def flatToIterableMap[B, ArrB <: Arr[B]](f: A => Iterable[B])(implicit ev: ArrMapBuilder[B, ArrB]): ArrB

Maps over a function from A to any Iterable and flattens the result into an RArr[A].

Maps over a function from A to any Iterable and flattens the result into an RArr[A].

Attributes

def foldHeadTail[B](initVal: B)(f: A => B, fAcc: (B, B) => B): B
def foldLeft[B](initial: B)(f: (B, A) => B): B

Folds over this sequence starting with the initial value

Folds over this sequence starting with the initial value

Attributes

def foldLeft[B](f: (B, A) => B)(implicit ev: DefaultValue[B]): B
def foldStr(f: A => String, seperator: String): String

Folds left to a String accumulator with an initial value of the empty string. The first parameter is a function from A tp String. The second parameter is a separator String the 2nd and subsequent A => String values.

Folds left to a String accumulator with an initial value of the empty string. The first parameter is a function from A tp String. The second parameter is a separator String the 2nd and subsequent A => String values.

Attributes

def forAll(p: A => Boolean): Boolean

Returns true if the predicate holds true for all values of this sequence, else retruns false.

Returns true if the predicate holds true for all values of this sequence, else retruns false.

Attributes

override def foreach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

Definition Classes
def head: A

The first element of this sequence.

The first element of this sequence.

Attributes

def headFold[B](noHead: => B)(ifHead: A => B): B

Folds over the non existence / existence of a head element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the head element.

Folds over the non existence / existence of a head element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the head element.

Attributes

def headFoldToString[B](noHead: => String): String

Folds over the non existence / existence of a head element. If the sequence is nonEmpty applies toString to head element else returns the noHead parameter string.

Folds over the non existence / existence of a head element. If the sequence is nonEmpty applies toString to head element else returns the noHead parameter string.

Attributes

def iFlatMap[ArrB <: Arr[_]](f: (Int, A) => ArrB)(implicit build: ArrFlatBuilder[ArrB]): ArrB

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

def iFlatMap[ArrB <: Arr[_]](iInit: Int)(f: (Int, A) => ArrB)(implicit build: ArrFlatBuilder[ArrB]): ArrB

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element flatMap. Applies the parameter function to the index and each respective element of this sequence. The function returns a Arr of elements of type B and the method as a whole flattens and then returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

def iForAll(p: (Int, A) => Boolean): Boolean

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

def iForeach[U](f: (Int, A) => U): Unit

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

def iForeach[U](startIndex: Int)(f: (Int, A) => U): Unit

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Index with foreach. Performs a side effecting function on the index and each element of this sequence. It takes a function as a parameter. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

def iMap[B, ArrB <: Arr[B]](f: (Int, A) => B)(implicit ev: ArrMapBuilder[B, ArrB]): ArrB

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. This method should be overridden in sub classes.

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. This method should be overridden in sub classes.

Attributes

def iMap[B, ArrB <: Arr[B]](startindex: Int)(f: (Int, A) => B)(implicit ev: ArrMapBuilder[B, ArrB]): ArrB

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Index with element map. Applies the parameter function to the index and each respective element of this sequence. The function returns an element of type B and the method as a whole returns the specialised Arr of type B. The method has 2 versions / name overloads. The default start for the index is 0 if just the function parameter is passed. The second version name overload takes an Int for the first parameter list, to set the start value of the index. Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature. Ideally this method should be overridden in sub classes.

Attributes

def ifHead[U](f: A => U): Unit

if this Sequ is nonEmpty performs the side effecting function on the head. If empty procedure is applied.

if this Sequ is nonEmpty performs the side effecting function on the head. If empty procedure is applied.

Attributes

def indexMapTo[B, BB <: SeqLike[B]](iFrom: Int, iTo: Int, iStep: Int)(f: A => B)(implicit build: SeqLikeMapBuilder[B, BB]): BB

A map operation on the range of indexed values, where the return type of the SeqLike is explicitly given by the the first parameter.

A map operation on the range of indexed values, where the return type of the SeqLike is explicitly given by the the first parameter.

Attributes

def indexOf(elem: A): Int
def indexToForeach[U](iFrom: Int, iTo: Int, iStep: Int)(f: A => U): Unit

Performs a side effecting function on each element of the range of index values for this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of the range of index values for this sequence in order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

def indexWhere(f: A => Boolean): Int

Return the index of the first element where predicate is true, or -1 if predicate not true forall.

Return the index of the first element where predicate is true, or -1 if predicate not true forall.

Attributes

def initForeach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence excluding the last. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence excluding the last. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

def last: A

The last element of this sequence.

The last element of this sequence.

Attributes

def lastFold[B](noLast: => B)(ifLast: A => B): B

Folds over the non existence / existence of a last element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the last element.

Folds over the non existence / existence of a last element. The first parameter is a value for an empty sequence, the second parameter passed as a separate parameter list is a function on the last element.

Attributes

def lastOpt: Option[A]
def lenStr: String

Just a handy short cut to give the length of this collection as a string.

Just a handy short cut to give the length of this collection as a string.

Attributes

def map[B, ArrB <: Arr[B]](f: A => B)(implicit build: ArrMapBuilder[B, ArrB]): ArrB

Specialised map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Specialised map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Attributes

def map2To1[B, ArrB <: Arr[B]](f: (A, A) => B)(implicit ev: ArrMapBuilder[B, ArrB]): ArrB

map 2 elements of A to 1 element of B. Ignores the last element on a collection of odd numbered length.

map 2 elements of A to 1 element of B. Ignores the last element on a collection of odd numbered length.

Attributes

def mapArray[B](f: A => B)(implicit ct: ClassTag[B]): Array[B]

Maps to an Array.

Maps to an Array.

Attributes

def mapCollectGoods[B, BB <: Arr[B]](f: A => EMon[B])(implicit ev: ArrMapBuilder[B, BB]): BB

maps from A to EMon[B], collects the good values.

maps from A to EMon[B], collects the good values.

Attributes

def mapList[B <: AnyRef](f: A => B): List[B]

maps ValueProduct collection to List

maps ValueProduct collection to List

Attributes

def mapPair[B1, ArrB1 <: Arr[B1], B2, B <: PairNoA1ParamElem[B1, B2], ArrB <: PairNoA1PramArr[B1, ArrB1, B2, B]](f1: A => B1)(f2: A => B2)(implicit build: PairArrMapBuilder[B1, ArrB1, B2, B, ArrB]): ArrB

Specialised map to an immutable PairNoA1PramArr of B. Applies the supplied function to every element of this sequence.

Specialised map to an immutable PairNoA1PramArr of B. Applies the supplied function to every element of this sequence.

Attributes

def mapTo[B, BB <: SeqLike[B]](build: SeqLikeMapBuilder[B, BB])(f: A => B): BB

A map operation where the return type of the SeqLike is explicitly given by the the first parameter.

A map operation where the return type of the SeqLike is explicitly given by the the first parameter.

Attributes

def mapUniqueGood[B](f: A => EMon[B]): EMon[B]

Takes a function from A to EMon[B]. If the function applied to eqch element produces a single Good, it is returned else returns Bad.

Takes a function from A to EMon[B]. If the function applied to eqch element produces a single Good, it is returned else returns Bad.

Attributes

def mapWithAcc[B, ArrB <: Arr[B], C](initC: C)(f: (C, A) => (B, C))(implicit ev: ArrMapBuilder[B, ArrB]): ArrB
def max[B >: A](implicit ord: Ordering[B]): A

Gives the maximum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Gives the maximum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Attributes

def min[B >: A](implicit ord: Ordering[B]): A

Gives the minimum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Gives the minimum value of this sequence according to the implicit ordering type class instance, which can be passed explicitly.

Attributes

def mkString(separator: String): String

Not sure about this method.

Not sure about this method.

Attributes

def nonEmpty: Boolean

Is this sequence non empty?

Is this sequence non empty?

Attributes

def optMap[B, ArrB <: Arr[B]](f: A => Option[B])(implicit build: ArrMapBuilder[B, ArrB]): ArrB

Specialised opt map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Specialised opt map to an immutable Arr of B. Applies the supplied function to every element of this sequence.

Attributes

def partition[ArrA <: Arr[A]](f: A => Boolean)(implicit build: ArrMapBuilder[A, ArrA]): (ArrA, ArrA)
def returnThis: ThisT

Method for keeping the typer happy when returning this as an instance of ThisT.

Method for keeping the typer happy when returning this as an instance of ThisT.

Attributes

def reverseForeach[U](f: A => U): Unit

Performs a side effecting function on each element of this sequence in reverse order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Performs a side effecting function on each element of this sequence in reverse order. The function may return Unit. If it does return a non Unit value it is discarded. The [U] type parameter is there just to avoid warnings about discarded values and can be ignored by method users.

Attributes

def reverseIForeach[U](f: (Int, A) => U): Unit

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Note the function signature follows the foreach based convention of putting the collection element 2nd or last as seen for example in fold methods' (accumulator, element) => B signature.

Attributes

final inline override def ssForeach[U](f: A => U): Unit

Performs a side effecting function on each element of the specifying sequence in order.

Performs a side effecting function on each element of the specifying sequence in order.

Attributes

Definition Classes
def sum(implicit ev: Sumable[A]): A
def sumBy(f: A => Int): Int

Sums aaccumulating the results of the A => Int function.

Sums aaccumulating the results of the A => Int function.

Attributes

def tailForeach[U](f: A => U): Unit

Foreachs over the tail of this sequence.

Foreachs over the tail of this sequence.

Attributes

def tailfold[B](initial: B)(f: (B, A) => B): B

foldLeft over the tail of this sequence.

foldLeft over the tail of this sequence.

Attributes

def toList: List[A]

Converts this SeqGen to a list.

Converts this SeqGen to a list.

Attributes

def toStrsCommaFold(fToStr: A => String): String
def toStrsCommaParenth(fToStr: A => String): String
def toStrsSemiFold(fToStr: A => String): String
def toStrsSemiParenth(fToStr: A => String): String
def zipMap[B, C, ArrC <: Arr[C]](operator: Sequ[B])(f: (A, B) => C)(implicit ev: ArrMapBuilder[C, ArrC]): ArrC

Takes a second collection as a parameter and zips the elements of this collection and the operand collection and applies the specialised map function from type A and type B to type C.

Takes a second collection as a parameter and zips the elements of this collection and the operand collection and applies the specialised map function from type A and type B to type C.

Attributes

def zipMap2[B, C, D, ArrD <: Arr[D]](operator1: Sequ[B], operator2: Sequ[C])(f: (A, B, C) => D)(implicit ev: ArrMapBuilder[D, ArrD]): ArrD

Takes a second collection and third collections as parameters and zips the elements of this collection and the operand collections and applies the specialised map function from type A and type B and type C to type D.

Takes a second collection and third collections as parameters and zips the elements of this collection and the operand collections and applies the specialised map function from type A and type B and type C to type D.

Attributes

Inherited methods

def fElemStr: (A) => String

Attributes

Inherited from:
SeqLike
override def toString: String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns:

a string representation of the object.

Definition Classes
SeqLike -> Any
Inherited from:
SeqLike
def typeStr: String

String specifying the type of this object.

String specifying the type of this object.

Attributes

Inherited from:
SeqLike
def unsafeSetElem(i: Int, newElem: A): Unit

Sets / mutates an element in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Sets / mutates an element in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Attributes

Inherited from:
SeqLike
def unsafeSetElems(index: Int, elems: A*): Unit

Sets / mutates elements in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Sets / mutates elements in the Arr. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Attributes

Inherited from:
SeqLike
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL