Haskell beats CL quite comfortably using the same algorithm :

module Main( main ) where
import System( getArgs )
arccot :: Integer -> Integer -> Integer
arccot x unity =
    arccot' x unity 0 start 1 1
      where start = unity `div` x
            arccot' x unity sum xpower n sign | xpower `div` n == 0 = sum
                                              | otherwise           =
                arccot' x unity (sum + sign*term) (xpower `div` (x*x)) (n+2) (-sign)
                  where term = xpower `div` n
machin_pi :: Integer -> Integer
machin_pi digits =
    pi' `div` (10 ^ 10)
      where unity = 10 ^ (digits+10)
            pi' = 4 * (4 * arccot 5 unity - arccot 239 unity)
main :: IO ()
main = do
    args <- getArgs
    putStrLn (show (machin_pi (read (head args) :: Integer)))

The first 10000 digits.

> time ./machin_pi 10000
31415926535897932384626433832795028841971693993751058209749445923078164062862089 ...
real    0m0.381s
user    0m0.290s
sys     0m0.061s




Saintly Man? - That Mitchell & Webb Look - BBC Two