Safe.Exact

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.

New functions

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

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

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

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

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

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

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

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

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

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

Safe wrappers

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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