Exception Handling

> head [10, 20, 30] 
10
it :: Num a => a
>

> head [] 
*** Exception: Prelude.head: empty list
>

> div 100 0 
*** Exception: divide by zero
>

> read "100" :: Int 
100
it :: Int
> read "-100" :: Int 
-100
it :: Int
> read "noise" :: Int 
*** Exception: Prelude.read: no parse
>

:{
headSafe :: [a] -> Maybe a
headSafe []     = Nothing 
headSafe (x:_)  = Just x
:}

> headSafe [1, 2, 3, 4, 5]
Just 1
it :: Num a => Maybe a
> headSafe []
Nothing
it :: Maybe a
> :t headSafe
headSafe :: [a] -> Maybe a
>

:t div 
> div :: Integral a => a -> a -> a
>

:{
divSafe :: Integral a => a -> a -> Maybe a
divSafe x 0 = Nothing
divSafe x y = Just (div x y)
:}

> divSafe 100 20 
Just 5
it :: Integral a => Maybe a
> divSafe 100 0 
Nothing
it :: Integral a => Maybe a
>

-- Use readMaybe instead of read 
-- 
> import Text.Read (readMaybe)
>

> readMaybe "Just 200" :: Maybe (Maybe Int)
Just (Just 200)
it :: Maybe (Maybe Int)
> readMaybe "Nothing" :: Maybe (Maybe Int)
Just Nothing
it :: Maybe (Maybe Int)
> readMaybe "Notasdasdas" :: Maybe (Maybe Int)
Nothing
it :: Maybe (Maybe Int)
> 

> readMaybe "[1, 2, 3, 4, 5]" :: Maybe [Int] 
Just [1,2,3,4,5]
it :: Maybe [Int]

> readMaybe "garbage" :: Maybe [Int] 
Nothing
it :: Maybe [Int]
> 

> readMaybe "[100.0, 200.0, 300.0]" :: Maybe [Double] 
Just [100.0,200.0,300.0]
it :: Maybe [Double]
> readMaybe ", 200.0, 300.0]" :: Maybe [Double] 
Nothing
it :: Maybe [Double]
>

import Text.Read (readMabye)

:{
validateAge :: String -> Int  
validateAge input =
  case readMaybe input of
    Nothing  -> error "Invalid age. Not a number"
    Just age -> case age of 
                _ | age < 0    -> error "Error: Invalid age. It must be greater than zero."
                _ | age <= 18  -> error "Error: Below legal age to sign the contract."
                _ | age > 200  -> error "Error: Invalid age. Impossible age."
                _              -> age   
:}

> validateAge "asdfa" 
*** Exception: Invalid age. Not a number
CallStack (from HasCallStack):
  error, called at <interactive>:1083:17 in interactive:Ghci54

> validateAge "-100" 
*** Exception: Error: Invalid age. It must be greater than zero.
CallStack (from HasCallStack):
  error, called at <interactive>:1085:35 in interactive:Ghci54

> validateAge "16" 
*** Exception: Error: Below legal age to sign the contract.
CallStack (from HasCallStack):
  error, called at <interactive>:1086:35 in interactive:Ghci54
>

> validateAge "300" 
*** Exception: Error: Invalid age. Impossible age.
CallStack (from HasCallStack):
  error, called at <interactive>:1087:35 in interactive:Ghci54
>

> validateAge "30" 
30
it :: Int

> validateAge "20" 
20
it :: Int

> validateAge "35"  
35
it :: Int
>

import Text.Read (readMabye)

:{
validateAge :: String -> Either String Int  
validateAge input =
  case readMaybe input of
    Nothing  -> Left "Invalid input. Not a number"
    Just age -> case age of 
                _ | age < 0    -> Left "Error: Invalid age. It must be greater than zero."
                _ | age <= 18  -> Left "Error: Below legal age to sign the contract."
                _ | age > 200  -> Left "Error: Invalid age. Impossible age."
                _              -> Right age   
:}

> validateAge "-100"
Left "Error: Invalid age. It must be greater than zero."
it :: Either String Int
> validateAge "16"
Left "Error: Below legal age to sign the contract."
it :: Either String Int
> validateAge "300"
Left "Error: Invalid age. Impossible age."
it :: Either String Int
> validateAge "400"
Left "Error: Invalid age. Impossible age."
it :: Either String Int
> validateAge "20"
Right 20
it :: Either String Int
> validateAge "19"
Right 19
it :: Either String Int
>

> mapM_ print $ map validateAge ["safsdf", "-100", "garbage", "400", "7", "15", "20", "25"]
Left "Invalid input. Not a number"
Left "Error: Invalid age. It must be greater than zero."
Left "Invalid input. Not a number"
Left "Error: Invalid age. Impossible age."
Left "Error: Below legal age to sign the contract."
Left "Error: Below legal age to sign the contract."
Right 20
Right 25
it :: ()
>

import Text.Read (readMabye)

:{ 
data AgeError = AgeInvalidInput
              | AgeBelowLegalAge
              | AgeImpossible
              deriving (Eq, Show, Read)
:}


:{
validateAge :: String -> Either AgeError Int  
validateAge input =
  case readMaybe input of
    Nothing  -> Left AgeInvalidInput
    Just age -> case age of 
                _ | age < 0    -> Left AgeImpossible
                _ | age <= 18  -> Left AgeBelowLegalAge
                _ | age > 200  -> Left AgeImpossible
                _              -> Right age   
:}

> map (\input -> (input, validateAge input)) ["safsdf", "-100", "garbage", "400", "7", "15", "20", "25"]
[("safsdf",Left AgeInvalidInput),("-100",Left AgeImpossible),("garbage",Left AgeInvalidInput),
 ("400",Left AgeImpossible),("7",Left AgeBelowLegalAge),
 ("15",Left AgeBelowLegalAge),("20",Right 20),
 ("25",Right 25)]
it :: [([Char], Either AgeError Int)]
> 
> 

> mapM_ print $ map validateAge ["safsdf", "-100", "garbage", "400", "7", "15", "20", "25"]
Left AgeInvalidInput
Left AgeImpossible
Left AgeInvalidInput
Left AgeImpossible
Left AgeBelowLegalAge
Left AgeBelowLegalAge
Right 20
Right 25
it :: ()
>

:{
showAgeError :: AgeError -> String
showAgeError age =
   case age of
     AgeBelowLegalAge ->  "Error: Below legal age to sign the contract."
     AgeImpossible     ->  "Error: Invalid age. Impossible age."
     AgeInvalidInput    ->  "Invalid input. Not a number"
:}

> showAgeError AgeImpossible
"Error: Invalid age. Impossible age."
it :: String
> showAgeError AgeInvalidInput
"Invalid input. Not a number"
it :: String
> showAgeError AgeImpossible
"Error: Invalid age. Impossible age."
it :: String
>


:{
mapLeft :: (e -> b) -> Either e a -> Either b a
mapLeft fn value =
  case value of
    Right a -> Right a
    Left  e -> Left (fn e)
:}

> mapLeft showAgeError $ validateAge "20000" 
Left "Error: Invalid age. Impossible age."
it :: Either String Int
> mapLeft showAgeError $ validateAge "-100" 
Left "Error: Invalid age. Impossible age."
it :: Either String Int
> mapLeft showAgeError $ validateAge "10" 
Left "Error: Below legal age to sign the contract."
it :: Either String Int
> mapLeft showAgeError $ validateAge "15" 
Left "Error: Below legal age to sign the contract."
it :: Either String Int
> mapLeft showAgeError $ validateAge "25" 
Right 25
it :: Either String Int
> mapLeft showAgeError $ validateAge "36" 
Right 36
it :: Either String Int
>

import Text.Read (readMabye)

:{ 
data AgeError = AgeInvalidInput
              | AgeBelowLegalAge
              | AgeImpossible
              deriving (Eq, Show, Read)
:}

type UserData = (String, Int)


:{
data UserDataError = UserAgeError AgeError
                   | UserNameError
                   deriving(Eq, Show, Read)
:}

:{
mapLeft :: (e -> b) -> Either e a -> Either b a
mapLeft fn value =
  case value of
    Right a -> Right a
    Left  e -> Left (fn e)
:}


:{
validateAge :: String -> Either UserDataError Int  
validateAge input = mapLeft UserAgeError $ validateAgeAux input 
  where
    validateAgeAux input = 
      case readMaybe input of
        Nothing  -> Left AgeInvalidInput
        Just age -> case age of 
                    _ | age < 0    -> Left AgeImpossible
                    _ | age <= 18  -> Left AgeBelowLegalAge
                    _ | age > 200  -> Left AgeImpossible
                    _              -> Right age   
:}


:{
validateName :: String -> Either UserDataError String   
validateName name =
  case name of
    "" -> Left $ UserNameError
    _  -> Right name
:}

:{
validateUser :: String -> String -> Either UserDataError UserData
validateUser name age = do
  userName <- validateName name
  userAge  <- validateAge age
  return (userName, userAge)
:}


-- Testing: 
--------------------

> validateAge "-200" 
Left (UserAgeError AgeImpossible)
it :: Either UserDataError Int
> validateAge "1000" 
Left (UserAgeError AgeImpossible)
it :: Either UserDataError Int
> validateAge "30" 
Right 30
it :: Either UserDataError Int
> validateAge "25" 
Right 25
it :: Either UserDataError Int
> validateAge "16" 
Left (UserAgeError AgeBelowLegalAge)
it :: Either UserDataError Int

> validateAge "25" 
Right 25
it :: Either UserDataError Int
>

> validateName "" 
Left UserNameError
it :: Either UserDataError String
> 
> validateName "John" 
Right "John"
it :: Either UserDataError String
>

> validateUser "John" "300" 
Left (UserAgeError AgeImpossible)
it :: Either UserDataError UserData
> validateUser "John" "15" 
Left (UserAgeError AgeBelowLegalAge)
it :: Either UserDataError UserData
> validateUser "John" "-100" 
Left (UserAgeError AgeImpossible)
it :: Either UserDataError UserData
> validateUser "" "-100" 
Left UserNameError
it :: Either UserDataError UserData
>

> validateUser "John" "20" 
Right ("John",20)
it :: Either UserDataError UserData
>

> div 10 0 

*** Exception: divide by zero
> > 
> div 10 0 
*** Exception: divide by zero
> head [] 
*** Exception: Prelude.head: empty list
> let x = undefined :: Int 
x :: Int
> x 
*** Exception: Prelude.undefined
CallStack (from HasCallStack):
  error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err
  undefined, called at <interactive>:1741:9 in interactive:Ghci116
> 

> readFile "/etc/issue" 
"Manjaro Linux \\r  (\\n) (\\l)\n\n\n"
it :: String

> readFile "/etc/issuesada" 
*** Exception: /etc/issuesada: openFile: does not exist (No such file or directory)
> 

> readFile "/etc/shadow" 
*** Exception: /etc/shadow: openFile: permission denied (Permission denied)
>

> readFile "/etc/" 
*** Exception: /etc/: openFile: inappropriate type (is a directory)
> 
> readFile "/etcsad/" 
*** Exception: /etcsad/: openFile: does not exist (No such file or directory)
> 
>

> import qualified System.Directory as D

> D.createDirectory "/etc/fstab/my-directory" 
*** Exception: /etc/fstab/my-directory: createDirectory: inappropriate type (Not a directory)

> D.createDirectory "/dev/sda1/dummy" 
*** Exception: /dev/sda1/dummy: createDirectory: inappropriate type (Not a directory)

> D.createDirectory "/i dont have permission" 
*** Exception: /i dont have permission: createDirectory: permission denied (Permission denied)
>

import Control.Exception
import System.IO.Error 

:{
ioExceptionTester thunk = catchIOError thunk handler 
  where
    handler e = do  
      putStrLn $ "Exception message = " ++ show e 
      case e of
        _ | isAlreadyExistsError e -> putStrLn "Error: Already Exists"
        _ | isDoesNotExistError e  -> putStrLn "Error: Doesn't exists"               
        _ | isEOFError e           -> putStrLn "Error: End of file"
        _ | isIllegalOperation e   -> putStrLn "Error: Illegal operation"
        _ | isPermissionError e    -> putStrLn "Error: Permission error"
        _ | isUserError e          -> putStrLn "Error: User error"              
        _                          -> do putStrLn "Error: I can't handler this type of error."
                                         ioError e -- Raise uncaught exception 
:}


> ioExceptionTester (readFile "/etc/issue" >>= putStrLn)
Manjaro Linux \r  (\n) (\l)



it :: ()
> ioExceptionTester (readFile "/etc/issueasd" >>= putStrLn)
Exception message = /etc/issueasd: openFile: does not exist (No such file or directory)
Error: Doesn't exists
it :: ()

> ioExceptionTester (readFile "/etc/" >>= putStrLn)
Exception message = /etc/: openFile: inappropriate type (is a directory)
Error: I can't handler this type of error.
*** Exception: /etc/: openFile: inappropriate type (is a directory)
> 
> 
> ioExceptionTester (readFile "/dev/sda1" >>= putStrLn)
Exception message = /dev/sda1: hGetContents: invalid argument (invalid byte sequence)
Error: I can't handler this type of error.
*** Exception: /dev/sda1: hGetContents: invalid argument (invalid byte sequence)
> 
> ioExceptionTester (readFile "/dev/tty0" >>= putStrLn)
Exception message = /dev/tty0: openFile: permission denied (Permission denied)
Error: Permission error
it :: ()
> 
> ioExceptionTester (readFile "/dev/shadow" >>= putStrLn)
Exception message = /dev/shadow: openFile: does not exist (No such file or directory)
Error: Doesn't exists
it :: ()
> 
> ioExceptionTester (readFile "/etc/shadow" >>= putStrLn)
Exception message = /etc/shadow: openFile: permission denied (Permission denied)
Error: Permission error
it :: ()
> 

> ioExceptionTester (throw $ userError "I raised an Exception")
Exception message = user error (I raised an Exception)
Error: User error
it :: ()
> 


{- ===== The exceptions below aren't caught by catchIOError ========== -}

> ioExceptionTester (print $ div 10 0)
*** Exception: divide by zero
>

> ioExceptionTester (print $ div 10 0)
*** Exception: divide by zero
> 
> let x = undefined
- 
x :: a
> ioExceptionTester (print $ x)
*** Exception: Prelude.undefined
CallStack (from HasCallStack):
  error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err
  undefined, called at <interactive>:51:5 in interactive:Ghci4
> 
> ioExceptionTester (error "Some error")
*** Exception: Some error
CallStack (from HasCallStack):
  error, called at <interactive>:55:20 in interactive:Ghci5
>

> ioExceptionTester (throw DivideByZero )
*** Exception: divide by zero


> ioExceptionTester (throw Underflow  )
*** Exception: arithmetic underflow
>

> import System.IO.Error 
> import Control.Exception
>
> :set -XScopedTypeVariables
>   

> :t catches
catches :: IO a -> [Handler a] -> IO a
> 

> :info Handler 
data Handler a where
  Handler :: Exception e => (e -> IO a) -> Handler a
        -- Defined in ‘Control.Exception’
instance Functor Handler -- Defined in ‘Control.Exception’
> 


let arithmeticHandler = putStrLn "Error I got an Arithmetic exception."

:{
ioExceptionHandler e
  | isAlreadyExistsError e = putStrLn "IO Exception - Already exists error"
  | isUserError e          = putStrLn "IO Exception - User Error"
  | otherwise              = do putStrLn "IO Exception - I don't know how to handle this exception"
                                throw e 
:}
ioExceptionHandler :: IOError -> IO ()
> 

:{
testCatches :: IO () -> IO ()
testCatches thunk = catches thunk handlers
  where handlers = [  Handler $ \ (e :: ArithException) -> arithmeticHandler
                    , Handler $ \ (e :: IOError)        -> ioExceptionHandler e                                         
                    , Handler $ \ (e :: ErrorCall)      -> putStrLn "I got an ErrorCall exception"
                    , Handler $ \ (e :: SomeException)  -> do putStrLn "I don't know how to handle this exception"
                                                              throw e
                   ]

:}

> 
> 
> testCatches (throw DivideByZero)
Error I got an Arithmetic exception.
it :: ()
> testCatches (throw Overflow )
Error I got an Arithmetic exception.
it :: ()
> testCatches (let x = undefined in print x)
I got an ErrorCall exception
it :: ()
> testCatches (error "Some Error")
I got an ErrorCall exception
it :: ()
> testCatches (readFile "/etc/issue" >>= putStrLn)
Manjaro Linux \r  (\n) (\l)



it :: ()
> testCatches (readFile "/etc/issuesf" >>= putStrLn)
IO Exception - I don't know how to handle this exception
*** Exception: /etc/issuesf: openFile: does not exist (No such file or directory)
> 
> testCatches (throw $ userError "throw my exception")
IO Exception - User Error
it :: ()
> 
>