Compiler allows comparing a comparable to a literal number

[fbonetti]

SSCCE

This should fail to compile, but it doesn't:

module Bug exposing (bug)


bug : comparable -> Bool
bug n =
    n == 1

Running the code doesn't produce a runtime exception, but it does return some strange results.

import Bug exposing (bug)

bug 1
> True

bug 'a'
> False

bug ""
> False

bug "asdf"
> False

bug []
> False

bug (0)
> True

bug (1)
> False

This bug only occurs when comparing a comparable to a literal number (as in, the number is hardcoded). For example, this correctly fails to compile:

bug : comparable -> number -> Bool
bug n a =
    n == a

Environment

$ elm --version
0.18.0

$ elm-repl --version
0.18.0

$ node --version
v8.1.0

$ sw_vers
ProductName:	Mac OS X
ProductVersion:	10.11.6
BuildVersion:	15G1108

Edit: Added environment info

[process-bot]

Thanks for the issue! Make sure it satisfies this checklist. My human colleagues will appreciate it!

Here is what to expect next, and if anyone wants to comment, keep these things in mind.

[jvoigtlaender]

@fbonetti, on the mailing list you asked whether this is a known problem. It does look like one of this conglomerate: #1581, #1268, #1270, #1281, #1316, which according to #1373 (comment) are fixed (but the fix not yet in a released version of the compiler).

[fbonetti]

@jvoigtlaender Thanks for looking into this. It does look like the same issue.

[evancz]

Given the code:

bug : comparable -> Bool
bug n =
    n == 1

The new compiler gives this error:

-- TYPE MISMATCH -------------------------------------------------

The right side of (==) is causing a type mismatch.

133|     n == 1
              ^
(==) is expecting the right side to be a:

    comparable

But the right side is:

    number

Hint: Your type annotation uses type variable `comparable` which means any type
of value can flow through. Your code is saying it CANNOT be anything though!
Maybe change your type annotation to be more specific? Maybe the code has a
problem? More at:
<https://github.com/elm-lang/elm-compiler/blob/0.19.0/hints/type-annotations.md>

Hint: With operators like (==) I always check the left side first. If it seems
fine, I assume it is correct and check the right side. So the problem may be in
how the left and right arguments interact.

The first hint could be improved now that it is catching this sort of thing, but it is an error now!

[fbonetti]

Thanks!!