Would it be ok if I decide to write all my Ruby as if it were Haskell?

Question

Given that Ruby has good list operation capabilities in-built - reduce, map, select, collect etc. It has Procs, Blocks and Lambdas, and has nice iteration support (the each family), would it be a bad design decision if I attempt to write all my Ruby stuff in the most pure-functional way possible? Escpecially for code that has little or no I/O (thus less obvious side-effects)?

I've been learning Haskell (called the 'real' Hacker's language), and am in love with it's way of doing things - I love Ruby, but think it can be even more fun when more Haskell spirit flows into it (well, didn't Ruby borrow / learn lots from it in the first place?)

Constructive guidance is welcome...

Answer 1

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:

def in_order(xs):
    for i in range(1,len(xs)):
        if xs[i] > xs[i+1]:
            return False
    return True

inOrder :: (Ord a) => [a] -> Bool
inOrder xs = and $ zipWith (<=) xs (tail xs)

Writing 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.

Answer 2

You can write Ruby code in functional style as if it were Scheme, not Haskell. To write it as if it were Haskell, it would need a Haskell-like type system, plus pervasive lazy evaluation.

Answer 3

I've found understanding functional programming, and Haskell in particular, to be helpful to me in certain situations I've encountered in Ruby. But the more I learn Haskell, the more I realize how far Ruby is from ever being able to be much like Haskell at all.

The module / code loading situation is abysmal, for one thing. The current interpreter doesn't have tail call optimization turned on, so you can't use recursion the way you do in Haskell. And once you get into Monads, there's really no comparison of the levels of abstraction you can achieve in Haskell vs. Ruby.

If you're interested, I've been posting some Ruby/Haskell comparison code on gist.github.com as I've been learning.

The technique I've brought over to Ruby that has worked out the best has been finding pure functions where I can, which is what it sounds like you are trying to do.

Answer 4

I would say "yes". What (I think) you're talking about is the functional programming influence in the ruby language. The functional paradigm has some really nice concepts that compliment or overlap with object oriented (no side effects, in particular).

The great thing about ruby is it allows you to code in a linear, objected oriented or functional style, or some blend of these. And your simple, linear script can morph into OO/functional style if and when it's complexity increases.

Answer 5

It depends on whether you will be collaborating with others. If you are working on the code by yourself, use whatever style you feel most comfortable with. However, if you are working with other Ruby programmers, they may not be used to a purely functional style of programming and thus be confused by your code. Then again, if your collaborators are also Haskell programmers who migrated to Ruby, you may not have this problem.