Functional Programming inside OOP? It’s possible with Python

Functional
Programming
inside OOP?
It’s possible with Python

>>>whoami()
Carlos Villavicencio
● Ecuadorian 󰎸
● Currently: Python & TypeScript
● Community leader
● Martial arts: 剣道、居合道
● Nature photography enthusiast
Cayambe Volcano, 2021.
po5i

>>>why_functional_programming
● Easier and efﬁcient
● Divide and conquer
● Ease debugging
● Makes code simpler and readable
● Also easier to test

>>>history()
● Functions were ﬁrst-class objects from design.
● Users wanted more functional solutions.
● 1994: map, ﬁlter, reduce and lambdas were included.
● In Python 2.2, lambdas have access to the outer scope.
“Not having the choice streamlines the thought process.”
- Guido van Rossum.
The fate of reduce() in Python 3000
https://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

>>>has_django_fp()
https://github.com/django/django/blob/46786b4193e04d398532bbfc3dcf63c03c1793cb/django/forms/formsets.py#L201-L213
https://github.com/django/django/blob/ca9872905559026af82000e46cde6f7dedc897b6/django/forms/formsets.py#L316-L328

Immutability An immutable object is an object
whose state cannot be modiﬁed after
it is created.
Booleans, strings, and integers are
immutable objects.
List and dictionaries are mutable
objects.
Thread safety

def update_list(value: list) -> None:
value += [10]
>>>immutability
>>> foo = [1, 2, 3]
>>> id(foo)
4479599424
>>> update_list(foo)
>>> foo
[1, 2, 3, 10]
>>> id(foo)
4479599424
def update_number(value: int) -> None:
value += 10
>>> foo = 10
>>> update_number(foo)
>>> foo
10
🤔

def update_number(value: int) -> None:
print(value, id(value))
value += 10
print(value, id(value))
>>>immutability
>>> foo = 10
>>> update_number(foo)
10 4478220880
20 4478221200
>>> foo
10
https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747
󰚃

Decorators They are functions which modify the
functionality of other functions.
Higher order functions.
Closures?

>>>decorators
def increment(x: int) -> int:
return x + 1
>>> increment(2)
3

>>>decorators
return x + 1
def double_increment(func: Callable) -> Callable:
def wrapper(x: int):
r = func(x) # func is saved in __closure__
y = r * 2
return y
return wrapper

>>>decorators
@double_increment
return x + 1
>>> increment(2)
6
>>> increment.__closure__[0].cell_contents
<function increment at 0x7eff362cf940>
>>> increment.__closure__[0].cell_contents(2)
3

They reduce the number of arguments
that any function takes.
Makes functions easier to compose
with others.
Partial application
of functions

>>>partial_application
def get_url(url: str, role: str) -> str:
pass
from functools import partial
get_admin_url = partial(get_url, "admin")

>>>partial_application
import re
from functools import partial
email_match = partial(re.match, r"^(w|.|_|-)+[@](w|_|-|.)+[.]w{2,3}$")
url_match = partial(re.match,
r"(?i)b((?:https?://|wwwd{0,3}[.]|[a-z0-9.-]+[.][a-z]{2,4}/)(?:[^s()<>]+|(([^s()<>
]+|(([^s()<>]+)))*))+(?:(([^s()<>]+|(([^s()<>]+)))*)|[^s`!()[]{};:'".,<>?
«»“”‘’]))")

Lazy Evaluation It holds the evaluation of an
expression until the value is ﬁnally
needed.
Reduce the memory footprint.

>>>lazy_evaluation
def generator():
i = 1
while True:
yield i
i += 1

>>>lazy_evaluation
with open(filename, 'r') as f:
for line in f:
process(line)

Type Annotations PEP 484
Available since Python 3.5
Reduce bugs at runtime
Improves readability

>>>__annotations__
Read tutorial at
stackbuilders.com
Watch my talk at
PyCon China 2020

Structural Pattern
Matching
PEP-634
Available since Python 3.10
It doesn’t work as C or JavaScript
It’s a declarative approach!

>>>structural_pattern_matching
# point is an (x, y) tuple[int, int]
match point:
case (0, 0):
print("Origin")
case (0, y):
print(f"Y={y}")
case (x, 0):
print(f"X={x}")
case (x, y) if x == y: # guard
print(f"X=Y={x}")
case (x, y):
print(f"X={x}, Y={y}")
case _: # wildcard
raise ValueError("Not a point")
https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching

>>>structural_pattern_matching
# test_variable is a tuple[str, Any, int]
match test_variable:
case ('warning', code, 40):
print("A warning has been received.")
case ('error', code, _):
print(f"An error {code} occurred.")

Other Functional
Programming
Patterns
When Python doesn’t offer a way to
do it, you can always implement it.
Currying
Composition

>>>currying
If a function ƒn
takes n arguments, then you can turn that into a
function cn
which takes one argument and returns a function cn−1
that takes n−1 arguments, and has access to the argument that
was passed to cn
(hence cn−1
is a closure)
https://sagnibak.github.io/blog/python-is-haskell-currying/

>>>currying
def f_5(a: int, b: int, c: int, d: int, e: int) -> int:
return a + b + c + d + e

>>>currying
def c_5(a: int) -> Callable:
def c_4(b: int) -> Callable:
def c_3(c: int) -> Callable:
def c_2(d: int) -> Callable:
def c_1(e: int): int:
return f_5(a, b, c, d, e)
return c_1
return c_2
return c_3
return c_4
Then, f_5(1, 2, 3, 4, 5) == c_5(1)(2)(3)(4)(5)

@curry(num_args=5)
def c_5(a: int, b: int, c: int, d: int, e: int) -> int:
a + b + c + d + e
>>>currying
https://sagnibak.github.io/blog/python-is-haskell-currying/

>>>composition
▶ cat .env|grep DEBUG
ASSETS_DEBUG=True
SENTRY_DEBUG=False

>>>composition
sortByDateDescending = reverse . sortByDate

>>>composition
def compose2(f, g):
return lambda x: f(g(x))
https://mathieularose.com/function-composition-in-python

import functools
def compose(*functions):
def compose2(f, g):
return lambda x: f(g(x))
return functools.reduce(compose2, functions, lambda x: x)
>>>composition

def td(val: str) -> str:
return f"<td>{val}</td>"
def tr(val: str) -> str:
return f"<tr>{val}</tr>"
def table(val: str) -> str:
return f"<table>{val}</table>"
>>> one_cell_table = compose(table, tr, td)
>>> one_cell_table("something")
'<table><tr><td>something</td></tr></table>'
>>>composition

Testing Everything we covered before makes
our tests easier.

>>>import unittest
“Code that is hard to test is not good code”
- Joe Eames.
https://dev.to/leolanese/making-unit-test-fun-again-with-functional-programming-4g8m

>>>import unittest
“The outcome of a function is dependent only on the input and nothing else”
- Unknown author.

>>>import unittest
“OO makes code understandable by encapsulating moving parts.
FP makes code understandable by minimizing moving parts.”
- Michael Feathers.

Thank you for your
attention 😊
Questions?
Feedback?
Suggestions?
po5i

Functional Programming inside OOP? It’s possible with Python

More Related Content

What's hot (20)

Similar to Functional Programming inside OOP? It’s possible with Python (20)

More from Carlos V. (6)

Recently uploaded (20)

Functional Programming inside OOP? It’s possible with Python