Create Compat.Iterators; add takewhile, dropwhile and map (#715)

Author: tkf

README.md

@@ -55,6 +55,12 @@ changes in `julia`.
 
 ## Supported features
 
+* `Compat.Iterators.map` is added. It provides another syntax `Iterators.map(f, iterators...)`
+  for writing `(f(args...) for args in zip(iterators...))`, i.e. a lazy `map`  ([#34352]).
+  (since Compat 3.14)
+
+* `takewhle` and `dropwhile` are added in `Compat.Iterators` ([#33437]). (since Compat 3.14)
+
 * Curried comparisons `!=(x)`, `>=(x)`, `<=(x)`, `>(x)`, and `<(x)` are defined as, e.g.,
   `!=(x) = y -> y != x` ([#30915]). (since Compat 3.14)
 
@@ -184,3 +190,5 @@ Note that you should specify the correct minimum version for `Compat` in the
 [#36360]: https://github.com/JuliaLang/julia/pull/36360
 [#35929]: https://github.com/JuliaLang/julia/pull/35929
 [#30915]: https://github.com/JuliaLang/julia/pull/30915
+[#33437]: https://github.com/JuliaLang/julia/pull/33437
+[#34352]: https://github.com/JuliaLang/julia/pull/34352

src/Compat.jl

@@ -594,6 +594,7 @@ if VERSION < v"1.2.0-DEV.257" # e7e726b3df1991e1306ef0c566d363c0a83b2dea
     Base.:(<)(x) = Base.Fix2(<, x)
 end
 
+include("iterators.jl")
 include("deprecated.jl")
 
 end # module Compat

src/iterators.jl

@@ -0,0 +1,92 @@
+module CompatIterators
+# Defining this module with the name `CompatIterators` and define
+# `const Iterators = CompatIterators` at the end of this file so that
+#
+#     julia> using Compat.Iterators
+#
+#     julia> Iterators
+#     Base.Iterators
+#
+#     julia> takewhile
+#     takewhile (generic function with 1 method)
+#
+# works without conflict in identifiers in all Julia versions.  Users
+# still need to explicitly import `Compat.Iterators` via `using
+# Compat: Iterators` to use, e.g., `Iterators.map` before Julia 1.6.
+# This is the case with and without the `CompatIterators` hack.
+
+using Base: SizeUnknown
+
+# We normally use `Base.f(...) = ...` style for overloading.  However,
+# we use `import Base: f` style here to make synchronizing the code
+# with `Base` easier.
+import Base: IteratorEltype, IteratorSize, eltype, iterate
+
+# Import exported APIs
+for n in names(Base.Iterators)
+    n === :Iterators && continue
+    @eval begin
+        using Base.Iterators: $n
+        export $n
+    end
+end
+
+# Import unexported public APIs
+using Base.Iterators: filter
+
+# https://github.com/JuliaLang/julia/pull/33437
+if VERSION < v"1.4.0-DEV.291"  # 5f013d82f92026f7dfbe4234f283658beb1f8a2a
+    export takewhile, dropwhile
+
+    # takewhile
+    struct TakeWhile{I,P<:Function}
+        pred::P
+        xs::I
+    end
+
+    takewhile(pred,xs) = TakeWhile(pred,xs)
+
+    function iterate(ibl::TakeWhile, itr...)
+        y = iterate(ibl.xs,itr...)
+        y === nothing && return nothing
+        ibl.pred(y[1]) || return nothing
+        y
+    end
+
+    IteratorSize(::Type{<:TakeWhile}) = SizeUnknown()
+    eltype(::Type{TakeWhile{I,P}}) where {I,P} = eltype(I)
+    IteratorEltype(::Type{TakeWhile{I,P}}) where {I,P} = IteratorEltype(I)
+
+    # dropwhile
+    struct DropWhile{I,P<:Function}
+        pred::P
+        xs::I
+    end
+
+    dropwhile(pred,itr) = DropWhile(pred,itr)
+
+    iterate(ibl::DropWhile,itr) = iterate(ibl.xs, itr)
+    function iterate(ibl::DropWhile)
+        y = iterate(ibl.xs)
+        while y !== nothing
+            ibl.pred(y[1]) || break
+            y = iterate(ibl.xs,y[2])
+        end
+        y
+    end
+
+    IteratorSize(::Type{<:DropWhile}) = SizeUnknown()
+    eltype(::Type{DropWhile{I,P}}) where {I,P} = eltype(I)
+    IteratorEltype(::Type{DropWhile{I,P}}) where {I,P} = IteratorEltype(I)
+end
+
+# https://github.com/JuliaLang/julia/pull/34352
+if VERSION < v"1.6.0-DEV.258"  # 1f8b44204fafb1caabc6a1cd6ca39458a550e2fc
+    map(f, args...) = Base.Generator(f, args...)
+else
+    using Base.Iterators: map
+end
+
+end  # module
+
+const Iterators = CompatIterators

test/iterators.jl

@@ -0,0 +1,40 @@
+module TestIterators
+
+using Compat.Iterators
+using Compat: Compat, Iterators
+using Test
+
+# https://github.com/JuliaLang/julia/pull/33437
+@testset "takewhile" begin
+    @test collect(takewhile(<(4),1:10)) == [1,2,3]
+    @test collect(takewhile(<(4),Iterators.countfrom(1))) == [1,2,3]
+    @test collect(takewhile(<(4),5:10)) == []
+    @test collect(takewhile(_->true,5:10)) == 5:10
+    @test collect(takewhile(isodd,[1,1,2,3])) == [1,1]
+    @test collect(takewhile(<(2), takewhile(<(3), [1,1,2,3]))) == [1,1]
+end
+
+# https://github.com/JuliaLang/julia/pull/33437
+@testset "dropwhile" begin
+    @test collect(dropwhile(<(4), 1:10)) == 4:10
+    @test collect(dropwhile(<(4), 1:10)) isa Vector{Int}
+    @test isempty(dropwhile(<(4), []))
+    @test collect(dropwhile(_->false,1:3)) == 1:3
+    @test isempty(dropwhile(_->true, 1:3))
+    @test collect(dropwhile(isodd,[1,1,2,3])) == [2,3]
+    @test collect(dropwhile(iseven,dropwhile(isodd,[1,1,2,3]))) == [3]
+end
+
+# https://github.com/JuliaLang/julia/pull/34352
+@testset "Iterators.map" begin
+    @test collect(Iterators.map(string, 1:3)::Base.Generator) == map(string, 1:3)
+    @test collect(Iterators.map(tuple, 1:3, 4:6)::Base.Generator) == map(tuple, 1:3, 4:6)
+end
+
+@testset "Iterators.filter" begin
+    # `Iterators.filter` already existed in Julia 1.0.  We just make
+    # sure that it is available under `Compat.Iterators` namespace.
+    @test Compat.Iterators.filter === Base.Iterators.filter
+end
+
+end  # module

test/runtests.jl

@@ -545,4 +545,6 @@ end
     @test lt5(4) && !lt5(5)
 end
 
+include("iterators.jl")
+
 nothing