Opened 9 years ago

Closed 9 years ago

Last modified 44 years ago

#409 closed bug (Fixed)

confusing error

Reported by: pimlott Owned by: simonpj
Priority: normal Milestone:
Component: Compiler (Type checker) Version: None
Keywords: Cc:
Operating System: Architecture:
Type of failure: Difficulty:
Test Case: Blocked By:
Blocking: Related Tickets:

Description

I got a perplexing error message.  Here is a concise
example:

    t = ((\Just x -> x) :: Maybe a -> a) (Just 1)
    
    Try.hs:1:6:
        Couldn't match the rigid variable `a' against
`t -> t1'
          `a' is bound by the polymorphic type `forall
a. Maybe a -> a' at Try.hs:1:5-34
          Expected type: a
          Inferred type: t -> t1
        In the expression: (\ Just x -> x) :: Maybe a -> a
        In the definition of `t': t = ((\ Just x -> x)
:: Maybe a -> a) (Just 1)
    Failed, modules loaded: none.

It seems to be telling me that the whole expression "(\
Just x -> x) ::
Maybe a -> a" was expected to have type a, in
contradiction to the explicit
type annotation it prints out!  In the context of a
larger program, this
threw me for a loop.  I would have expected

          Expected type: Maybe -> a
          Inferred type: Maybe -> t -> t1

Even better, if I change the code, I get a helpful
diagnostic:

    t = (\Just x -> x) (Just 1)

    Try.hs:1:6:
        Constructor `Just' should have 1 argument, but
has been given 0
        When checking the pattern: Just
        In a lambda abstraction: \ Just x -> x
        In the definition of `t': t = (\ Just x -> x)
(Just 1)
    Failed, modules loaded: none.

Could I get that error in the first example?  You could
probably go even further: "(did you forget parentheses
around the pattern?)".

Change History (2)

comment:1 Changed 9 years ago by simonpj

  • Status changed from assigned to closed
Logged In: YES 
user_id=50165

Good bug report.  I've improved the message a lot:

tcfail140.hs:16:6:
    The lambda expression `\ Just x -> ...' has two argumentss,
    but its type `Maybe a -> a' has only one
    In the expression: (\ Just x -> x) :: Maybe a -> a
    In the definition of `t': t = ((\ Just x -> x) :: Maybe a -> a) 
(Just 1)

test is tcfail140

Simon


comment:2 Changed 9 years ago by pimlott

Logged In: YES 
user_id=498741

That's excellent.  In fact, I look forward to making this
mistake in the future.
Note: See TracTickets for help on using tickets.