The dark side of Ruby, or Learn functional programming with Ruby

I18n.locale = :ru
puts I18n.t('me.ﬁrst_name')
#=> Женя

my_contact = Contact.mine
puts my_contact.company
#=> iTechArt

Learn functional
programming
with Ruby

Learn functional
programming...
with Ruby !

It's all about hype !
The dark side of Ruby, or Learn functional programming with Ruby, by Evgeny Garlukovich 12/178

Moore’s law

RAM price

Let's ask Uncle Bob

Why functional programming?
FP is easier to write, easier to read, easier to test, and easier to
understand.
— Robert C. Martin (Uncle Bob)

I'm not a guru

Almost Everything is an object

Ruby is thoroughly object-oriented

1.class #=> Integer
3.14.class #=> Float
'string'.class #=> String
[1, 'string'].class #=> Array

MyArray = Class.new(Array) do
def append(new_item)
self << new_item
end
def prepend(new_item)
unshift(new_item)
end
end
MyArray.class #=> Class

my_array = MyArray[1, 2, 3]
append_method = my_array.method(:append)
append_method.class #=> Method

Ruby is multi-paradigm

Ruby is multi-paradigm
Ruby has been described as a multi-paradigm programming language:
it allows procedural programming (defining functions/variables
outside classes makes them part of the root, 'self' Object), with object
orientation (everything is an object) or functional programming (it has
anonymous functions, closures, and continuations; statements all have
values, and functions return the last evaluation)
— Wikipedia

Let's ask Matz

Matz about Ruby
Ruby is a language designed in the following steps:
* take a simple lisp language (like one prior to CL).
* remove macros, s-expression.
* add simple object system (much simpler than CLOS).
* add blocks, inspired by higher order functions.
* add methods found in Smalltalk.
* add functionality found in Perl (in OO way).
So, Ruby was a Lisp originally, in theory.
Let's call it MatzLisp from now on. ;-)
— matz

class Ruby
# ...
include Lisp
include Perl
include Smalltalk
# ...
end
MatzLisp = Ruby

Smalltalk

Perl

Lisp

Scheme

Clojure

Bubble-sort in Clojure
(defn- bubble [ys x]
(if-let [y (peek ys)]
(if (> y x)
(conj (pop ys) x y)
(conj ys x))
[x]))
(defn bubble-sort [xs]
(let [ys (reduce bubble [] xs)]
(if (= xs ys)
xs
(recur ys))))

Ruby allows functional
programming

What is functional
programming?

What is functional programming?
Functional programming is a programming paradigm that treats
computation as the evaluation of mathematical functions and avoids
changing-state and mutable data.
— Wikipedia

It's all about functions

What is function?

FP concepts
» First-class function
» Higher-order functions
» Pure functions
» Currying
» Lazy evaluation
» Immutable data

First-class function

» Assigning functions to variables
» Returning functions as the values from other functions
» Passing functions as arguments

add = ->(x, y) { x + y }
add.call(2, 2)
#=> 4
multiply = proc { |x, y| x * y }
multiply.call(3, 3)
#=> 9

add = ->(x, y) { x + y }
add.call(2, 2)
#=> 4
multiply.call(3, 3)
#=> 9

build_add_function = proc do |x|
->(y) { x + y }
end
add_one = build_add_function.call(1)
add_one.call(1)
#=> 2
add_two = build_add_function.call(2)
add_two.call(2)
#=> 4

->(y) { x + y }
end
add_one.call(1)
#=> 2
add_two.call(2)
#=> 4

f(x) in FP == object in OOP

Higher-order functions

» Takes functions as arguments
» Returns function as a result

Higher-order function that returns
function as a result
->(y) { x + y }
end
add_one.call(1)
#=> 2
add_two.call(2)
#=> 4

Higher-order function that takes function
as argument
[1, 2, 3, 4, 5].map { |x| x + 1 }
#=> [2, 3, 4, 5, 6]

as argument
add_one = ->(x) { x + 1 }
[1, 2, 3, 4, 5].map(&add_one)
#=> => [2, 3, 4, 5, 6]

as argument
add_one = 1.method(:+)
[1, 2, 3, 4, 5].map(&add_one)
#=> => [2, 3, 4, 5, 6]

» Takes functions as arguments
» Returns function as a result

provide a way to build
useful functions with simple
interface

Pure functions

Pure functions
» Always evaluates the same result value given the same
argument values
» Does not cause any side effect

Pure function

No side effects

Pure
add = ->(x, y) { x + y }

Not pure
display = ->(value) { puts value }

Pure
'string'.upcase

Not pure
Time.now

Pure or not?
[1, 2, 3].size

Pure or not?
[1, 2, 3].size
✅ Pure

Pure or not?
File.read('/path/to/ﬁle')

Pure or not?
File.read('/path/to/ﬁle')
❌ Not pure

Pure or not?
Random.rand(100_000)

Pure or not?
Random.rand(100_000)
❌ Not pure

Pure or not?
map = proc do |collection, function|
array = []
collection.each { |item| array << function.call(item) }
array
end

Pure or not?
map = proc do |collection, function|
array = []
collection.each { |item| array << function.call(item) }
array
end
✅ Pure

Why it is important?

Non-pure functions are
unpredictable

Pure functions are
easier to reason about

Which kind of functions
would you like to see more
in your apps?

Currying

Currying
Currying is the technique of translating the evaluation of a function
that takes multiple arguments (or a tuple of arguments) into
evaluating a sequence of functions, each with a single argument.
— Wikipedia

Currying

Currying
add = ->(x, y) { x + y }
add.call(1, 2)
#=> 3
add_one = ->(x) { add.call(1, x) }
add_one.call(2)
#=> 3

Proc#curry

Proc#curry
add = ->(x, y) { x + y }.curry
add.call(1, 2)
#=> 3
add_one = add.call(1)
add_one.call(1)
#=> 2
add_two = add.call(2)
add_two.call(2)
#=> 4

Proc#curry
add.call(1, 2)
#=> 3
add_one.call(1)
#=> 2
add_two.call(2)
#=> 4

Currying allows us to have
small and reusable functions

Lazy evaluation

Lazy evaluation
Lazy evaluation is an evaluation strategy which delays the evaluation
of an expression until its value is needed (non-strict evaluation) and
which also avoids repeated evaluations (sharing).
— Wikipedia

Eager evaluation

Eager evaluation
add_one = ->(x) { x + 1 }
times_two = ->(x) { x * 2 }
[1, 2, 3].map(&add_one).map(&times_two)
#=> [4, 6, 8]

Eager evaluation
[1, 2, 3] -> map(&add_one) -> [2, 3, 4]
[2, 3, 4] -> map(&times_two) -> [4, 6, 8]

Lazy evaluation

Enumerator::Lazy in Ruby 2.0

Lazy evaluation
add_one = ->(x) { x + 1 }
times_two = ->(x) { x * 2 }
[1, 2, 3].map(&add_one).map(&times_two)
#=> [4, 6, 8]

Lazy evaluation
add_one = ->(x) { x + 1 }
times_two = ->(x) { x * 2 }
[1, 2, 3]
.lazy
.map(&add_one)
.map(&times_two)
#=> #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: [1, 2, 3]>:map>:map>

Lazy evaluation
add_one = ->(x) { x + 1 }
times_two = ->(x) { x * 2 }
[1, 2, 3]
.lazy
.map(&add_one)
.map(&times_two)
.force
#=> [4, 6, 8]

Lazy evaluation
[1, 2, 3].map do |x|
times_two.call(add_one.call(x))
end

Lazy evaluation
1 -> add_one -> 2 -> times_two -> 4

Lazy evaluation
class GenerateRandomString
def call
(0..Float::INFINITY)
.lazy
.map(&method(:generete_random_string))
.select(&method(:genereted_string_is_not_obscene?))
.ﬁnd(&method(:unique_string?))
end
# ...
end

Lazy evaluation
def call
.lazy
end
# ...
end

Ruby 2.0 Works Hard So You Can Be Lazy, by Pat Shaughnessy

Lazy evaluation allows us
to consume data on demand,
instead of evaluating everything
up front

Immutable data

Immutable data
Immutable object (unchangeable object) is an object whose state
cannot be modified after it is created. This is in contrast to a mutable
object (changeable object), which can be modified after it is created.
— Wikipedia

Why you should avoid mutation?

» Mutation is a source of bugs
» Mutation requires you to spend extra energy when reading and
writing code

string = 'hello'
do_something_with_string(string)
puts string
#=> ???

Ruby allows to mutate data

string = 'hello'
string.upcase!
puts string
#=> "HELLO"

array = [1, 2, 3]
array << 4
puts array.inspect
#=> [1, 2, 3, 4]
array.unshift(0)
puts array.inspect
#=> [0, 1, 2, 3, 4]

hash = { a: 1, b: 2, c: 3 }
hash.merge!(d: 4)
puts hash
#=> {:a=>1, :b=>2, :c=>3, :d=>4}
hash[:e] = 5
puts hash
#=> {:a=>1, :b=>2, :c=>3, :d=>4, :e=>5}

Immutability In Ruby

Object#freeze

Object#freeze
Point = Struct.new(:x, :y)
zero_point = Point.new(0, 0)
zero_point.freeze
zero_point.x = 1 #=> RuntimeError: can't modify frozen Point

Object#freeze
languages = ['Ruby', 'Elixir'].freeze
languages << 'Go' #=> RuntimeError: can't modify frozen Array
languages[0].upcase!
p languages
#=> ["RUBY", "Elixir"]

Object#freeze
p languages

Frozen string literals in Ruby 2.3

string = 'hello'
string.upcase!
puts string
#=> HELLO

# frozen_string_literal: true
string = 'hello'
string.upcase! #=> RuntimeError: can't modify frozen String
puts string
#=> hello

string = String.new('hello')
string.upcase!
puts string #=> 'HELLO'

string = 'hello'.dup
string.upcase!
puts string #=> 'HELLO'

Design classes to be immutable

class BlogPost
attr_reader :title, :body
def initialize(title:, body:)
@title = title
@body = body
end
def rename(new_title)
BlogPost.new(title: new_title, body: body)
end
end

class BlogPost
@title = title
@body = body
end
end
end

post = BlogPost.new(title: 'Hi', body: 'This is my first post')
#=> #<BlogPost:0x007f9ef20474d0 @title="Hi", @body="This is my first post">
renamed_post = post.rename('First Post')
#=> #<BlogPost:0x007f9ef202ea20 @title="First Post", @body="This is my first post">
post.title
#=> "Hi"

post.title
#=> "Hi"

Persistent data structures

Persistent data structures
Persistent data structure is a data structure that always preserves the
previous version of itself when it is modified. Such data structures are
effectively immutable, as their operations do not (visibly) update the
structure in-place, but instead always yield a new updated structure.
— Wikipedia

Hamster gem

Hamster gem
Efficient, immutable, and thread-safe collection classes for Ruby.
Hamster provides 6 Persistent Data Structures: Hash, Vector, Set,
SortedSet, List, and Deque (which works as an immutable queue or
stack).

Hamster::Hash
require 'hamster/hash'
john = Hamster::Hash[name: 'John', gender: :male]
#=> Hamster::Hash[:name => "John", :gender => :male]
john[:name]
#=> "John"

Hamster::Hash
peter = john.put(:name, 'Peter')
#=> Hamster::Hash[:name => "Peter", :gender => :male]
peter[:name]
#=> "Peter"
john[:name]
#=> "John"

Hamster::Hash
male = john.delete(:name)
#=> Hamster::Hash[:gender => :male]
male[:name]
#=> nil
john[:name]
#=> "John"

» Mutation is a source of bugs
» Mutation requires you to spend extra energy when reading and
writing code

Ruby has many
functional features !

Ruby allows you
to blend functional and OO
approaches

...but Ruby
is not a functional language !

Try to learn functional language

Scala

Clojure

Haskell

Elm

Erlang

Elixir

Elixir
defmodule Quicksort do
def sort(list) when length(list) <= 1, do: list
def sort(list) do
[pivot | rest] = list
{before_pivot, after_pivot} = split_relative_to_pivot(pivot, rest)
merge_parts(pivot, sort(before_pivot), sort(after_pivot))
end
defp split_relative_to_pivot(pivot, list) do
Enum.split_with(list, fn(x) -> x < pivot end)
end
defp merge_parts(pivot, before_pivot, after_pivot) do
before_pivot ++ [pivot | after_pivot]
end
end

Happy hacking! !

The dark side of Ruby, or Learn functional programming with Ruby

Recommended

More Related Content

What's hot (20)

Similar to The dark side of Ruby, or Learn functional programming with Ruby (20)

Recently uploaded (20)

The dark side of Ruby, or Learn functional programming with Ruby