Colours

final class Colours(val unsafeArray: Array[Int]) extends AnyVal with ArrInt1s[Colour]

Specialist Arr, immutable sequence Array[Int] based class for Colours.

Companion:
object
trait SeqGen[Colour]
class AnyVal
trait Matchable
class Any

Type members

Types

type ThisT = Colours

Value members

Concrete methods

override def dataElem(intValue: Int): Colour
Definition Classes
override def fElemStr: Colour => String
Definition Classes
override def typeStr: String
Definition Classes
override def unsafeFromArray(array: Array[Int]): Colours
Definition Classes

Inherited methods

def ++[N <: ArrValueNs[Colour]](operand: N)(implicit factory: Int => N): N

Appends ProductValue collection with the same type of Elements to a new ValueProduct collection. Note the operand collection can have a different type, although it shares the same element type. In such a case, the returned collection will have the type of the operand not this collection.

Appends ProductValue collection with the same type of Elements to a new ValueProduct collection. Note the operand collection can have a different type, although it shares the same element type. In such a case, the returned collection will have the type of the operand not this collection.

Inherited from:
ArrValueNs
def :+[N <: ArrValueNs[Colour]](operand: Colour)(implicit factory: Int => N): N

Appends an element to a new ProductValue collection of type N with the same type of Elements.

Appends an element to a new ProductValue collection of type N with the same type of Elements.

Inherited from:
ArrValueNs
def append(op: Colour): ThisT

Functionally appends the operand of type A. This alphanumeric method is not aliased by the ++ operator, to avoid confusion with numeric operators.

Functionally appends the operand of type A. This alphanumeric method is not aliased by the ++ operator, to avoid confusion with numeric operators.

Inherited from:
ArrInt1s
@inline
def apply(index: Int): Colour

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 arrLen: Int

The length of the Array[Int] backing array.

The length of the Array[Int] backing array.

Inherited from:
DataIntNs
def collect[B, BB <: SeqImut[B]](pf: PartialFunction[Colour, 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 contains[A1 >: Colour](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.

Inherited from:
SeqGen
@inline
def cycleGet(index: Int): Colour

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 dataFold[B](initVal: B)(f: (B, Colour) => B): B
Inherited from:
DataGen
def dataForeach[U](f: Colour => 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, Colour) => 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, Colour) => 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
Inherited from:
DataGen
final override def dataLength: Int

The number of product elements in this collection. For example in a [[PolygonImp], this is the number of Pt2s in the Polygon

The number of product elements in this collection. For example in a [[PolygonImp], this is the number of Pt2s in the Polygon

Definition Classes
Inherited from:
DataValueNs
def dataLengthStr: 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 dataMap[B, ArrB <: SeqImut[B]](f: Colour => 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: Colour => 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, Colour) => 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: Colour => EMon[B])(implicit ev: ArrBuilder[B, ArrB]): EMon[ArrB]
Inherited from:
SeqGen
def eMapList[B](f: Colour => EMon[B]): EMon[List[B]]
Inherited from:
SeqGen
override def elemProdSize: Int
Definition Classes
Inherited from:
DataInt1s
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: Colour => 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 fMax[B](defaultValue: B)(f: Colour => 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: Colour => 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[Colour]](f: Colour => Boolean)(implicit ev: ArrBuilder[Colour, ArrA]): ArrA
Inherited from:
SeqGen
def filterNot[ArrA <: SeqImut[Colour]](f: Colour => Boolean)(implicit ev: ArrBuilder[Colour, ArrA]): ArrA
Inherited from:
SeqGen
def filterToList(f: Colour => Boolean): List[Colour]
Inherited from:
SeqGen
def find(f: Colour => Boolean): Option[Colour]
Inherited from:
SeqImut
def findIndex(value: Colour): OptInt

This method could be made more general.

This method could be made more general.

Inherited from:
ArrInt1s
def flatMap[ArrB <: SeqImut[_]](f: Colour => ArrB)(implicit ev: ArrFlatBuilder[ArrB]): ArrB

Specialised flatMap to a SeqImut.

Specialised flatMap to a SeqImut.

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

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

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

Inherited from:
SeqGen
def foldHeadTail[B](initVal: B)(f: Colour => B, fAcc: (B, B) => B): B
Inherited from:
SeqGen
def foldLeft[B](f: (B, Colour) => B)(implicit ev: DefaultValue[B]): B
Inherited from:
SeqGen
def foldLeft[B](initial: B)(f: (B, Colour) => 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: Colour => 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 foldWithPrevious[B](initPrevious: Colour, initAcc: B)(f: (B, Colour, Colour) => B): B
Inherited from:
ArrValueNs
def forAll(p: Colour => 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: Colour => 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

The first element of this sequence.

The first element of this sequence.

Inherited from:
SeqGen
def headFold[B](noHead: => B)(ifHead: Colour => 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, Colour) => 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, Colour) => 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, Colour) => 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, Colour) => 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, Colour) => 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, Colour) => 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, Colour) => 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: Colour => 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
final override def indexData(index: Int): Colour
Definition Classes
Inherited from:
DataInt1s
def indexOf(elem: Colour): Int
Inherited from:
SeqGen
def indexWhere(f: Colour => 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: Colour => 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
@inline

The last element of this sequence.

The last element of this sequence.

Inherited from:
SeqGen
def lastFold[B](noLast: => B)(ifLast: Colour => 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
final override def length: Int
Definition Classes
Inherited from:
ArrInt1s
def map[B, ArrB <: SeqImut[B]](f: Colour => 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: (Colour, Colour) => 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: Colour => 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: Colour => B): List[B]

maps ValueProduct collection to List

maps ValueProduct collection to List

Inherited from:
SeqGen
def mapUniqueGood[B](f: Colour => 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.

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

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.

Inherited from:
SeqGen
def min[B >: Colour](implicit ord: Ordering[B]): Colour

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.

Inherited from:
SeqGen
def mkString(separator: String): String

Not sure about this method.

Not sure about this method.

Inherited from:
SeqGen
def modifyWhere(pred: Colour => Boolean, fNewValue: Colour => Colour): 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.

Inherited from:
SeqImut
@inline
def nonEmpty: Boolean

Is this sequence non empty?

Is this sequence non empty?

Inherited from:
SeqGen
def removeFirst(f: Colour => 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.

Inherited from:
SeqImut
def replace(oldValue: Colour, newValue: Colour): ThisT

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

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

Inherited from:
SeqImut
def replaceWhere(pred: Colour => Boolean, newValue: Colour): 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.

Inherited from:
SeqImut
@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
override def reverseData: ThisT
Definition Classes
Inherited from:
DataIntNs
def reverseForeach[U](f: Colour => 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, Colour) => 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[Colour]): Colour
Inherited from:
SeqGen
def sumBy(f: Colour => Int): Int

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

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

Inherited from:
SeqGen
def tailForeach[U](f: Colour => 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, Colour) => B): B

foldLeft over the tail of this sequence.

foldLeft over the tail of this sequence.

Inherited from:
SeqGen
def toList: List[Colour]

Converts this SeqGen to a list.

Converts this SeqGen to a list.

Inherited from:
SeqGen
final override def toString: String
Definition Classes
DataGen -> Any
Inherited from:
DataGen
def toStrsCommaFold(fToStr: Colour => String): String
Inherited from:
SeqGen
def toStrsCommaNoSpaceFold(fToStr: Colour => String): String
Inherited from:
SeqGen
def toStrsCommaParenth(fToStr: Colour => String): String
Inherited from:
SeqGen
def toStrsSemiFold(fToStr: Colour => String): String
Inherited from:
SeqGen
def toStrsSemiParenth(fToStr: Colour => String): String
Inherited from:
SeqGen
final override def unsafeSameSize(length: Int): ThisT

Method for creating a new Array[Int] backed collection class of this collection class's final type.

Method for creating a new Array[Int] backed collection class of this collection class's final type.

Definition Classes
Inherited from:
DataIntNs
final override def unsafeSetElem(index: Int, elem: Colour): Unit
Definition Classes
Inherited from:
DataInt1s
def unsafeSetElemSeq(index: Int, elems: Iterable[Colour]): Unit
Inherited from:
SeqImut
def unsafeSetElems(index: Int, elems: Colour*): 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 unsafeSetHead(value: Colour): 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.

Inherited from:
SeqImut
def unsafeSetLast(value: Colour): 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 from:
SeqImut
def zipMap[B, C, ArrC <: SeqImut[C]](operator: SeqGen[B])(f: (Colour, 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: (Colour, 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

Concrete fields

val unsafeArray: Array[Int]