SeqImut

trait SeqImut[+A] extends SeqGen[A] with DataImut[A]

Base trait for specialised immutable Arrays. "Arr" is the prescript for all immutable collection classes backed by underlying Arrays. The final classes extend AnyVal using standard Java /Javascript Arrays for their underlying storage. A lot of the time this is a compile time wrapper with no boxing run cost.

trait DataImut[A]
trait SeqGen[A]
trait DataGen[A]
class Any
class Arr[A]
trait ArrArrayDbl[A]
trait ArrValueNs[A]
trait ArrDblNs[A]
trait ArrDbl1s[A]
class Angles
trait ArrDbl2s[A]
class MyDbl2s
class PolygonM
class Pt2s
class Vec2MArr
class LatLongs
trait ArrDbl3s[A]
class Pt3s
trait ArrDbl4s[A]
class LineSegs
trait ArrDbl5s[A]
trait ArrDbl6s[A]
trait ArrDbl7s[A]
trait ArrIntNs[A]
trait ArrInt1s[A]
class Colours
class HSteps
trait ArrInt2s[A]
class Coods
class Roords
class HCens
class HCoords
class HSides
class HVerts
trait ArrInt4s[A]
class CoodLines
trait ArrLongNs[A]
trait ArrLong1s[A]
class Booleans
class Chars
class Dbls
class Floats
class Ints
class Longs
class Strings

Type members

Types

override
type ThisT <: SeqImut[A]

Value members

Concrete methods

def find(f: A => Boolean): Option[A]
def modifyWhere(pred: A => Boolean, fNewValue: A => A): ThisT

Replaces all instances of the old value that fulfill predicate with the new value.

Replaces all instances of the old value that fulfill predicate with the new value.

def removeFirst(f: A => Boolean): ThisT

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.

def replace(oldValue: A, newValue: A): ThisT

Replaces all instances of the old value with the new value.

Replaces all instances of the old value with the new value.

def replaceWhere(pred: A => Boolean, newValue: A): ThisT

Replaces all instances of the old value that fulfill predicate with the new value.

Replaces all instances of the old value that fulfill predicate with the new value.

def unsafeSetElemSeq(index: Int, elems: Iterable[A]): Unit
def unsafeSetHead(value: A): Unit

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

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

def unsafeSetLast(value: A): Unit

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

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

Inherited methods

@inline
def apply(index: Int): A

apply method accesses the individual elements of the sequence by 0 based index.

apply method accesses the individual elements of the sequence by 0 based index.

Inherited from
SeqGen
def collect[B, BB <: SeqImut[B]](pf: PartialFunction[A, B])(implicit ev: ArrBuilder[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.

Inherited from
SeqGen
def collectList[B](pf: PartialFunction[A, B]): List[B]

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

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

Inherited from
SeqGen
def contains[A1 >: A](elem: A1): Boolean
Inherited from
SeqGen
@inline
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.

Inherited from
SeqGen
def dataForeach[U](f: A => U): Unit

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

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

Inherited from
DataGen
def dataIForeach[U](initIndex: Int)(f: (Int, A) => U): Unit

Index with foreach on the data elements. Performs a side effecting function on the index and each element of the data 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 on the data elements. Performs a side effecting function on the index and each element of the data 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.

Inherited from
DataGen
def dataIForeach[U](f: (Int, A) => Any): Unit

Index with foreach on the data elements. Performs a side effecting function on the index and each element of the data 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 on the data elements. Performs a side effecting function on the index and each element of the data 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.

Inherited from
DataGen
def dataLast: A
Inherited from
DataGen
def dataMap[B, ArrB <: SeqImut[B]](f: A => B)(implicit ev: ArrBuilder[B, ArrB]): ArrB

Specialised map to an immutable SeqImut of B. For SeqGen dataMap is the same as map, but for other structures it will be different, for example a PolygonLike will map to another PolgonLike.

Specialised map to an immutable SeqImut of B. For SeqGen dataMap is the same as map, but for other structures it will be different, for example a PolygonLike will map to another PolgonLike.

Inherited from
DataGen
def dataTailForeach[U](f: A => U): Unit

Foreachs over the tail of the data sequence.

Foreachs over the tail of the data sequence.

Inherited from
DataGen
def dataTailfold[B](initial: B)(f: (B, A) => B): B

foldLeft over the tail of the data sequence.

foldLeft over the tail of the data sequence.

Inherited from
DataGen
def eMap[B, ArrB <: SeqImut[B]](f: A => EMon[B])(implicit ev: ArrBuilder[B, ArrB]): EMon[ArrB]
Inherited from
SeqGen
def eMapList[B](f: A => EMon[B]): EMon[List[B]]
Inherited from
SeqGen
def elemsLenStr: 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.

Inherited from
DataGen
def elemsNum: Int

The number of elements in the collection. These collections use underlying mutable Arrays and ArrayBuffers. The length of the underlying Array will be this number or a multiple of this number.

The number of elements in the collection. These collections use underlying mutable Arrays and ArrayBuffers. The length of the underlying Array will be this number or a multiple of this number.

Inherited from
DataGen
final
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.

Inherited from
DataGen
@inline
def empty: Boolean

Is this sequence empty?

Is this sequence empty?

Inherited from
SeqGen
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

Inherited from
SeqGen
def fElemStr: A => String
Inherited from
DataGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def filter[ArrA <: SeqImut[A]](f: A => Boolean)(implicit ev: ArrBuilder[A, ArrA]): ArrA
Inherited from
SeqGen
def filterNot[ArrA <: SeqImut[A]](f: A => Boolean)(implicit ev: ArrBuilder[A, ArrA]): ArrA
Inherited from
SeqGen
def filterToList(f: A => Boolean): List[A]
Inherited from
SeqGen
def flatMap[ArrB <: SeqImut[_]](f: A => ArrB)(implicit ev: ArrFlatBuilder[ArrB]): ArrB

Specialised flatMap to a SeqImut.

Specialised flatMap to a SeqImut.

Inherited from
SeqGen
def foldHeadTail[B](initVal: B)(f: A => B, fAcc: (B, B) => B): B
Inherited from
SeqGen
def foldLeft[B](f: (B, A) => B)(implicit ev: DefaultValue[B]): B
Inherited from
SeqGen
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

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
@inline
def head: A

The first element of this sequence.

The first element of this sequence.

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def iFlatMap[ArrB <: SeqImut[_]](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 SeqImut of elements of type B and the method as a whole flattens and then returns the specialised SeqImut 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 SeqImut of elements of type B and the method as a whole flattens and then returns the specialised SeqImut 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.

Inherited from
SeqGen
def iFlatMap[ArrB <: SeqImut[_]](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 SeqImut of elements of type B and the method as a whole flattens and then returns the specialised SeqImut 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 SeqImut of elements of type B and the method as a whole flattens and then returns the specialised SeqImut 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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def iMap[B, ArrB <: SeqImut[B]](startindex: Int)(f: (Int, A) => B)(implicit ev: ArrBuilder[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 SeqImut 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 SeqImut 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.

Inherited from
SeqGen
def iMap[B, ArrB <: SeqImut[B]](f: (Int, A) => B)(implicit ev: ArrBuilder[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 SeqImut 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 SeqImut 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.

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

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

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

Inherited from
SeqGen
@inline
def indexData(index: Int): A

apply method accesses the individual elements of the sequence by 0 based index.

apply method accesses the individual elements of the sequence by 0 based index.

Inherited from
DataGen
def indexOf(elem: A): Int
Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def iterFlatMap[B, ArrB <: SeqImut[B]](f: A => Iterable[B])(implicit ev: ArrBuilder[B, ArrB]): ArrB

FlatMaps over a function from A to any Iterable.

FlatMaps over a function from A to any Iterable.

Inherited from
SeqGen
@inline
def last: A

The last element of this sequence.

The last element of this sequence.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def map[B, ArrB <: SeqImut[B]](f: A => B)(implicit ev: ArrBuilder[B, ArrB]): ArrB

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

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

Inherited from
SeqGen
def map2To1[B, ArrB <: SeqImut[B]](f: (A, A) => B)(implicit ev: ArrBuilder[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.

Inherited from
SeqGen
def mapCollectGoods[B, BB <: SeqImut[B]](f: A => EMon[B])(implicit ev: ArrBuilder[B, BB]): BB

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

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

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

maps ValueProduct collection to List

maps ValueProduct collection to List

Inherited from
SeqGen
def mapWithAcc[B, ArrB <: SeqImut[B], C](initC: C)(f: (C, A) => (B, C))(implicit ev: ArrBuilder[B, ArrB]): ArrB
Inherited from
SeqGen
def max[B >: A](implicit ord: Ordering[B]): A
Inherited from
SeqGen
def min[B >: A](implicit ord: Ordering[B]): A
Inherited from
SeqGen
def mkString(separator: String): String

Not sure about this method.

Not sure about this method.

Inherited from
SeqGen
@inline
def nonEmpty: Boolean

Is this sequence non empty?

Is this sequence non empty?

Inherited from
SeqGen
@inline

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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
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.

Inherited from
SeqGen
def sum(implicit ev: Sumable[A]): A
Inherited from
SeqGen
def sumBy(f: A => Int): Int
Inherited from
SeqGen
def tailForeach[U](f: A => U): Unit

Foreachs over the tail of this sequence.

Foreachs over the tail of this sequence.

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

foldLeft over the tail of this sequence.

foldLeft over the tail of this sequence.

Inherited from
SeqGen
def toList: List[A]
Inherited from
SeqGen
final override
def toString: String
Definition Classes
DataGen -> Any
Inherited from
DataGen
def toStrsCommaFold(fToStr: A => String): String
Inherited from
SeqGen
def toStrsCommaNoSpaceFold(fToStr: A => String): String
Inherited from
SeqGen
def toStrsCommaParenth(fToStr: A => String): String
Inherited from
SeqGen
def toStrsSemiFold(fToStr: A => String): String
Inherited from
SeqGen
def toStrsSemiParenth(fToStr: A => String): String
Inherited from
SeqGen
def typeStr: String

String specifying the type of this object.

String specifying the type of this object.

Inherited from
DataGen
def unsafeSameSize(length: Int): ThisT

This method should rarely be needed to be used by end users, but returns a new uninitialised ArrT of the this SeqImut's final type.

This method should rarely be needed to be used by end users, but returns a new uninitialised ArrT of the this SeqImut's final type.

Inherited from
DataImut
def unsafeSetElem(i: Int, value: 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.

Inherited from
DataGen
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.

Inherited from
DataGen
def zipMap[B, C, ArrC <: SeqImut[C]](operator: SeqGen[B])(f: (A, B) => C)(implicit ev: ArrBuilder[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.

Inherited from
SeqGen
def zipMap2[B, C, D, ArrD <: SeqImut[D]](operator1: SeqGen[B], operator2: SeqGen[C])(f: (A, B, C) => D)(implicit ev: ArrBuilder[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.

Inherited from
SeqGen