Pure(no side-effects) functional programming means a lot less bugs and it is easier to find the ones that you do create. It also means more modular code because of natural separation of concerns.

It is much more expressive than imperative/OO programming.

I especially like Haskell, in my opinion the most expressive language there is and at the forefront of new exciting programming features.

Haskell has an awesome typesystem. Statically typed but with optional declarations. It will infer the types by itself and verify consistency. You can ask the interpreter for the type of a specific function(and search hoogle to find a function with the type you desire). But it is not only interpreted, on the contrary it is a compiled language and a very fast one. Much faster than Python, Ruby etc, rivals C at some stuff and it scales without problems to multiple cores so that advantage will only grow. Pattern-matching, not only is thetypesystem very good for avoiding bugs but patternmatching really helps to make code more readable and makes it easier to verify that you have covered every case.

I also find functional code very beautiful and easy to read, here is a naive mergesort in haskell:

  merge :: (Ord t) => [t] -> [t] -> [t]
  merge xs [] = xs
  merge [] ys = ys
  merge (x:xs) (y:ys)
         | x < y       = x:(merge xs (y:ys))
         | otherwise   = y:(merge ys (x:xs))

  mergesort :: Ord a => [a] -> [a]
  mergesort []  = []
  mergesort [x] = [x]
  mergesort xs = merge (mergesort left) (mergesort right) 
            where
              middle = div (length xs) 2
              (left, right) = splitAt middle xs

Easy to read even if you never programmed in haskell before right?

Scala is also cool since it takes the best from both worlds and really delivers. Building on an already existing platform and also providing nice abstractions for concurrency and parallellism.