This document discusses functional programming concepts in Ruby. It defines functional programming as treating computation as the evaluation of functions without state or mutable data. This is compared to imperative programming which describes computation through statements that change program state. Pure functions are described as always returning the same result given the same arguments without side effects. Functional programming benefits include reliability, parallelism, and ease of testing and debugging, while disadvantages include perceived complexity and difficulties with IO and state.

1. Functional programming in Ruby
Alex Teut
aka
@jaturken

2. Functional Programming
A programming paradigm that treats
computation as the evaluation of functions
and avoids state and mutable data.

3. Imperative Programming
A programming paradigm that treats
computation as the evaluation of functions
and avoids state and mutable data.
A programming paradigm that describes
computation in terms of statements that
change a program state.

4. The difference
A programming paradigm that treats
computation as the evaluation of functions
and avoids state and mutable data.
A programming paradigm that describes
computation in terms of statements that
change a program state.
Imperative functions can have side effects
that may change the value of program
state, so this approach looses...

5. Referential transparency
The same language expression can result
in different values at different times
depending on the state of the executing
program.

6. Pure Functions
● Always evaluates the same result value
given the same argument values
● Evaluation of the result does not cause
any side effect

7. Pure
● sin
● to_s
● Enumerable#select
● Enumerable#collect
● Array#uniq
● Hash#merge

8. Non-pure
Non-determinated: Side-effects:
● Date.today ● print
● rand ● require
● Externall API ● Enumerable#select!
calls ● Enumerable#collect!
● Array#uniq!
● Hash#merge!
● Hash#delete

9. Pure Functions is Good
● Can be cached/memoized
● Order of calculation does not matter
● Any evaluation strategy can be used
● Chain can be easily paralellized

10. Functional Programming
X=X+1

11. Functional Programming
X=X+1

12. Iterations without iterator?

13. Recursion

14. Example

15. Tail Call
A special case of recursion when recursive
call of function itself is its last operation.

16. Example

17. Expand example code
tail_call_factorial: non_tail_call_factorial:
(fact-tail 3 1) (fact 3)
(fact-tail 2 3) (* 3 (fact 2))
(fact-tail 1 6) (* 3 (* 2 (fact 1)))
6 (* 3 (* 2 1))
(* 3 2)
6

18. Tail Call Optimization
Tail call is equivalent to iteration. So Tail
Call Optimization(TCO) is evaluating of
Tail Call as an iteration.
In Ruby TCO is turned off by default.

19. First Class Objects
● can be stored in values and data
structures
● can be passed as a parameter to an
expression
● can be returned as the result of a
expression

20. Higher-order Functions
Functions that can either take other
functions as arguments or return them as
results

21. Closure
A function or reference to a function
together with a referencing environment

22. Example

23. Currying
The technique of transforming a function
that takes multiple arguments to a chain of
functions each with a single argument.

24. Without currying

25. With currying

26. Lazy Evaluation
An evaluation strategy which delays the
evaluation of an expression until its value
is needed

27. Example

28. Advantages of Functional
Programming
● Reliability
● Parallelizm
● Easy unit testing
● Easy debugging

29. Disadvantages of Functional
Programming
● Seems to be more difficult
● Typically less efficient
● Garbage collector needed
● Difficulties with IO methods and states

30. Thank you for attention!