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
