Please enable JavaScript.

Coggle requires JavaScript to display documents.

learnyouahaskell.com part 1 - Coggle Diagram

- - - - So in purely functional languages, a function has no side-effects.
        The only thing a function can do is calculate something and return it as a result
    - - Haskell won't execute functions and calculate things until it's really forced to show you a result
    - - Haskell uses a very good type system that has type inference
        
        If you say a = 5 + 4, you don't have to tell Haskell that a is a number, it can figure that out by itself
    - - shorter programs are easier to maintain than longer ones and have less bugs.
- - - - ghci> zip [1,2,3,4,5] [5,5,5,5,5]
        [(1,5),(2,5),(3,5),(4,5),(5,5)]
        ghci> zip [1 .. 5] ["one", "two", "three", "four", "five"]
        [(1,"one"),(2,"two"),(3,"three"),(4,"four"),(5,"five")]
        ghci> zip [5,3,2,6,2,7,2,5,4,6,6] ["im","a","turtle"]
        [(5,"im"),(3,"a"),(2,"turtle")]
        ghci> zip [1..] ["apple", "orange", "cherry", "mango"]
        [(1,"apple"),(2,"orange"),(3,"cherry"),(4,"mango")]
- - - - ghci> :t "HELLO!"
        "HELLO!" :: [Char] => a list of characters
  - - - ghci> :t (==)
        (==) :: (Eq a) => a -> a -> Bool
        => We can read the previous type declaration like this: the equality function takes any two values that are of the same type and returns a Bool. The type of those two values must be a member of the Eq class (this was the class constraint).
    - - but read "4" =>GHCI is telling us here is that it doesn't know what we want in return
        
        ex: ghci> read "5" :: Int
        5
        ghci> read "(3, 'a')" :: (Int, Char)
        (3, 'a')
      - Most expressions are such that the compiler can infer what their type is by itself. But sometimes, the compiler doesn't know
        => So we have to tell Haskell: "Hey, this expression should have this type, in case you don't know!".
      - Type annotations are a way of explicitly saying what the type of an expression should be. We do that by adding :: at the end of the expression and then specifying a type. ex: read "5" :: Int
- - - - When you call sayMe, the patterns will be checked from top to bottom and when it conforms to a pattern, the corresponding function body will be used => it's the same switch case
    - - We can also define a factorial function recursively
    - - addVectors :: (Num a) => (a, a) -> (a, a) -> (a, a)
        addVectors (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)
      - The _ means the same thing as it does in list comprehensions. It means that we really don't care what that part is, so we just write a __.
        
        first :: (a, b) -> a
        first (x, _ ) = x
        second :: (a, b,) -> b
        second (_ , y ) = y
    - - ghci> let xs = [(1,3), (4,3), (2,4), (5,3), (5,6), (3,1)]
        ghci> [a+b | (a,b) <- xs]
        [4,7,6,8,11,4]
    - - tell :: (Show a) => [a] -> String
        tell [] = "The list is empty"
        tell (x:[]) = "The list has one element: " ++ show x
        tell (x:y:[]) = "The list has two elements: " ++ show x ++ " and " ++ show y
        tell (x:y:_) = "This list is long. The first two elements are: " ++ show x ++ " and " ++ show y
      - length' :: (Num b) => [a] -> b
        length' [] = 0
        length' (_:xs) = 1 + length' xs
        sum' :: (Num a) => [a] -> a
        sum' [] = 0
        sum' (x:xs) = x + sum' xs
        => (:xs) vs (x:xs) : splitting it into a head and a tail, and use to match the head because we don't actually care what it is
      - capital :: String -> String
        capital "" = "Empty string, whoops!"
        capital all@ ( x : xs) = "The first letter of " ++ all ++ " is " ++ [x]
      - you can't use ++ in pattern matches
  - - - ...
        where bmi = weight / height ^ 2
        (skinny, normal, fat) = (18.5, 25.0, 30.0)
        initials :: String -> String -> String
        initials firstname lastname = [f] ++ ". " ++ [l] ++ "."
        where (f:) = firstname
        (l:) = lastname
        calcBmis :: (RealFloat a) => [(a, a)] -> [a]
        calcBmis xs = [bmi w h | (w, h) <- xs]
        where bmi weight height = weight / height ^ 2
  - - - describeList :: [a] -> String
        describeList xs = "The list is " ++ case xs of [] -> "empty."
        [x] -> "a singleton list."
        xs -> "a longer list."