# Functional Programming 101

“Amazing!”  that was my initial reaction when I heard and read about functional programming , I am very new to the whole concept so I might go a little off while writing about it so I am open to criticism .  This is basically my understanding about functional programming and why I got hooked to it .

Functional Programming is a concept just like Object Oriented Programming , a lot of people confuse these concept and start relating to a particular language , thing that needs to be clear is languages are tools to implement concepts. There is imperative programming where you tell the machine what to do ? For example

1.  `Assign x to y`
2.  `Open a file`
3.  `Read a file`

While when we specifically talk about `FP` it is a way to tell how to do things ? The nearest example that I can come up with is `SQL` query  where you say something like

`SELECT  * FROM Something where bang=something and bing=something`

Here we didn’t tell what to do but we told how to do it. This is what I got as a gist of functional programming where we divide our task into various `functional` parts and then we tell how things have to be implemented on the data.

Some of the core concepts that I came across was `pure functions` and `functions treated as first class citizen` or `first class object` . What each term means  lets narrow it down .

`Pure functions`  is a function whose return value is determined by the input given, the best example of `pure functions` are `Math` functions for example `Math.sqrt(x)` will return the same value for same value of `x`. Keeping in mind that `x` will never be altered. Lets go on a tangent and see that how this `immutability` of x is a good thing, this actually prevents data from getting corrupt.  Okay! That is alot to take in one go, lets understand this with a simple borrowed example from the talk I attended.

We will take example of a simple `Library System`  now for every library system there should be a book store, the `book store` here is an `immutable` data structure now what will happen if I want to add a new book to it ? Since it is `immutable` I can’t modify it , correct ? So a simple solution to this problem is every time I add or remove a book I will actually deliver a new `book store` and this new book store will replace the old one. That way I can preserve the old data because hey we are creating a whole new store. This is probably the gist or pros of functional programming.

book\_store = \["Da Vinci's Code", "Angles and Demons", "The Lost Symbol"\]
def add\_book( book\_store, book):
    new\_book\_store = \[\]
    map(lambda old\_book: new\_book\_store.append(old\_book), book\_store)
    new\_book\_store.append(book)
    return new\_book\_store

print add\_book(book\_store, "Inferno") # \["Da Vinci's Code", "Angles and Demons", "The Lost Symbol", "Inferno"\]

print book\_store # \["Da Vinci's Code", "Angles and Demons", "The Lost Symbol"\]

In the above code you can actually see that a new `book store` is returned on addition of a new book. This is what a pure function looks like.

`Function as first class citizens` , I can relate a lot to this because of python where we say that everything is a first class objects. So, basically when we say functions are first class citizen we are implying that `functions` can be assigned to a variable, passed as a parameter and returned from a function. This is way more powerful then it sounds this bring a lot modular behavior to the software you are writing, it makes the project more organized and less tightly coupled. Which is a good thing in case you want to make quick changes or even feature related big changes.

def find\_odd(num):
    return num if(num%2 != 0) else None

def find\_even(num):
    return num if(num%2 == 0) else None

def filter\_function(number\_list, function\_filter):
    return \[num for num in number\_list if(function\_filter(num) != None)\]

number\_list = \[1,2,3,4,5,6,7,8,9\]
print filter\_function(number\_list, find\_odd) # \[1,2,5,7,9\]
print filter\_function(number\_list, find\_even) # \[2,4,6,8\]

In the above code you can see that function is passed as an argument to another function.

I have not yet explored into `lambda calculus` which I am thinking of getting into . There is a lot more power and beauty in functional programming.  I want to keep this post a quick read so I might cover some code example later, but I really want to demonstrate this code.

def fact(n, acc=1):
    return acc if ( n==1 ) else fact(n-1, n\*acc)

where `acc=1`  this is `pure textbook` and really beautiful code which calculates factorial of `n` ,  when it comes to `FP` it is said `To iterate is Human, to recurse is Divine`. I will leave you to think more about it, will try to keep writing about things I learn.

Happy Hacking!