>>41
Premature postaculation
9. Useful higher-order functions, like for example curry/partial, which return a function which is the same as another function for which some parameters have been set.
10. Other list tools like while (returns elements while some function is true), also useful for generators (sequences whose elements are determined as they are requested).
11. Lazy evaluation: stuff, like list elements, gets defined but doesn't get really calculated until you actually need it.
12. Tail recursion AKA tail call optimization: A function may call another function (typically itself) as its last subexpression, in which case the function gets replaced by the next function without increasing stack size, so that you can implement massively recursive algorithms which work almost as fast as their usually much longer, usually more complex and sometimes harder to think iterative counterparts (e.g. factorial).
13. Everything an expression. You'll want everything to be an expression (and rarely rely on statements). The more stuff you can accomplish with an expression, the better.
Note that there are pure functional languages like Haskell, which are kinda extremist and deal with pretty complex concepts; looser functional languages like Lisp which implement different ways to do things and allow you to work differently when it's really a pain in the ass to stick to pure functional programming, and even more down-to-Earth, realistic languages such as Python or Ruby which support most of the features I mentioned, but allow you to combine this power with traditional programming and OOP. I prefer this last kind as it's the most flexible and allows me to do the right job with the right tool all the time, but YMMV.