Safe Haskell	Safe-Inferred
Language	Haskell98

Safe.Exact

Contents

New functions
Safe wrappers

Description

Provides functions that raise errors in corner cases instead of returning "best effort" results, then provides wrappers like the Safe module. For example:

takeExact 3 [1,2] raises an error, in contrast to take which would return just two elements.
takeExact (-1) [1,2] raises an error, in contrast to take which would return no elements.
zip [1,2] [1] raises an error, in contrast to zip which would only pair up the first element.

Note that the May variants of these functions are strict in at least the bit of the prefix of the list required to spot errors. The standard and Note versions are lazy, but throw errors later in the process - they do not check upfront.

Synopsis

New functions

takeExact :: Int -> [a] -> [a] Source

takeExact n xs =
  | n >= 0 && n <= length xs = take n xs
  | otherwise                = error "some message"

dropExact :: Int -> [a] -> [a] Source

dropExact n xs =
  | n >= 0 && n <= length xs = drop n xs
  | otherwise                = error "some message"

splitAtExact :: Int -> [a] -> ([a], [a]) Source

splitAtExact n xs =
  | n >= 0 && n <= length xs = splitAt n xs
  | otherwise                = error "some message"

zipExact :: [a] -> [b] -> [(a, b)] Source

zipExact xs ys =
  | length xs == length ys = zip xs ys
  | otherwise              = error "some message"

zipWithExact :: (a -> b -> c) -> [a] -> [b] -> [c] Source

zipWithExact f xs ys =
  | length xs == length ys = zipWith f xs ys
  | otherwise              = error "some message"

Safe wrappers

takeExactMay :: Int -> [a] -> Maybe [a] Source

takeExactNote :: String -> Int -> [a] -> [a] Source

takeExactDef :: [a] -> Int -> [a] -> [a] Source

dropExactMay :: Int -> [a] -> Maybe [a] Source

dropExactNote :: String -> Int -> [a] -> [a] Source

dropExactDef :: [a] -> Int -> [a] -> [a] Source

splitAtExactMay :: Int -> [a] -> Maybe ([a], [a]) Source

splitAtExactNote :: String -> Int -> [a] -> ([a], [a]) Source

splitAtExactDef :: ([a], [a]) -> Int -> [a] -> ([a], [a]) Source

zipExactMay :: [a] -> [b] -> Maybe [(a, b)] Source

zipExactNote :: String -> [a] -> [b] -> [(a, b)] Source

zipExactDef :: [(a, b)] -> [a] -> [b] -> [(a, b)] Source

zipWithExactMay :: (a -> b -> c) -> [a] -> [b] -> Maybe [c] Source

zipWithExactNote :: String -> (a -> b -> c) -> [a] -> [b] -> [c] Source

zipWithExactDef :: [c] -> (a -> b -> c) -> [a] -> [b] -> [c] Source