Creating list of values of the same typeclass but different types

Question

I'm new to Haskell and trying to do something which I'm sure is easy but I'm not seeing the right way to do it.

What I want is a list of values of a particular typeclass, but different types of that typeclass. Eg:

class Shape a where
  area :: a -> Double
  numVertices :: a -> Integer

data Triangle = Triangle {...}
data Square = Square {...}

instance Shape Triangle where ...  
instance Shape Square where ...

x = [Triangle (...), Square (...)]

I'm getting a compiler error because the list has different types. What's the right way to do what I'm trying to do here? The only thing I've been able to come up with is doing something like this:

data WrappedShape = WrappedShape {
    getArea :: () -> Double
  , getNumVertices :: () -> Integer
}

wrap s = WrappedShape {
    getArea = \ () -> area s
  , getNumVertices = \ () -> vertices s
}

x = [wrap (Triangle (...)), wrap (Square (...))]

This works, but it's heavy on boilerplate, since I have to effectively define Shape twice and with differently-named members. What's the standard way to do this sort of thing?

Possible duplicate of List of different types?

jberryman
– jberryman

2018-10-20 17:22:28 +00:00
Commented Oct 20, 2018 at 17:22 — jberryman
– jberryman, Commented Oct 20, 2018 at 17:22

assembly.jc · Accepted Answer · 2018-10-20 16:35:30Z

1

If you just need a few different shapes, you can enumerate each shape as a constructor, here is a example:

data SomeShapes = Triangle {...}
                  | Square {...}

instance Shape SomeShapes where 
    area (Triangle x) = ...
    area (Square x) = ....

now you can put them in a list, because they are same type of SomeShapes

[Triangle {...}, Square {...}]

answered Oct 20, 2018 at 16:35

assembly.jc

2,0761 gold badge9 silver badges16 bronze badges

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

Comments

chi · Accepted Answer · 2018-10-20 16:47:15Z

Your wrapped type is probably the best idea.

It can be improved by noting that, in a lazy language like Haskell, the type () -> T essentially works like the plain T. You probably want to delay computation and write stuff like let f = \ () -> 1+2 which does not perform addition until the function f is called with argument (). However, let f = 1+2 already does not perform addition until f is really needed by some other expression -- this is laziness.

So, we can simply use

data WrappedShape = WrappedShape {
    getArea :: Double
  , getNumVertices :: Integer
}

wrap s = WrappedShape {
    getArea = area s
  , getNumVertices = vertices s
}

x = [wrap (Triangle (...)), wrap (Square (...))]

and forget about passing () later on: when we will access a list element, the area/vertices will be computed (whatever we need). That is print (getArea (head x)) will compute the area of the triangle.

The \ () -> ... trick is indeed needed in eager languages, but in Haskell it is an anti-pattern. Roughly, in Haskell everything has a \ () -> ... on top, roughly speaking, s o there's no need to add another one.

These is another solution to your problem, which is called an "existential type". However, this sometimes turns into an anti-pattern as well, so I do not recommend to use it lightly.

It would work as follows

data WrappedShape = forall a. Shape a => WrappedShape a

x = [WrappedShape (Triangle ...), WrappedShape (Square ...)]

exampleUsage = case head x of WrappedShape s -> area s

This is more convenient when the type class has a lots of methods, since we do not have to write a lot of fields in the wrapped type.

The main downside of this technique is that it involves more complex type machinery, for no real gain. I mean a basic list [(Double, Integer)] has the same functionality of [WrappedShape] (list of existentials), so why bother with the latter?

Luke Palmer wrote about this anti-pattern. I do not agree with that post completely, but I think he does have some good points.

I do not have a clear-cut line where I would start using existentials over the basic approach, but these factors are what I would consider:

How many methods does the type class have?
Are there any methods of the type class where the type a (the one related to the class) appears not only as an argument? E.g. a method foo :: a -> (String, a)?

Collectives™ on Stack Overflow

Creating list of values of the same typeclass but different types

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related