problem with typemin and typemax for Irrational

[bkamins]

I think it is a bug:

julia> t = typeof(pi)
Irrational{:π}

julia> hasmethod(typemin, (t,))
true

julia> typemin(t)
ERROR: MethodError: no method matching typemin(::Type{Irrational{:π}})

The same happens with typemax

[bkamins]

@nalimilan - a little corner-case surprise

I do not know the internals of jl_gf_invoke_lookup for a general fix, but for Irrational probably we can just define typemax and typemin to return the singleton.

Now I also see that we have also a problem here:

julia> typemax(Real)
ERROR: MethodError: no method matching typemax(::Type{Real})
Closest candidates are:
  typemax(::Type{Pkg.Types.PackageMode}) at Enums.jl:191
  typemax(::Type{LibGit2.Consts.GIT_OPT}) at Enums.jl:191
  typemax(::Type{Int64}) at int.jl:726
  ...
Stacktrace:
 [1] top-level scope at REPL[54]:1

julia> hasmethod(typemax, (Real,))
true

[bkamins]

Also while we are at it:

julia> zero(pi)
false

julia> zero(pi) + pi
3.141592653589793

do we think it is consistent?

[User-764Q]

Bumping this I tested today on Julia 1.6.2 and got a similar error.

julia> t = typeof(pi)
Irrational{:π}

julia> hasmethod(typemin, (t,))
true

julia> typemin(t)
ERROR: MethodError: no method matching typemin(::Type{Irrational{:π}})
Closest candidates are:
  typemin(::Union{Dates.DateTime, Type{Dates.DateTime}}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Dates/src/types.jl:427
  typemin(::Union{Dates.Date, Type{Dates.Date}}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Dates/src/types.jl:429
  typemin(::Union{Dates.Time, Type{Dates.Time}}) at /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Dates/src/types.jl:431
  ...
Stacktrace:
 [1] top-level scope
   @ REPL[3]:1

julia> ```



`

[KristofferC]

There is Base.hastypemax which is probably the more correct thing to do. hasmethod is not really useful in normal code, as shown by this example.

[brenhinkeller]

Still reproduces on 1.8.3

[nsajko]

I don't think this is connected to typemin or typemax at all, it's just how hasmethod works. The issue seems to be that people expect hasmethod to work recursively, while this is not the case, even though it would be more "user-friendly".

For example:

julia> h(::T) where {T} = hasmethod(typemin, Tuple{T})
h (generic function with 1 method)

julia> h(::Type{T}) where {T} = hasmethod(typemin, Tuple{Type{T}})
h (generic function with 2 methods)

julia> h(pi)
true

julia> h(typeof(pi))
false

h(pi) is equivalent to the hasmethod call in the original post above, and it correctly returns true because a method exists for the call typemin(pi). But, typemin(pi) proceeds (in its implementation) to call typemin(typeof(pi)), which does not have a method, resulting in a MethodError anyway.

Furthermore, I don't think it's even theoretically possible to have a recursive hasmethod that wouldn't have any false-positives or false-negatives in general.

So this issue should probably be closed, perhaps in favor of a "recursive hasmethod and applicable" issue.

Note that applicable is very similar to hasmethod, but has an interface that is, perhaps, a bit friendlier - it takes values instead of their types:

julia> a(x) = applicable(typemin, x)
a (generic function with 1 method)

julia> a(pi)
true

julia> a(typeof(pi))
false

EDIT: for reference: hasmethod and applicable are very similar, but one difference between them (at least on the current nightly, perhaps because of #48639) is that hasmethod can be constant-folded, making it a better choice for users in some cases.

[bkamins]

Good point. Then probably there should be a special definition for typemin and typemax for Irrational to avoid calling the generic method defined for Rational?

[nalimilan]

You mean we should define typemin(::typeof(pi)) = pi and typemax(::typeof(pi)) = pi? Sounds like a logical definition to me.

[nsajko]

I think the PR is OK, but some will be confused by one(pi) < typemin(pi) and similar.

[bkamins]

Well one(pi) already breaks the contract of one:

julia> pi * true == pi
false

I am not sure what is best. But I meant what @nalimilan has written.

Also note that one function is not required to return the value of type passed, it only is required to guarantee to return multiplicative identity.

Note that oneunit correctly errors:

julia> oneunit(pi)
ERROR: MethodError: no method matching Irrational{:π}(::Bool)