## DEV Community is a community of 892,765 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

Evin

Posted on

# An insight about functional programming

I first touched Haskell >1 year ago, and have studied on and off in the time since, though I haven't touched in a while at present due to being too busy with other things. But one thing I got hung up on - okay, this is probably what every newcomer to Haskell gets hung up on - is the idea that imperative programming is disallowed or made more difficult in Haskell. Now I want to write about a realization I had around the last time I was working with it, because I'm not sure that this is the case.

What is the difference between a function and an action, and how does Haskell treat it differently than other languages? This itself was a question I wasn't sure about after weeks of trying to learn it, and still aren't really sure. But where I'm currently at is that.

In other words, functions are a subset of actions. Every function can be trivially converted to an action. In Haskell, I can take this beautiful functional code:

``````main = getLine >>= (\a -> getLine >>= (\b -> print \$ fibbonaci (read a ::Int) (read b ::Int)))

fibbonaci a b = fibbonaciInner a b []

fibbonaciInner a b list
| length list < 10 = fibbonaciInner (b) (a + b) (list ++ [a + b])
| otherwise = list
``````

And convert it to a typical imperative version:

``````main = do
a <- getLine
b <- getLine
print fibbSeq

fibbonaci :: Int -> Int -> IO [Int]
fibbonaci a b = fibbonaciInner a b []

fibbonaciInner :: Int -> Int -> [Int] -> IO [Int]
fibbonaciInner a b list =
if length list < 10 then
fibbonaciInner b (a + b) (list ++ [a + b])
else return list
``````

See what I did there? I made the `fibbonaciInner` function an IO action that takes arguments, does a computation, and "returns" its value, instead of a function that merely defines a mapping of values.

(Haskellers more experienced than me often say that Haskell `return` has nothing to do with what that word means in other languages, but I think it's actually a very good analogy.)

And what this made me realize is that every other language is doing the latter. In a way, is a pure language strictly better than non-pure ones?

Haskell doesn't stop you from doing things imperatively. Other languages force you to be imperative, so that having the option to be pure feels like a constraint.

All I did by converting the function to an imperative style was lose the ability to use it in pure contexts. I can't import the module and `reverse \$ fibbonaci x y` now (I can use `fmap` to get around it, but with the pure version I don't have that extra layer of complexity). But in imperative languages, everything is already impure, even if it doesn't need to be.

I think if you get past seeing it this way, Haskell starts to seem a lot less arcane.

But then, this is coming from someone who still thinks Haskell is arcane and doesn't understand it, so...