When I write a function with the type constraint "embedded" in the function's type declaration, instead of at the beginning, the function takes longer each time it is run. The simplest example I could write is this: http://lpaste.net/134563. "run1" is near instantaneous the first time, but gets marginally slower after each iteration... after thousands of iterations it takes about a millisecond to run (and keeps getting worse). "run2" is always near instantaneous. What is happening in "run1" that makes it slow down?

PS: The example is fairly contrived, I know "run1"'s type declaration wouldn't be used in practice.

Thanks for any guidance!

{-# LANGUAGE RankNTypes #-}

{-# LANGUAGE FlexibleContexts #-}

module Main where

import Control.Monad.State.Strict

import qualified Data.Time.Clock as Clock

import Control.Exception

run1 :: (Int -> (Num Int => State Int Bool)) -> Int -> IO ()

run1 f state = do

t1 <- Clock.getCurrentTime

evaluate $ runState (f 1) state

t2 <- Clock.getCurrentTime

print $ Clock.diffUTCTime t2 t1

run1 f state

run2 :: Num s => (Int -> State s Bool) -> s -> IO ()

run2 f state = do

t1 <- Clock.getCurrentTime

evaluate $ runState (f 1) state

t2 <- Clock.getCurrentTime

print $ Clock.diffUTCTime t2 t1

run2 f state

main :: IO ()

main = run1 (const $ return False) 1

--main = run2 (const $ return False) 1