ArrNoParam

The final type of this class many method operands and return values take this type.

Returns new Arr with the first N elements dropped.

Returns new Arr with the last N elements dropped.

Reverses the order of the elements of this sequence.

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

Returns new Arr without the last element.

Modifies all instances of the old value that fulfill predicate, with a new value by applying the parameter function.

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

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

Returns new Arr without the first element.

Partitions the code and element's Strings into an alphabetic String and a natural number. First matches onth on the alphabetic and then for results that match the same number of letters, it matches on the numbers.

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

Returns true if this sequence contains a value equal to the parameter value. The passed value for equivalence testing can be a super type of the element type.

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.

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

Is this sequence empty?

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

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

String for element, can be overridden.

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 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.

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

Takes a function that returns an ErrBi and returns the first Succ.

Specialised flatMap to a Arr.

flatMaps each element to an ErrBiAcc accumulating successes and errors.

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

Folds over this sequence starting with the initial value

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

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.

The first element of this sequence.

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. If the sequence is nonEmpty applies toString to head element else returns the noHead parameter string.

Returns the Some of the first element unless the sequence is empty in which case it returns None.

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 subclasses.

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 subclasses.

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.

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 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 subclasses.

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 subclasses.

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

like the apply method accesses the defining sequence element by a 0 based index, but cycles around for indexes less that 0 and equal or greater than index length.

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

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.

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

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.

Specialised map to an immutable Arr of B. But takes 2 functions. Applies the first supplied function to every element of the init of this sequence and the second is applied to the last element if there is one.

The last element of this sequence.

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.

Returns the Some of the last element unless the sequence is empty in which case it returns None.

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

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

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

Maps to an Array.

maps from A to ErrBi[B], collects the successful values.

Map from A => ErrBi[E, B]. There is a name overload that usingly takes a narrower BuilderArrMap as the second parameter list.

Map from A => ErrBi[E, B]. Returns a successful Arr of B as long as the function produces no errors, in which case it returns a Fail of the first error encountered usingly takes a BuilderArrMap. There is a name overload that explicitly takes a more flexible BuilderMap as the first parameter list.

maps each element to an ErrBi accumulating successes and errors.

Map from A => B, returning an ErrBi of List.

maps this Sequ to a List

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

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

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

Maps from A to B like normal map,but has an additional accumulator of type C that is discarded once the traversal is completed. 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.

Gives the maximum 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.

Applies the function to convert each element to a String and then appends them with the separator. There is a name overload which uses toString to replace the first parameter.

Applies toString to each element and appends them with given separator. There ia name overload where the first paremter is a function to convert the elements into Strings.

Make a String using comma-space as separators.

Make a String using just commas no spaces as separators.

Make a String using semicolon-space as separators.

Mutates an element in the Arr at the given index. This method should rarely be needed by end users, but is used by the initialisation and factory methods.

Is this sequence non-empty?

Takes a map function from A to Option[B] but only returns the Arr of B if all the elements map to a Some. Hence, the ArrB if returned will be the same length as this sequence.

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

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

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.

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.

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

Returns a new Arr sorted from least to greatest. Takes a function determining if the first value is greater than the second.

Sums accumulating the results of the A => Double function.

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

Foreachs over the tail of this sequence. Performs a side effecting function on each element of this sequence excluding the first.

foldLeft over the tail of this sequence.

Converts this Sequ to a list.

Returns a string representation of the object.

The default representation is platform dependent.

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 last element in the Arr. This method should rarely be needed by end users, but is used by initialisation and factory methods.

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 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.

Accesses the defining sequence element by a 0 based index.

Accesses the specifying sequence element by a 0 based index. For Sequs this will an alternative name for apply.

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

The number of data elements in the defining sequence. These collections use underlying mutable Arrays and ArrayBuffers. The length of the underlying Array will be a multiple of this number. For Sequs this will be an alternative name for length.

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

String specifying the type of this object.