Functional Lessons Learnt

The story of my experience learning Clojure and Elixir, and overall the functional paradigm.

Transcript

1. Functional lessons learnt "I'm still learning" - me 1
2. Agenda Love at first sight? Changing the mindset Technicalities Keeping functions pure Geometrical readability Don't reduce reducers Encapsulate data with functions 2
3. Love at first sight? Not How do I store some shared mutable state? How do I mock stuff? How does dependency injection work? ... 3
4. Shifting the mind 4
5. Bruce Lee Empty your cup so that it may be filled; become devoid to gain totality. “ “ 5
6. Bukowski The less I needed, the better I felt. “ “ 6
7. Fredrik Nael It takes both sides to build a bridge. “ “ 7
8. Technicalities "Whatever the truth is, I don't see how it will help me get food on the table." - Suzanne Collins 8
9. Keeping functions pure My first lesson 9
10. Impurity as lack of immutability var carPark = new CarPark(); var porsche = new Car("Porsche"); carPark.open(); carPark.park(porsche); carPark.unpark(porsche); carPark.close(); 10
11. Embracing immutability for a purer world CarPark park = new CarPark(); CarPark openPark = park.open(); CarPark parkWithPorsche = openPark.park("Porsche"); CarPark parkWithoutPorsche = openPark.unpark("Porsche"); CarPark finalPark = parkWithoutPorsche.close(); Where, for example, CarPark::park looks like: public CarPark open() { return new CarPark("Open", this.cars); } 11
12. Very similarly in Elixir CarPark.new() |> CarPark.open() |> CarPark.park("porsche") |> CarPark.unpark("porsche") |> CarPark.close() But elixir comes with immutability out of the box :) 12
13. But purity is so much more than immutability Logging HTTP Requests Calling your agent [Insert your fav here] 13
14. Pure design pushes us towards ports and adapters 14
15. Geometrical Readability My second lesson 15
16. Horizontal def save_contact(name, params) do with {:ok, contact} <- find(name), {:ok, saved_contact} <- save(contact, params), :ok <- notify_owner(saved_contact) do {:ok, saved_contact} end end 16
17. Vertical def process(document_title) do document_title |> load() |> format_content() |> format_metadata() |> convert_to_pdf() |> upload(:google-drive) end 17
18. Not this def process(document_title) do {:ok, document} = load(document_title) pdf = document |> format_content() |> format_metadata() |> convert_to_pdf() upload(:google-drive, pdf) end 18
19. One last example from Londibot defp to_subscriptions_message(subscriptions) do lines = subscriptions |> Enum.map(fn x -> Map.get(x, :tfl_lines) end) |> List.flatten() |> Enum.join(", ") if String.length(lines) > 0 do "You are currently subscribed to: #{lines}" else "You are currently not subscribed to any line" end end 19
20. # Vertical function defp to_subscriptions_message(subscriptions) do subscriptions |> Enum.map(fn x -> Map.get(x, :tfl_lines) end) |> List.flatten() |> Enum.join(", ") |> subscriptions_message_text() end # Horizontal functions defp subscriptions_message_text(""), do: "You are currently not subscribed to any line" defp subscriptions_message_text(lines), do: "You are currently subscribed to: #{lines}" 20
21. Don't reduce reducers My third lesson 21
22. What is a reducer? a reducer is simply a function that accepts some data, applies some transformations to it, and returns the modified version of the data “ “ 22
23. Some examples of reducers iex> String.capitalize("abcd") "Abcd" 23
24. We can wrap it in a struct def capitalize(%SomeStruct{value: value} = s) do %SomeStruct{s | value: String.capitalize(s)} end 24
25. Then we can call its siblings... def hash(%SomeStruct{value: value} = s) do hashed = :crypto.hash(:sha, value) |> Base.encode16 %SomeStruct{s | value: hashed} end def downcase(%SomeStruct{value: value} = s) do %SomeStruct{s | value: String.downcase(s)} end 25
26. Thus allowing us to... iex> %SomeStruct{value: "javier"} |> capitalize() |> hash() |> downcase() %SomeStruct{value: "7f3d0970ec0e336aa08a9e14d4d88e79131e0065"} 26
27. Lastly, if anybody's fond of testing... def assert_result(%SomeStruct{value: v} = s, expected) do assert v == expected s end test "complex hashing works!" do %SomeStruct{value: "javier"} |> capitalize() |> assert_result("Javier") |> hash() |> assert_result("7F3D0970EC0E336AA08A9E14D4D88E79131E0065") |> downcase() |> assert_result("7f3d0970ec0e336aa08a9e14d4d88e79131e0065") end 27
28. Encapsulating data with functions My fourth lesson 28
29. A common pattern in OOP public class Car { private int wheels; public Car(int wheels) { this.wheels = wheels; } public String getWheels() { return wheels; } } 29
30. In Clojure (defn new-job [userid cronexpression service] {:userid userid :cronexpression cronexpression :service service}) (defn get-id [job] (:id job)) (defn get-cron-expr [job] (:cronexpression job)) (defn get-user-id [job] (:userid job)) 30
31. Wrapping up 31
32. Thank you all! All this stuff written down hojasdemanzano Manzanit0 32