Improve support for conversion (#15)

- Also fix numerous ambiguities that were not previously detected
- Also test 1.6

Author: timholy

.github/workflows/CI.yml

@@ -15,6 +15,7 @@ jobs:
         version:
           - '0.7'
           - '1.0'
+          - '1.6'
           - '1'
 #          - 'nightly'
         os:

Project.toml

@@ -1,6 +1,6 @@
 name = "RoundingIntegers"
 uuid = "d5f540fe-1c90-5db3-b776-2e2f362d9394"
-version = "1.0.0"
+version = "1.0.1"
 
 [compat]
 julia = "0.7, 1"

src/RoundingIntegers.jl

@@ -67,10 +67,14 @@ Base.promote_rule(::Type{RI}, ::Type{T}) where {T<:Number,RI<:RInteger} =
 
 Base.Signed(x::RSigned) = reinterpret(itype(x), x)
 Base.Unsigned(x::RUnsigned) = reinterpret(itype(x), x)
+RSigned(x::RSigned) = x
 RSigned(x::Signed) = reinterpret(rtype(x), x)
+RUnsigned(x::RUnsigned) = x
 RUnsigned(x::Unsigned) = reinterpret(rtype(x), x)
 Base.Integer(x::RSigned) = Signed(x)
 Base.Integer(x::RUnsigned) = Unsigned(x)
+Base.Integer(x::RInteger) = reinterpret(itype(x), x)
+RInteger(x::RInteger) = x
 RInteger(x::Signed) = RSigned(x)
 RInteger(x::Unsigned) = RUnsigned(x)
 
@@ -94,13 +98,24 @@ RUInt128(x::UInt128) = reinterpret(RUInt128, x)
 (::Type{R})(x::Complex) where R<:RInteger = R(round(itype(R), x))
 (::Type{R})(x::AbstractFloat) where R<:RInteger = R(round(itype(R), x))
 
-@inline Base.convert(::Type{T}, x::RInteger) where {T<:Number} = convert(T, Integer(x))
+# Ambiguity resolution
+(::Type{T})(x::RInteger) where {T<:RInteger} = convert(T, x)
+Base.Bool(x::RInteger) = Bool(Integer(x))
+Base.Rational(x::RInteger) = Rational(Integer(x))
+Base.Rational{T}(x::RInteger) where {T<:Integer} = Rational(Integer(x))
+Base.BigInt(x::RInteger) = BigInt(Integer(x))
+Base.Float16(x::RInteger) = Float16(Integer(x))
+Base.BigFloat(x::RInteger; kwargs...) = BigFloat(Integer(x); kwargs...)
+
+(::Type{T})(x::RInteger) where {T<:Real} = convert(T, Integer(x))
+Base.convert(::Type{T}, x::T) where {T<:RInteger} = x
+Base.convert(::Type{T}, x::RInteger) where {T<:RInteger} = T(convert(itype(T), Integer(x)))
 
 # rem conversions
-@inline Base.rem(x::T, ::Type{T}) where {T<:RInteger} = T
-@inline Base.rem(x::Integer, ::Type{T}) where {T<:RInteger} = RInteger(rem(x, itype(T)))
+Base.rem(x::T, ::Type{T}) where {T<:RInteger} = T
+Base.rem(x::Integer, ::Type{T}) where {T<:RInteger} = RInteger(rem(x, itype(T)))
 # ambs
-@inline Base.rem(x::BigInt, ::Type{T}) where {T<:RInteger} = error("no rounding BigInt available")
+Base.rem(x::BigInt, ::Type{T}) where {T<:RInteger} = error("no rounding BigInt available")
 
 
 Base.flipsign(x::RSigned, y::RSigned) = RInteger(flipsign(Integer(x), Integer(y)))

test/runtests.jl

@@ -1,6 +1,6 @@
 using Test
 using RoundingIntegers
-@test isempty(detect_ambiguities(Base, Core, RoundingIntegers))
+@test isempty(detect_ambiguities(RoundingIntegers))
 
 @testset "Basics" begin
     r16 = RInt16(3)
@@ -18,6 +18,10 @@ using RoundingIntegers
     @test typemin(RInt32) === RInt32(typemin(Int32))
     @test widen(r16) === convert(RInt32, r16)
 
+    @test RInt16(r16) === r16
+    @test float(r16) === Float64(r16) === 3.0
+    @test convert(Float32, r) === 5.0f0
+
     @test !(r < r)
     @test r <= r
     @test !(r > r)