Mathias Verraes
August 17, 2016
1.9k

# How to Find the Bar

Lightning talk for SocratesBe
http://verraes.net

August 17, 2016

## Transcript

3. ### joining some lookup tables Integer to Character 1 => 'a'

2 => 'b' 3 => 'c' Character to String 'a' => "foo" 'b' => "bar" String to Msg "foo" => "No bar here" "bar" => "You found the bar"
4. ### import Dict exposing (get, fromList) findC n = get n

(fromList [ ( 1, 'a' ), ( 2, 'b' ), (3, 'c') ]) findS c = get c (fromList [ ( 'a', "foo" ), ( 'b', "bar" ) ]) findM s = get s (fromList [ ( "foo", "No bar here" ) , ( "bar", "You found the bar" ) ] )
5. ### regular programming find n = findM (findS (findC n)) mediocre

functional style find n = findC n |> findS |> findM composing computations like a boss find = findC >> findS >> findM
6. ### ==================================== ERRORS ==================================== -- TYPE MISMATCH --------------------------------------------- repl-temp-000.elm The right

argument of (|>) is causing a type mismatch. 5| findC 2 |> findS ^^^^^ (|>) is expecting the right argument to be a: Maybe Char -> a But the right argument is: Char -> Maybe String Hint: I always figure out the type of the left argument first and if it is acceptable on its own, I assume it is "correct" in subsequent checks. So the problem may actually be in how the left and right arguments interact.
7. ### Y YOU NO COMPOSE?! > findC 1 Just 'a' :

Maybe.Maybe Char > findC 5 Nothing : Maybe.Maybe Char lookups have 0 or 1 results! findC : Int -> Maybe Char findS : Char -> Maybe String findM : String -> Maybe Msg
8. ### find : Int -> Maybe Msg find n = case

findC n of Nothing -> Nothing Just c -> case findS c of Nothing -> Nothing Just s -> findM s
9. ### andThen : Maybe a -> (a -> Maybe b) ->

Maybe b andThen x f = case x of Nothing -> Nothing Just a -> f a find n = findC n `andThen` findS `andThen` findM > find 1 Nothing : Maybe.Maybe Msg > find 2 Just "You found the bar" : Maybe.Maybe Msg
10. ### elm: generalised andThen for all computations that can return nothing

or fail haskell: generalised for even more contexts (>>=) :: m a -> (a -> m b) -> m b aka "bind"
11. ### you understand monads now (>>=) :: m a -> (a

-> m b) -> m b m can be many many things