[Haskell-beginners] profiling weirdness?

[Thomas]

Hello all!

Currently this is more of a curiosity for me rather than a real obstacle 
to learn Haskell, but I'd appreciate any insight into this behaviour 
nevertheless.

Given the (dumb, I know, but it's for illustration purpose) program:
---
import Data.Char

type Position = (Char, Integer)

sameSquare :: Position -> Position -> Bool
sameSquare p1 p2
	= ssqHelper p1 p2

ssqHelper :: Position -> Position -> Bool
ssqHelper (r1, c1) (r2, c2)
         | (((c1-1) `div` 3) == ((c2-1) `div` 3) && ((((ord r1) - 65) 
`div` 3) == (((ord r2) - 65) `div` 3))) = True
         | otherwise = False

main :: IO ()
main = print (sameSquare ('A', 2) ('B', 2))
---

If I compile this with profiling info and run the profiler all seems 
well (independently of optimization settings). Now, if I comment the line
--ssqHelper :: Position -> Position -> Bool
and do the same (compile with profiling info) I can see rather 
surprising results. While I'd expect exactly one call to ssqHelper for 
every call to sameSquare this is actually only the case if compiled 
without optimizations. Using -O2 when compiling I get a full 5 calls of 
ssqHelper for every call to sameSquare.

I am unable to imagine an optimization that would be more efficient with 
five calls instead of one. And I do not understand either what this has 
to do with the type annotation. Within such a trivial program the 
inferred type should be equivalent, shouldn't it?
Actually ghci generalizes slightly: Integral instead of Integer. But 
that's no clue for me either...

BTW I'm using ghc 6.10.4. (In case it matters.)

Any hint would be appreciated.
Thanks,
Thomas