The following runs without a problem. Prelude> let null' xs = xs == [] null' :: (Eq a) => [a] -> Bool Prelude> let main' = do print (null' []) main' :: IO () Prelude> main' True it :: () But if I put essentially the same code in a file and try to load the file I get an error. File: Null null' xs = xs == [] main = do print (null' []) Prelude> :load "Null.hs" [1 of 1] Compiling Main ( Null.hs, interpreted ) Null.hs:3:17: Ambiguous type variable `a' in the constraint: `Eq a' arising from a use of `null'' at Null.hs:3:17-24 Probable fix: add a type signature that fixes these type variable(s) Failed, modules loaded: none. Why is that? I had thought that the ambiguity was referring to the type of [] in the print statement, i.e., that GHC can't figure out the type of []. If I modify the print statement to be print ( null' ([] :: [Int]) ) everything is ok. But if that's the case, why is this not a problem at the interactive level? Here is a related question. In the following what does it mean to say that x is of type [a] where "a" is a type variable? Prelude> let x = [] x :: [a] For example, Prelude> x == (tail [1 :: Int]) True it :: Bool Prelude> x == (tail [1 :: Float]) True it :: Bool Prelude> (tail [1 :: Int]) == (tail [1 :: Float]) <interactive>:1:28: Couldn't match expected type `Int' against inferred type `Float' In the expression: 1 :: Float In the first argument of `tail', namely `[1 :: Float]' In the second argument of `(==)', namely `(tail [1 :: Float])' Can a value like the value of x really be of an incompletely specified type? I couldn't do that in the file. When I tried the following in the file, print (null' ([] :: (Eq a) => a)) I got this error message on loading the file. Null.hs:3:24: Couldn't match expected type `a1' against inferred type `[a]' `a1' is a rigid type variable bound by an expression type signature at Null.hs:3:34 In the first argument of `null'', namely `([] :: (Eq a) => a)' In the first argument of `print', namely `(null' ([] :: (Eq a) => a))' In the expression: print (null' ([] :: (Eq a) => a)) Thanks. -- Russ