From 6a35def38b07aaa1787bb7c8150fde8f2e6be4c5 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 18:58:19 -0500
Subject: [PATCH 01/33] support `x % Unsigned` where `isa(x, Signed)`

This follows from a discussion on Slack; the implementation was suggested by @keno.
---
 base/int.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/int.jl b/base/int.jl
index 169adf424abc9..0ac4c0c970767 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -506,6 +506,7 @@ 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::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)

From 6b87b767494cdb47f1e306fa2b2c08b1e2877ae0 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:02:38 -0500
Subject: [PATCH 02/33] support `x % Unsigned` where `isa(x, Signed)`

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index c17d36b1f7021..00f62d08869f6 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -65,7 +65,7 @@ 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 % Unsigned` now works where `typeof(x) :< Signed`.
 
 Standard library changes
 ------------------------

From 17f3c796d14ecca8abe7302f04b610032231dfe3 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:30:55 -0500
Subject: [PATCH 03/33] support `x % Unsigned` where `isa(x, Signed)`

---
 test/int.jl | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/int.jl b/test/int.jl
index 0ed8f3f771912..828d3ef4f2116 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -266,6 +266,10 @@ end
     U in [Base.BitInteger_types..., BigInt]
     @test typeof(rand(U(0):U(127)) % T) === T
 end
+@testset "x % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...],
+    @test typeof(rand(T) % Unsigned) <: Unsigned
+    @test sizeof(rand(T) % Unsigned) == sizeof(T)
+end
 
 @testset "issue #15489" begin
     @test 0x00007ffea27edaa0 + (-40) === (-40) + 0x00007ffea27edaa0 === 0x00007ffea27eda78

From 58f8708501b3c8e8ecd66dd8ddf5a4acf8fb4e55 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:34:24 -0500
Subject: [PATCH 04/33] `x % Unsigned` where `isa(x, Signed)` (remove comma)

---
 test/int.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/int.jl b/test/int.jl
index 828d3ef4f2116..15fcffcb3fc28 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -266,7 +266,7 @@ end
     U in [Base.BitInteger_types..., BigInt]
     @test typeof(rand(U(0):U(127)) % T) === T
 end
-@testset "x % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...],
+@testset "x % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...]
     @test typeof(rand(T) % Unsigned) <: Unsigned
     @test sizeof(rand(T) % Unsigned) == sizeof(T)
 end

From 65367c518f3c4a17c83dcc83596afee503440f45 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:37:50 -0500
Subject: [PATCH 05/33] `x::Signed % Unsigned, x::Unsigned % Signed`

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 00f62d08869f6..8b3f0cf499ab1 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -65,7 +65,7 @@ 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 % Unsigned` now works where `typeof(x) :< Signed`.
+* `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported.
 
 Standard library changes
 ------------------------

From 1a1b028fc3c74fde83e3ee963d77092732b03cd3 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:39:52 -0500
Subject: [PATCH 06/33] `rem(x::Unsigned, Signed)`

---
 base/int.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/int.jl b/base/int.jl
index 0ac4c0c970767..27184c69cda45 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -507,6 +507,7 @@ 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)

From bcaa805cf62eec77f91f4fe841a9ae02f3bdac44 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 19:42:27 -0500
Subject: [PATCH 07/33] `x::Unsigned % Signed`

---
 test/int.jl | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/int.jl b/test/int.jl
index 15fcffcb3fc28..60b50689cbb9b 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -266,10 +266,14 @@ end
     U in [Base.BitInteger_types..., BigInt]
     @test typeof(rand(U(0):U(127)) % T) === T
 end
-@testset "x % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...]
+@testset "x::Signed % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...]
     @test typeof(rand(T) % Unsigned) <: Unsigned
     @test sizeof(rand(T) % Unsigned) == sizeof(T)
 end
+@testset "x::Unsigned % Signed returns a T, T = $T" for T in [Base.BitUnsigned_types...]
+    @test typeof(rand(T) % Signed) <: Signed
+    @test sizeof(rand(T) % Signed) == sizeof(T)
+end
 
 @testset "issue #15489" begin
     @test 0x00007ffea27edaa0 + (-40) === (-40) + 0x00007ffea27edaa0 === 0x00007ffea27eda78

From fb30b6309c5f252a7060e596ed5481c0d258007b Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Mon, 24 Feb 2020 20:30:12 -0500
Subject: [PATCH 08/33] remove trailing space

---
 base/int.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 27184c69cda45..746150fc50180 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -506,8 +506,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::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)

From bfd416b57dd44480ebb79c3157aeb0032d92d049 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 00:40:30 -0500
Subject: [PATCH 09/33] interconvert BitInteger pairs

---
 base/int.jl | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/base/int.jl b/base/int.jl
index 746150fc50180..774976d08d7ac 100644
--- a/base/int.jl
+++ b/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)

From 536948e775b1994aa435aa168339208b9aab3b09 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 00:50:31 -0500
Subject: [PATCH 10/33] remove `unsigned(<:Signed)` lines, import `unsigned`
 from Base

---
 base/multinverses.jl | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/base/multinverses.jl b/base/multinverses.jl
index 319072e7214ac..f0e69c16eb236 100644
--- a/base/multinverses.jl
+++ b/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.

From 152d6e831a309e08991d6b3fcc71ecf719fdb491 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 01:58:56 -0500
Subject: [PATCH 11/33] add tests, improve tests

---
 test/int.jl | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index 60b50689cbb9b..cc5b4add9526e 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -260,19 +260,25 @@ 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 "x::Signed % Unsigned returns a T, T = $T" for T in [Base.BitSigned_types...]
-    @test typeof(rand(T) % Unsigned) <: Unsigned
-    @test sizeof(rand(T) % Unsigned) == sizeof(T)
+
+@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes" for S in Base.BitSigned_types,
+    U in 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 "x::Unsigned % Signed returns a T, T = $T" for T in [Base.BitUnsigned_types...]
-    @test typeof(rand(T) % Signed) <: Signed
-    @test sizeof(rand(T) % Signed) == sizeof(T)
+@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

From 98204f5119ce6449bcc229b1897d19e0c3bb9f80 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 02:06:59 -0500
Subject: [PATCH 12/33] news about `signed(T)`, `unsigned(T)`

---
 NEWS.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 8b3f0cf499ab1..3734247447a1c 100644
--- a/NEWS.md
+++ b/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.
+* `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
 ------------------------

From c1988c1c4321f3f303f4055372b844824a868cdb Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 02:08:56 -0500
Subject: [PATCH 13/33] remove trailing whitespace

---
 NEWS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 3734247447a1c..4842e53200365 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -66,7 +66,7 @@ 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.  
+* `unsigned(signed_type)` and `signed(unsigned_type)` are supported for integer bitstypes.
 
 Standard library changes
 ------------------------

From 61e23622be9db2aa0b016781bc6ab525c15a8eb3 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 06:32:38 -0500
Subject: [PATCH 14/33] fix test

---
 test/int.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index cc5b4add9526e..492a7bb85ee54 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -267,8 +267,8 @@ end
     @test typeof(rand(U(0):U(127)) % T) === T
 end
 
-@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes" for S in Base.BitSigned_types,
-    U in Base.BitUnsigned_types
+@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes"
+    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
     @test signed(U) === S
     @test unsigned(S) === U
 end

From 3fbcf180bbf5fcfafeee791289296c55ff169649 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 08:15:58 -0500
Subject: [PATCH 15/33] fix missing `begin`

---
 test/int.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/int.jl b/test/int.jl
index 492a7bb85ee54..532425eda9016 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -267,7 +267,7 @@ end
     @test typeof(rand(U(0):U(127)) % T) === T
 end
 
-@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes"
+@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

From a1da6f4798e1150e5701737c29ac3ddba26f5751 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 10:35:36 -0500
Subject: [PATCH 16/33] add missing end

---
 test/int.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index 532425eda9016..3d9dac91f92ba 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -269,8 +269,9 @@ 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
+        @test signed(U) === S
+        @test unsigned(S) === U
+    end
 end
 @testset "s::Signed % Unsigned returns u::T, T = $T" for T in Base.BitSigned_types
     @test (typemin(T) % Unsigned) % Signed === typemin(T)

From 8542442fa213e761f8ed292b51966ece97c661c4 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 10:58:36 -0500
Subject: [PATCH 17/33] revise tests

---
 test/int.jl | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index 3d9dac91f92ba..d9c1f156c288e 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -273,13 +273,17 @@ end
         @test unsigned(S) === U
     end
 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
+@testset "x::[Un]Signed % [Un]Signed returns x" begin
+    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
+        @test typemin(S) % Signed === typemin(S)
+        @test typemax(U) % Unsigned === typemax(U)
+    end
 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
+@testset "x::[Un]Signed % Un[Signed] % [Un]Signed returns x for bitstypes" begin
+    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
+        @test -one(S) % Unsigned % Signed === -one(S)
+        @test ~one(U) % Signed % Unsigned === ~one(U)
+    end
 end
 
 @testset "issue #15489" begin

From 9172d4d0d9fd6091962748fc416f33b437dcd7c7 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 25 Feb 2020 13:35:31 -0500
Subject: [PATCH 18/33] fixup typo in test

---
 test/int.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/int.jl b/test/int.jl
index d9c1f156c288e..7a0d0b46b472f 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -260,7 +260,7 @@ 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(I, -129) === Int8(127)
+    @test unsafe_trunc(Int8, -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]

From 612b19d3576cc82e854f14f36c138fa4cdf42aaa Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 29 Feb 2020 01:40:14 -0500
Subject: [PATCH 19/33] restore multinverses.jl

---
 base/multinverses.jl | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/base/multinverses.jl b/base/multinverses.jl
index f0e69c16eb236..319072e7214ac 100644
--- a/base/multinverses.jl
+++ b/base/multinverses.jl
@@ -3,9 +3,16 @@
 module MultiplicativeInverses
 
 import Base: div, divrem, rem, unsigned
-using  Base: IndexLinear, IndexCartesian, tail, unsigned
+using  Base: IndexLinear, IndexCartesian, tail
 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.

From 53ec10b5a962176e4b905fd18cdb53bd17810b91 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 29 Feb 2020 01:50:09 -0500
Subject: [PATCH 20/33] remove `unsigned(::Type{BitSigned})` (was available). 
 add `signed(::Type{BitUnsigned})`

`unsigned(Int32) === UInt32` and similar for the other BitSigned types has been available. The corresponding `signed(UInt32) === Int32` and similar has not been available.  I have added them.
---
 base/int.jl | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 774976d08d7ac..7a7ac8b1c2c6d 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -44,15 +44,8 @@ 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
-
+# convert BitUnsigned types to equilength BitSigned types
+# these exist for `unsigned`
 signed(::Type{UInt8}) = Int8
 signed(::Type{UInt16}) = Int16
 signed(::Type{UInt32}) = Int32

From 3371f21dc59aa42863c2b30ceef871acccb2b2e8 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 29 Feb 2020 01:59:28 -0500
Subject: [PATCH 21/33] add tests `BigInt(x) % Signed` `BigInt(x) % Unsigned`

---
 test/gmp.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/gmp.jl b/test/gmp.jl
index 9f6e5f39f59b7..3dc00724f4ad2 100644
--- a/test/gmp.jl
+++ b/test/gmp.jl
@@ -441,6 +441,15 @@ end
     @test big(Int128(-170141183460469231731687303715884105728)) == big"-170141183460469231731687303715884105728"
 end
 
+@testset "type conversion with Signed, Unsigned" begin
+    x = BigInt(typemin(Int128)) - 1
+    @test x % Signed === x
+    @test_throws MethodError x % Unsigned
+    y = BigInt(1)
+    @test y % Signed === y
+    @test_throws MethodError y % Unsigned
+end
+
 @testset "conversion to Float" begin
     x = big"2"^256 + big"2"^(256-53) + 1
     @test Float64(x) == reinterpret(Float64, 0x4ff0000000000001)

From 0518e73a6429798757d26a780dc1fad69fe1a408 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 29 Feb 2020 02:04:47 -0500
Subject: [PATCH 22/33] resolve conflict?

---
 NEWS.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 4842e53200365..62504e31f6d40 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -65,8 +65,9 @@ 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])
+* `accumulate`, `cumsum`, and `cumprod` now support `Tuple` ([#34654]).
 * `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported for integer bitstypes.
-* `unsigned(signed_type)` and `signed(unsigned_type)` are supported for integer bitstypes.
+* `signed(unsigned_type)` is supported for integer bitstypes, `unsigned(signed_type)` has been supported.
 
 Standard library changes
 ------------------------

From e16cffb2d2bc5d94b7a9dea51eb3bf306edd94a7 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 29 Feb 2020 06:15:29 -0500
Subject: [PATCH 23/33] add back what was a merge conflict in News

---
 NEWS.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 899d4bb06a942..02a58cd18f57d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -66,6 +66,10 @@ 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])
 * `accumulate`, `cumsum`, and `cumprod` now support `Tuple` ([#34654]).
+* `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported for integer bitstypes.
+* `signed(unsigned_type)` is supported for integer bitstypes, `unsigned(signed_type)` has been supported.
+
+>>>>>>> master
 
 Standard library changes
 ------------------------

From a67e742a1c48da12b88ddb95c9df12e5c107e0ef Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Tue, 3 Mar 2020 16:24:59 -0500
Subject: [PATCH 24/33] Update NEWS.md

Co-Authored-By: Matt Bauman <mbauman@gmail.com>
---
 NEWS.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 02a58cd18f57d..98c2e5f044d5e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -69,7 +69,6 @@ New library features
 * `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported for integer bitstypes.
 * `signed(unsigned_type)` is supported for integer bitstypes, `unsigned(signed_type)` has been supported.
 
->>>>>>> master
 
 Standard library changes
 ------------------------

From ecb9966429a3447a79c1edec03729d679ca0d04b Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 14 Mar 2020 00:54:34 -0400
Subject: [PATCH 25/33] remove `signed(UIntNN) = IntNN` (does it fix?)

---
 base/int.jl | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 7a7ac8b1c2c6d..746150fc50180 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -44,15 +44,6 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
-# convert BitUnsigned types to equilength BitSigned types
-# these exist for `unsigned`
-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)

From 3cbbec4e352adb184049ece2e6e59ed8b81c7b67 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 14 Mar 2020 00:57:22 -0400
Subject: [PATCH 26/33] remove `signed(UIntNN) == IntNN` tests (does it fix?)

---
 test/int.jl | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index 7a0d0b46b472f..534df907b2d63 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -267,12 +267,6 @@ end
     @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
-end
 @testset "x::[Un]Signed % [Un]Signed returns x" begin
     for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
         @test typemin(S) % Signed === typemin(S)

From 574d8a695a1cf2d3fbdaea6244e37184e7324f33 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 14 Mar 2020 08:11:46 -0400
Subject: [PATCH 27/33] restore `signed(::Type{UIntNN}) = IntNN`

---
 base/int.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/base/int.jl b/base/int.jl
index 746150fc50180..5b37a936daa16 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -44,6 +44,15 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
+# convert BitUnsigned types to equilength BitSigned types
+# the partner functions `unsigned(::Type{IntNN})` exist 
+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)

From 100884e0e9e90991e88c7e0c0f182c7be78acde6 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 14 Mar 2020 08:13:18 -0400
Subject: [PATCH 28/33] restore `signed(::Type{UIntNN}) = IntNN` tests

---
 test/int.jl | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/int.jl b/test/int.jl
index 534df907b2d63..7a0d0b46b472f 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -267,6 +267,12 @@ end
     @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
+end
 @testset "x::[Un]Signed % [Un]Signed returns x" begin
     for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
         @test typemin(S) % Signed === typemin(S)

From cf1954ae24325240b3fdb1d0c90d37fa868bf89d Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Sat, 14 Mar 2020 08:14:57 -0400
Subject: [PATCH 29/33] whitespace

---
 base/int.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/int.jl b/base/int.jl
index 5b37a936daa16..0afbb9b72bba4 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -45,7 +45,7 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
 # convert BitUnsigned types to equilength BitSigned types
-# the partner functions `unsigned(::Type{IntNN})` exist 
+# the partner functions `unsigned(::Type{IntNN})` exist
 signed(::Type{UInt8}) = Int8
 signed(::Type{UInt16}) = Int16
 signed(::Type{UInt32}) = Int32

From 6dc7fab626070157150442d707c2d9258141c0db Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Fri, 27 Mar 2020 10:30:28 -0400
Subject: [PATCH 30/33] remove old line

---
 NEWS.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 6cc06b3db395f..ad7d6f02f0e6d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -92,7 +92,6 @@ 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])
-* `accumulate`, `cumsum`, and `cumprod` now support `Tuple` ([#34654]).
 * `x::Signed % Unsigned` and `x::Unsigned % Signed` are supported for integer bitstypes.
 * `signed(unsigned_type)` is supported for integer bitstypes, `unsigned(signed_type)` has been supported.
 * `accumulate`, `cumsum`, and `cumprod` now support `Tuple` ([#34654]) and arbitrary iterators ([#34656]).

From 9c2befcbc7da26a5f17685e00aa1d5e8cd21d08b Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Fri, 27 Mar 2020 10:34:19 -0400
Subject: [PATCH 31/33] combine 3 testsets

---
 test/int.jl | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/test/int.jl b/test/int.jl
index 7a0d0b46b472f..aa5bd1c0d22d3 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -267,20 +267,12 @@ end
     @test typeof(rand(U(0):U(127)) % T) === T
 end
 
-@testset "signed(<:Unsigned), unsigned(<:Signed) for bitstypes" begin
+@testset "Signed, Unsigned, signed, unsigned for bitstypes" begin
     for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
         @test signed(U) === S
         @test unsigned(S) === U
-    end
-end
-@testset "x::[Un]Signed % [Un]Signed returns x" begin
-    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
         @test typemin(S) % Signed === typemin(S)
         @test typemax(U) % Unsigned === typemax(U)
-    end
-end
-@testset "x::[Un]Signed % Un[Signed] % [Un]Signed returns x for bitstypes" begin
-    for (S,U) in zip(Base.BitSigned_types, Base.BitUnsigned_types)
         @test -one(S) % Unsigned % Signed === -one(S)
         @test ~one(U) % Signed % Unsigned === ~one(U)
     end

From 7b00bd5a7a750620a5d62130d398510e12284bc2 Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Fri, 27 Mar 2020 11:20:27 -0400
Subject: [PATCH 32/33] docstrings for signed(T) unsigned(T)

---
 base/int.jl | 32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 0afbb9b72bba4..32c7d2ee02d19 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -44,8 +44,19 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
-# convert BitUnsigned types to equilength BitSigned types
 # the partner functions `unsigned(::Type{IntNN})` exist
+"""
+    signed(T::Integer)
+
+Convert an integer bitstype to the signed type of the same size.
+# Examples
+```jldoctest
+julia> signed(UInt16)
+Int16
+julia> signed(UInt64)
+Int64
+```
+"""
 signed(::Type{UInt8}) = Int8
 signed(::Type{UInt16}) = Int16
 signed(::Type{UInt32}) = Int32
@@ -147,19 +158,15 @@ abs(x::Signed) = flipsign(x,x)
 ~(n::Integer) = -n-1
 
 """
-    unsigned(x) -> Unsigned
-
+    unsigned(x)
 Convert a number to an unsigned integer. If the argument is signed, it is reinterpreted as
 unsigned without checking for negative values.
-
 # Examples
 ```jldoctest
 julia> unsigned(-2)
 0xfffffffffffffffe
-
 julia> unsigned(2)
 0x0000000000000002
-
 julia> signed(unsigned(-2))
 -2
 ```
@@ -168,8 +175,19 @@ unsigned(x) = x % typeof(convert(Unsigned, zero(x)))
 unsigned(x::BitSigned) = reinterpret(typeof(convert(Unsigned, zero(x))), x)
 
 """
-    signed(x)
+    unsigned(T::Integer)
+Convert an integer bitstype to the unsigned type of the same size.
+# Examples
+```jldoctest
+julia> unsigned(Int16)
+UInt16
+julia> unsigned(UInt64)
+UInt64
+```
+""" unsigned
 
+"""
+    signed(x)
 Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
 signed without checking for overflow.
 """

From f46360a9e7159944edb94aaac9bd759de65b84bf Mon Sep 17 00:00:00 2001
From: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com>
Date: Fri, 27 Mar 2020 11:28:01 -0400
Subject: [PATCH 33/33] move docstring up

---
 base/int.jl | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 32c7d2ee02d19..f349cd0bce233 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -44,7 +44,20 @@ const BitUnsigned64T   = Union{Type{UInt8}, Type{UInt16}, Type{UInt32}, Type{UIn
 
 const BitIntegerType = Union{map(T->Type{T}, BitInteger_types)...}
 
-# the partner functions `unsigned(::Type{IntNN})` exist
+# >> this use of `unsigned` is defined somewhere else << the docstring should migrate there
+"""
+    unsigned(T::Integer)
+
+Convert an integer bitstype to the unsigned type of the same size.
+# Examples
+```jldoctest
+julia> unsigned(Int16)
+UInt16
+julia> unsigned(UInt64)
+UInt64
+```
+""" unsigned
+
 """
     signed(T::Integer)
 
@@ -159,6 +172,7 @@ abs(x::Signed) = flipsign(x,x)
 
 """
     unsigned(x)
+
 Convert a number to an unsigned integer. If the argument is signed, it is reinterpreted as
 unsigned without checking for negative values.
 # Examples
@@ -174,20 +188,9 @@ julia> signed(unsigned(-2))
 unsigned(x) = x % typeof(convert(Unsigned, zero(x)))
 unsigned(x::BitSigned) = reinterpret(typeof(convert(Unsigned, zero(x))), x)
 
-"""
-    unsigned(T::Integer)
-Convert an integer bitstype to the unsigned type of the same size.
-# Examples
-```jldoctest
-julia> unsigned(Int16)
-UInt16
-julia> unsigned(UInt64)
-UInt64
-```
-""" unsigned
-
 """
     signed(x)
+
 Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
 signed without checking for overflow.
 """