add partially-applied versions of ∋, ∉, ∌, occursin (#38475)

NEWS.md

@@ -113,6 +113,10 @@ New library features
 * `keys(io::IO)` has been added, which returns all keys of `io` if `io` is an `IOContext` and an empty
   `Base.KeySet` otherwise ([#37753]).
 * `count` now accepts an optional `init` argument to control the accumulation type ([#37461]).
+* New method `occursin(haystack)` that returns a function that checks whether its argument occurs in
+  `haystack` ([#38475]).
+* New methods `∉(collection)`, `∋(item)`, and `∌(item)` returning corresponding containment-testing
+  functions ([#38475]).
 
 Standard library changes
 ------------------------

base/operators.jl

@@ -1092,13 +1092,14 @@ julia> map(Base.splat(+), zip(1:3,4:6))
 """
 splat(f) = args->f(args...)
 
-## in & contains
+## in and related operators
 
 """
-    in(x)
+    in(collection)
+    ∈(collection)
 
-Create a function that checks whether its argument is [`in`](@ref) `x`, i.e.
-a function equivalent to `y -> y in x`. See also [`insorted`](@ref) for the use
+Create a function that checks whether its argument is [`in`](@ref) `collection`, i.e.
+a function equivalent to `y -> y in collection`. See also [`insorted`](@ref) for use
 with sorted collections.
 
 The returned function is of type `Base.Fix2{typeof(in)}`, which can be
@@ -1120,14 +1121,31 @@ function in(x, itr)
 end
 
 const ∈ = in
-∋(itr, x) = ∈(x, itr)
 ∉(x, itr) = !∈(x, itr)
+∉(itr) = Fix2(∉, itr)
+
+"""
+    ∋(collection, item) -> Bool
+
+Like [`in`](@ref), but with arguments in reverse order.
+Avoid adding methods to this function; define `in` instead.
+"""
+∋(itr, x) = in(x, itr)
+
+"""
+    ∋(item)
+
+Create a function that checks whether its argument contains the given `item`, i.e.
+a function equivalent to `y -> item in y`.
+"""
+∋(x) = Fix2(∋, x)
+
 ∌(itr, x) = !∋(itr, x)
+∌(x) = Fix2(∌, x)
 
 """
     in(item, collection) -> Bool
     ∈(item, collection) -> Bool
-    ∋(collection, item) -> Bool
 
 Determine whether an item is in the given collection, in the sense that it is
 [`==`](@ref) to one of the values generated by iterating over the collection.
@@ -1194,7 +1212,7 @@ julia> [1, 2] .∈ ([2, 3],)
  1
 ```
 """
-in, ∋
+in
 
 """
     ∉(item, collection) -> Bool

base/strings/search.jl

@@ -621,4 +621,14 @@ See also: [`contains`](@ref).
 occursin(needle::Union{AbstractString,AbstractChar}, haystack::AbstractString) =
     _searchindex(haystack, needle, firstindex(haystack)) != 0
 
+"""
+    occursin(haystack)
+
+Create a function that checks whether its argument occurs in `haystack`, i.e.
+a function equivalent to `needle -> occursin(needle, haystack)`.
+
+The returned function is of type `Base.Fix2{typeof(occursin)}`.
+"""
+occursin(haystack) = Base.Fix2(occursin, haystack)
+
 in(::AbstractString, ::AbstractString) = error("use occursin(x, y) for string containment")

test/operators.jl

@@ -244,5 +244,14 @@ end
     @test lt5(4) && !lt5(5)
 end
 
+@testset "ni" begin
+    @test ∋([1,5,10,11], 5)
+    @test !∋([1,10,11], 5)
+    @test ∋(5)([5,1])
+    @test !∋(42)([0,1,100])
+    @test ∌(0)(1:10)
+    @test ∋(0)(-2:2)
+end
+
 a = rand(3, 3)
 @test transpose(a) === a'ᵀ

test/strings/search.jl

@@ -355,6 +355,9 @@ end
 # occursin with a String and Char needle
 @test occursin("o", "foo")
 @test occursin('o', "foo")
+# occursin in curried form
+@test occursin("foo")("o")
+@test occursin("foo")('o')
 
 # contains
 @test contains("foo", "o")