Deprecate ~ in favor of flipbits

Author: ararslan

NEWS.md

@@ -937,6 +937,8 @@ Deprecated or removed
 
   * `findin(a, b)` has been deprecated in favor of `find(occursin(b), a)` ([#24673]).
 
+  * `~` has been deprecated in favor of `flipbits` ([#25514]).
+
 
 Command-line option changes
 ---------------------------
@@ -1187,3 +1189,4 @@ Command-line option changes
 [#25231]: https://github.com/JuliaLang/julia/issues/25231
 [#25365]: https://github.com/JuliaLang/julia/issues/25365
 [#25424]: https://github.com/JuliaLang/julia/issues/25424
+[#25514]: https://github.com/JuliaLang/julia/issues/25514

base/atomics.jl

@@ -203,7 +203,7 @@ function atomic_and! end
 
 Atomically bitwise-nand (not-and) `x` with `val`
 
-Performs `x[] = ~(x[] & val)` atomically. Returns the **old** value.
+Performs `x[] = flipbits(x[] & val)` atomically. Returns the **old** value.
 
 For further details, see LLVM's `atomicrmw nand` instruction.
 

base/bitarray.jl

@@ -81,7 +81,7 @@ IndexStyle(::Type{<:BitArray}) = IndexLinear()
 
 ## aux functions ##
 
-const _msk64 = ~UInt64(0)
+const _msk64 = flipbits(UInt64(0))
 @inline _div64(l) = l >> 6
 @inline _mod64(l) = l & 63
 @inline _msk_end(l::Integer) = _msk64 >>> _mod64(-l)
@@ -94,7 +94,7 @@ function glue_src_bitchunks(src::Vector{UInt64}, k::Int, ks1::Int, msk_s0::UInt6
     @inbounds begin
         chunk = ((src[k] & msk_s0) >>> ls0)
         if ks1 > k && ls0 > 0
-            chunk_n = (src[k + 1] & ~msk_s0)
+            chunk_n = (src[k + 1] & flipbits(msk_s0))
             chunk |= (chunk_n << (64 - ls0))
         end
     end
@@ -117,20 +117,20 @@ function copy_chunks!(dest::Vector{UInt64}, pos_d::Integer, src::Vector{UInt64},
 
     u = _msk64
     if delta_kd == 0
-        msk_d0 = ~(u << ld0) | (u << (ld1+1))
+        msk_d0 = flipbits(u << ld0) | (u << (ld1 + 1))
     else
-        msk_d0 = ~(u << ld0)
+        msk_d0 = flipbits(u << ld0)
         msk_d1 = (u << (ld1+1))
     end
     if delta_ks == 0
-        msk_s0 = (u << ls0) & ~(u << (ls1+1))
+        msk_s0 = (u << ls0) & flipbits(u << (ls1+1))
     else
         msk_s0 = (u << ls0)
     end
 
     chunk_s0 = glue_src_bitchunks(src, ks0, ks1, msk_s0, ls0)
 
-    dest[kd0] = (dest[kd0] & msk_d0) | ((chunk_s0 << ld0) & ~msk_d0)
+    dest[kd0] = (dest[kd0] & msk_d0) | ((chunk_s0 << ld0) & flipbits(msk_d0))
 
     delta_kd == 0 && return
 
@@ -152,7 +152,7 @@ function copy_chunks!(dest::Vector{UInt64}, pos_d::Integer, src::Vector{UInt64},
 
     chunk_s = (chunk_s0 >>> (64 - ld0)) | (chunk_s1 << ld0)
 
-    dest[kd1] = (dest[kd1] & msk_d1) | (chunk_s & ~msk_d1)
+    dest[kd1] = (dest[kd1] & msk_d1) | (chunk_s & flipbits(msk_d1))
 
     return
 end
@@ -177,24 +177,24 @@ function copy_chunks_rtol!(chunks::Vector{UInt64}, pos_d::Integer, pos_s::Intege
         delta_ks = ks1 - ks0
 
         if delta_kd == 0
-            msk_d0 = ~(u << ld0) | (u << (ld1+1))
+            msk_d0 = flipbits(u << ld0) | (u << (ld1+1))
         else
-            msk_d0 = ~(u << ld0)
+            msk_d0 = flipbits(u << ld0)
             msk_d1 = (u << (ld1+1))
         end
         if delta_ks == 0
-            msk_s0 = (u << ls0) & ~(u << (ls1+1))
+            msk_s0 = (u << ls0) & flipbits(u << (ls1 + 1))
         else
             msk_s0 = (u << ls0)
         end
 
-        chunk_s0 = glue_src_bitchunks(chunks, ks0, ks1, msk_s0, ls0) & ~(u << s)
-        chunks[kd0] = (chunks[kd0] & msk_d0) | ((chunk_s0 << ld0) & ~msk_d0)
+        chunk_s0 = glue_src_bitchunks(chunks, ks0, ks1, msk_s0, ls0) & flipbits(u << s)
+        chunks[kd0] = (chunks[kd0] & msk_d0) | ((chunk_s0 << ld0) & flipbits(msk_d0))
 
         if delta_kd != 0
             chunk_s = (chunk_s0 >>> (64 - ld0))
 
-            chunks[kd1] = (chunks[kd1] & msk_d1) | (chunk_s & ~msk_d1)
+            chunks[kd1] = (chunks[kd1] & msk_d1) | (chunk_s & flipbits(msk_d1))
         end
 
         left -= s
@@ -212,10 +212,10 @@ function fill_chunks!(Bc::Array{UInt64}, x::Bool, pos::Integer, numbits::Integer
 
     u = _msk64
     if k1 == k0
-        msk0 = (u << l0) & ~(u << (l1+1))
+        msk0 = (u << l0) & flipbits(u << (l1 + 1))
     else
         msk0 = (u << l0)
-        msk1 = ~(u << (l1+1))
+        msk1 = flipbits(u << (l1 + 1))
     end
     @inbounds if x
         Bc[k0] |= msk0
@@ -224,11 +224,11 @@ function fill_chunks!(Bc::Array{UInt64}, x::Bool, pos::Integer, numbits::Integer
         end
         k1 > k0 && (Bc[k1] |= msk1)
     else
-        Bc[k0] &= ~msk0
+        Bc[k0] &= flipbits(msk0)
         for k = k0+1:k1-1
             Bc[k] = 0
         end
-        k1 > k0 && (Bc[k1] &= ~msk1)
+        k1 > k0 && (Bc[k1] &= flipbits(msk1))
     end
 end
 
@@ -253,10 +253,10 @@ function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{Bool}
 
     u = _msk64
     if delta_kd == 0
-        msk_d0 = msk_d1 = ~(u << ld0) | (u << (ld1+1))
+        msk_d0 = msk_d1 = flipbits(u << ld0) | (u << (ld1+1))
         lt0 = ld1
     else
-        msk_d0 = ~(u << ld0)
+        msk_d0 = flipbits(u << ld0)
         msk_d1 = (u << (ld1+1))
         lt0 = 63
     end
@@ -269,7 +269,7 @@ function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{Bool}
             c |= (UInt64(C[ind]) << j)
             ind += 1
         end
-        Bc[kd0] = (Bc[kd0] & msk_d0) | (c & ~msk_d0)
+        Bc[kd0] = (Bc[kd0] & msk_d0) | (c & flipbits(msk_d0))
         bind += 1
     end
 
@@ -306,7 +306,7 @@ function copy_to_bitarray_chunks!(Bc::Vector{UInt64}, pos_d::Int, C::Array{Bool}
             c |= (UInt64(C[ind]) << j)
             ind += 1
         end
-        Bc[kd1] = (Bc[kd1] & msk_d1) | (c & ~msk_d1)
+        Bc[kd1] = (Bc[kd1] & msk_d1) | (c & flipbits(msk_d1))
     end
 end
 
@@ -408,7 +408,7 @@ function copyto!(dest::BitArray, src::BitArray)
             destc[nc] = srcc[nc]
         else
             msk_s = _msk_end(src)
-            msk_d = ~msk_s
+            msk_d = flipbits(msk_s)
             destc[nc] = (msk_d & destc[nc]) | (msk_s & srcc[nc])
         end
     end
@@ -634,7 +634,7 @@ end
     u = UInt64(1) << i2
     @inbounds begin
         c = Bc[i1]
-        Bc[i1] = ifelse(x, c | u, c & ~u)
+        Bc[i1] = ifelse(x, c | u, c & flipbits(u))
     end
 end
 
@@ -676,7 +676,7 @@ function _unsafe_setindex!(B::BitArray, x, I::BitArray)
         end
     else
         for i = 1:length(Bc)
-            Bc[i] &= ~Ic[i]
+            Bc[i] &= flipbits(Ic[i])
         end
     end
     return B
@@ -705,7 +705,7 @@ function _unsafe_setindex!(B::BitArray, X::AbstractArray, I::BitArray)
             if Imsk & u != 0
                 lx < c && throw_setindex_mismatch(X, c)
                 @inbounds x = convert(Bool, X[c])
-                C = ifelse(x, C | u, C & ~u)
+                C = ifelse(x, C | u, C & flipbits(u))
                 c += 1
             end
             u <<= 1
@@ -879,7 +879,7 @@ function insert!(B::BitVector, i::Integer, item)
     end
 
     msk_aft = (_msk64 << j)
-    msk_bef = ~msk_aft
+    msk_bef = flipbits(msk_aft)
     Bc[k] = (msk_bef & Bc[k]) | ((msk_aft & Bc[k]) << 1)
     B[i] = item
     B
@@ -889,7 +889,7 @@ function _deleteat!(B::BitVector, i::Integer)
     k, j = get_chunks_id(i)
 
     msk_bef = _msk64 >>> (63 - j)
-    msk_aft = ~msk_bef
+    msk_aft = flipbits(msk_bef)
     msk_bef >>>= 1
 
     Bc = B.chunks
@@ -1088,13 +1088,13 @@ function (-)(B::BitArray)
 end
 broadcast(::typeof(sign), B::BitArray) = copy(B)
 
-function broadcast(::typeof(~), B::BitArray)
+function broadcast(::typeof(flipbits), B::BitArray)
     C = similar(B)
     Bc = B.chunks
     if !isempty(Bc)
         Cc = C.chunks
         for i = 1:length(Bc)
-            Cc[i] = ~Bc[i]
+            Cc[i] = flipbits(Bc[i])
         end
         Cc[end] &= _msk_end(B)
     end
@@ -1104,7 +1104,7 @@ end
 """
     flipbits!(B::BitArray{N}) -> BitArray{N}
 
-Performs a bitwise not operation on `B`. See [`~`](@ref).
+Performs a bitwise not operation on `B`. See [`flipbits`](@ref).
 
 # Examples
 ```jldoctest
@@ -1123,7 +1123,7 @@ function flipbits!(B::BitArray)
     Bc = B.chunks
     @inbounds if !isempty(Bc)
         for i = 1:length(Bc)
-            Bc[i] = ~Bc[i]
+            Bc[i] = flipbits(Bc[i])
         end
         Bc[end] &= _msk_end(B)
     end
@@ -1162,7 +1162,7 @@ broadcast(::typeof(&), B::BitArray, x::Bool) = x ? copy(B) : falses(size(B))
 broadcast(::typeof(&), x::Bool, B::BitArray) = broadcast(&, B, x)
 broadcast(::typeof(|), B::BitArray, x::Bool) = x ? trues(size(B)) : copy(B)
 broadcast(::typeof(|), x::Bool, B::BitArray) = broadcast(|, B, x)
-broadcast(::typeof(xor), B::BitArray, x::Bool) = x ? .~B : copy(B)
+broadcast(::typeof(xor), B::BitArray, x::Bool) = x ? flipbits.(B) : copy(B)
 broadcast(::typeof(xor), x::Bool, B::BitArray) = broadcast(xor, B, x)
 for f in (:&, :|, :xor)
     @eval begin
@@ -1471,7 +1471,7 @@ end
 
 #findfirst(B::BitArray) = findnext(B, 1)  ## defined in array.jl
 
-# aux function: same as findnext(~B, start), but performed without temporaries
+# aux function: same as findnext(flipbits(B), start), but performed without temporaries
 function findnextnot(B::BitArray, start::Integer)
     start > 0 || throw(BoundsError(B, start))
     start > length(B) && return 0
@@ -1482,7 +1482,7 @@ function findnextnot(B::BitArray, start::Integer)
 
     chunk_start = _div64(start-1)+1
     within_chunk_start = _mod64(start-1)
-    mask = ~(_msk64 << within_chunk_start)
+    mask = flipbits(_msk64 << within_chunk_start)
 
     @inbounds if chunk_start < l
         if Bc[chunk_start] | mask != _msk64
@@ -1557,7 +1557,7 @@ function findprevnot(B::BitArray, start::Integer)
     Bc = B.chunks
 
     chunk_start = _div64(start-1)+1
-    mask = ~_msk_end(start)
+    mask = flipbits(_msk_end(start))
 
     @inbounds begin
         if Bc[chunk_start] | mask != _msk64
@@ -1688,24 +1688,24 @@ maximum(B::BitArray) = isempty(B) ? throw(ArgumentError("argument must be non-em
 # arrays since there can be a 64x speedup by working at the level of Int64
 # instead of looping bit-by-bit.
 
-map(::Union{typeof(~), typeof(!)}, A::BitArray) = bit_map!(~, similar(A), A)
+map(::Union{typeof(flipbits), typeof(!)}, A::BitArray) = bit_map!(flipbits, similar(A), A)
 map(::typeof(zero), A::BitArray) = fill!(similar(A), false)
 map(::typeof(one), A::BitArray) = fill!(similar(A), true)
 map(::typeof(identity), A::BitArray) = copy(A)
 
-map!(::Union{typeof(~), typeof(!)}, dest::BitArray, A::BitArray) = bit_map!(~, dest, A)
+map!(::Union{typeof(flipbits), typeof(!)}, dest::BitArray, A::BitArray) = bit_map!(flipbits, dest, A)
 map!(::typeof(zero), dest::BitArray, A::BitArray) = fill!(dest, false)
 map!(::typeof(one), dest::BitArray, A::BitArray) = fill!(dest, true)
 map!(::typeof(identity), dest::BitArray, A::BitArray) = copyto!(dest, A)
 
 for (T, f) in ((:(Union{typeof(&), typeof(*), typeof(min)}), :(&)),
                (:(Union{typeof(|), typeof(max)}),            :(|)),
                (:(Union{typeof(xor), typeof(!=)}),           :xor),
-               (:(Union{typeof(>=), typeof(^)}),             :((p, q) -> p | ~q)),
-               (:(typeof(<=)),                               :((p, q) -> ~p | q)),
-               (:(typeof(==)),                               :((p, q) -> ~xor(p, q))),
-               (:(typeof(<)),                                :((p, q) -> ~p & q)),
-               (:(typeof(>)),                                :((p, q) -> p & ~q)))
+               (:(Union{typeof(>=), typeof(^)}),             :((p, q) -> p | flipbits(q))),
+               (:(typeof(<=)),                               :((p, q) -> flipbits(p) | q)),
+               (:(typeof(==)),                               :((p, q) -> flipbits(xor(p, q)))),
+               (:(typeof(<)),                                :((p, q) -> flipbits(p) & q)),
+               (:(typeof(>)),                                :((p, q) -> p & flipbits(q))))
     @eval map(::$T, A::BitArray, B::BitArray) = bit_map!($f, similar(A), A, B)
     @eval map!(::$T, dest::BitArray, A::BitArray, B::BitArray) = bit_map!($f, dest, A, B)
 end

base/bitset.jl

@@ -265,7 +265,7 @@ intersect(s1::BitSet, s2::BitSet) =
 
 intersect!(s1::BitSet, s2::BitSet) = _matched_map!(&, s1, s2)
 
-setdiff!(s1::BitSet, s2::BitSet) = _matched_map!((p, q) -> p & ~q, s1, s2)
+setdiff!(s1::BitSet, s2::BitSet) = _matched_map!((p, q) -> p & flipbits(q), s1, s2)
 
 symdiff!(s::BitSet, ns) = foldl(int_symdiff!, s, ns)
 

base/bool.jl

@@ -32,7 +32,7 @@ function !(x::Bool)
     return not_int(x)
 end
 
-(~)(x::Bool) = !x
+bitflip(x::Bool) = !x
 (&)(x::Bool, y::Bool) = and_int(x, y)
 (|)(x::Bool, y::Bool) = or_int(x, y)
 

base/checked.jl

@@ -148,8 +148,8 @@ end
 if BrokenUnsignedInt != Union{}
 function add_with_overflow(x::T, y::T) where T<:BrokenUnsignedInt
     # x + y > typemax(T)
-    # Note: ~y == -y-1
-    x + y, x > ~y
+    # Note: flipbits(y) == -y-1
+    x + y, x > flipbits(y)
 end
 end
 

base/deprecated.jl

@@ -292,12 +292,13 @@ module Operators
     for op in [:!, :(!=), :(!==), :%, :&, :*, :+, :-, :/, ://, :<, :<:, :<<, :(<=),
                :<|, :(==), :(===), :>, :>:, :(>=), :>>, :>>>, :\, :^, :colon,
                :adjoint, :getindex, :hcat, :hvcat, :setindex!, :transpose, :vcat,
-               :xor, :|, :|>, :~, :×, :÷, :∈, :∉, :∋, :∌, :∘, :√, :∛, :∩, :∪, :≠, :≤,
+               :xor, :|, :|>, :×, :÷, :∈, :∉, :∋, :∌, :∘, :√, :∛, :∩, :∪, :≠, :≤,
                :≥, :⊆, :⊈, :⊊, :⊻, :⋅]
         if isdefined(Base, op)
             @eval Base.@deprecate_binding $op Base.$op
         end
     end
+    Base.@deprecate ~(x) Base.flipbits(x)
 end
 export Operators
 
@@ -2972,6 +2973,7 @@ end
 
 @deprecate findin(a, b) find(occursin(b), a)
 
+@deprecate ~(x) flipbits(x)
 
 # END 0.7 deprecations
 

base/exports.jl

@@ -214,7 +214,6 @@ export
     ^,
     |,
     |>,
-    ~,
     :,
     =>,
     ∘,
@@ -286,6 +285,7 @@ export
     flipsign,
     float,
     tryparse,
+    flipbits,
     floor,
     fma,
     frexp,