Here is the Haskell equivalent of your Clojure code:

    import Data.IORef
    import Control.Concurrent

    increment _ 0 = return ()
    increment x i = do
        alter x succ
        threadDelay 1000
        increment x (i - 1)

    decrement _ 0 = return ()
    decrement x i = do
        alter x pred
        threadDelay 1000
        decrement x (i - 1)

    printref _ 0 = return ()
    printref x i = do
        val <- readIORef x
        putStrLn ("in printref " ++ (show val))
        threadDelay 1000
        printref x (i - 1)

    main = do
        x <- newIORef 1

        forkIO (increment x 10)

        forkIO (printref x 15)

        forkIO (decrement x 10)

        threadDelay 100000

    -- This is just a helper to more closely match the clojure
    alter x fn = atomicModifyIORef' x (\y -> (fn y, ()))

I'd argue the Haskell is even nicer.