x % Unsigned, x % Signed

NEWS.md

@@ -65,7 +65,8 @@ New library features
 
 * `isapprox` (or `≈`) now has a one-argument "curried" method `isapprox(x)` which returns a function, like `isequal` (or `==`)` ([#32305]).
 * `Ref{NTuple{N,T}}` can be passed to `Ptr{T}`/`Ref{T}` `ccall` signatures ([#34199])
-
+* `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported for integer bitstypes.
+* `unsigned(signed_type)` and `signed(unsigned_type)` are supported for integer bitstypes.
 
 Standard library changes
 ------------------------

base/int.jl

@@ -44,6 +44,22 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
+# interconvert equilength BitInteger types
+
+unsigned(::Type{Int8}) = UInt8
+unsigned(::Type{Int16}) = UInt16
+unsigned(::Type{Int32}) = UInt32
+unsigned(::Type{Int64}) = UInt64
+unsigned(::Type{Int128}) = UInt128
+unsigned(::Type{T}) where {T<:Unsigned} = T
+
+signed(::Type{UInt8}) = Int8
+signed(::Type{UInt16}) = Int16
+signed(::Type{UInt32}) = Int32
+signed(::Type{UInt64}) = Int64
+signed(::Type{UInt128}) = Int128
+signed(::Type{T}) where {T<:Signed} = T
+
 ## integer comparisons ##
 
 (<)(x::T, y::T) where {T<:BitSigned}  = slt_int(x, y)
@@ -506,6 +522,8 @@ if nameof(@__MODULE__) === :Base
 end
 
 rem(x::T, ::Type{T}) where {T<:Integer} = x
+rem(x::Signed, ::Type{Unsigned}) = x % unsigned(typeof(x))
+rem(x::Unsigned, ::Type{Signed}) = x % signed(typeof(x))
 rem(x::Integer, T::Type{<:Integer}) = convert(T, x)  # `x % T` falls back to `convert`
 rem(x::Integer, ::Type{Bool}) = ((x & 1) != 0)
 mod(x::Integer, ::Type{T}) where {T<:Integer} = rem(x, T)

base/multinverses.jl

@@ -3,16 +3,9 @@
 module MultiplicativeInverses
 
 import Base: div, divrem, rem, unsigned
-using  Base: IndexLinear, IndexCartesian, tail
+using  Base: IndexLinear, IndexCartesian, tail, unsigned
 export multiplicativeinverse
 
-unsigned(::Type{Int8}) = UInt8
-unsigned(::Type{Int16}) = UInt16
-unsigned(::Type{Int32}) = UInt32
-unsigned(::Type{Int64}) = UInt64
-unsigned(::Type{Int128}) = UInt128
-unsigned(::Type{T}) where {T<:Unsigned} = T
-
 abstract type  MultiplicativeInverse{T} end
 
 # Computes integer division by a constant using multiply, add, and bitshift.

test/int.jl

@@ -260,13 +260,27 @@ end
     @test unsafe_trunc(Int8, 128) === Int8(-128)
     @test unsafe_trunc(Int8, -127) === Int8(-127)
     @test unsafe_trunc(Int8, -128) === Int8(-128)
-    @test unsafe_trunc(Int8, -129) === Int8(127)
+    @test unsafe_trunc(I, -129) === Int8(127)
 end
 @testset "x % T returns a T, T = $T" for T in [Base.BitInteger_types..., BigInt],
     U in [Base.BitInteger_types..., BigInt]
     @test typeof(rand(U(0):U(127)) % T) === T
 end
 
+@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes" begin
+    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
+    @test signed(U) === S
+    @test unsigned(S) === U
+end
+@testset "s::Signed % Unsigned returns u::T, T = $T" for T in Base.BitSigned_types
+    @test (typemin(T) % Unsigned) % Signed === typemin(T)
+    @test typeof(typemin(T) % Unsigned) <: Unsigned
+end
+@testset "u::Unsigned % Signed returns s::T, T = $T" for T in Base.BitUnsigned_types
+    @test (typemax(T) % Signed) % Unsigned === typemax(T)
+    @test typeof(typemax(T) % Signed) <: Signed
+end
+
 @testset "issue #15489" begin
     @test 0x00007ffea27edaa0 + (-40) === (-40) + 0x00007ffea27edaa0 === 0x00007ffea27eda78
     @test UInt64(1) * Int64(-1) === typemax(UInt64)