Indeed. I spent a year working rather intensively on both ML and Haskell (which are structurally similar but have some crucial differences) and one of the first things I learned is that while it's tempting to implement a factorial like this:

fact 0 = 1
fact 1 = 1
fact n | n < 0 = error "Negative factorial!"
       | otherwise = n * fact (n - 1)
[download]

your life will be vastly improved if you implement it like this:

fact 0 = 1
fact 1 = 1
fact n | n < 0 = error "Negative factorial!"
       | otherwise = g 1 n where
            g x 1 = x
            g x n' = g (x * n') (n' - 1)
[download]

because the latter uses tail recursion and the former doesn't.

If, in Lisp|Perl|C|whatever, you write a recursive function that runs a few thousand times, then you're going to suck up some RAM and the stack-push/pop CPU time. LISP, Scheme, ML, and their compadres are pretty well designed to minimize this. But, if you write a tail-recursive function, you're fine; overhead is exactly the same as for iteration.

Tail recursion can be converted directly into iteration; this is part of the Scheme standard, I believe, and most implementations of other functional languages support it. If you're unlucky enough to have an implementation that doesn't, though, tail recursion will still suck up stack space for function calls.