IndexedSeq<A> mixin

Seqs with efficient [] and length operators

Superclass Constraints

• RIterable<A>
• RSeq<A>

Mixin Applications

• IVector
• Range

Properties

hashCode → int

The hash code for this object.

no setter, inherited

head → A

Returns the first element of this collection, or throws if it is empty.

no setter, inherited

headOption → Option<A>

Returns the first element of this collection as a Some if non-empty. If this collction is empty, None is returned.

no setter, inherited

isEmpty → bool

no setter, inherited

isNotEmpty → bool

no setter, inherited

isTraversableAgain → bool

no setter, inherited

iterator → RIterator<A>

no setter, inherited

knownSize → int

Returns the number of elements in this collection, if that number is already known. If not, -1 is returned.

no setter, inherited

last → A

Returns the last element of this collection, or throws if it is empty.

no setter, inherited

lastOption → Option<A>

Returns the last element of this collection as a Some, or None if this collection is empty.

no setter, inherited

length → int

no setter, inherited

nonEmpty → bool

no setter, inherited

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

size → int

Returns the number of elements in this collection.

no setter, inherited

Methods

appended(A elem) → IndexedSeq<A>

Returns a new Seq, with the given elem added to the end.

override

appendedAll(RIterableOnce<A> suffix) → IndexedSeq<A>

Returns a new Seq, with elems added to the end.

override

collect<B>(Function1<A, Option<B>> f) → IndexedSeq<B>

Returns a new collection by applying f to each element an only keeping results of type Some.

override

collectFirst<B>(Function1<A, Option<B>> f) → Option<B>

Applies f to each element of this collection, returning the first element that results in a Some, if any.

inherited

combinations(int n) → RIterator<IndexedSeq<A>>

Returns an Iterator that will produce all combinations of elements from this sequence of size n in order.

override

concat(covariant RIterableOnce<A> suffix) → IndexedSeq<A>

Returns a copy of this collection, with elems added to the end.

override

contains(A elem) → bool

Returns true, if any element of this collection equals elem.

inherited

containsSlice(RSeq<A> that) → bool

Returns true if that is contained in this collection, in order.

inherited

corresponds<B>(covariant RIterable<B> that, Function2<A, B, bool> p) → bool

Returns true if this collection has the same size as that and each corresponding element from this and that satisfies the given predicate p.

inherited

count(Function1<A, bool> p) → int

Return the number of elements in this collection that satisfy the given predicate.

inherited

diff(RSeq<A> that) → IndexedSeq<A>

Returns a new collection with the difference of this and that, i.e. all elements that appear in only this collection.

override

distinct() → RSeq<A>

Returns a new collection where every element is distinct according to equality.

inherited

distinctBy<B>(Function1<A, B> f) → IndexedSeq<A>

Returns a new collection where every element is distinct according to the application of f to each element.

override

drop(int n) → IndexedSeq<A>

override

dropRight(int n) → IndexedSeq<A>

Return a new collection with the last n elements removed.

override

dropWhile(Function1<A, bool> p) → IndexedSeq<A>

override

endsWith(RIterable<A> that) → bool

Returns true if the end of this collection has the same elements in order as that. Otherwise, false is returned.

inherited

exists(Function1<A, bool> p) → bool

Returns true if any element of this collection satisfies the given predicate, false if no elements satisfy it.

inherited

filter(Function1<A, bool> p) → IndexedSeq<A>

override

filterNot(Function1<A, bool> p) → IndexedSeq<A>

override

find(Function1<A, bool> p) → Option<A>

Returns the first element from this collection that satisfies the given predicate p. If no element satisfies p, None is returned.

inherited

findLast(Function1<A, bool> p) → Option<A>

inherited

flatMap<B>(covariant Function1<A, RIterableOnce<B>> f) → IndexedSeq<B>

override

fold(A init, Function2<A, A, A> op) → A

Returns a summary value by applying op to all elements of this collection, moving from left to right. The fold uses a seed value of z.

inherited

foldLeft<B>(B z, Function2<B, A, B> op) → B

Returns a summary value by applying op to all elements of this collection, moving from left to right. The fold uses a seed value of z.

inherited

foldRight<B>(B z, Function2<A, B, B> op) → B

Returns a summary value by applying op to all elements of this collection, moving from right to left. The fold uses a seed value of z.

inherited

forall(Function1<A, bool> p) → bool

Returns true if all elements of this collection satisfy the given predicate, false if any elements do not.

inherited

foreach<U>(Function1<A, U> f) → void

Applies f to each element of this collection, discarding any resulting values.

inherited

groupBy<K>(Function1<A, K> f) → IMap<K, IndexedSeq<A>>

Partitions all elements of this collection by applying f to each element and accumulating duplicate keys in the returned IMap.

override

grouped(int size) → RIterator<RIterable<A>>

Returns a new iterator where each element is a collection of size elements from the original collection. The last element may contain less than size elements.

inherited

groupMap<K, B>(Function1<A, K> key, Function1<A, B> f) → IMap<K, IndexedSeq<B>>

Creates a new map by generating a key-value pair for each elements of this collection using key and f. Any elements that generate the same key will have the resulting values accumulated in the returned map.

override

groupMapReduce<K, B>(Function1<A, K> key, Function1<A, B> f, Function2<B, B, B> reduce) → IMap<K, B>

Partitions all elements of this collection by applying key to each element. Additionally f is applied to each element to generate a value. If multiple values are generating for the same key, those values will be combined using reduce.

inherited

indexOf(A elem, [int from = 0]) → Option<int>

Returns the first index, if any, where the element at that index equals elem. If no index contains elem, None is returned.

inherited

indexOfSlice(RSeq<A> that, [int from = 0]) → Option<int>

Finds the first index in this collection where the next sequence of elements is equal to that. If that cannot be found in this collection, None is returned.

inherited

indexWhere(Function1<A, bool> p, [int from = 0]) → Option<int>

Returns the index of the first element that satisfies the predicate p. If no element satisfies, None is returned.

inherited

init() → RSeq<A>

Returns all elements from this collection except the last. If this collection is empty, an empty collection is returned.

inherited

inits() → RIterator<RIterable<A>>

Returns an iterator of all potential tails of this collection, starting with the entire collection and ending with an empty one.

inherited

intersect(RSeq<A> that) → IndexedSeq<A>

Returns a new collection with the intersection of this and that, i.e. all elements that appear in both collections.

override

intersperse(A x) → IndexedSeq<A>

Returns a new collection with sep inserted between each element.

override

isDefinedAt(int idx) → bool

Returns true if this collection has an element at the given idx.

inherited

lastIndexOf(A elem, [int end = 2147483647]) → Option<int>

Returns the last index, if any, where the element at that index equals elem. If no index contains elem, None is returned.

inherited

lastIndexOfSlice(RSeq<A> that, [int end = 2147483647]) → Option<int>

Finds the last index in this collection where the next sequence of elements is equal to that. If that cannot be found in this collection, None is returned.

inherited

lastIndexWhere(Function1<A, bool> p, [int end = 2147483647]) → Option<int>

Returns the index of the last element that satisfies the predicate p. If no element satisfies, None is returned.

inherited

lift(int ix) → Option<A>

Returns the element at index ix as a Some. If ix is outside the range of this collection, None is returned.

inherited

map<B>(covariant Function1<A, B> f) → RSeq<B>

inherited

maxByOption<B>(Function1<A, B> f, Order<B> order) → Option<A>

Finds the largest element in this collection by applying f to each element and using the given Order to find the greatest.

inherited

maxOption(Order<A> order) → Option<A>

Finds the largest element in this collection according to the given Order.

inherited

minByOption<B>(Function1<A, B> f, Order<B> order) → Option<A>

Finds the smallest element in this collection by applying f to each element and using the given Order to find the greatest.

inherited

minOption(Order<A> order) → Option<A>

Finds the largest element in this collection according to the given Order.

inherited

mkString({String? start, String? sep, String? end}) → String

Returns a String by using each elements toString(), adding sep between each element. If start is defined, it will be prepended to the resulting string. If end is defined, it will be appended to the resulting string.

inherited

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

padTo(int len, A elem) → IndexedSeq<A>

Returns a new collection with a length of at least len.

override

partition(Function1<A, bool> p) → (IndexedSeq<A>, IndexedSeq<A>)

Returns 2 collections as a tuple where the first tuple element will be a collection of elements that satisfy the given predicate p. The second item of the returned tuple will be elements that do not satisfy p.

override

partitionMap<A1, A2>(Function1<A, Either<A1, A2>> f) → (IndexedSeq<A1>, IndexedSeq<A2>)

Applies f to each element of this collection and returns a separate collection for all applications resulting in a Left and Right respectively.

override

patch(int from, RIterableOnce<A> other, int replaced) → IndexedSeq<A>

override

permutations() → RIterator<IndexedSeq<A>>

Returns an Iterator that will emit all possible permutations of the elements in this collection.

override

prepended(A elem) → IndexedSeq<A>

Returns a new collection with elem added to the beginning.

override

prependedAll(RIterableOnce<A> prefix) → IndexedSeq<A>

Returns a new collection with all elems added to the beginning.

override

reduce(Function2<A, A, A> op) → A

inherited

reduceLeft(Function2<A, A, A> op) → A

inherited

reduceLeftOption(Function2<A, A, A> op) → Option<A>

Returns a summary values of all elements of this collection by applying f to each element, moving left to right.

inherited

reduceOption(Function2<A, A, A> op) → Option<A>

Returns a summary values of all elements of this collection by applying f to each element, moving left to right.

inherited

reduceRight(Function2<A, A, A> op) → A

inherited

reduceRightOption(Function2<A, A, A> op) → Option<A>

Returns a summary values of all elements of this collection by applying f to each element, moving right to left.

inherited

removeAt(int idx) → RSeq<A>

inherited

removeFirst(Function1<A, bool> p) → RSeq<A>

inherited

reverse() → RSeq<A>

Returns a new collection with the order of the elements reversed.

inherited

reverseIterator() → RIterator<A>

Returns an iterator that will emit all elements in this collection, in reverse order.

inherited

sameElements(RIterable<A> that) → bool

Returns true if this collection has the same elements, in the same order, as that.

inherited

scan<B>(B z, Function2<B, A, B> op) → IndexedSeq<B>

Returns a new collection of the accumulation of results by applying f to all elements of the collection, including the inital value z. Traversal moves from left to right.

override

scanLeft<B>(B z, Function2<B, A, B> op) → IndexedSeq<B>

override

scanRight<B>(B z, Function2<A, B, B> op) → IndexedSeq<B>

override

segmentLength(Function1<A, bool> p, [int from = 0]) → int

inherited

slice(int from, int until) → RIterable<A>

inherited

sliding(int size, [int step = 1]) → RIterator<IndexedSeq<A>>

Returns an iterator where elements are fixed size chunks of size n of the original collection. Each chunk is calculated by sliding a 'window' of size n over the original collection, moving the window step elements at a time.

override

sortBy<B>(Order<B> order, Function1<A, B> f) → IndexedSeq<A>

Returns a new collection that is sorted according to order after applying f to each element in this collection.

override

sorted(Order<A> order) → IndexedSeq<A>

Returns a new collection that is sorted according to order.

override

sortWith(Function2<A, A, bool> lt) → IndexedSeq<A>

Returns a new collection sorted using the provided function lt which is used to determine if one element is less than the other.

override

span(Function1<A, bool> p) → (RSeq<A>, RSeq<A>)

inherited

splitAt(int n) → (RSeq<A>, RSeq<A>)

Returns 2 collectins of all elements before and after index n respectively.

inherited

startsWith(RIterableOnce<A> that, [int offset = 0]) → bool

Returns true if the beginning of this collection corresponds with that.

inherited

tail() → RSeq<A>

Returns a new collection with the first element removed. If this collection is empty, an empty collection is returned.

inherited

tails() → RIterator<RIterable<A>>

Returns an iterator of all potential tails of this collection, starting with the entire collection and ending with an empty one.

inherited

take(int n) → RIterable<A>

inherited

takeRight(int n) → RIterable<A>

Returns a new collection with the last n elements of this collection. If n is greater than the size of this collection, the original collection is returned.

inherited

takeWhile(Function1<A, bool> p) → RIterable<A>

inherited

tapEach<U>(Function1<A, U> f) → RIterable<A>

Applies f to each element in this collection, discarding any results and returns this collection.

inherited

toIList() → IList<A>

Returns an IList with the same elements as this collection.

inherited

toIndexedSeq() → IndexedSeq<A>

Returns an IndexedSeq with the same elements as this collection.

inherited

toISet() → ISet<A>

Returns an ISet with the same elements as this collection, duplicates removed.

inherited

toIVector() → IVector<A>

Returns an IVector with the same elements as this collection.

inherited

toList({bool growable = true}) → List<A>

Returns a new List with the same elements as this collection.

inherited

toSeq() → RSeq<A>

Returns a RSeq with the same elements as this collection.

inherited

toString() → String

A string representation of this object.

inherited

traverseEither<B, C>(Function1<A, Either<B, C>> f) → Either<B, RSeq<C>>

Applies f to each element of this RSeq and collects the results into a new collection. If Left is encountered for any element, that result is returned and any additional elements will not be evaluated.

inherited

traverseOption<B>(Function1<A, Option<B>> f) → Option<RSeq<B>>

Applies f to each element of this RSeq and collects the results into a new collection. If None is encountered for any element, that result is returned and any additional elements will not be evaluated.

inherited

updated(int index, A elem) → RSeq<A>

inherited

view() → SeqView<A>

inherited

zip<B>(RIterableOnce<B> that) → IndexedSeq<(A, B)>

Returns a new collection that combines corresponding elements from this collection and that as a tuple. The length of the returned collection will be the minimum of this collections size and the size of that.

override

zipAll<B>(RIterableOnce<B> that, A thisElem, B thatElem) → IndexedSeq<(A, B)>

Returns a new collection that combines corresponding elements from this collection and that as a tuple. The length of the returned collection will be the maximum of this collections size and thes size of that. If this collection is shorter than that, thisElem will be used to fill in the resulting collection. If that is shorter, thatElem will be used to will in the resulting collection.

override

zipWithIndex() → IndexedSeq<(A, int)>

Return a new collection with each element of this collection paired with it's respective index.

override

Operators

operator ==(Object other) → bool

The equality operator.

inherited

operator [](int idx) → A

inherited

Static Methods

from<A>(RIterableOnce<A> elems) → IndexedSeq<A>

override

fromDart<A>(Iterable<A> elems) → IndexedSeq<A>

override