How can I implement this kind of IO action?

Question

I have the following datatype, which encodes arbitrary real numbers:

newtype ArbReal = ArbReal {approximate :: Word -> Integer}

I have the following function, which finds the limit of a converging sequence of real numbers:

inexactToReal :: (Word -> ArbReal) -> ArbReal
inexactToReal f = ArbReal $ \n -> let
    ArbReal g = f n
    in g n

I implemented a constant, the natural logarithm of ten:

ln10 :: ArbReal
ln10 = inexactToReal $ \n -> if 0 == n
    then 2
    else let
        halfN = ceiling (n % 2)
        a = inexactToReal $ \m -> go (2 * logBaseZ m 2) 1 (4 / 10 ^ halfN)
        in pi / (2 * a * fromInteger halfN)
  where
    go n a b = let
        newA = (a + b) / 2
        in if 0 == n
            then newA
            else go (n-1) newA (sqrt (a * b))

But this has some bugs. I think this falls in an infinite loop. So I wanted to turn it to a debugging routine. And that's where the problem is. Consider the following variant of go above:

debugAGM :: Word -> ArbReal -> ArbReal -> IO ArbReal
debugAGM n a b = let
    newA = (a + b) / 2
    in if 0 == n
        then putStrLn "Iteration complete." >> return newA
        else do
            putStrLn ("debugAGM iteration: n = " ++ show n)
            debugAGM (n-1) newA (sqrt (a * b))

This is too much of IO. There is no variant of inexactToReal that can handle this.

Yet consider this:

debugAGM :: Word -> ArbReal -> ArbReal -> (ArbReal, IO ())
debugAGM n a b = let
    newA = (a + b) / 2
    in if 0 == n
        then (newA, putStrLn "Iteration complete.")
        else let
            (x, action) = debugAGM (n-1) newA (sqrt (a * b))
            in (x, putStrLn ("debugAGM iteration: n = " ++ show n) >> action)

This is too little of IO. The IO action is parallel to the returned value. There is no variant of inexactToReal that can handle this.

In summary, I must somehow escapsulate IO so the followings will be achieved:

• The returned value, which is essentially a function, must be pure.

• Yet there must be also an IO action that depends on the potential argument of the returned function.

How can this be achieved? It's quite heartbreaking that an imperative language can do this easily.

Answer 1

I think this works:

debugAGM :: Word -> ArbReal -> ArbReal -> Word -> (Integer, IO ())
debugAGM n a b p = let
    newA@(ArbReal f) = (a + b) / 2
    in if 0 == n
        then f p `seq` (f p, putStrLn "Iteration complete.")
        else let
            (x, action) = debugAGM (n-1) newA (sqrt (a * b)) p
            in x `seq` (x, putStrLn ("debugAGM iteration: n = " ++ show n) >> action)

ln10 :: Word -> IO ()
ln10 n = if 0 == n
    then putStrLn "2"
    else let
        halfN = ceiling (n % 2)
        f = \p -> debugAGM (2 * logBaseZ p 2) 1 (4 / 10 ^ halfN) p
        ArbReal g = pi / (2 * ArbReal (fst . f) * fromInteger halfN)
        in snd (f n) >> putStrLn (show (g n))