Updated homework

Author: rober-m

Homework/Homework15/app/Homework15A.hs

@@ -1,8 +1,5 @@
 module Main where
 
-import Control.Exception (catch, try)
-import Text.Read (readMaybe)
-
 --------------------------------------------------------------------------------
 --------------------------------------------------------------------------------
 -- IMPORTANT: Read the README.md file before completing the homework.
@@ -29,31 +26,19 @@ prompt todos = do
   command <- getLine
   interpretCommand command todos
 
-delete :: Maybe Int -> [a] -> [a]
-delete Nothing as = as
+delete :: Int -> [a] -> [a]
+delete 0 (_ : as) = as
 delete _ [] = []
-delete (Just 0) (_ : as) = as
-delete (Just n) (a : as) = a : delete (Just (n - 1)) as
+delete n (a : as) = a : delete (n - 1) as
 
 interpretCommand :: String -> [String] -> IO ()
 interpretCommand cmd todos = case cmd of
   "q" -> return ()
   ('+' : ' ' : todo) -> prompt (todo : todos)
-  ('-' : ' ' : num) -> prompt $ delete (readMaybe num) todos
+  ('-' : ' ' : num) -> prompt $ delete (read num) todos
   ('s' : ' ' : fn) ->
-    writeFile fn (show todos) `catch` \e -> do
-      putStrLn $ "Could not write to file because: " ++ show (e :: IOError)
-      prompt todos
-  -- There's no reason as to why this and the previous case should handle
-  -- errors differently. I did it this way so you can see how to handle errors
-  -- in different ways.
-  ('l' : ' ' : fn) -> do
-    contents <- try $ readFile fn >>= return . read
-    case contents of
-      Left e -> do
-        putStrLn $ "Could not read from file because: " ++ show (e :: IOError)
-        prompt todos
-      Right todos' -> prompt todos'
+    writeFile fn (show todos)
+  ('l' : ' ' : fn) -> readFile fn >>= prompt . read
   _ -> do
     putStrLn ("Invalid command: `" ++ cmd ++ "`")
     prompt todos

Homework/Homework15/src/Homework15B.hs

@@ -2,8 +2,6 @@
 
 module Homework15B where
 
-import Control.Exception (IOException, try)
-
 --------------------------------------------------------------------------------
 --------------------------------------------------------------------------------
 -- IMPORTANT: Read the README.md file before completing the homework.
@@ -14,26 +12,19 @@ import Control.Exception (IOException, try)
 -- If the list is empty, return Nothing.
 
 headMaybe :: [a] -> Maybe a
-headMaybe [] = Nothing
-headMaybe (x : _) = Just x
+headMaybe = undefined
 
 -- 2. Write a function that takes a list of Maybe values and returns a list of all the Just values.
 -- If there are no Just values, return an empty list.
 
 catMaybes :: [Maybe a] -> [a]
-catMaybes [] = []
-catMaybes (Nothing : xs) = catMaybes xs
-catMaybes (Just x : xs) = x : catMaybes xs
+catMaybes = undefined
 
 -- 3. Write a function that tries to read from a file and returns the contents of the file.
 -- If the file does not exist, return Nothing.
 
 readFileMaybe :: FilePath -> IO (Maybe String)
-readFileMaybe path = do
-  contents <- try $ readFile path
-  case contents of
-    Left (_ :: IOException) -> return Nothing
-    Right c -> return (Just c)
+readFileMaybe = undefined
 
 -- 4. Write a function that checks all the requirements for a password using the
 -- Either type with a custom data type for errors.
@@ -43,53 +34,19 @@ readFileMaybe path = do
 -- - The password must contain at least one uppercase letter.
 -- - The password must contain at least one lowercase letter.
 
-data PasswordError
-  = NotLongEnough
-  | NoDigit
-  | NoUppercase
-  | NoLowercase
-  deriving (Eq, Show)
+data PasswordError = WrongConstructor
 
 passwordLongEnough :: String -> Either PasswordError String
-passwordLongEnough password =
-  if length password >= 10
-    then Right password
-    else Left NotLongEnough
+passwordLongEnough = undefined
 
 passwordHasDigit :: String -> Either PasswordError String
-passwordHasDigit password =
-  if any (`elem` ['0' .. '9']) password
-    then Right password
-    else Left NoDigit
+passwordHasDigit = undefined
 
 passwordHasUppercase :: String -> Either PasswordError String
-passwordHasUppercase password =
-  if any (`elem` ['A' .. 'Z']) password
-    then Right password
-    else Left NoUppercase
+passwordHasUppercase = undefined
 
 passwordHasLowercase :: String -> Either PasswordError String
-passwordHasLowercase password =
-  if any (`elem` ['a' .. 'z']) password
-    then Right password
-    else Left NoLowercase
-
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
--- As you can see, the passwordRequirements function is very repetitive.
--- This is one of the downsides of using nested optional values.
--- We're going to solve this problem in the "Basic Abstractions" section of the coruse.
---------------------------------------------------------------------------------
---------------------------------------------------------------------------------
+passwordHasLowercase = undefined
 
 passwordRequirements :: String -> Either PasswordError String
-passwordRequirements password =
-  case passwordLongEnough password of
-    Left err -> Left err
-    Right _ -> case passwordHasDigit password of
-      Left err -> Left err
-      Right _ -> case passwordHasUppercase password of
-        Left err -> Left err
-        Right _ -> case passwordHasLowercase password of
-          Left err -> Left err
-          Right _ -> Right password
+passwordRequirements = undefined