Safe Haskell | Safe |
---|---|

Language | Haskell2010 |

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

raises an error, in contrast to`takeExact`

3 [1,2]`take`

which would return just two elements.

raises an error, in contrast to`takeExact`

(-1) [1,2]`take`

which would return no elements.

raises an error, in contrast to`zip`

[1,2] [1]`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.

- takeExact :: Partial => Int -> [a] -> [a]
- dropExact :: Partial => Int -> [a] -> [a]
- splitAtExact :: Partial => Int -> [a] -> ([a], [a])
- zipExact :: Partial => [a] -> [b] -> [(a, b)]
- zipWithExact :: Partial => (a -> b -> c) -> [a] -> [b] -> [c]
- zip3Exact :: Partial => [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith3Exact :: Partial => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- takeExactMay :: Int -> [a] -> Maybe [a]
- takeExactNote :: Partial => String -> Int -> [a] -> [a]
- takeExactDef :: [a] -> Int -> [a] -> [a]
- dropExactMay :: Int -> [a] -> Maybe [a]
- dropExactNote :: Partial => String -> Int -> [a] -> [a]
- dropExactDef :: [a] -> Int -> [a] -> [a]
- splitAtExactMay :: Int -> [a] -> Maybe ([a], [a])
- splitAtExactNote :: Partial => String -> Int -> [a] -> ([a], [a])
- splitAtExactDef :: ([a], [a]) -> Int -> [a] -> ([a], [a])
- zipExactMay :: [a] -> [b] -> Maybe [(a, b)]
- zipExactNote :: Partial => String -> [a] -> [b] -> [(a, b)]
- zipExactDef :: [(a, b)] -> [a] -> [b] -> [(a, b)]
- zipWithExactMay :: (a -> b -> c) -> [a] -> [b] -> Maybe [c]
- zipWithExactNote :: Partial => String -> (a -> b -> c) -> [a] -> [b] -> [c]
- zipWithExactDef :: [c] -> (a -> b -> c) -> [a] -> [b] -> [c]
- zip3ExactMay :: [a] -> [b] -> [c] -> Maybe [(a, b, c)]
- zip3ExactNote :: Partial => String -> [a] -> [b] -> [c] -> [(a, b, c)]
- zip3ExactDef :: [(a, b, c)] -> [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith3ExactMay :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> Maybe [d]
- zipWith3ExactNote :: Partial => String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zipWith3ExactDef :: [d] -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

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

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

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

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

splitAtExactMay :: Int -> [a] -> Maybe ([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 #