haskell: creating list of records

Question

How to create a list of records in haskell

I have a Record

data TestList = Temp1 (String,[String])
          | Temp2 (String,[(String,String)])
    deriving (Show, Eq)

I am creating a list of records

testLists :: [TestList]
testLists =  [minBound..maxBound]

When I run, it throws me an error.

No instance for (Enum TestList)
      arising from the arithmetic sequence `minBound .. maxBound'
    Possible fix: add an instance declaration for (Enum TestList)
    In the expression: [minBound .. maxBound]
    In an equation for `testLists': testLists = [minBound .. maxBound]

It gives me a possible fix but I don't understand what it means. can anyone explain it and tell me how to fix it.

Fred Foo · Accepted Answer · 2011-10-21T09:06:14.543

3

You can't use minBound and maxBound unless you declare beforehand what they mean for your type (which by the way is not a record type). You must, as the error also tells you, declare the type as an instance of Bounded. Without knowledge of what your type is to represent, it's impossible to say what such a declaration should look like exactly, but its general form is

instance Bounded TestList where
  minBound = ...
  maxBound = ...

(Fill in the ...)

edited Oct 21 '11 at 09:06

answered Oct 20 '11 at 17:50

Fred Foo

355,277
75
744
836

I understand the problem. But one thing is that its a list of size 0 to infinite.. So how can I define the minBound and maxBound. – veda Oct 20 '11 at 18:08
@veda: you can't write a generic instance that would make sense for all uses of a list, however you can write one which is sensible for your problem domain, presuming that you do know an upper bound in advance. – John L Oct 20 '11 at 18:13
1

@larsmans: I disagree with your statements. 1) there are `Enum` types that have an infinite number of values (e.g. `Integer`) 2) `maxBound` has nothing to do with `Enum` (it is part of `Bounded`) 3) Nevertheless, I could still imagine there being a type that is bounded and still has an infinite number of values "in the middle" – newacct Oct 20 '11 at 20:16
Where I said `Enum` I meant `Bounded`. Sorry. – Fred Foo Oct 21 '11 at 09:06

score 2 · Answer 2 · answered Oct 20 '11 at 17:51

You didn't tell it how to enumerate values of type TestList. Even if it understands what minBound and maxBound are, it doesn't know how to discover what all of the values in between are (in order to create a list with those values).

By adding an instance declaration for Enum TestList, you would basically be instructing it on how to enumerate values, so it would be able to construct that sequence for you.

score 1 · Answer 3 · answered Oct 20 '11 at 18:12

There are two problems here. First, you'll need to create an Enum instance (as others have said). An Enum instance is required because you've used the special enumeration syntax [ a .. b].

Once you've created the Enum instance, you'll also need to write an instance for Bounded because you've used minBound and maxBound.

Usually you can tell Haskell compilers to derive both of these instances, however that won't work here because neither Lists nor Strings have instances for either type class. What value should maxBound :: String have, anyway? You could always make a longer string, or add another element to a list. Since you can't derive the instances, you'll have to manually write the Enum instance as in larsmans answer and similarly a Bounded instance.

haskell: creating list of records

3 Answers3