Add Iterators.first and Iterators.last which don't throw for empty collections

[non-Jedi]

EDIT: This PR now implements option 2 discussed at the bottom of this post rather than option 1 which it originally implemented.

On zulip, there was a thread about the fact that there's not a good
way of finding the first item matching a predicate in a non-indexable iterable without
manually writing out the for-loop
(https://julialang.zulipchat.com/#narrow/stream/225540-gripes/topic/.60find.60.20in.20iterables). One
possibility is using the existing first function composed with
Iterators.filter:

first(Iterators.filter(>(5), 1:10))

The problem with this approach is that it requires wrapping in a try
block if the predicate not being satisfied is a
possibility (Iterators.filter returns an empty collection). There
should be a way of expressing this without using exception-handling as
control flow or writing the for-loop manually.

Ideally, I think first and last should just return
Union{Some{T},Nothing} always, but that would be a breaking
change. So I see two obvious alternatives:

1. This commit adds an optional predicate argument to first and last
   which is mapped over the collection and the first/last value
   satisfying predicate is returned wrapped in Some.
2. Add a Iterators.first/Iterators.last which are identical to the
   versions in Base except that when successful they return Some{T}
   and when the collection is empty return Nothing

[non-Jedi]

Should the docstrings instead be combined with the existing docstring for first(coll) as e.g.:

"""
    first([predicate=_ -> true,] coll)

...
"""

Also, I really appreciate the detailed code review. It would be great to get some feedback on the overall concept as well.

[mbauman]

I'm not fully convinced about the functionality, but could be persuaded.

[mbauman]

This is interesting — and deviates from the existing first which would throw an error. This gives me a bit of pause, but at a minimum it means that we cannot combine these docstrings:

julia> first(_->true, [])

julia> first([])
ERROR: BoundsError: attempt to access 0-element Array{Any,1} at index [1]

[non-Jedi]

Good point on the docstrings.

[mbauman]

I'm not thrilled about Some here — I don't think we have a single API in base that returns Some. That said, this is unlike the other find/search APIs in that they return indices or RegexMatches or values from some other limited type set that does not include Nothing.

[non-Jedi]

I think I've convinced myself that at the very least this should be a separate function from first/last. Does Iterators.first (as suggested in OP) sound like a good name to you? In that case, we wouldn't have to create a predicate accepting version as it would compose with Iterators.filter. EDIT: this PR now implements Iterators.first instead.

In reality, I think all APIs that generically return an element of a collection but throw if the element isn't present should instead return Union{Some{T},Nothing}. This includes first, last, getindex, reduce, foldl, etc. This is obviously breaking; I should probably create a "Taking something seriously" issue to get feedback on that idea for julia 2.0.

[non-Jedi]

Could someone educate me on the history of Some? @mbauman correctly noted that no base functions currently return values wrapped in Some. It seems odd to have an exported type in base that's basically unused (except for a few internal reduction functions). Was it added to base to be a point of coordination for external packages? Is remnant of the days of Nullable? Is it purely so that something(Some(_->nothing)) can return nothing?

[non-Jedi]

I'd like to bump this.

The core functionality I'm trying to get into Base here is some function that allows getting the first element of a lazily filtered (possibly empty) collection without wrapping in a try block; a function returning Union{Some{T},Nothing} seems like the obvious way of doing this. I'm relatively ambivalent on how that should be spelled.

If the decision is that a function for getting the first element of a lazily filtered collection isn't necessary in Base, I'm happy to close this. If a different approach would be better, I'd be happy to work on this further.

[rfourquet]

I like trying to solve the stated problem

there's not a good way of finding the first item matching a predicate in a non-indexable iterable [...]

• So my first comment: while having a non-throwing first seems like a good general solution, what about designing a function which solves directly the problem? e.g. Iterators.findfirst(f, iter) (which could for example return the "index" (a la enumerate) together with the found object).

• Regarding using Some, it looks like an appropriate use here even if it's currently seldom used elsewhere. Note this other PR implementing "2-argument get returning Union{Nothing,Some}".

• I don't like putting this functionality in Iterators.first. As far as I am aware, other public functions in Iterators create an iterator. Naming this one Iterators.first feels just like adding a random namespace in front of first just because first is already taken. What about tryfirst (by analogy to tryparse which doesn't throw (unlike parse) ?

[non-Jedi]

• So my first comment: while having a non-throwing first seems like a good general solution, what about designing a function which solves directly the problem? e.g. Iterators.findfirst(f, iter) (which could for example return the "index" (a la enumerate) together with the found object).

Not all iterables have meaningful indices (e.g. readeach), or is the idea that it would work exactly like enumerate and count the number of elements?

• I don't like putting this functionality in Iterators.first. As far as I am aware, other public functions in Iterators create an iterator. Naming this one Iterators.first feels just like adding a random namespace in front of first just because first is already taken. What about tryfirst (by analogy to tryparse which doesn't throw (unlike parse) ?

I agree on the unsuitability of the Iterators namespace; mostly I was trying to put it next to Iterators.filter where I feel it's most useful. tryfirst is a pretty good name given the precedent of tryparse. Another possibility would be to introduce a new namespace/module where this could live as first alongside Union{Some{T},Nothing}-returning versions of getindex, reduce, etc.

[non-Jedi]

So revisiting this in 2023, I think what I really want is for Maybe.jl (which didn't have Maybe.first at the time I authored this PR) to be a standard library. For reference, the best collection of links to related issues and PRs about functions returning Union{Some{T}, Nothing} is probably #43746, but there are probably others missing from the list there (it's not something easy to find using github's search abilities).

If there's not appetite for a change like this, I'm happy to update this PR to rename the function tryfirst as suggested by @rfourquet above. I think the specific case of first without throwing on empty is more important than the generalization Maybe.jl gives.