Backport keepat! (#770) and README update (#772) to 3.44.0 (#773)

Project.toml

@@ -1,6 +1,6 @@
 name = "Compat"
 uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "3.43.0"
+version = "3.44.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

README.md

@@ -22,11 +22,26 @@ To use Compat in your Julia package, add it as a dependency of your package usin
 ```julia
 pkg> add Compat
 ```
-and add a [version specifier line](https://julialang.github.io/Pkg.jl/v1/compatibility/#Version-specifier-format-1) such as `Compat = "2.2, 3"` in the `[compat]`section of the `Project.toml` file
+and add a [version specifier line](https://julialang.github.io/Pkg.jl/v1/compatibility/#Version-specifier-format-1)
+such as `Compat = "3.22, 4"` in the `[compat]`section of the `Project.toml` file
 in your package directory. The version in the latter should be the minimum
-version that supports all needed fatures (see list below), and (if applicable)
-any newer major versions verified to be compatible. Then, in your package,
-shortly after the `module` statement a line like this:
+version that supports all needed features (see list below). Note that Compat v4
+requires Julia v1.6, but some features may have been backported to Compat v3
+(see the
+[feature list of the release-3 branch](https://github.com/JuliaLang/Compat.jl/tree/release-3#supported-features)).
+If you require any of those backported features, be sure to specify the correct
+compatibility in your `Project.toml`. E.g. if the feature from Compat v4.x has
+been backported to v3.y, use `Compat = 3.y, 4.x`. If you use a feature that had
+originally been added in Compat v3 (e.g. in 3.x), don't forget to also declare
+compatibility with v4 with `Compat = 3.x, 4` (unless you use one the very few
+things that got removed between Compat v3 and v4, which you most probably
+don't).
+
+To minimize dependency conflicts between packages it is recommended that packages
+allow for both appropriate v4 and v3 versions of Compat.jl in their Project.toml
+(except for rare cases of packages that support only v4 or v3 version of Compat.jl).
+
+Then, in your package, shortly after the `module` statement a line like this:
 
 ```julia
 using Compat
@@ -54,6 +69,9 @@ changes in `julia`.
 
 ## Supported features
 
+* `keepat!` removes the items at all the indices which are not given and returns
+  the modified source ([#36229], [#42351]). (since Compat 3.44.0, 4.1.0)
+
 * `@compat (; a, b) = (; c=1, b=2, a=3)` supports property descturing assignment syntax ([#39285]).
 
 * `allequal`, the opposite of `allunique` ([#43354]). (since Compat 3.42.0)
@@ -296,3 +314,7 @@ Note that you should specify the correct minimum version for `Compat` in the
 [#41328]: https://github.com/JuliaLang/julia/pull/41328
 [#43354]: https://github.com/JuliaLang/julia/pull/43354
 [#39285]: https://github.com/JuliaLang/julia/pull/39285
+[#29901]: https://github.com/JuliaLang/julia/issues/29901
+[#36229]: https://github.com/JuliaLang/julia/issues/36229
+[#39245]: https://github.com/JuliaLang/julia/issues/39245
+[#42351]: https://github.com/JuliaLang/julia/issues/42351

src/Compat.jl

@@ -1238,9 +1238,9 @@ if VERSION < v"1.8.0-DEV.300"
 end
 
 # https://github.com/JuliaLang/julia/pull/39245
-if VERSION < v"1.8.0-DEV.487"  
+if VERSION < v"1.8.0-DEV.487"
     export eachsplit
-    
+
     """
         eachsplit(str::AbstractString, dlm; limit::Integer=0)
         eachsplit(str::AbstractString; limit::Integer=0)
@@ -1249,14 +1249,14 @@ if VERSION < v"1.8.0-DEV.487"
     substrings.  `dlm` can be any of the formats allowed by [`findnext`](@ref)'s first argument
     (i.e. as a string, regular expression or a function), or as a single character or collection
     of characters.
-    
+
     If `dlm` is omitted, it defaults to [`isspace`](@ref).
-    
+
     The iterator will return a maximum of `limit` results if the keyword argument is supplied.
     The default of `limit=0` implies no maximum.
-    
+
     See also [`split`](@ref).
-    
+
     # Examples
     ```julia
     julia> a = "Ma.rch"
@@ -1268,7 +1268,7 @@ if VERSION < v"1.8.0-DEV.487"
     ```
     """
     function eachsplit end
-    
+
     struct SplitIterator{S<:AbstractString,F}
         str::S
         splitter::F
@@ -1278,13 +1278,13 @@ if VERSION < v"1.8.0-DEV.487"
 
     Base.eltype(::Type{<:SplitIterator}) = SubString
     Base.IteratorSize(::Type{<:SplitIterator}) = Base.SizeUnknown()
-    
+
     function Base.iterate(iter::SplitIterator, (i, k, n)=(firstindex(iter.str), firstindex(iter.str), 0))
         i - 1 > ncodeunits(iter.str)::Int && return nothing
         r = findnext(iter.splitter, iter.str, k)::Union{Nothing,Int,UnitRange{Int}}
         while r !== nothing && n != iter.limit - 1 && first(r) <= ncodeunits(iter.str)
             r = r::Union{Int,UnitRange{Int}} #commit dcc2182db228935fe97d03a44ae3b6889e40c542
-            #follow #39245, improve inferrability of iterate(::SplitIterator)            
+            #follow #39245, improve inferrability of iterate(::SplitIterator)
             #Somehow type constraints from the complex `while` condition don't
             #propagate to the `while` body.
             j, k = first(r), nextind(iter.str, last(r))::Int
@@ -1323,6 +1323,47 @@ if VERSION < v"1.8.0-DEV.1494" # 98e60ffb11ee431e462b092b48a31a1204bd263d
     allequal(r::AbstractRange) = iszero(step(r)) || length(r) <= 1
 end
 
+# This function is available as of Julia 1.7.
+@static if !isdefined(Base, :keepat!)
+    export keepat!
+
+    keepat!(B::BitVector, inds) = _keepat!(B, inds)
+    keepat!(B::BitVector, inds::AbstractVector{Bool}) = _keepat!(B, inds)
+    keepat!(a::Vector, inds) = _keepat!(a, inds)
+    keepat!(a::Vector, m::AbstractVector{Bool}) = _keepat!(a, m)
+
+    function _keepat!(a::AbstractVector, inds)
+        local prev
+        i = firstindex(a)
+        for k in inds
+            if @isdefined(prev)
+                prev < k || throw(ArgumentError("indices must be unique and sorted"))
+            end
+            ak = a[k] # must happen even when i==k for bounds checking
+            if i != k
+                @inbounds a[i] = ak # k > i, so a[i] is inbounds
+            end
+            prev = k
+            i = nextind(a, i)
+        end
+        deleteat!(a, i:lastindex(a))
+        return a
+    end
+
+    function _keepat!(a::AbstractVector, m::AbstractVector{Bool})
+        length(m) == length(a) || throw(BoundsError(a, m))
+        j = firstindex(a)
+        for i in eachindex(a, m)
+            @inbounds begin
+                if m[i]
+                    i == j || (a[j] = a[i])
+                    j = nextind(a, j)
+                end
+            end
+        end
+        deleteat!(a, j:lastindex(a))
+    end
+end
 
 include("iterators.jl")
 include("deprecated.jl")

test/runtests.jl

@@ -1316,8 +1316,8 @@ end
 #=
 cmcaine commented on Sep 8, 2021
 
-This PR implements split with eachsplit and uses eachsplit in a few other places in Base, 
-so it's kind of already covered by the existing tests. 
+This PR implements split with eachsplit and uses eachsplit in a few other places in Base,
+so it's kind of already covered by the existing tests.
 Not sure it needs any more?
 
 so, these are the Base.split tests, but replacing split with eachsplit |> collect
@@ -1413,3 +1413,41 @@ end
     @test !allequal(LinRange(1, 2, 2))
 end
 
+@testset "keepat!" begin
+    a = [1:6;]
+    @test a === keepat!(a, 1:5)
+    @test a == 1:5
+    @test keepat!(a, [2, 4]) == [2, 4]
+    @test isempty(keepat!(a, []))
+
+    a = [1:6;]
+    @test_throws BoundsError keepat!(a, 1:10) # make sure this is not a no-op
+    @test_throws BoundsError keepat!(a, 2:10)
+    @test_throws ArgumentError keepat!(a, [2, 4, 3])
+
+    b = BitVector([1, 1, 1, 0, 0])
+    @test b === keepat!(b, 1:5)
+    @test b == [1, 1, 1, 0, 0]
+    @test keepat!(b, 2:4) == [1, 1, 0]
+    @test_throws BoundsError keepat!(a, -1:10)
+    @test_throws ArgumentError keepat!(a, [2, 1])
+    @test isempty(keepat!(a, []))
+
+    # Vector
+    a = Vector(1:10)
+    keepat!(a, [falses(5); trues(5)])
+    @test a == 6:10
+    @test_throws BoundsError keepat!(a, trues(1))
+    @test_throws BoundsError keepat!(a, trues(11))
+
+    # BitVector
+    ba = rand(10) .> 0.5
+    @test isa(ba, BitArray)
+    keepat!(ba, ba)
+    @test all(ba)
+
+    # empty array
+    ea = []
+    keepat!(ea, Bool[])
+    @test isempty(ea)
+end