deprecate some trues and falses constructors (#24867)

- falses(A::AbstractArray) -> falses(size(A))
  - trues(A::AbstractArray)  -> trues(size(A))

Author: fredrikekre

NEWS.md

@@ -693,6 +693,9 @@ Deprecated or removed
   * `a:b` is deprecated for constructing a `StepRange` when `a` and `b` have physical units
     (Dates and Times). Use `a:s:b`, where `s = Dates.Day(1)` or `s = Dates.Second(1)`.
 
+  * `trues(A::AbstractArray)` and `falses(A::AbstractArray)` are deprecated in favor of
+    `trues(size(A))` and `falses(size(A))` respectively ([#24595]).
+
   * `cumsum`, `cumprod`, `accumulate`, and their mutating versions now require a `dim`
     argument instead of defaulting to using the first dimension ([#24684]).
 

base/bitarray.jl

@@ -382,25 +382,6 @@ julia> falses(2,3)
 """
 falses(dims::Dims) = fill!(BitArray(uninitialized, dims), false)
 falses(dims::Integer...) = falses(map(Int,dims))
-"""
-    falses(A)
-
-Create a `BitArray` with all values set to `false` of the same shape as `A`.
-
-# Examples
-```jldoctest
-julia> A = [1 2; 3 4]
-2×2 Array{Int64,2}:
- 1  2
- 3  4
-
-julia> falses(A)
-2×2 BitArray{2}:
- false  false
- false  false
-```
-"""
-falses(A::AbstractArray) = falses(size(A))
 
 """
     trues(dims)
@@ -417,25 +398,6 @@ julia> trues(2,3)
 """
 trues(dims::Dims) = fill!(BitArray(uninitialized, dims), true)
 trues(dims::Integer...) = trues(map(Int,dims))
-"""
-    trues(A)
-
-Create a `BitArray` with all values set to `true` of the same shape as `A`.
-
-# Examples
-```jldoctest
-julia> A = [1 2; 3 4]
-2×2 Array{Int64,2}:
- 1  2
- 3  4
-
-julia> trues(A)
-2×2 BitArray{2}:
- true  true
- true  true
-```
-"""
-trues(A::AbstractArray) = trues(size(A))
 
 function one(x::BitMatrix)
     m, n = size(x)

base/deprecated.jl

@@ -2162,6 +2162,10 @@ end
 # issue #24822
 @deprecate_binding Display AbstractDisplay
 
+# 24595
+@deprecate falses(A::AbstractArray) falses(size(A))
+@deprecate trues(A::AbstractArray) trues(size(A))
+
 # issue #24794
 @deprecate linspace(start, stop)     linspace(start, stop, 50)
 @deprecate logspace(start, stop)     logspace(start, stop, 50)

doc/src/manual/arrays.md

@@ -54,9 +54,7 @@ omitted it will default to [`Float64`](@ref).
 | [`zeros(T, dims...)`](@ref)                    | an `Array` of all zeros                                                                                                                                                                                                                      |
 | [`ones(T, dims...)`](@ref)                     | an `Array` of all ones                                                                                                                                                                                                                       |
 | [`trues(dims...)`](@ref)                       | a [`BitArray`](@ref) with all values `true`                                                                                                                                                                                                  |
-| [`trues(A)`](@ref)                             | a `BitArray` with all values `true` and the same shape as `A`                                                                                                                                                                                |
 | [`falses(dims...)`](@ref)                      | a `BitArray` with all values `false`                                                                                                                                                                                                         |
-| [`falses(A)`](@ref)                            | a `BitArray` with all values `false` and the same shape as `A`                                                                                                                                                                               |
 | [`reshape(A, dims...)`](@ref)                  | an array containing the same data as `A`, but with different dimensions                                                                                                                                                                      |
 | [`copy(A)`](@ref)                              | copy `A`                                                                                                                                                                                                                                     |
 | [`deepcopy(A)`](@ref)                          | copy `A`, recursively copying its elements                                                                                                                                                                                                   |

test/bitarray.jl

@@ -62,11 +62,11 @@ allsizes = [((), BitArray{0}), ((v1,), BitVector),
     @test b == trues(sz)
     @test all(b)
     @test sz == size(b)
-    c = trues(a)
+    c = trues(size(a))
     @test all(c)
     @test !any(a)
     @test sz == size(c)
-    d = falses(b)
+    d = falses(size(b))
     @test !any(d)
     @test all(b)
     @test sz == size(d)