A (not so) gentle introduction to functional programming

Transcript

1. A (not so) gentle introduction to functional programming ! @gcapizzi
2. I. Let’s get started
3. What is FP? Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids side effects and mutable data.
4. What is FP? • A function doesn’t do anything • It’s just a mapping between a domain and a codomain • Input and output values already exist
5. What is FP? … -1 0 1 2 3 … … 0 1 2 3 4 … domain codomain f(x) = x + 1
6. Values vs identities • A value is something that doesn't change • An identity is a stable logical entity associated with a series of different values over time • A state is the value of an identity at a point in time
7. Values vs identities • Objects are identities • So are real world objects, or at least that’s how we perceive them • Typical OOP has imperative programming baked into it
8. “No man ever steps in the same river twice, for it's not the same river and he's not the same man.” — Heraclitus
9. “Identities are mental tools we use to superimpose continuity on a world which is constantly, functionally, creating new values of itself.” — Rich Hickey
10. “Equality in the presence of mutability has no meaning.” ! — Michael Fogus
11. Why FP? Functions are easier to • understand • reason about • refactor • test
12. Why FP? Functions can be • evaluated lazily • cached / memoized • massively parallelized
13. “Immutable objects are always thread safe.” ! — Brian Goetz
14. Throw away your loops! ! sum :: [Int] -> Int sum [] = 0 sum (x:xs) = x + sum xs Example 1
15. II. Function as things
16. FP • Functions • Functions • Functions, also • Functions • Yes, functions • Oh my, functions again! • Functions • Functions :) OOP • Single Responsibility Principle • Open/Closed principle • Dependency Inversion Principle • Interface Segregation Principle • Factory pattern • Strategy pattern • Decorator pattern • Visitor pattern From OOP to FP
17. From OOP to FP
18. Functions are values! Let’s take SRP and ISP to the extreme: ! interface BunchOfStuff { int doSomething(int x); string doSomethingElse(int x); void doAThirdThing(string x); }
19. Functions are values! Let’s take SRP and ISP to the extreme: ! interface IntToIntFunction { int invoke(int x); }
20. “Verbs in Javaland are responsible for all the work, but as they are held in contempt by all, no Verb is ever permitted to wander about freely. If a Verb is to be seen in public at all, it must be escorted at all times by a Noun.” ! — Steve Yegge
21. Functions are values! That interface is equivalent to the following type: ! Int -> Int which is the type of every function taking an integer and returning an integer.
22. interface Action { Response call(Request request); } ! interface EmailValidator { boolean validateEmail(String email); } Example 2
23. class UpdateProfile implements Action { private EmailValidator emailValidator; ! public UpdateProfile(EmailValidator emailValidator) { this.emailValidator = emailValidator; } ! public Response call(Request request) { … } } Example 2
24. isValidEmail :: String -> Bool isValidEmail = … ! updateProfile :: (String -> Bool) -> Request -> Response updateProfile emailValidation req resp = … ! —— Partial application as Dependency Injection ! updateProfileIfEmailIsValid :: Request -> Response updateProfileIfEmailIsValid = updateProfile isValidEmail ! —— *Any* function of type (String -> Bool) will do! ! updateProfileIfEmailIsPalindrome = updateProfile isPalindrome Example 2
25. f :: Int -> Int -> Int -> Int f x y z = … —— or f x y = \z -> … —— or f x = \y -> \z -> … —— or f = \x -> \y -> \z -> … Currying
26. sum :: [Int] -> Int sum [] = 0 sum (x:xs) = x + sum xs ! prod :: [Int] -> Int prod [] = 1 prod (x:xs) = x * prod xs High-order functions
27. foldl :: (b -> a -> b) -> b -> [a] -> b foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs ! sum :: [Int] -> Int sum = foldl (+) 0 ! prod :: [Int] -> Int prod = foldl (*) 1 High-order functions
28. map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs ! strToUpper :: String -> String strToUpper = map toUpper ! doubleAll :: [Int] -> [Int] doubleAll = map (*2) High-order functions
29. filter :: (a -> Bool) -> [a] -> [a] filter f [] = [] filter f (x:xs) | f x = x : filter f xs | otherwise = filter f xs ! ! filterEven = filter (\x -> x `mod` 2 == 0) filterAlpha = filter isAlpha High-order functions
30. III. Composition
31. (g ∘ f )(x) = g(f(x))
32. splitDelim :: String -> String -> [String] splitDelim delim = splitRegex (mkRegex delim) ! stringsToInts :: [String] -> [Int] stringsToInts = map read ! sumString :: String -> Int sumString = sum . stringsToInts . splitDelim “,” ! > sumString “1,2,3,4,5” —— 15 Example 3
33. extractUserAgent :: String -> String extractUserAgent = … ! countUserAgents :: String -> Int countUserAgents = length . nub . map extractUserAgent . filter (not . null) . lines Example 4
34. IV. Functions all the way down
36. Request updateProfile Response
37. Request fromReq Customer saveCustomer Customer toResponse Response
38. Request fromReq Customer validate Valid Customer update Valid Customer toResponse Response
39. V. Questions?