safe-0.3.3: Library for safe (pattern match free) functions

Copyright(c) Neil Mitchell 2007-2010
LicenseBSD3
Maintainerhttp://community.haskell.org/~ndm/safe
Stabilityin-progress
Portabilityportable
Safe HaskellSafe-Inferred
LanguageHaskell98

Safe

Description

A library for safe functions, based on standard functions that may crash. For more details see http://community.haskell.org/~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

Documentation

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

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

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

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

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

tail "help me" [] = error "Pattern match failure, tail [], help me"
tail "help me" [1,3,4] = [3,4]

tailSafe :: [a] -> [a]

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

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

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

See fromMaybe

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

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

Same as (!!), but better error message

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

lookupJust key = fromJust . lookup key

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

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

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

findJust op = fromJust . find op

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

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

abort :: String -> a

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.