Using a class in a datatype constructor

Question

Currently I have something like this:

data MyData = SomeData | MoreData | EvenMore
data DataLists = DataLists [MyData] [MyData]

Which allows me to obviously do something like this:

myDataList :: DataLists
myDataList = DataLists [SomeData, MoreData] [EvenMore, SomeData]

But I would like to instead do something like this:

-- Static Module File:

class MyClass b where
    evaluate :: b -> Int

data SomeData = SomeData
data MoreData = MoreData
data EvenMore = EvenMore

instance MyClass SomeData where
    evaluate _ = 2
instance MyClass MoreData where
    evaluate _ = 3
instance MyClass EvenMore where
    evaluate _ = 4

data DataList = DataList [MyClass] [MyClass] -- Obviously this is wrong

I would like that part of my code to remain static. Because later I would like to add in some types using that module to put in the Data List. I need this separate because the overall module will be used in 2 different projects and I don't want to have to keep going into edit it.

data MyVeryOwnData = MyVeryOwnData
--I should be able to make up as many datastructures as I want

instance MyClass MyVeryOwnData where
   evaluate _ = 99

myList :: DataList
myList = DataList [MyVeryOwnData, SomeData] [SomeData, EvenMore]

I realize that I could simply put MyVeryOwnData in the module file like this:

data MyData = SomeData | MyVeryOwnData ...

instance MyClass MyData where
    evaluate SomeData = 2
    evaluate MoreData = 3
    ... etc.

But I dont want to do that since as I said before I want to add an arbitrary amount of datatypes in.

Tarrasch · Accepted Answer · 2012-08-08 07:35:50Z

6

What you're looking for is called Heterogenous lists, and haskell supports them in mainly two ways, Existentials or GADTs. I show you a runnable code example that solved the problem with existentials.

{-# LANGUAGE ExistentialQuantification #-}

class Eval b where
    evaluate :: b -> Int

data SomeData = SomeData
data MoreData = MoreData
data EvenMore = EvenMore

instance Eval SomeData where
    evaluate _ = 2
instance Eval MoreData where
    evaluate _ = 3
instance Eval EvenMore where
    evaluate _ = 4

data Evalable = forall a . Eval a => Evalable a

instance Eval Evalable where
    evaluate (Evalable a) = evaluate a

pack :: Eval a => a -> Evalable
pack = Evalable

data DataLists = DataLists [Evalable] [Evalable]

getFirst :: DataLists -> [Evalable]
getFirst (DataLists xs ys) = xs

main = do
  let dl = DataLists [pack SomeData, pack EvenMore] [pack MoreData]
  print . map evaluate . getFirst $ dl

It should be clear that you can add instance Eval MyVeryOwnData in outside modules, and you can then pack those values so they become Evalable and you can then put them inside your Datalists.

answered Aug 8, 2012 at 7:35

Tarrasch

10.6k7 gold badges45 silver badges57 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

Petr Over a year ago

You can find more information on this topic at HaskellWiki: Heterogenous collections.

Joachim Breitner Over a year ago

Note that using Existentials, you can do nothing with Evalable besides calling evalute on it (or, in general, what the type class provides). In particular, you cannot pattern-match on the original constructors.

Gabriella Gonzalez Over a year ago

Ok, maybe this is a really dumb question, but what is the difference between this approach and just evaluating them and storing the evaluated ints in a list? What advantage is there in storing the preevaluated value if the only permissible operation once packed is to evaluate it?

Ptharien's Flame Over a year ago

@GabrielGonzalez In this case, there is no difference, and storing the Ints is likely to be cheaper, too. In general, though, the type class may have more (and more complex) operations than just evaluate; for example, the Num class may be useful under an existential in this way.

Gabriella Gonzalez Over a year ago

@Ptharien'sFlame Thanks, although I have another question, then. For the specific case of Num, it wouldn't be useful because all Num operations are parametric in the final result, which would be inaccessible since the type parameter is existentially quantified. However, if you only include classes or portions of classes that have concrete signatures in the positive position, then it seems like you could still do the same trick of just storing the concrete portions in the list.

|

Collectives™ on Stack Overflow

Using a class in a datatype constructor

1 Answer 1

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related