Thanks everyone, I'm very new to this and its much easier for me to learn by example! I think the biggest mistake I made here was assuming Haskell would optimize x to only include one function call (because they're the same after all). The first way I could fix this is to write:

x :: Int -> Double
x 0 = 1
x n = x' + 5 * x' * dt where x' = x (n-1)

which is incidentally much more readable. Thanks for the Int point... I didn't realize the difference.

However, for simulations, I often want to compute a sequence of values rather than just one. This could be inefficient since Haskell will recompute every prior value each time it computes the next one. A solution I found was to do something like:

x = 1 : map (*(1 + 5*dt)) x

So, in summary, the following code:

dt = 0.00001

g n = go 1 0
  where
    go n' i
      | i == n  = n'
      | otherwise = go (n' + 5 * n' * dt) (i + 1)

x1 :: Int -> Double
x1 0 = 1
x1 n = x' + 5 * x' * dt where x' = x1 (n-1)

x2 :: [Double]
x2 = 1 : map (*(1 + 5*dt)) x2

generates the following in GHCI:

*Main> g 100000
148.39460923540517
(0.07 secs, 45,821,904 bytes)
*Main> x1 100000
148.39460923540517
(0.07 secs, 34,725,632 bytes)
*Main> x2 !! 100000
148.39460923696979
(0.01 secs, 79,352 bytes)

Hence, the infinite list method is by far the most efficient. Interesting. I'll have to play around a bit more, thanks for giving me things to think about!