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

Safe.Exact

Contents

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] ` 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 :: Partial => Int -> [a] -> [a] Source

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

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

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

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

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

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

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

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

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

zip3Exact :: Partial => [a] -> [b] -> [c] -> [(a, b, c)] Source

```zip3Exact xs ys zs =
| length xs == length ys && length xs == length zs = zip3 xs ys zs
| otherwise                                        = error "some message"```

zipWith3Exact :: Partial => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source

```zipWith3Exact f xs ys zs =
| length xs == length ys && length xs == length zs = zipWith3 f xs ys zs
| otherwise                                        = error "some message"```

# Safe wrappers

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

zip3ExactNote :: Partial => String -> [a] -> [b] -> [c] -> [(a, b, c)] Source

zip3ExactDef :: [(a, b, c)] -> [a] -> [b] -> [c] -> [(a, b, c)] Source

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

zipWith3ExactNote :: Partial => String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source

zipWith3ExactDef :: [d] -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] Source