Rational of `Base.hastypemax(BigInt)` (not exported) vs `typemax(BigInt) = Inf`

[o314]

BigInt is unbounded by construction, but is not reachable via the classical typemax/typemin public api
https://github.com/JuliaLang/julia/blob/v1.6.0-beta1/base/exports.jl#L348

Instead of that, one has to deal with the Base.hastypemax function that is not exported,

• it is unnecessary
• if my comprehension is correct, code could go broken at any new version, not only major
  a contrario of typemax/typemin
• if involves writing wrapper at the consumer side

Can we, instead of

hastypemax(::Type{BigInt}) = false

@ https://github.com/JuliaLang/julia/blob/v1.6.0-beta1/base/gmp.jl#L263

define those lines :

typemax(::Type{BigInt}) = Inf
typemin(::Type{BigInt}) = -Inf # may be too

BTW hastypemax seems to be barely used (3 times) https://github.com/JuliaLang/julia/search?q=hastypemax
pace of change / risk of break seems not to be a hurdle

or is there any good motive to not do it ?

[rfourquet]

One problem of typemax(::Type{BigInt}) = Inf is that it doesn't fit with the current definition of typemax:

The highest value representable by the given (real) numeric DataType.

Of course the definition could be changed...

[JeffBezanson]

Returning Inf for typemax(BigInt) really violates the meaning of the function IMO. But, it would be helpful to look at some usage examples. Are there common cases where that does the right thing?

We could also export hastypemax.

[o314]

I have no personal preference between typemax=Inf and export hastypemax meanwhile IMO the full behavior must be available eg. publish and version at once to provide a complete interface.

Examples

That issue comes from a review/rewrite of LightGraphs https://github.com/JuliaGraphs/LightGraphs.jl/blob/v1.3.5/src/utils.jl#L230

"""
    isbounded(n)

Returns true if `typemax(n)` of an integer `n` exists.
"""
isbounded(n::Integer) = true
isbounded(n::BigInt) = false

"""
    isbounded(T)

Returns true if `typemax(T)` of a type `T <: Integer` exists.
"""
isbounded(::Type{T}) where {T<:Integer} = isconcretetype(T)
isbounded(::Type{BigInt}) = false

Proposal Draft

That may be rewritten to v1

hastypemax(n) = hastypemax(typeof(n))
hastypemax(::Type{BigInt}) = false
hastypemax(::Type{T}) where {T<:Integer} = isconcretetype(T)

Perhaps better to v2

hastypemax(::Type) = false
hastypemax(::Type{T}) where {T<:Integer} = isconcretetype(T)
hastypemax(::Type{T}) where {T<:Union{Float16,Float32,Float64}} = true # @ v1.6.0-beta1 ./base/float.jl # IEEEFloat
hastypemax(::Type{T}) where {T<:AbstractChar} = true # @ v1.6.0-beta1 ./base/char.jl#L186
hastypemax(n) = hastypemax(typeof(n))

Issue reopened ?

However Inf as a typemax is the default for Float and BigFloat

@ https://github.com/JuliaLang/julia/blob/v1.6.0-beta1/base/float.jl#L743-L765

@eval begin
    typemin(::Type{Float16}) = $(bitcast(Float16, 0xfc00))
    typemax(::Type{Float16}) = $(Inf16)
    typemin(::Type{Float32}) = $(-Inf32)
    typemax(::Type{Float32}) = $(Inf32)
    typemin(::Type{Float64}) = $(-Inf64)
    typemax(::Type{Float64}) = $(Inf64)
    typemin(x::T) where {T<:Real} = typemin(T)
    typemax(x::T) where {T<:Real} = typemax(T)

    floatmin(::Type{Float16}) = $(bitcast(Float16, 0x0400))
    floatmin(::Type{Float32}) = $(bitcast(Float32, 0x00800000))
    floatmin(::Type{Float64}) = $(bitcast(Float64, 0x0010000000000000))
    floatmax(::Type{Float16}) = $(bitcast(Float16, 0x7bff))
    floatmax(::Type{Float32}) = $(bitcast(Float32, 0x7f7fffff))
    floatmax(::Type{Float64}) = $(bitcast(Float64, 0x7fefffffffffffff))

    eps(x::AbstractFloat) = isfinite(x) ? abs(x) >= floatmin(x) ? ldexp(eps(typeof(x)), exponent(x)) : nextfloat(zero(x)) : oftype(x, NaN)
    eps(::Type{Float16}) = $(bitcast(Float16, 0x1400))
    eps(::Type{Float32}) = $(bitcast(Float32, 0x34000000))
    eps(::Type{Float64}) = $(bitcast(Float64, 0x3cb0000000000000))
    eps() = eps(Float64)
end

@ https://github.com/JuliaLang/julia/blob/v1.6.0-beta1/base/mpfr.jl#L891

@eval typemax(::Type{BigFloat}) = $(BigFloat(Inf))
@eval typemin(::Type{BigFloat}) = $(BigFloat(-Inf))

That hurts a bit if one wants a whole conformance on the full line

---

Related ? #38232