Question

I create my own type parameters as follow:

data Node a = Node a

data Cost = Int | Float

data Edge Node Cost = Edge ((Node,Node),Cost)

data Graph Edge = Graph [Edge]

And get an error:

Unexpected type Node' where type variable expected
In the declaration ofEdge Node Cost’

How can I fix it?

Answer 1

Type Constructors vs Data Constructors

You have to tag the types in a union type in haskell:

data Cost = Int | Float

should say

data Cost = I Int | F Float

Notice that this is because Int and Float are types. Example data would be I 5 or F 5.6. We need data constructors too. I and F are data constructors here. I :: Int -> Cost and F :: Float -> Cost. They’re functions that turn Ints or Floats into Costs. You can have a constructor that doesn’t take an argument, for example, as in your comment,

data Bool = True | False

Here True and False are constructors, not types. Example data would be just True or False. You do have to have constructors every time, which is why we need to tag the types Int and Float

The definition

data Node a = Node a

is a bit confusing, because on the left hand side, Node is a sort of type function we call a type constructor, and has kind * -> *, but on the right hand side Node is a data constructor of type a -> Node a. Example data: Node "hello" of type Node String. This would be less confusing if we wrote

data Node a = N a

So Node is the type constructor and N is the data constructor. This gives sample data N "Hello" of type Node String. For this sort of definition, we haven’t made a lot of difference, so we tend to say

newtype Node a = N a

because the compiler can optimise it away in most cases, but we get type safety at the source code end.

Type Constructors need types

You also need

data Edge a = Edge ((Node a,Node a),Cost)

because Node is a type constructor (it has kind * -> *) so you have to always give it a type to work on. I’ve given it a so you can make your node out of anything.

However, you don’t need the brackets, and a union of Int and Float is probably not as useful as allowing any cost type, by using lower case cost instead of the fixed type Cost

data Edge a cost = Edge (Node a) (Node a) cost

(If you want to make sure no-one ever makes an edge out of any cost that is non-numerical, you can say data Num cost => Edge a cost = Edge (Node a) (Node a) cost. In my view that’s a much better compromise between the awkwardness of tagging Int and Float and allowing arbitrary costs, but you don’t need it – you can quite happily add the restriction just exactly when you need it on a function that combines costs with +.)

Your whole definitions would then be

data Node a = Node a
data Edge a cost = Edge (Node a) (Node a) cost
data Graph a c = Graph [Edge a c]

Again, you need to write Graph [Edge a c] because Edge takes two types, so has kind * -> * -> *.