This is a first try of a simple lift of Delay to functions spaces.

timedRecursion :: ((a -> T b) -> (a -> T b)) -> (a -> T b)
timedRecursion f = \ a -> Delay (f (timedRecursion f) a)

rfac :: (Int -> T Int) -> (Int -> T Int)
rfac f 0 = Stop 1
rfac f n = t (n*) (f (n-1))

fac :: Int -> T Int
fac = timedRecursion rfac

http://www.cs.bham.ac.uk/~mhe/papers/metricpcf.pdf

I would define, in Haskell, corresponding to the above note,

data T a = Stop a | Delay(T a)

instance Monad T where
return = eta
xs >>= f = mu(t f xs)

eta :: a -> T a
eta x = Stop x

mu :: T(T a) -> T a
mu(Stop xs) = xs
mu(Delay xss) = Delay(mu xss)

t :: (a -> b) -> (T a -> T b)
t f (Stop x) = Stop(f x)
t f (Delay xs) = Delay(t f xs)

timeout :: Int -> T a -> Maybe a
timeout n (Stop x) = Just x
timeout 0 (Delay xs) = Nothing
timeout (n+1) (Delay xs) = timeout n xs

timeof :: T a -> Int
timeof (Stop x) = 0
timeof (Delay xs) = 1 + timeof xs

timedRecursion :: (T a -> T a) -> T a
timedRecursion f = Delay (f (timedRecursion f))

The last one ticks once for each recursion unfolding. Notice the similarity (and difference) with lazy natural numbers. But, as the paper discusses, it is perhaps more sensible, in a call-by-name language, to tick only at ground types. Then you define, by induction on types, a new delay function (starting with delay=Delay at ground types) pointwise. The paper proves some properties of this.

Notice that an infinite computation returns, rather than bottom, infty, where

infty = Delay infty.

The output type of timeof can of course (and sensibly) be replaced by the lazy natural numbers.

Timeout can be presented as a monad, which follows from the general theory of effect that Matija has referred to, but I would still like to see a concrete Haskell implementation that results from Matija’s theory.