1

Functional Programming (FP) &

Ruby in Functional style

- Niranjan Sarade

2

Agenda

• WWW of FP• Spectrum of languages• OOP and FP• Imperative vs. Functional• Examples• Ruby in a functional style• References

3

Why FP ?

• Programming has become complex• Multiprocessors are common place• Multithreading• But why?

– Domain is only part of the reason

– We have gone too far with OO programming and mutable state

4

Perils of Mutable state

• Mutable state

– Leads to more bugs

– Makes concurrency quite difficult

– Shared mutability

5

What’s Old is New again!

6

y = f(x)

7

FP @wikipedia

“In computer science, functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions, in contrast to the imperative programming style, which emphasizes changes in state.”

8

Spectrum of Languages Non-functional Hybrid Functional

Java

C++

C#

Ruby

Groovy

Scala

F#

Clojure

Haskell

LISP

Erlang

Stati

cally

ty

ped

Dyn

amic

ally

ty

ped

9

Real world applications of FP

• Erlang: used to implement fault-tolerant telecommunication system.

• Lisp: used as basis for several applications on early Apple Macintosh computers.

• Ocaml: use in areas such as financial analysis, driver verification, industrial robot programming and static analysis of embedded software.

10

Continued

• Haskell: aerospace systems, hardware design and web programming.

• Using the functional ideas, Google has developed framework called MapReduce for processing massive amounts of data in parallel.

• Embedded Lisp interpreters add programmability to some systems, such as Emacs.

11

Continued

• Lisp is used for artificial intelligence applications.

- Knowledge representation- machine learning- Natural language processing- Modeling of speech and vision

12

Principles of FP

• Assignment-less programming• Immutable state• Functions as first class citizens• Higher order functions• Functions with no side effects• Referential Transparency• Lazy evaluation• Memoization• Recursion

13

Closure

It is closure because it encloses an environment that is in place when that code block is instantiated.

def get_adder(value) proc { |x| x + value }end

adder5 = get_adder(5) adder10 = get_adder(10)adder5.call(2) # 7 adder10.call(5) #15adder5.call(4) # 9 adder10.call(8) #18

14

Immutability / No side effect

Higher order Functions

Functional Style

Ruby GroovyPython

SmalltalkClojure

Scala

Purely Functional

HaskellErlang

Lisp

15

OOP and FP

“OO makes code understandable by encapsulating moving parts…

FP makes code understandable by minimizing moving parts.”

- Michael Feathers, author of 'Working with Legacy Code'

16

Imperative vs. Functional

ImperativeSpecify each stepHow to do stuffData mutatedOften has side effectAccepts data/objectsHard to compose

FunctionalMore directive in styleWhat you want to getData transformedHas no side effectAccepts functions alsoFunctional composition

17

Memoization

18

Without memoize

def fib(n) return n if n < 2 fib(n-1) + fib(n-2)end

fib(35) # slow

#2.879s

19

With memoizerequire 'memoize' # https://github.com/djberg96/memoize

include Memoize

def fib(n) return n if n < 2 fib(n-1) + fib(n-2)end

memoize(:fib)fib(35) # fast

# 0.07s

20

Example 1

Squares of Integers

21

Java & Clojure

public class Squint { public static void main(String args[]) { for (int i=1; i<=25; i++) System.out.println(i*i); }}

Clojure : (take 25 (squares-of (integers))

(1 2 3 4 5 6 7 8 ...)

(1 4 9 16 25 36 49 64 ...)

(1 4 9 16 25 36 49 64 ... 576 625)

22

Haskell :- [ x*x | x <- [1..10]]

Ruby :-(1..10).collect { |x| x*x}(1..10).map { |x| x*x}

=> [1,4,9,16,25,36,49,64,81, 100]

23

Haskell :-[ x+1 | x <- [ x*x | x <- [1..10]]]

Ruby :-(1..10).collect {|x| x*x }.collect {|x| x+1 }

=> [2,5,10,17,26,37,50,65,82,101]

Lazy evaluation:-take 10 [ x+1 | x <- [ x*x | x <- [1..]]]

24

Lazy evaluation in Ruby 2.0

(0..Float::INFINITY).lazy.map { |x| 2*x }.take(5).to_a

#=> [0, 2, 4, 6, 8]

Making an enumerable lazy makes it possible to enumerate infinite collections. A lazy enumerable will evaluate the entire chain for each element at a time, rather than all elements at each stage of the chain.

25

Example 2

What's the sum of the first 10 natural number whose square value is divisible by 5?

26

Imperative

Ruby :n, num_elements, sum = 1, 0, 0while num_elements < 10 if n**2 % 5 == 0 sum += n num_elements += 1 end n += 1endsum #=> 275

27

FunctionalRuby 2.0:Integer::natural.select { |x| x**2 % 5 == 0 }.take(10).inject(:+) #=> 275

28

Ruby in a Functional style

29

Everything is an expression

message = “”if found_dog == our_dog name = found_dog.name message = "We found our dog #{name}!"else message = "No luck"end

30

Continued

message = if found_dog == our_dog "We found our dog #{found_dog.name}!"else "No luck"end

31

Higher-order functions: map

output = [][1, 2, 3, 4].each do |x| output << x * 2endoutput # [2, 4, 6, 8]

output = [1, 2, 3, 4].map do |x| x * 2end # [2, 4, 6, 8]

32

Higher-order functions: selectoutput = [][1, 2, 3, 4].each do |x| output << x if x > 2endoutput # [3, 4]

output = [1, 2, 3, 4].select do |x| x > 2end # [3, 4]

33

Higher-order functions: detectoutput = nil[1, 2, 3, 4].each do |x| if x > 2 output = x break endendoutput # 3

output = [1, 2, 3, 4].detect do |x| x > 2end # 3

34

Higher-order functions: inject/reduce

total = 0[1, 2, 3, 4].each do |x| total += xendtotal # 10

total = [1, 2, 3, 4].inject(0) do |acc, x| acc + xend # 10

For simple cases like this:total = [1, 2, 3, 4].inject(0, :+)

35

Higher-order functions: zipx = [1, 2, 3]y = [:a, :b, :c]output = []0.upto(x.length - 1).each do |idx| output << [x[idx], y[idx]]endoutput #=> [[1, :a], [2, :b], [3, :c]]

x = [1, 2, 3]y = [:a, :b, :c]output = x.zip(y) #=> [[1, :a], [2, :b], [3, :c]]

36

Take away

Let’s try to learn at least One “Functional” Language

and experience the power of functions !

37

References

• http://en.wikipedia.org/wiki/Functional_programming• http://pragprog.com/magazines/2013-01/functional-p

rogramming-basics• http://www.agiledeveloper.com/• http://www.defmacro.org/ramblings/fp.html• http://rubysource.com/functional-programming-techn

iques-with-ruby-part-i/

• https://code.google.com/p/tokland/wiki/RubyFunctionalProgramming

• http://stackoverflow.com/questions/36504/why-functional-languages

38

Some Reference videos

• http://vimeo.com/28105411• http://www.youtube.com/watch?v=8DvxOLzmLSI• http://

www.infoq.com/presentations/Functional-Programming-A-Pragmatic-Introduction

• http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey

• http://www.youtube.com/watch?feature=endscreen&NR=1&v=z0N1aZ6SnBk

39

Thank you all for being patient and hearing me out.

Hope this helps you!