Safe.Exact

safe-0.3.9: Library of safe (exception free) functions

Safe Haskell | Safe
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

- takeExact :: Int -> [a] -> [a]
- dropExact :: Int -> [a] -> [a]
- splitAtExact :: Int -> [a] -> ([a], [a])
- zipExact :: [a] -> [b] -> [(a, b)]
- zipWithExact :: (a -> b -> c) -> [a] -> [b] -> [c]
- 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]

# 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]