The element currently at the back of the queue, or null if the queue is empty.

The first element returned by the iterator, if any, or null if this stream is empty. For a stream with an unstable iteration order, a different value might be produced each time first is evaluated.

The element currently at the front of the queue, or null if the queue is empty.

The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that:

• if x==y then x.hash==y.hash.

Therefore, a class which refines equals must also refine hash.

In general, hash values vary between platforms and between executions of the same program.

Note that when executing on a Java Virtual Machine, the 64-bit Integer value returned by an implementation of hash is truncated to a 32-bit integer value by taking the exclusive disjunction of the 32 lowest-order bits with the 32 highest-order bits, before returning the value to the caller.

The last element returned by the iterator, if any, or null if this stream is empty. In the case of an infinite stream, this operation never terminates; furthermore, this default implementation iterates all elements, which might be very expensive.

The index of the last element of the list, or null if the list is empty. Always size>0 then size-1.

The number of elements returned by the iterator of this stream, if the iterator terminates. In the case of an infinite stream, this operation never terminates.

The element currently at the top of the stack, or null if the stack is empty.

Remove and return the element at the front of the queue.

Add the given element to the end of this list, incrementing the length of the list.

Add the given elements to the end of this list, increasing the length of the list.

Determines if there is at least one element of this stream that satisfies the given predicate function (selecting). If the stream is empty, returns false. For an infinite stream, this operation might not terminate.

Remove every element from this list, leaving an empty list with no elements.

A shallow copy of this collection, that is, a collection with identical elements which does not change if this collection changes. If this collection is immutable, it is acceptable to return a reference to this collection. If this collection is mutable, a newly instantiated collection must be returned.

Produce a new sequence (Sequential) containing the results of applying the given mapping (collecting) to the elements of this stream.

This operation is an eager counterpart to map. For any stream it, and mapping f:

it.collect(f) == [*it.map(f)]

Returns true if the given value belongs to this Category, that is, if it is an element of this Category, or false otherwise.

For any instance c of Category, c.contains(element) may be written using the in operator:

element in c

For most Categorys, the following relationship is satisfied by every pair of elements x and y:

• if x==y, then x in category == y in category

However, it is possible to form a useful Category consistent with some other equivalence relation, for example ===. Therefore implementations of contains() which do not satisfy this relationship are tolerated.

Produces the number of elements in this stream that satisfy the given predicate function (selecting). For an infinite stream, this method never terminates.

Determines if there is a value defined for the given key.

Remove the element at the specified index, returning the removed element, if any, or null if there was no such element.

Remove every element with an index in the measured range from:length. If length<=0, no elements are removed.

Remove every element with an index in the spanned range from..to.

Call the given function (step) for each element of this stream, passing the elements in the order they occur in this stream.

For example:

words.each((word) {
    print(word.lowercased);
    print(word.uppercased);
});

Has the same effect as the following for loop:

for (word in words) {
    print(word.lowercased);
    print(word.uppercased);
}

For certain streams this method is highly efficient, surpassing the performance of for loops on the JVM. Thus, each() is sometimes preferred in highly performance-critical low-level code.

Determine if two values are equal.

For any two non-null objects x and y, x.equals(y) may be written as:

x == y 

Implementations should respect the constraints that:

• if x===y then x==y (reflexivity),
• if x==y then y==x (symmetry),
• if x==y and y==z then x==z (transitivity).

Furthermore it is recommended that implementations ensure that if x==y then x and y have the same concrete class.

A class which explicitly refines equals() is said to support value equality, and the equality operator == is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from Identifiable.

Note that an implementation of equals() that always returns false does satisfy the constraints given above. Therefore, in very rare cases where there is no reasonable definition of value equality for a class, for example, function references (Callable), it is acceptable for equals() to be defined to return false for every argument.

Determines if all elements of this stream satisfy the given predicate function (selecting). If the stream is empty, return true. For an infinite stream, this operation might not terminate.

The first element of this stream which is not null and satisfies the given predicate function (selecting), if any, or null if there is no such element. For an infinite stream, this method might not terminate.

For example, the expression

(-10..10).find(Integer.positive)

evaluates to 1.

Remove the first element that satisfies the given predicate function from this list, returning the removed element, or null if no such element was found in this list.

Remove the last element that satisfies the given predicate function from this list, returning the removed element, or null if no such element was found in this list.

Replace the first element of this list that satisfies the given predicate function with the given replacement, returning the replaced element, or null if no such element was found in this list.

Replace the last element of this list that satisfies the given predicate function with the given replacement, returning the replaced element, or null if no such element was found in this list.

The last element of this stream which is not null and satisfies the given predicate function (selecting), if any, or null if there is no such element. For an infinite stream, this method will not terminate.

For example, the expression

(-10..10).findLast(3.divides)

evaluates to 9.

The first index in this list for which the element is not null and satisfies the given predicate function (selecting).

The indexth element returned by an iterator of this stream, or null if there are fewer than index+1 elements in the stream. For a stream with an unstable iteration order, a different value might be produced each time getFromFirst(index) is called for a given integer index.

Replace all null values in this list with the given replacement value.

Insert the given element at the specified index, incrementing the length of the list.

Insert the given elements at the specified index, growing the length of the list by the number of given elements.

An iterator for the elements belonging to this stream.

If this is a nonempty stream with type {Element+}, the iterator must produce at least one element.

The last index in this list for which the element is not null and satisfies the given predicate function (selecting).

Obtain a measure containing the mapped values starting from the given starting index (from), with the given length. If length<=0, the resulting measure is empty.

For any ranged stream r, r.measure(from, length) may be written using the measure operator:

r[from:length]

The measure should contain the given number (length) of elements of this stream, starting from the element at the given starting index (from), in the same order as they are produced by the iterator of the stream. In the case where the iterator would be exhausted before length elements are produced, the resulting measure contains only those elements which were produced before the iterator was exhausted, and the length of the measure is less then the given length.

When the given index does not belong to this ranged object, the behavior is implementation dependent.

Add a new element to the back of the queue.

Remove and return the element at the top of the stack.

Remove all null elements from this list, leaving a list with no null elements, returning the number of elements removed.

Push a new element onto the top of the stack.

Beginning with the first element of this stream, apply the given combining function (accumulating) to each element of this stream in turn, progressively accumulating a single result.

For an empty stream, reduce() always returns null.

For a stream with one element, reduce() returns that element:

{ first }.reduce(f) == first

For a given stream it with more than one element, and combining function f, the result of reduce() is obtained according to the following recursive definition:

it.reduce(f) == f(it.exceptLast.reduce(f), it.last)

For example, the expression

(1..100).reduce(plus)

results in the integer 5050.

Remove all occurrences of every one of the given values from this list, returning the number of elements removed.

Remove every element that satisfies the given predicate function from this list, returning the number of elements that were removed.

Replace every element in this list that satisfies the given predicate function with the given replacement.

A sequence (Sequential) containing all the elements of this stream, in the same order they occur in this stream. This operation eagerly evaluates and collects every element of the stream.

If this stream is known to be nonempty, that is, if it is an instance of {Anything+}, then this operation has a nonempty return type, that is, a subtype of [Anything+]. For example:

[String+] bits = "hello world".split().sequence();

Set the item associated with the given index to the given item, replacing the item previously associated with this index.

For any instance c of IndexedCorrespondenceMutator, c.set(index, item) may be written using the item and assignment operators:

c[index] = item

Obtain a span containing the elements between the two given indices.

For any ranged stream r, r.span(from, to) may be written using the span operator:

r[from..to]

The span should contain elements of this stream, starting from the element at the given starting index (from), and ending with the element at the given ending index (to), in the same order as they are produced by the iterator of the stream, except when the ending index occurs earlier than the starting index, in which case they occur in the opposite order.

When one or both of the given indices does not belong to this ranged stream, the behavior is implementation dependent.

Obtain a span containing the elements between the given starting index (from) and the last index of this ranged object.

For any ranged stream r, r.spanFrom(from) may be written using the span operator:

r[from...]

The span should contain elements of this stream, starting from the element at the given starting index (from), in the same order as they are produced by the iterator of the stream.

When the given index does not belong to this ranged stream, the behavior is implementation dependent.

Obtain a span containing the elements between the first index of this ranged stream and given end index (to).

For any ranged stream r, r.spanTo(to) may be written using the span operator:

r[...to]

The span should contain elements of this stream, up to the element at the given ending index (to), in the same order as they are produced by the iterator of the stream.

When the given index does not belong to this ranged stream, the behavior is implementation dependent.

Truncate this list to the given size by removing elements from the end of the list, if necessary, leaving a list with at most the given size.