safe-0.2: Library for safe (pattern match free) functionsSource codeContentsIndex
Safe
Portabilityportable
Stabilityin-progress
Maintainerhttp://www.cs.york.ac.uk/~ndm/
Description

A library for safe functions, based on standard functions that may crash. For more details see http://www-users.cs.york.ac.uk/~ndm/safe/

In general, each unsafe function has up to 4 forms. Since tail has all the possible forms, it is fully documented. The others all follow the same pattern.

  • Note, takes an extra argument which supplements the error message, tailNote
  • Def, take an extra argument to give when a crash would otherwise happen, tailDef
  • May, wraps the result in a Maybe, tailMay
  • Safe, returns a default type if possible, tailSafe

This library also introduces three brand new functions:

  • at - synonym for (!!)
  • lookupJust - defined as lookupJust k = fromJust . lookup k
  • abort - same as error, but different intended meaning
Synopsis
tailDef :: [a] -> [a] -> [a]
tailMay :: [a] -> Maybe [a]
tailNote :: String -> [a] -> [a]
tailSafe :: [a] -> [a]
initDef :: [a] -> [a] -> [a]
initMay :: [a] -> Maybe [a]
initNote :: String -> [a] -> [a]
initSafe :: [a] -> [a]
headDef :: a -> [a] -> a
headMay :: [a] -> Maybe a
headNote :: String -> [a] -> a
lastDef :: a -> [a] -> a
lastMay :: [a] -> Maybe a
lastNote :: String -> [a] -> a
minimumDef :: Ord a => a -> [a] -> a
minimumMay :: Ord a => [a] -> Maybe a
minimumNote :: Ord a => String -> [a] -> a
maximumDef :: Ord a => a -> [a] -> a
maximumMay :: Ord a => [a] -> Maybe a
maximumNote :: Ord a => String -> [a] -> a
foldr1Def :: a -> (a -> a -> a) -> [a] -> a
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
foldr1Note :: String -> (a -> a -> a) -> [a] -> a
foldl1Def :: a -> (a -> a -> a) -> [a] -> a
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
foldl1Note :: String -> (a -> a -> a) -> [a] -> a
fromJustDef :: a -> Maybe a -> a
fromJustNote :: String -> Maybe a -> a
assertNote :: String -> Bool -> a -> a
at :: [a] -> Int -> a
atDef :: a -> [a] -> Int -> a
atMay :: [a] -> Int -> Maybe a
atNote :: String -> [a] -> Int -> a
readDef :: Read a => a -> String -> a
readMay :: Read a => String -> Maybe a
readNote :: Read a => String -> String -> a
lookupJust :: Eq a => a -> [(a, b)] -> b
lookupJustDef :: Eq a => b -> a -> [(a, b)] -> b
lookupJustNote :: Eq a => String -> a -> [(a, b)] -> b
abort :: String -> a
Documentation
tailDef :: [a] -> [a] -> [a]Source
 tailDef [12] [] = [12]
 tailDef [12] [1,3,4] = [3,4]
tailMay :: [a] -> Maybe [a]Source
 tailMay [] = Nothing
 tailMay [1,3,4] = Just [3,4]
tailNote :: String -> [a] -> [a]Source
 tail "help me" [] = error "Pattern match failure, tail [], help me"
 tail "help me" [1,3,4] = [3,4]
tailSafe :: [a] -> [a]Source
 tailSafe [] = []
 tailSafe [1,3,4] = [3,4]
initDef :: [a] -> [a] -> [a]Source
initMay :: [a] -> Maybe [a]Source
initNote :: String -> [a] -> [a]Source
initSafe :: [a] -> [a]Source
headDef :: a -> [a] -> aSource
headMay :: [a] -> Maybe aSource
headNote :: String -> [a] -> aSource
lastDef :: a -> [a] -> aSource
lastMay :: [a] -> Maybe aSource
lastNote :: String -> [a] -> aSource
minimumDef :: Ord a => a -> [a] -> aSource
minimumMay :: Ord a => [a] -> Maybe aSource
minimumNote :: Ord a => String -> [a] -> aSource
maximumDef :: Ord a => a -> [a] -> aSource
maximumMay :: Ord a => [a] -> Maybe aSource
maximumNote :: Ord a => String -> [a] -> aSource
foldr1Def :: a -> (a -> a -> a) -> [a] -> aSource
foldr1May :: (a -> a -> a) -> [a] -> Maybe aSource
foldr1Note :: String -> (a -> a -> a) -> [a] -> aSource
foldl1Def :: a -> (a -> a -> a) -> [a] -> aSource
foldl1May :: (a -> a -> a) -> [a] -> Maybe aSource
foldl1Note :: String -> (a -> a -> a) -> [a] -> aSource
fromJustDef :: a -> Maybe a -> aSource
See fromMaybe
fromJustNote :: String -> Maybe a -> aSource
assertNote :: String -> Bool -> a -> aSource
at :: [a] -> Int -> aSource
Same as (!!), but better error message
atDef :: a -> [a] -> Int -> aSource
atMay :: [a] -> Int -> Maybe aSource
atNote :: String -> [a] -> Int -> aSource
readDef :: Read a => a -> String -> aSource
readMay :: Read a => String -> Maybe aSource
readNote :: Read a => String -> String -> aSource
lookupJust :: Eq a => a -> [(a, b)] -> bSource
 lookupJust key = fromJust . lookup key
lookupJustDef :: Eq a => b -> a -> [(a, b)] -> bSource
lookupJustNote :: Eq a => String -> a -> [(a, b)] -> bSource
abort :: String -> aSource
Exactly the same as error. Use this for instances where the program has decided to exit because of invalid user input, or the user pressed quit etc. This allows error to be reserved for genuine coding mistakes.
Produced by Haddock version 2.4.2