I have been doing this with python. I find that it is cumbersome to write in a hereditarily pure functional style in a language that wasn't designed for it. For example, contrast the two definitions of in_order:
for i in range(1,len(xs)):
if xs[i] > xs[i+1]:
inOrder :: (Ord a) => [a] -> Bool
inOrder xs = and $ zipWith (<=) xs (tail xs)
in_order the Haskell way in python is going to be both verbose (since python does not support the necessary idioms very well) and slow (linear space instead of Haskell's constant space due to laziness).
However, I have had success creating python programs with functional organization, and an idiomatic implementation of each function. The idea that this is a good way to program is actually the thesis behind my codecatalog project. So, my components are oriented around abstractions and functions (with pure interface) operating on them, rather than classes with state, and it is coming together nicely. In fact, code organized this way seems to be more flexible to reuse than code organized with classes. That could be a personal bias, however, since I am still a Haskell devotee.
So I would say the answer to your question is kinda. Use your functional roots to help you think, but don't overdo it. Eg. simulating lazy lists in Ruby just for idiom's sake is probably going to be more trouble than it's worth.