Functional programming and ruby in functional style

Functional Programming (FP)
&
Ruby in Functional style
- Niranjan Sarade
1

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

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
3

Perils of Mutable state
• Mutable state
– Leads to more bugs
– Makes concurrency quite difficult
– Shared mutability
4

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

Spectrum of Languages
Non-functional Hybrid Functional
Java
C++
C#
Ruby
Groovy
Scala
F#
Clojure
Haskell
LISP
Erlang
8

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

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

Continued
• Lisp is used for artificial intelligence
applications.
- Knowledge representation
- machine learning
- Natural language processing
- Modeling of speech and vision
11

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
12

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) #15
adder5.call(4) # 9 adder10.call(8) #18
13

Immutability /
No side effect
Higher
order Functions
Functional
Style
Ruby
Groovy
Python
Smalltalk
Clojure
Scala
Purely Functional
Haskell
Erlang
Lisp
14

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'
15

Imperative vs. Functional
Imperative
Specify each step
How to do stuff
Data mutated
Often has side effect
Accepts data/objects
Hard to compose
Functional
More directive in style
What you want to get
Data transformed
Has no side effect
Accepts functions also
Functional composition
16

Without memoize
def fib(n)
return n if n < 2
fib(n-1) + fib(n-2)
end
fib(35) # slow
#2.879s
18

With memoize
require '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
19

Example 1
Squares of Integers
20

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)
21

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]
22

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..]]]
23

Lazy evaluation in Ruby 2.0
(0..Float::INFINITY).lazy.map { |x| 2*x }.take(5).to_a
#=> [0, 2, 4, 6, 8]
24
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.

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

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

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

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
29

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

Higher-order functions: map
output = []
[1, 2, 3, 4].each do |x|
output << x * 2
end
output # [2, 4, 6, 8]
output = [1, 2, 3, 4].map do |x|
x * 2
end
# [2, 4, 6, 8]
31

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

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

Higher-order functions: inject/reduce
total = 0
[1, 2, 3, 4].each do |x|
total += x
end
total # 10
total = [1, 2, 3, 4].inject(0) do |acc, x|
acc + x
end # 10
For simple cases like this:
total = [1, 2, 3, 4].inject(0, :+)
34

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

Take away
Let’s try to learn at least
One “Functional” Language
and
experience the power of functions !
36

References
• http://en.wikipedia.org/wiki/Functional_programming
• http://pragprog.com/magazines/2013-01/functional-
programming-basics
• http://www.agiledeveloper.com/
• http://www.defmacro.org/ramblings/fp.html
• http://rubysource.com/functional-programming-
techniques-with-ruby-part-i/
• https://code.google.com/p/tokland/wiki/RubyFunction
alProgramming
• http://stackoverflow.com/questions/36504/why-
functional-languages
37

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
38

Thank you all for being patient
and hearing me out.
Hope this helps you!
39

Functional programming and ruby in functional style

Recommended

More Related Content

What's hot (20)

Similar to Functional programming and ruby in functional style (20)

Recently uploaded (20)

Functional programming and ruby in functional style

Editor's Notes