Safe

A module wrapping Prelude/Data.List functions that can throw exceptions, such as head and !!. Each unsafe function has up to four variants, e.g. with tail:

• tail :: [a] -> [a], raises an error on tail [].
• tailMay :: [a] -> Maybe [a], turns errors into Nothing.
• tailDef :: [a] -> [a] -> [a], takes a default to return on errors.
• tailNote :: String -> [a] -> [a], takes an extra argument which supplements the error message.
• tailSafe :: [a] -> [a], returns some sensible default if possible, [] in the case of tail.

This module also introduces some new functions, documented at the top of the module.

New functions

abort :: String -> a

Synonym for error. Used for instances where the program has decided to exit because of invalid user input, or the user pressed quit etc. This function allows error to be reserved for programmer errors.

at :: [a] -> Int -> a

Synonym for !!, but includes more information in the error message.

lookupJust :: Eq a => a -> [(a, b)] -> b

 lookupJust key = fromJust . lookup key

findJust :: (a -> Bool) -> [a] -> a

 findJust op = fromJust . find op

elemIndexJust :: Eq a => a -> [a] -> Int

 elemIndexJust op = fromJust . elemIndex op

findIndexJust :: (a -> Bool) -> [a] -> Int

 findIndexJust op = fromJust . findIndex op

Safe wrappers

tailMay :: [a] -> Maybe [a]

 tailMay [] = Nothing
 tailMay [1,3,4] = Just [3,4]

tailDef :: [a] -> [a] -> [a]

 tailDef [12] [] = [12]
 tailDef [12] [1,3,4] = [3,4]

tailNote :: String -> [a] -> [a]

 tailNote "help me" [] = error "Safe.tailNote [], help me"
 tailNote "help me" [1,3,4] = [3,4]

tailSafe :: [a] -> [a]

 tailSafe [] = []
 tailSafe [1,3,4] = [3,4]

initMay :: [a] -> Maybe [a]

initDef :: [a] -> [a] -> [a]

initNote :: String -> [a] -> [a]

initSafe :: [a] -> [a]

headMay :: [a] -> Maybe a

headDef :: a -> [a] -> a

headNote :: String -> [a] -> a

lastMay :: [a] -> Maybe a

lastDef :: a -> [a] -> a

lastNote :: String -> [a] -> a

minimumMay :: Ord a => [a] -> Maybe a

minimumDef :: Ord a => a -> [a] -> a

minimumNote :: Ord a => String -> [a] -> a

maximumMay :: Ord a => [a] -> Maybe a

maximumDef :: Ord a => a -> [a] -> a

maximumNote :: Ord a => String -> [a] -> a

minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a

minimumByDef :: a -> (a -> a -> Ordering) -> [a] -> a

minimumByNote :: String -> (a -> a -> Ordering) -> [a] -> a

maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a

maximumByDef :: a -> (a -> a -> Ordering) -> [a] -> a

maximumByNote :: String -> (a -> a -> Ordering) -> [a] -> a

foldr1May :: (a -> a -> a) -> [a] -> Maybe a

foldr1Def :: a -> (a -> a -> a) -> [a] -> a

foldr1Note :: String -> (a -> a -> a) -> [a] -> a

foldl1May :: (a -> a -> a) -> [a] -> Maybe a

foldl1Def :: a -> (a -> a -> a) -> [a] -> a

foldl1Note :: String -> (a -> a -> a) -> [a] -> a

foldl1May' :: (a -> a -> a) -> [a] -> Maybe a

foldl1Def' :: a -> (a -> a -> a) -> [a] -> a

foldl1Note' :: String -> (a -> a -> a) -> [a] -> a

scanl1May :: (a -> a -> a) -> [a] -> Maybe [a]

scanl1Def :: [a] -> (a -> a -> a) -> [a] -> [a]

scanl1Note :: String -> (a -> a -> a) -> [a] -> [a]

scanr1May :: (a -> a -> a) -> [a] -> Maybe [a]

scanr1Def :: [a] -> (a -> a -> a) -> [a] -> [a]

scanr1Note :: String -> (a -> a -> a) -> [a] -> [a]

fromJustDef :: a -> Maybe a -> a

An alternative name for fromMaybe, to fit the naming scheme of this package. Generally using fromMaybe directly would be considered better style.

fromJustNote :: String -> Maybe a -> a

assertNote :: String -> Bool -> a -> a

atMay :: [a] -> Int -> Maybe a

atDef :: a -> [a] -> Int -> a

atNote :: String -> [a] -> Int -> a

readMay :: Read a => String -> Maybe a

readDef :: Read a => a -> String -> a

readNote :: Read a => String -> String -> a

lookupJustDef :: Eq a => b -> a -> [(a, b)] -> b

lookupJustNote :: Eq a => String -> a -> [(a, b)] -> b

findJustDef :: a -> (a -> Bool) -> [a] -> a

findJustNote :: String -> (a -> Bool) -> [a] -> a

elemIndexJustDef :: Eq a => Int -> a -> [a] -> Int

elemIndexJustNote :: Eq a => String -> a -> [a] -> Int

findIndexJustDef :: Int -> (a -> Bool) -> [a] -> Int

findIndexJustNote :: String -> (a -> Bool) -> [a] -> Int