Intro to Functional Programming in Android with Kotlin

Transcript

1. Funktional Android Functional Programming for Android with Kotlin
2. What is Functional Programming?
3. What is Functional Programming? Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions.
4. Keys of FP
5. Keys of FP -First class and Higher-Order functions
6. Keys of FP -First class and Higher-Order functions -Referential transparency
7. Keys of FP -First class and Higher-Order functions -Referential transparency -Pure functions
8. Keys of FP -First class and Higher-Order functions -Referential transparency -Pure functions -Strict vs Non-Strict evaluation
9. Keys of FP Eliminating side effects can make it much easier to understand and predict the behavior of a program.
10. Monads
11. Monads A monad is just a monoid in the category of endofunctors, what's the problem?
12. Monads A monad is just a monoid in the category of endofunctors, what's the problem?
13. Monads
14. Monads Monads are wrappers with context for a value. So, like contexts, you can have different Monads for different use cases.
15. Monads Absence
16. Monads Absence Option<T> // None or Some<T>
17. Monads Absence Option<T> // None or Some<T> Runtime Exceptions
18. Monads Absence Option<T> // None or Some<T> Runtime Exceptions Try<T> // Failure<T> or Success<T>
19. Monads Absence Option<T> // None or Some<T> Runtime Exceptions Try<T> // Failure<T> or Success<T> Exceptional cases
20. Monads Absence Option<T> // None or Some<T> Runtime Exceptions Try<T> // Failure<T> or Success<T> Exceptional cases Either<L, R> // Left<L> or Right<R>
21. Monads Option(2).map { it + 3 }
22. Monads Option(2).map { it + 3 }
23. Handling exceptions with Rx useCase.fetchUser() .onErrorReturn(error -> null) .subscribe(user -> { if (user != null) … // Success case else … // Failure case })
24. Handling exceptions with Rx val userSingle = useCase.fetchUser() .onErrorReturn(error -> null)
25. Handling exceptions with Rx val userSingle = useCase.fetchUser() .onErrorReturn(error -> null) val companySingle = useCase.fetchUserCompany() .onErrorReturn(error -> null)
26. Handling exceptions with Rx val userSingle = useCase.fetchUser() .onErrorReturn(error -> null) val companySingle = useCase.fetchUserCompany() .onErrorReturn(error -> null) userSingle.zip(companySingle, (user, company) -> { if (user != null && company != null) … // Merge them else … // ??? }) .subscribe(userWithCompany -> // Success case)***Kind of
27. Handling exceptions with Monads
28. Handling exceptions with Monads // Forget about threading for a second :) val userResult: Either<ExceptionCase, User> = … val companyResult: Either<ExceptionCase, Company> = … val userWithCompany = userResult.flatMap { user -> companyResult.map { company -> // Merge them } }
29. Handling exceptions with Monads // Forget about threading for a second :) val userResult: Either<ExceptionCase, User> = … val companyResult: Either<ExceptionCase, Company> = … val userWithCompany = EitherMonad<User>().binding { val user = bind { userResult } val company = bind { companyResult } yields(/* Merge them */) }
30. Handling exceptions with Monads // userWithCompany is an Either<ExceptionCase, User> when(userWithCompany) { is Either.Left -> // Error case is Either.Right -> // Success case }
31. Monads vs Exceptions Pros: • Safer code • Less tests • Less unexpected behaviours Cons: • Complex code • Advanced types + inference = higher compile times
32. But there's one more thing...
33. Monads
34. Handling exceptions with Monads val userResult: Either<ExceptionCase, User> = … val companyResult: Either<ExceptionCase, Company> = … val userWithCompany = EitherMonad<User>().binding { val user = bind { userResult } val company = bind { companyResult } yields(/* Merge them */) }
35. Handling exceptions with Monads val userResult: Future<Either<ExceptionCase, User>> = … val companyResult: Future<Either<ExceptionCase, Company>> = … val userWithCompany = FutureMonad<User>().binding { val user = bind { userResult } val company = bind { companyResult } yields(/* Merge them */) }
36. Handling exceptions with Monads val userResult: Future<User> = … val companyResult: Future<Company> = … val userWithCompany = FutureMonad<User>().binding { val user = bind { userResult } val company = bind { companyResult } yields(/* Merge them */) }
37. Handling exceptions with Monads val userResult: Future<User> = … val companyResult: Future<Company> = … val userWithCompany = FutureMonad<User>().binding { val user = bind { userResult } // Runs in parallel* val company = bind { companyResult } // Runs in parallel* yields(/* Merge them */) } *Potentially
38. Handling exceptions with Monads val userResult: Future<User> = … val companyResult: Future<Company> = … val userWithCompany = FutureMonad<User>().binding { val user = bind { userResult } val company = bind { companyResult } yields(/* Merge them */) } // WIP :)
39. Thanks
40. Questions?