Jake Penton djp at arqux.com
Wed Jun 1 02:48:41 CEST 2011

```Greetings. I post here from time to time as I work my way through Real World Haskell. I believe that I have understood most of what I have studied. However, today I ran into something that seems like magic.

I hope it's ok to refer to RWH here, as I believe that the book is very commonly used for learning the language. I'll include the code that is puzzling me here anyway, though.

On p.310 of RWH we have:

data Op = Plus | Minus | Mul | Div | Pow
deriving (Eq, Show)

data SymbolicManip a =
Number a
| Arith Op (SymbolicManip a) (SymbolicManip a)
deriving (Eq, Show)

instance Num a => Num (SymbolicManip a) where
a + b = Arith Plus a b
a - b = Arith Minus a b
a * b = Arith Mul a b
negate a = Arith Mul (Number (-1)) a
abs a = error "abs is unimplemented"
signum _ = error "signum is unimplemented"
fromInteger i = Number (fromInteger i)

Ok, so far so good. But the following example seems quite astounding to me:

ghci> (5 * 10 + 2)::SymbolicManip Int
Arith Plus (Arith Mul (Number 5) (Number 10)) (Number 2)

The book says to notice that haskell "converted" 5 * 10 + 2 into a SymbolicManip. Indeed!

My understanding breaks down at this point. I suspect that it may be my weak grasp of the implications of lazy evaluation, and typeclasses generally. My (incorrect) intuition makes me think that the stuff inside the parentheses should be evaluated first, and then typed as a SymbolicManip. This would give the result Number 52.

My question may be too vague to answer easily, but what I am hoping for is a bit of a narrative regarding how haskell knows that the pieces inside the parentheses are each of type SymbolicManip Int. Or something like that....