Question

Again Haskellers & Haskellettes,

I still have the problem, that I don’t really know when to use (Class a) => a, Type or
Type a where Type is a “union type” as for example Val and ExprTree

Now i want to make my datatype ExprTree a bit more versatile by adding a few instances:

import Ratio
data Fun = Add|Sub|Mul|Div|Pow
    deriving (Eq,Ord)
instance Show Fun where
    show Add = "+"
    show Sub = "-"
    show Mul = "*"
    show Div = "/"
    show Pow = "^"
type Label = Rational
type Var = String
class Eval e where
eval :: (Num a) => e -> a -> a
data ExprTree a = Leaf {lab::Label, val::Val a}
          | Node {lab::Label, fun::Fun, lBranch::ExprTree a, rBranch::ExprTree a}
          deriving(Eq,Ord)
data Val a = Num a | Var String deriving (Eq, Ord, Show)

---

instance (Num a) => Num (ExprTree a) where
    ...
    fromInteger i = Leaf (0%1) i -- <--error

instance Show (ExprTree a) where
    show (Leaf l a) = show a -- <-- error
    show (Node l f lb rb) = (show lb)++"  "++(show l)
                      ++(show f)++"  "++(show rb)++"\n"

instance Eval (Val a) where
    eval (Var v) n = n
    eval a _ = a -- <-- error

I think this problems – are all of the same kind. And the NOT understanding the difference between class and type and so forth in a more than trivial setting – is a hole in the basis of my haskell programming; so i really want to understand this not to solve any homework.

Note: The label is a Rational – which makes inserting and searching much easier, than labelling with natural numbers or integers.

Thanks in advance!

Answer 1

The problem with your fromInteger is that i needs to be converted to a Val a.

instance Num a => Num (ExprTree a) where
    -- ...
    fromInteger i = Leaf (0%1) (Val (fromInteger i))

The Val wrapper makes it a Val; the inner fromInteger creates an a, which is a caller-specified type, which we know can be created with fromInteger because of the Num a constraint) from the Integer. Pay close attention to that last: it’s the reason behind typeclasses. The Num a => constraint insures that, given an a, we know that we can use any of the Num instance methods on it.

The other problem is the same issue in reverse: you are calling show, but you haven’t done anything to make sure that show makes sense on an a.

instance Show a => ExprTree a where
    show (Leaf _ a) = show a -- this works now because we told it a is show-able
    -- ...

The problem with Eval is slightly different: a just appears without any source, so the compiler doesn’t know anything about it. In particular, eval a _ = a requires that an e be a valid a — but a is an unknown, so the compiler correctly says “what?”. For this one you need to think about what you’re really trying to do; the simplest solution is to drop the e and use a everywhere, but is that really what you intended?