Hello, I am writing a function which returns an exception/error string should an unexpected parameter is passed in. Borrowing from the Maybe module I have the following: ------------------------------------------------------------ data Result a = Ex String | Value a deriving Show -- Testing the Result a type first_h :: [a] -> Result a first_h [] = Ex "No list" first_h (x:xs) = Value x -- Trying out the first_h main :: IO() main = print (first_h []) ------------------------------------------------------------ Which the compiler complains: Ambiguous type variable(s) `a' in the constraint `Show a' arising from use of `print' at atype.hs:8 In the definition of `main': print (first_h []) This is understandable since it is unable to unify the empty list with a concrete list of type 'a' i.e. there are an infinite types which would match. My question is how can I indicate to the compiler that it does not matter which type the empty list is since the return result is of a concreate type. Thanks Tee
In short, you cannot. What if your main were: main = getArgs >>= print . first_h The compiler doesn't know the difference and so it needs a type. Simple fix:
main = print (first_h ([] :: [Char]))
-- Hal Daume III "Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume On Fri, 17 May 2002 tty@SAFe-mail.net wrote:
Hello, I am writing a function which returns an exception/error string should an unexpected parameter is passed in. Borrowing from the Maybe module I have the following: ------------------------------------------------------------ data Result a = Ex String | Value a deriving Show
-- Testing the Result a type first_h :: [a] -> Result a first_h [] = Ex "No list" first_h (x:xs) = Value x
-- Trying out the first_h main :: IO() main = print (first_h []) ------------------------------------------------------------
Which the compiler complains:
Ambiguous type variable(s) `a' in the constraint `Show a' arising from use of `print' at atype.hs:8 In the definition of `main': print (first_h [])
This is understandable since it is unable to unify the empty list with a concrete list of type 'a' i.e. there are an infinite types which would match. My question is how can I indicate to the compiler that it does not matter which type the empty list is since the return result is of a concreate type.
Thanks
Tee _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Erm, I think I said something stupid (or at least implied it). main = getArgs >>= print . first_h *will* work, because it knows that the result of a getArgs is a list of Strings. The problem you originally had was that when you say: first_h [] The "[]" could refer to a list of any type of element. Since not every element type is an instance of Show, it doesn't know that it can apply show to the list. By saying, for instance, (first_h ([] :: [Char])) you're saying "okay, this is an empty list, but it's a list of Characters and you know that a character can be shown." If you backtrack what the type checker is doing, it says: print (first_h []) okay, the argument to print must be an instance of Show (print has type Show a => a -> IO ()). therefore, first_h [] must be an instance of Show. well, what's the type of first_h []? Well, the type of first_h is [a] -> Result a. is "Result a" an instance of show? well, let's see...you said data Result a = ... deriving (Show). this basically means you get an instance declaration: instance Show a => Show (Result a) where ...some stuf... so, we want to know if Result a is an instance of show. Well, it is whenever a is an instance of show. so, if the elements of your list are an instance of show, then (first_h []) is an instance of Show, as we require. however, since you just say "[]" it knows this is of type [a], but it *doesn't* know what a is. therefore, a could either be or not be an instance of show. however, if you explicitly specify what a is and that explicit type is an instance of show (like Char in my example), then everything is fine. -- Hal Daume III "Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume On Fri, 17 May 2002, Hal Daume III wrote:
In short, you cannot.
What if your main were:
main = getArgs >>= print . first_h
The compiler doesn't know the difference and so it needs a type.
Simple fix:
main = print (first_h ([] :: [Char]))
-- Hal Daume III
"Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume
On Fri, 17 May 2002 tty@SAFe-mail.net wrote:
Hello, I am writing a function which returns an exception/error string should an unexpected parameter is passed in. Borrowing from the Maybe module I have the following: ------------------------------------------------------------ data Result a = Ex String | Value a deriving Show
-- Testing the Result a type first_h :: [a] -> Result a first_h [] = Ex "No list" first_h (x:xs) = Value x
-- Trying out the first_h main :: IO() main = print (first_h []) ------------------------------------------------------------
Which the compiler complains:
Ambiguous type variable(s) `a' in the constraint `Show a' arising from use of `print' at atype.hs:8 In the definition of `main': print (first_h [])
This is understandable since it is unable to unify the empty list with a concrete list of type 'a' i.e. there are an infinite types which would match. My question is how can I indicate to the compiler that it does not matter which type the empty list is since the return result is of a concreate type.
Thanks
Tee _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
participants (2)
-
Hal Daume III -
tty＠SAFe-mail.net