Genericize AbstractString predicates to all iterables

[jariji]

contains, occursin, startswith, endswith all require AbstractString (or similar) arguments. I don't see why they couldn't be generic.

The only problem is that they currently are unclear on whether the first argument is an element or a sequence of elements: does occursin mean "is an element of" or "is a subsequence of"? The docs say it's the latter but occursin('a', "abc") works.

[andrewjradcliffe]

These seem fairly similar already:

x = ['J', 'u', 'l', 'i', 'a']
x ∋ 'J'
'u' ∈ x

y = reduce(*, x)
contains(y, 'J')
occursin('J', y)

first(x) == 'J'
last(x) == 'a'

startswith(y, 'J')
endswith(y, 'a')

[jariji]

julia> startswith([1,2,3], [1])
ERROR: MethodError: no method matching startswith(::Vector{Int64}, ::Vector{Int64})

[andrewjradcliffe]

Other than the literal meaning of those words, there is little reason to expect a specific function for something which can be handled by simple functions.

julia> first([1,2,3]) == 1
true

julia> first([1,2,3], 2) == [1,2]
true

julia> first([1,2,3,4], 3) == [1,2,3]
true

[ParadaCarleton]

Other than the literal meaning of those words, there is little reason to expect a specific function for something which can be handled by simple functions.

julia> first([1,2,3]) == 1
true

julia> first([1,2,3], 2) == [1,2]
true

julia> first([1,2,3,4], 3) == [1,2,3]
true

That's a reasonable argument, but then why does startswith exist at all? It should either be defined for all iterables or none of them, not just strings.

[StefanKarpinski]

Checking whether a string starts with another string is a bit non-trivial to do correctly given Unicode. That said, we might as well implement these for other types. startswith(target, prefix) can work with arbitrary iterables: iterate both arguments in parallel until they disagree or one of them is done; if they disagree or target ends first, return false; if prefix ends before or at the same time as target and they never disagree, return true. Other ones are harder with iterables, of course, but can certainly be implemented for anything that can do indexing.

[andrewjradcliffe]

The implementation below is simple but should suffice.

function startswith(target, prefix)
    for (a, b) in zip(target, prefix)
        a == b || return false
    end
    true
end

function endswith(target, suffix)
    for (a, b) in Iterators.reverse(zip(target, suffix))
        a == b || return false
    end
    true
end

Collections lacking inherent order have ambiguous returns, e.g.

d = Dict(i => i + 1 for i = 1:3);
ps = [2 => 3, 3 => 4];
startswith(d, ps)

Of course, there are questions to ask about treatment of arrays -- treat everything as flat? (sensible, easy). Also, potentially introduce a dims kwarg? (seems interesting to explore the concept).
Incidentally, it seems likely that a specialization for ::AbstractArray would provide better performance than the above.

Another question which comes to mind: == or isequal for the comparison? (EDIT: this seems clear -- isequal)

I do not fully endorse the idea below, but one must admit, it is conceivable that it would be of use:

# Equivalent to startswith(f.(target), prefix)
function startswith(f, target, prefix)
    for (a, b) in zip(target, prefix)
        f(a) == b || return false
    end
    true
end

# and an example to match
A = [[1], [1, 1], [1,1,1]]
B = [1,2]
startswith(sum, A, B)

words = ["hello", "world!", "today we study...", "...tomorrow we apply"]
io = IOBuffer()
for word in words
    println(io, word)
end
startswith(length, readlines(io), (5,6))

[jariji]

It's not obvious to me why f would apply to the a but not the b. Either way the f method could be a separate issue.

[andrewjradcliffe]

It's not obvious to me why f would apply to the a but not the b.

I have no preference either way.