Working with Maybe

View the live presentation: https://www.youtube.com/watch?v=43eM4kNbb6c

One of the selling points of Elm is that you cannot get null errors. Maybe is what allows Elm to avoid this billion-dollar problem entirely. It’s a beautiful solution.

But it doesn’t take too long before your code is one long ugly nested case statement checking Maybes at every level. Surely this can’t be right. There must be a better way.

We have an array of tools at our disposal to solve this problem, from simple convenience functions all the way to eliminating Maybe altogether in favor of other constructs. Join me on a whirlwind tour of these solutions and take back control of your codebase.

Transcript

1. WORKING WITH MAYBE
2. There are only two certainties in life: death, and taxes.
3. UNCERTAINTY IN CODE
4. USER INPUT
5. OTHER SYSTEMS
6. INSIDE YOUR PROGRAM
8. SOCIETY FOR THE PRESERVATION OF VOWEL NAMES
9. > All names lowercase > Vowel names prefixed with asterisk > Display unknown donors as "Anonymous"
12. JAVASCRIPT let displayName = function(user) { if (startsWithVowel(user.name)) { "*" + user.name.toLowerCase(); } else { user.name.toLowerCase(); } }
13. IS THIS SAFE?
14. ¯\_(ϑ)_/¯
15. UNCERTAINTY let user1 = null; let user2 = { name: null }; displayName(user1); displayName(user2);
16. You can never trust anything
17. NULL EXCEPTIONS
18. TYPE SYSTEMS?
19. NULL IS VIRAL
20. Uncertainty begets uncertainty
21. NULL IS USED TO REPRESENT MANY DIFFERENT CONCEPTS
22. THE ELM APPROACH
23. "Trust no one" vs "Trust everyone"
24. UNCERTAINTY PROBLEMS 1. any value can be missing at any time
25. UNCERTAINTY PROBLEMS 1. any value can be missing at any time
26. UNCERTAINTY PROBLEMS 1. any value can be missing at any time 2. Maybe is viral
27. UNCERTAINTY PROBLEMS 1. any value can be missing at any time 2. Maybe is viral 3. Programmers abuse the concept
28. formatName : Maybe User -> Maybe String startsWithVowel : Maybe String -> Maybe Bool
29. type alias User = { name : Maybe String } formatName : Maybe User -> Maybe String formatName maybeUser = case maybesUser of Just user -> case startsWithVowel user.name of Just True -> case user.name of Just name -> Just <| "*" ++ String.toLower name Nothing -> Nothing -- should never happen Just False -> case user.name of Just name -> Just <| String.toLower name Nothing -> Nothing -- should never happen Nothing -> Just "Anonymous" startsWithVowel : Maybe String -> Maybe Bool startsWithVowel name = -- ...
30. !!!
31. ELIMINATE THE MAYBE
32. UNWRAPPING EARLY getNameOrDefault : Maybe User -> String getNameOrDefault optionalUser = case optionalUser of Just user -> user.name Nothing -> ""
33. "DEFAULT VALUES"
34. ANOTHER FORM OF OPTIONAL viewName : Maybe User -> Html a viewName optionalUser = case getNameOrDefault optionalUser of "" -> text "Anonymous" actualName -> text actualName
35. EXPLICIT OPTIONAL VALUE viewName : Maybe User -> Html a viewName optionalUser = case optionalUser of Nothing -> text "Anonymous" Just user -> text user.name
36. POLYMORPHISM Passing default values like "" into a chain of functions is a clever way of no-opp
38. GUIDELINE 1 Separate code that checks for presence from code that calculates values.
41. CONFIDENT BUSINESS FUNCTION formatName : User -> String formatName user = user.name |> String.toLower |> prefixVowelName
42. HANDLE THE MAYBE Maybe.map formatName optionalUser |> Maybe.withDefault "Anonymous"
43. Business functions cannot take Maybe as an argument
44. 2 MAYBES Uncertain user and uncertain donation amount
45. BUSINESS FUNCTION WITH NO MAYBES userWithDonation : User -> Int -> String userWithDonation user donation = (formatName user) ++ " - $" ++ toString donation
46. map2 Maybe.map2 userWithDonation optionalUser optionalDonation |> Maybe.withDefault "Anonymous"
47. Write confident business-logic functions and only deal with Maybe at the edges of your system (with the appropriate map function)
48. UNCERTAINTY FROM WITHIN
49. findByName : String -> List User -> Maybe User findByName name users = users |> List.filter (\user -> user.name == name) |> List.head
50. GUIDELINE 2 Business functions may return Maybe but may not accept Maybe as any of its arguments.
51. QUARANTINE
52. type alias Session = { searchTerm : Maybe String } session.searchTerm |> Maybe.andThen (\name -> findByName name users)
53. IS Maybe BAD?
54. TWO MEANINGS List.head [] -- Nothing List.head [Nothing, { name = "Arthur" }] -- Nothing
55. MODEL THE DIFFERENCE type Donor = Anonymous | Named String
56. GUIDELINE 0 Actively try to model your data structures to avoid Maybe
57. FORCING A SINGLE SHAPE
58. UNCERTAINTY FROM WITHIN type alias DonorWizard = { donor : Maybe Donor , donationAmount : Maybe Int }
59. IMPOSSIBLE STATES { donor = Nothing , donationAmount = Just 100000 }
60. UNION TYPES type DonorWizard = Step1 (Maybe Donor) | Step2 Donor (Maybe Int) | Complete Donor Int
62. > Actively try to model your data structures to avoid Maybe > Separate code that checks for presence from code that calculates values. > Business functions may return Maybe but may not accept Maybe as any of its arguments.
63. JOËL QUENNEVILLE > Github - github.com/JoelQ > Slack - @joelq > Twitter - @joelquen Come talk to me, I have postcards!