Creates a cursor by transforming values produced by the source cursor with a partial function, dropping those values for which the partial function is not defined.

NOTE: application of this function can be either strict or lazy (depending on the underlying cursor type), but it does not modify the original collection.

Creates a new cursor that advances this cursor past the first n elements, or the length of the cursor, whichever is smaller.

Returns an cursor over all the elements of the source cursor that satisfy the predicate p. The order of the elements is preserved.

NOTE: application of this function can be either strict or lazy (depending on the underlying cursor type), but it does not modify the original collection.

Applies a binary operator to a start value and all elements of this cursor, going left to right.

NOTE: applying this function on the cursor will consume it completely.

Tests whether this cursor can provide another element.

This method can be side-effecting, depending on the implementation and thus it can also throw exceptions. This is because in certain cases the only way to know if there is a next element or not involves triggering dangerous side-effects.

This method is idempotent until the call to next happens, meaning that multiple hasNext calls can be made and implementations are advised to memoize the result.

Returns true in case our cursor is empty or false if there are more elements to process.

Alias for !cursor.hasNext().

Creates a new cursor that maps all produced values of this cursor to new values using a transformation function.

NOTE: application of this function can be either strict or lazy (depending on the underlying cursor type), but it does not modify the original collection.

Produces the next element of this iterator.

This method is side-effecting, as it mutates the internal state of the cursor and can throw exceptions.

Returns true in case our cursor has more elements to process or false if the cursor is empty.

Alias for hasNext.

In case this cursor is going to be processed eagerly, in batches then this value should be the recommended batch size for the source cursor.

Examples:

• if this cursor is iterating over a standard collection with a finite size, it can be something generous like 1024
• if it's iterating over a cheap infinite iterator (e.g. Iterator.range), it could be 128.
• if it does any sort of I/O or blocking of threads, then the recommended value is 1.

Basically the batch size should be adjusted according to how expensive processing this cursor is. If it's a strict collection of a finite size, then it can probably be processed all at once. But if it's a big database result set that can block threads on reads, then it's probably wise to do it one item at a time.

Creates an cursor returning an interval of the values produced by this cursor.

Creates a new cursor that will only emit the first n values of this cursor.

Converts this cursor into an Array, consuming it in the process.

Converts this cursor into a reusable array-backed Batch, consuming it in the process.

Converts this cursor into a Scala Iterator.

Converts this cursor into a Scala immutable List, consuming it in the process.