feat: ch 09 to last exercise

Author: glebec

09-lists/01-exercises.lhs

@@ -3,6 +3,11 @@
 
 > module Chapter9Exercises where
 
+\begin{code}
+import Data.Bool (bool)
+import Data.Char
+\end{code}
+
 \section{9.5 EnumFromTo}
 
 \begin{code}
@@ -66,5 +71,112 @@ e2' = [(x, y) | x <- mySqrs, y <- myCubes, x < 50, y < 50]
 
 -- 3. determine how many tuples inhabit your output list
 e3' = (length e1', length e2') -- 25, 15
+\end{code}
+
+
+\section{9.8 Spines and nonstrict evaluation}
+
+Bottom Madness: will the following expressions return a value or be ⊥?
+
+\begin{code}
+-- b1 =  [x^y | x <- [1..5], y <- [2, undefined]] -- ⊥
+b2 =  take 1 $ [x^y | x <- [1..5], y <- [2, undefined]] -- value ([1])
+-- b3 =  sum [1, undefined, 3] -- ⊥
+b4 =  length [1, 2, undefined] -- value (3)
+-- b5 =  length $ [1, 2, 3] ++ undefined -- ⊥
+b6 =  take 1 $ filter even [1, 2, 3, undefined] -- value ([2])
+-- b7 =  take 1 $ filter even [1, 3, undefined] -- ⊥
+b8 =  take 1 $ filter odd [1, 3, undefined] -- value ([1])
+b9 =  take 2 $ filter odd [1, 3, undefined] -- value ([1, 3])
+-- b10 = take 3 $ filter odd [1, 3, undefined] -- ⊥
+\end{code}
+
+For each expression below, determine whether it’s in NF, WHNF, or neither.
+
+1. [1, 2, 3, 4, 5] -- NF
+2. 1 : 2 : 3 : 4 : _ -- WHNF
+3. enumFromTo 1 10 -- neither
+4. length [1, 2, 3, 4, 5] -- neither
+5. sum (enumFromTo 1 10) -- neither
+6. ['a'..'m'] ++ ['n'..'z'] -- neither
+7. (_, 'b') -- WHNF
+
+
+\section{9.9 Transforming lists of values}
+
+More Bottom
+
+\begin{code}
+-- mb1 = take 1 $ map (+1) [undefined, 2, 3] -- ⊥
+mb2 = take 1 $ map (+1) [1, undefined, 3] -- value (2)
+-- mb3 = take 2 $ map (+1) [1, undefined, 3] -- ⊥
+
+itIsMystery xs = map (\x -> elem x "aeiou") xs -- creates list of bools predicated on vowels
+
+mb5a = map (^2) [1..10] -- [1, 4, 9, 16 etc.]
+mb5b = map minimum [[1..10], [10..20], [20..30]] -- [1, 10, 20]
+mb5c = map sum [[1..5], [1..5], [1..5]] -- [15, 15, 15]
+
+mb6 = map (\x -> bool x (-x) (x == 3))
+\end{code}
+
+
+\section{9.10 Filtering lists of values}
+
+How might we write a filter function that would give us all the multiples of 3 out of a list from 1-30?
+
+\begin{code}
+getMultiple3 = filter (\x -> x `mod` 3 == 0)
+howManyMult3 = length . getMultiple3
+removeArticles = unwords . filter (\s -> not $ s `elem` ["a", "an", "the"]) . words
+\end{code}
+
+
+\section{9.11 Zipping lists}
+
+\begin{code}
+myZip :: [a] -> [b] -> [(a, b)]
+myZip [] _ = []
+myZip _ [] = []
+myZip (x:xs) (y:ys) = (x, y) : myZip xs ys
+
+myZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+myZipWith _ [] _ = []
+myZipWith _ _ [] = []
+myZipWith f (x:xs) (y:ys) = f x y : myZipWith f xs ys
+
+myZipB :: [a] -> [b] -> [(a, b)]
+myZipB = zipWith (,)
+\end{code}
+
+
+\section{9.12 Chapter Exercises}
+
+Data.Char:
+
+1. isUpper :: Char -> Bool; toUpper :: Char -> Char
+
+\begin{code}
+getUppers :: String -> String
+getUppers = filter isUpper
+
+capitalize :: String -> String
+capitalize [] = []
+capitalize (c:cs) = toUpper c : cs
+
+allCaps :: String -> String
+-- allCaps [] = []
+-- allCaps (c:cs) = toUpper c : allCaps cs
+allCaps = map toUpper
+
+capFirst :: String -> Char
+capFirst = toUpper . head
+\end{code}
+
+Cipher: see 03-cipher.hs
+
+Implementing standard functions:
+
+\begin{code}
 
 \end{code}

09-lists/03-cipher.hs

@@ -0,0 +1,20 @@
+module Cipher where
+
+import Data.Char
+
+-- 65 A to 90 Z, 97 a to 122 z
+caesar, unCaesar :: Int -> String -> String
+caesar shift = map (translate shift)
+unCaesar = caesar . negate
+
+toAlphaNum :: Char -> Int
+toAlphaNum c
+  | isUpper c = code - 65
+  | isLower c = code - 71
+  where code = ord c
+
+translate :: Int -> Char -> Char
+translate shift c
+  | isAlpha c = letters !! ((toAlphaNum c + shift) `mod` 52)
+  | otherwise = c
+  where letters = ['A'..'Z'] ++ ['a'..'z']

09-lists/README.md

@@ -40,3 +40,32 @@ Comprehensions:
 - `[x^y | x <- [1..5], y <- [2, 3], x^y < 200]`
 - `[(x, y) | x <- [1, 2, 3], y <- ['a', 'b']]` is (1, a), (1, b), (2, a) etc.
 - `[x | x <- "Three Letter Acronym", elem x ['A'..'Z']]` is "TLA"
+
+---
+
+`:sprint` command can indicate (somewhat) what expressions have been evaluated.
+
+```
+λ: let blah = enumFromTo 'a' 'z'
+λ: :sprint blah
+blah = _
+λ: take 3 blah
+"abc"
+λ: sprint blah
+blah = 'a' : 'b' : 'c' : _
+```
+
+**WHNF** (Weak Head Normal Form) – evaluated to at least a data constructor.
+
+- `(1, 2)` WHNF & NF
+- `(1, 1 + 1)` WHNF (not NF)
+
+`length` is strict in the spine but not the values. Using `_` in pattern matching can be used to ignore values.
+
+`take 2 $ map (+1) [1, 2, undefined]` prints `[2, 3]`.
+
+---
+
+- `bool :: a -> a -> Bool -> a`
+- `chr :: Int -> Char`
+- `ord :: Char -> Int`