Introduce occursin() predicate and use it

Also reorganize exports for clarity.

Author: nalimilan

base/abstractarray.jl

@@ -1217,7 +1217,7 @@ _cs(d, a, b) = (a == b ? a : throw(DimensionMismatch(
     "mismatch in dimension $d (expected $a got $b)")))
 
 dims2cat(::Val{n}) where {n} = ntuple(i -> (i == n), Val(n))
-dims2cat(dims) = ntuple(i -> (i in dims), maximum(dims))
+dims2cat(dims) = ntuple(occursin(dims), maximum(dims))
 
 cat(dims, X...) = cat_t(dims, promote_eltypeof(X...), X...)
 

base/deprecated.jl

@@ -2130,16 +2130,16 @@ finalizer(f::Ptr{Void}, o::Function) = invoke(finalizer, Tuple{Ptr{Void}, Any},
 @deprecate search(a::ByteArray, b::Char, i::Integer) findnext(equalto(UInt8(b)), a, i)
 @deprecate search(a::ByteArray, b::Char) findfirst(equalto(UInt8(b)), a)
 
-@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findnext(x -> x in c, s, i)
-@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findfirst(x -> x in c, s)
+@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findnext(occursin(c), s, i)
+@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findfirst(occursin(c), s)
 @deprecate search(s::AbstractString, t::AbstractString, i::Integer) findnext(t, s, i)
 @deprecate search(s::AbstractString, t::AbstractString) findfirst(t, s)
 
 @deprecate search(buf::IOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
 @deprecate search(buf::Base.GenericIOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
 
-@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findprev(x -> x in c, s, i)
-@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findlast(x -> x in c, s)
+@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findprev(occursin(c), s, i)
+@deprecate rsearch(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findlast(occursin(c), s)
 @deprecate rsearch(s::AbstractString, t::AbstractString, i::Integer) findprev(t, s, i)
 @deprecate rsearch(s::AbstractString, t::AbstractString) findlast(t, s)
 @deprecate rsearch(s::ByteArray, t::ByteArray, i::Integer) findprev(t, s, i)

base/exports.jl

@@ -436,18 +436,6 @@ export
     extrema,
     fill!,
     fill,
-    find,
-    findfirst,
-    findlast,
-    findin,
-    findmax,
-    findmin,
-    findmin!,
-    findmax!,
-    findn,
-    findnext,
-    findprev,
-    findnz,
     first,
     flipdim,
     hcat,
@@ -505,9 +493,6 @@ export
     rot180,
     rotl90,
     rotr90,
-    searchsorted,
-    searchsortedfirst,
-    searchsortedlast,
     shuffle,
     shuffle!,
     size,
@@ -532,6 +517,34 @@ export
     view,
     zeros,
 
+# search, find, match and related functions
+    contains,
+    eachmatch,
+    endswith,
+    equalto,
+    find,
+    findfirst,
+    findlast,
+    findin,
+    findmax,
+    findmin,
+    findmin!,
+    findmax!,
+    findn,
+    findnext,
+    findprev,
+    findnz,
+    ismatch,
+    occursin,
+    match,
+    matchall,
+    rsearchindex,
+    searchindex,
+    searchsorted,
+    searchsortedfirst,
+    searchsortedlast,
+    startswith,
+
 # linear algebra
     bkfact!,
     bkfact,
@@ -644,7 +657,6 @@ export
     any!,
     any,
     collect,
-    contains,
     count,
     delete!,
     deleteat!,
@@ -711,7 +723,6 @@ export
 # strings and text output
     ascii,
     base,
-    startswith,
     bin,
     bitstring,
     bytes2hex,
@@ -723,8 +734,6 @@ export
     digits,
     digits!,
     dump,
-    eachmatch,
-    endswith,
     escape_string,
     graphemes,
     hex,
@@ -740,7 +749,6 @@ export
     isdigit,
     isgraph,
     islower,
-    ismatch,
     isnumber,
     isprint,
     ispunct,
@@ -754,8 +762,6 @@ export
     lowercase,
     lpad,
     lstrip,
-    match,
-    matchall,
     ndigits,
     nextind,
     normalize_string,
@@ -771,10 +777,8 @@ export
     repr,
     reverseind,
     rpad,
-    rsearchindex,
     rsplit,
     rstrip,
-    searchindex,
     show,
     showcompact,
     showerror,
@@ -844,7 +848,6 @@ export
     identity,
     isbits,
     isequal,
-    equalto,
     isimmutable,
     isless,
     ifelse,

base/operators.jl

@@ -993,3 +993,22 @@ The returned function is of type `Base.EqualTo`. This allows dispatching to
 specialized methods by using e.g. `f::Base.EqualTo` in a method signature.
 """
 const equalto = EqualTo
+
+struct OccursIn{T} <: Function
+    x::T
+
+    OccursIn(x::T) where {T} = new{T}(x)
+end
+
+(f::OccursIn)(y) = y in f.x
+
+"""
+    occursin(x)
+
+Create a function that checks whether its argument is [`in`](@ref) `x`; i.e. returns
+`y -> y in x`.
+
+The returned function is of type `Base.OccursIn`. This allows dispatching to
+specialized methods by using e.g. `f::Base.OccursIn` in a method signature.
+"""
+const occursin = OccursIn

base/repl/REPLCompletions.jl

@@ -40,7 +40,7 @@ function complete_symbol(sym, ffunc)
 
     lookup_module = true
     t = Union{}
-    if findlast(x -> x in non_identifier_chars, sym) < findlast(equalto('.'), sym)
+    if findlast(occursin(non_identifier_chars), sym) < findlast(equalto('.'), sym)
         # Find module
         lookup_name, name = rsplit(sym, ".", limit=2)
 
@@ -257,7 +257,7 @@ function find_start_brace(s::AbstractString; c_start='(', c_end=')')
     end
     braces != 1 && return 0:-1, -1
     method_name_end = reverseind(r, i)
-    startind = nextind(s, findprev(x -> x in non_identifier_chars, s, method_name_end))
+    startind = nextind(s, findprev(occursin(non_identifier_chars), s, method_name_end))
     return (startind:endof(s), method_name_end)
 end
 
@@ -413,7 +413,7 @@ end
 
 function bslash_completions(string, pos)
     slashpos = findprev(equalto('\\'), string, pos)
-    if (findprev(x -> x in bslash_separators, string, pos) < slashpos &&
+    if (findprev(occursin(bslash_separators), string, pos) < slashpos &&
         !(1 < slashpos && (string[prevind(string, slashpos)]=='\\')))
         # latex / emoji symbol substitution
         s = string[slashpos:pos]
@@ -537,7 +537,7 @@ function completions(string, pos)
     end
 
     dotpos = findprev(equalto('.'), string, pos)
-    startpos = nextind(string, findprev(x -> x in non_identifier_chars, string, pos))
+    startpos = nextind(string, findprev(occursin(non_identifier_chars), string, pos))
 
     ffunc = (mod,x)->true
     suggestions = String[]

base/strings/util.jl

@@ -279,7 +279,7 @@ split(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:SubString}
     _split(str, splitter, limit, keep, T[])
 split(str::T, splitter::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}};
       limit::Integer=0, keep::Bool=true) where {T<:SubString} =
-    _split(str, x -> x in splitter, limit, keep, T[])
+    _split(str, occursin(splitter), limit, keep, T[])
 split(str::T, splitter::Char; limit::Integer=0, keep::Bool=true) where {T<:SubString} =
     _split(str, equalto(splitter), limit, keep, T[])
 
@@ -314,7 +314,7 @@ split(str::T, splitter;
     _split(str, splitter, limit, keep, SubString{T}[])
 split(str::T, splitter::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}};
       limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
-    _split(str, x -> x in splitter, limit, keep, SubString{T}[])
+    _split(str, occursin(splitter), limit, keep, SubString{T}[])
 split(str::T, splitter::Char;
       limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
     _split(str, equalto(splitter), limit, keep, SubString{T}[])
@@ -378,7 +378,7 @@ rsplit(str::T, splitter; limit::Integer=0, keep::Bool=true) where {T<:AbstractSt
     _rsplit(str, splitter, limit, keep, SubString{T}[])
 rsplit(str::T, splitter::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}};
     limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
-  _rsplit(str, x -> x in splitter, limit, keep, SubString{T}[])
+  _rsplit(str, occursin(splitter), limit, keep, SubString{T}[])
 rsplit(str::T, splitter::Char;
     limit::Integer=0, keep::Bool=true) where {T<:AbstractString} =
   _rsplit(str, equalto(splitter), limit, keep, SubString{T}[])
@@ -413,7 +413,7 @@ replace_new(str::String, pattern::Char, repl, count::Integer) =
     replace_new(str, equalto(pattern), repl, count)
 replace_new(str::String, pattern::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}},
             repl, count::Integer) =
-    replace_new(str, x -> x in pattern, repl, count)
+    replace_new(str, occursin(pattern), repl, count)
 function replace_new(str::String, pattern, repl, count::Integer)
     count == 0 && return str
     count < 0 && throw(DomainError(count, "`count` must be non-negative."))

test/arrayops.jl

@@ -1184,7 +1184,7 @@ end
 
         # logical indexing
         a = [1:10;]; acopy = copy(a)
-        @test deleteat!(a, map(i -> i in idx, 1:length(a))) == [acopy[1:(first(idx)-1)]; acopy[(last(idx)+1):end]]
+        @test deleteat!(a, map(occursin(idx), 1:length(a))) == [acopy[1:(first(idx)-1)]; acopy[(last(idx)+1):end]]
     end
     a = [1:10;]
     @test deleteat!(a, 11:10) == [1:10;]

test/bitset.jl

@@ -6,7 +6,7 @@
     data_in = (1,5,100)
     s = BitSet(data_in)
     data_out = collect(s)
-    @test all(map(d->in(d,data_out), data_in))
+    @test all(map(occursin(data_out), data_in))
     @test length(data_out) === length(data_in)
 end
 

test/choosetests.jl

@@ -165,7 +165,7 @@ function choosetests(choices = [])
     end
 
     if !net_on
-        filter!(x -> !(x in net_required_for), tests)
+        filter!(!occursin(net_required_for), tests)
     end
 
     if "stdlib" in skip_tests
@@ -182,7 +182,7 @@ function choosetests(choices = [])
         filter!(x -> (x != "Profile"), tests)
     end
 
-    filter!(x -> !(x in skip_tests), tests)
+    filter!(!occursin(skip_tests), tests)
 
     tests, net_on, exit_on_error, seed
 end

test/distributed_exec.jl

@@ -1090,7 +1090,7 @@ if DoFullTest
     pids=addprocs_with_testenv(4);
     @test_throws ErrorException rmprocs(pids; waitfor=0.001);
     # wait for workers to be removed
-    while any(x -> (x in procs()), pids)
+    while any(occursin(procs()), pids)
         sleep(0.1)
     end
 end
@@ -1555,7 +1555,7 @@ function reuseport_tests()
     end
 
     # Ensure that the code has indeed been successfully executed everywhere
-    @test all(p -> p in results, procs())
+    @test all(occursin(results), procs())
 end
 
 # Test that the client port is reused. SO_REUSEPORT may not be supported on

test/sets.jl

@@ -11,7 +11,7 @@ using Main.TestHelpers.OAs
     s = Set(data_in)
     data_out = collect(s)
     @test ===(typeof(data_out), Array{Any,1})
-    @test all(map(d->in(d,data_out), data_in))
+    @test all(map(occursin(data_out), data_in))
     @test length(data_out) == length(data_in)
     let f17741 = x -> x < 0 ? false : 1
         @test isa(Set(x for x = 1:3), Set{Int})

test/strings/search.jl

@@ -17,9 +17,9 @@ end
 # sure that findnext/findprev/searchindex/rsearchindex are consistent
 # no matter what type of AbstractString the second argument is
 @test_throws BoundsError findnext(equalto('a'), "foo", 0)
-@test_throws BoundsError findnext(x -> x in Char[], "foo", 5)
-# @test_throws BoundsError findprev(x -> x in Char[], "foo", 0)
-@test_throws BoundsError findprev(x -> x in Char[], "foo", 5)
+@test_throws BoundsError findnext(occursin(Char[]), "foo", 5)
+# @test_throws BoundsError findprev(occursin(Char[]), "foo", 0)
+@test_throws BoundsError findprev(occursin(Char[]), "foo", 5)
 
 # @test_throws BoundsError searchindex("foo", Char[], 0)
 # @test_throws BoundsError searchindex("foo", Char[], 5)