Working out why Hugs gives you a particular error message can be tricky. This page pulls together a collection of error messages and the code that produced them; the entry for the error message you have provoked can hopefully help you to diagnose your particular problem.
This page shows some code fragments, in red, followed by the error message they provoke, in blue, and an explanation of the source of the problem.
You can search for particular errors by giving keywords.
Please mail me with any
examples which you would like to be included in the list
Thanks to Daniel Barie, Eerke Boiten, Jane Chan,
Rodger Hayes, Brian Herlihy, Ralf Hinze, Stefan
Kahrs, Tom Kaiser, Richard O'Keefe and the students on the functional programming courses
at the University of Kent for contributing many of these errors.
3 'div' 4
ERROR: Improperly terminated character constant
The problem here is the use of the wrong sort of quotes.
To turn a function, which is written before its arguments,
into an operator, which is written between its arguments,
you need to enclose it in backquotes. The backquote is round
on the same key as the tilde on US keyboards (commonly the top
left hand corner of the main block, just above TAB).
data BTree a = EmptyBTree | Node a (BTree a) (BTree a)
ERROR: Equations give different arities for "card"
Incorrect bracketing causes the problem here. It looks as though card is a one
argument function (arity 1) from the first equation in the definition, and as
though it's a three argument function from the second. The misplaced closing
bracket is the culprit, and a correct version of the code says
card (Node x lt rt) = (height lt) + (height rt) + 1
> maxFour :: Int -> Int -> Int -> Int -> Int
ERROR "test.lhs" (line 3): Undefined variable "a"
The definition of maxFour has its variables missing. The second line should read maxFour a b c d.
> exOr :: bool -> bool -> bool
ERROR "test.lhs" (line 3): Declared type too general
The problem here is with the bools in the type. The Boolean type
is written Bool and so the first line should read
exOr :: Bool -> Bool -> Bool
What does the error message mean? The bool is taken to be a type
variable, and so the declaration asserts that the function has a
polymorphic type (which of course it doesn't).
> ex = (2==3))
ERROR "test.lhs" (line 1): Syntax error in input (unexpected `)')
The presence of an extra closing parenthesis is signalled as an unexpected
piece of input. Other `unexpected' symbols can be more enigmatic....
> fun x
ERROR "test.lhs" (line 2): Syntax error in input (unexpected `;')
The problem here is that the first line is incomplete. Formatting means
that the symbol fun in the second line signals by layout that the construct
in the first line is finished. The explicit Haskell symbol for the end of
a construct is `;'; hence the message.
> fun x
which is not erroneous. It means the same as
> fun x y 2 = 34
because the second use of fun is treated as a variable!
> module Junk where
ERROR "Junk.lhs" (line 4): Syntax error in expression (unexpected `}')
This problem happens because there is a closing bracket missing at the end of
the line. The } symbol is used to group definitions together, and also to define
records with named fields. An error like this occurs when grouping is incorrect
or, if you are using records, in record syntax.
> f :: Int -> [Int] -> [Int]
ERROR "test.lhs" (line 4): Syntax error in expression (unexpected `}', possibly due to bad layout)
The problem here is not so much bad layout as a missing closing parenthesis!
> fun x = 17
ERROR "test.lhs" (line 2): Syntax error in input (unexpected keyword "type")
This problem happens because of the indentation of the second line is incorrect;
it should be indented to the same level as the first line.
> fun x = 17
ERROR "test.lhs" (line 2): Syntax error in input (unexpected keyword "type")
This problem happens because of the indentation of the second line is incorrect;
it should be indented to the same level as the first line.
> Fun x = 17
ERROR "test.lhs" (line 1): Undefined constructor function "Fun"
The syntax of the language dictates that names for functions and other
defined values begin with a small letter. Names beginning with capitals
are reserved for constructors (of data types) and for types and type
classes. Here the use of a capital letter in Fun is seen to be the use
of a constructor which is not defined.
> fun x = 17
ERROR "test.lhs" (line 2): Syntax error in input (unexpected keyword "type")
The problem here is that type definitions are not allowed in where clauses.
> fun x x = 17
ERROR "test.lhs" (line 1): Repeated variable "x" in pattern
A variable can only occur once on the left-hand side of a definition. You can get the same effect with
> fun x y
double - 4
ERROR: Illegal Haskell 98 class constraint in inferred type
where double is of type Int -> Int. The problem is that -4 needs
to be parenthesised, as in double (-4).
> fun x = x + abs -2
ERROR "test.lhs" (line 1): a -> a is not an instance of class "Num"
In the definition here, the function abs is supposed to be applied to -2;
what happens instead is that 2 is subtracted from the function abs.
> fun x = x + abs (-2)
In Hugs98 a different error message is generated by the same script.
ERROR "text.lhs" (line 1): Illegal Haskell 98 class constraint in inferred type
Are two integers in ascending order?
ERROR "test.lhs" (line 2): Program line next to comment
The message here is slightly misleading: the program line is
immediately below a comment, and that is not acceptable syntax.
> test :: (Bool,Bool) -> Bool
"test.lhs" (line 2): Illegal pattern syntax
The illegality is to have mistyped b2 as 2b.
> predecessor n :: Num a => a -> a
Syntax error in input (unexpected `|')
The problem here is the argument n which appears in the type declaration. This should read:
> predecessor :: Num a => a -> a
which states that the type of the predecessor function is a -> a for any type
ain the Num class.
> Any Haskell code in literate form
ERROR "test.hs" (line 3): Syntax error in input (unexpected symbol ">")
This is due to having a literate script in a .hs file.
> Any Haskell code in non-literate form
ERROR "test.lhs" (line 8): Empty script - perhaps you forgot the `>'s?
As the message implies, this results from having a non-literate script in a .lhs file.
> fred :: Int -> Int
ERROR "test.lhs" (line 1): Missing binding for variable "fred" in type signature
The problem here is that the function fred has its type declared,
but it is not actually defined in the module.
> elem :: Int -> [Int] -> Bool
ERROR "test.lhs" (line 2): Definition of variable "elem" clashes with import
This definition re-defines something imported from the standard Prelude.
It can be hidden on import by including the import statement
> import Prelude hiding (elem)
at the start of the module.
ERROR "File2.lhs": Module "Main" already loaded
This error happens if you load two anonymous modules into (Win)Hugs. The solution is
to name the modules concerned and to set up the appropriate import/export structures.
> f [] = 23
ERROR "test.hs" (line 2): "f" multiply defined
The first line of the file defines the function f, and the second the function g; the third, erroneously,
adds another clause of the definition of f. This is an error. This could happen by inserting by mistake
a section into an existing definition.
> foo :: Int -> [Char]
*** term : foo
The intention here was to divide the numerical input x by 10; div
should have appeared in back-quotes: `div`. The program is a correct
program, in which x is applied to the function div, hence the error
appears as a mis-typing. This is a good example of why it is sensible
to include type declarations in definitions; if the declaration was missing,
the foo function would be accepted, only to be rejected (presumably) at
the first point at which it is used.
empty :: [a] -> Bool
ERROR "test.hs" (line 2): Cannot justify constraints in explicitly
The problem here is that in order to compare lists for equality one
can only do this when the elements themselves carry an equality function.
This is necessary even when comparing with the empty list. It is fixed thus
empty :: Eq a => [a] -> Bool
> compress :: [a] -> [a]
ERROR "lab2.hs" (line 2): Cannot justify constraints in explicitly typed binding
The problem here is that the equality function, ==, is used over the elements
of the list. This needs to be acknowedged in the type of the function, making
it include the constraint that the type a belongs to the equality class, Eq,
> compress :: Eq a => [a] -> [a]
> ascendingOrder :: Int -> Int -> Bool
ERROR "test.lhs" (line 3): Type error in application
The function here should return a Boolean indicating whether
its two arguments, a and b are in ascending order.
> ascendingOrder :: Int -> Int -> Bool
ERROR "test.lhs" (line 3): Type error in application
> ex = [('2',2),('1','1'),('a',3)]
ERROR "test.lhs" (line 1): Char is not an instance of class "Num"
The problem here is that a character '1' is being used in a place where a number should appear.
> fun x = x ++ 2
ERROR "test.lhs" (line 1): Illegal class constraint Num (a b) in inferred type.
The operator ++ needs to be applied to lists; here it is applied to (a list and) a number. The right-hand side is fixed thus: x ++ [2].
> convert :: String -> String
ERROR "test.lhs" (line 2): Instance of Num [Char] required for definition of convert
A problem here is the use of + to join a number to a string; the compiler therefore tries to find a definition of + over string, i.e. [Char] and fails.
> fun x = [2]:[2]
ERROR "test.lhs" (line 1): [a] is not an instance of class "Num"
Here a list is being added to the front of a list of numbers; a list is used where a number is expected.
> myCheck :: Int -> Bool
ERROR "test.lhs" (line 2): Type error in function binding
The problem here is that an incorrect type is specified for
a correct definition. The type assertion needs to be replaced by
> myCheck :: Char -> Bool
> type Fred = (Fred,Int)
ERROR "test.lhs" (line 11): Recursive type synonym "Fred"
Only types defined using data can be recursive. The intended effect is given by
> data Fred = Fred Fred Int
> proximity :: a -> a -> Double
Type checking
The problem here is the type declaration g :: b -> Double in
the local definition: without this, the code type checks. What is the difficulty?
It is in the interpretation of a statement like g :: b -> Double,
which means that g can be passed an argument of any type. The problem
is that this isn't the role of g here: this function can only receive
an element of whatever q is passed. The type of g
can only be expressed correctly in the presence of scoped type variables: we need the
b in q :: b -> Int to be usable (in scope) throughout
the definition of q rather than just in the type declaration itself,
as is the case in the current language definition.
3/0
Program error: {primDivDouble 3.0 0.0}
Here a number is being divided by zero: the `primitive' function, primDivDouble,
causes an error when being trying to divide by zero. Exactly the same error message is given by
evaluating
(1+2)/0
showing that the error message shows the values for which the division is called, rather than the
expressions which have those values.
> fun n = fun (n+1)
Segmentation Fault (core dumped)
Evaluating fun 1 initiates a recursion that carries
on indefinitely: the Hugs system (on Unix) crashes with this classic error message!
> fun n = fun (n+1)
ERROR: Control stack overflow
If you try to evaluate fun 1: the recursion calls
fun 2, which calls fun 3 and so on....
This never gives an answer, but rather goes on forever; after some time it overruns the
`control stack' which causes the message that you saw.
[1 .. 10]!!23
Program error: PreludeList.!!: index too large
This error message is helpful. It indicates the function causing the problem,
namely the !! function from the PreludeList module; qualified naming is being
used here. The error message itself is contained in the error call in the definition of the !!
function in PreludeList:
[] !! _ = error "PreludeList.!!: index too large"
concat [1,2,3]
ERROR: Illegal class constraint Num (a b) in inferred type.
This is a type error(!): concat expects a list of lists, but
is instead passed a list of numbers. The problem here is that -- in Hugs 1.4,
at least -- concat is overloaded to work over all monads (which generalise lists)
and this gives rise to this kind of error. This should not be a problem in
implementations of Haskell 98. Assuming that
concat :: [[a]] -> [a]
the error message generated for concat [1,2,3] will be
ERROR: [a] is not an instance of class "Num"
> test :: [Bool] -> [Bool]
Program error: {test [True]}
This error message here is less helpful. It indicates that an error is caused by applying test to the list [True], but fails to say that this is due to a missing pattern. An alternative definition
> test xs = case xs of > [] -> [False] provokes the message
Program error: {test_v850 [False]} showing that an error occurs in a pattern match somewhere inside the function test. At worst, a missing pattern can give rise to the message
Program error: {_FAIL} A similar problem is produced by times2 :: (Float,Float) -> Float reverse []
ERROR: Cannot find "show" function for:
The top-level system for Hugs can only print values which belong to a type which can be shown,
that is a type which belongs to the Show class. Now, the list type is an instance
of Show, so what is wrong with reverse [] (which evaluates to [])?
The problem is that the type of [] is polymorphic: [] :: [a] for all a.
Not knowing a Hugs refuses to print a value of type [a]. Note that this behaviour
applies to all polymorphic values. Given the definition
data Tree a = Empty | Node (Tree a) a (Tree a)
we have, on evaluating
Empty
the error message
ERROR: Cannot find "show" function for:
Functions can be shown, but not very helpfully; printing any function results in
<<function>>
(1,2,3,4,5,6)
ERROR: Cannot find "show" function for:
The Hugs system derives show functions, which convert values into Strings,
for various types automatically, and uses these functions in printing out values. Unfortunately,
it will only derive show functions for tuples with five or fewer components.
ERROR: Garbage collection fails to reclaim sufficient space
This occurs during or after evaluation of a large expression;
it means that the heap for Hugs is too small. Heap size can be
changed; consult the documentation; use :set to find the current size.
card :: BTree a -> Integer
card EmptyBTree = 0
card (Node x) lt rt = (height lt) + (height rt) + 1
> maxFour
> | a >= b && a >= c && a >= d = a
> | b >= c && b >= d = b
> | c >= d = c
> | otherwise = d
> exOr b1 b2
> = (b1 && not b2) || (b2 && not b1)
*** Expression : exOr
*** Declared type : a -> a -> a
*** Inferred type : Bool -> Bool -> Bool
> fun 2 = 34
Another peculiarity of the system is given by
> fun 2 = 34
>
> a = (True, [1,2,3,4]
> f a x = (a:x
> type Fred = Int
> type Fred = Int
> where
> type Fun = Int
> | x==y = 17
*** Expression : double - 4
*** Type : Num (Int -> Int) => Int -> Int
Negative literals need to be enclosed in parentheses, as in
*** Expression : fun
*** Type : (Num (a -> a), Num a) => (a -> a) -> a -> a
> ascendingOrder :: Int -> Int -> Bool
> ascendingOrder x y = (x<=y)
> test (b1,2b) = b1
> predecessor n
> | n>0 = n-1
> | n==0 = 0
> elem x xs = [y | y<-xs, y==x] /= []
> g y = 2
> f (x:xs) = 6
> foo x = ['1'] ++ foo(x div 10)
*** type : ((a -> a -> a) -> b -> Int) -> [Char]
*** does not match : Int -> [Char]
empty as = (as == [])
typed binding
*** Expression : empty
*** Type : [a] -> Bool
*** Given context : ()
*** Constraints : Eq a
empty as = (as == [])
> compress [] = []
> compress [a] = [a]
> compress (x:y:xs)
> | (x == y) = compress (x:xs)
> | otherwise = x : compress (y:xs)
*** Expression : compress
*** Type : [a] -> [a]
*** Given context : ()
*** Constraints : Eq a
> ascendingOrder a b
> | a<=b = a b
> | otherwise = b a
*** expression : a b
*** term : b
*** type : a -> b
*** does not match : a
*** because : unification would give infinite type
Instead the function attempts to return the two ``in ascending order''.
Looking at the definition, in the third line a is applied to b,
so a must be a function which can be applied to b. On the other
hand, in line 4 the reverse happens, so b is applied to a. Trying to resolve
these two constraints gives rise to the ``infinite type'' in the error message.
The problem here is compounded here by using a, b
and so on as variable names, since the system uses them also as type variable names. Rewriting
the function to use x, y etc. as variables helps to make the
error message more comprehensible:
> ascendingOrder x y
> | x<=y = x y
> | otherwise = y x
*** expression : x y
*** term : y
*** type : a -> b
*** does not match : a
*** because : unification would give infinite type
This error message refers to the class system in Haskell; if you don't know about this, then you
can still get some useful information from the error message, namely
- the error occurs on line 1;
- a character is being used when something else is expected;
- the name of the class mentioned, Num, suggests that a number was expected.
In general, an error containing Blah is not an instance of class "Plonk"
indicates that something of type Blah appears (on the line in question) in a place
where something related to Plonk was expected.
> convert s = "Co" ++ (300 + tail s)
> myCheck n = ord n == 6
*** term : myCheck
*** type : Char -> Bool
*** does not match : Int -> Bool
> proximity x y = 0
> q :: b -> Int
> q p = 0
> where
> g :: b -> Double
> g = proximity p
ERROR "test.hs" (line 8): Inferred type is not general enough
*** Expression : g
*** Expected type : a -> Double
*** Inferred type : _2 -> Double
...
> test [] = [False]
test [True]
totalArea [(a,b)] = map times2 [(a,b)]
times2 (a,b) = a * b
*** expression : reverse []
*** of type : [a]
*** expression : Empty
*** of type : Tree a
*** Expression : (1,2,3,4,5,6)
*** Of type : (Integer,Integer,Integer,Integer,Integer,Integer)