Safe Haskell | Safe-Inferred |
---|

- toUpperChar :: Char -> Char
- toLowerChar :: Char -> Char
- toUpperString :: String -> String
- toLowerString :: String -> String
- toCapitalString :: String -> String
- withPrefix :: [a] -> [a] -> [a]
- withSuffix :: [a] -> [a] -> [a]
- sep :: a -> [a] -> [a]
- pre :: a -> [a] -> [a]
- post :: a -> [a] -> [a]
- wrap :: a -> a -> [a] -> [a]
- concatSep :: [a] -> [[a]] -> [a]
- concatPre :: [a] -> [[a]] -> [a]
- concatPost :: [a] -> [[a]] -> [a]
- concatWrap :: [a] -> [a] -> [[a]] -> [a]
- divideList :: Int -> [a] -> [[a]]
- splitWhile :: (a -> Bool) -> [a] -> [[a]]
- breakList :: Int -> [a] -> [a] -> [a]
- mapIndexed :: (Int -> a -> b) -> [a] -> [b]
- dup :: a -> (a, a)
- unf :: (a -> Maybe a) -> a -> [a]
- mapF :: (b -> b) -> [b] -> [b]
- mapT :: (b -> b) -> [b] -> [b]
- mapL :: (b -> b) -> [b] -> [b]
- mapFTL :: (a -> b) -> (a -> b) -> (a -> b) -> [a] -> [b]
- filterOnce :: (a -> Bool) -> [a] -> [a]
- rots :: [a] -> [[a]]
- rotl :: [a] -> [a]
- rotr :: [a] -> [a]
- rotated :: Int -> [a] -> [a]
- curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
- uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
- untripl :: (a, b, c) -> ((a, b), c)
- tripl :: ((a, b), c) -> (a, b, c)
- tripr :: (a, (b, c)) -> (a, b, c)
- list :: r -> ([a] -> r) -> [a] -> r
- merge :: Ord a => [a] -> [a] -> [a]
- mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]
- mergeBy' :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- composed :: [b -> b] -> b -> b
- unRatio :: Integral a => Ratio a -> (a, a)
- showRatio :: (Integral a, Show a) => Ratio a -> String
- retainUpdates :: Eq a => [a] -> [Maybe a]
- replic :: Integral a => a -> b -> [b]
- swap :: (a, b) -> (b, a)
- withNext :: [a] -> [(a, Maybe a)]
- mapWithNext :: (a -> Maybe a -> b) -> [a] -> [b]

# Documentation

toUpperChar :: Char -> CharSource

toLowerChar :: Char -> CharSource

toUpperString :: String -> StringSource

toLowerString :: String -> StringSource

withPrefix :: [a] -> [a] -> [a]Source

withSuffix :: [a] -> [a] -> [a]Source

concatPost :: [a] -> [[a]] -> [a]Source

concatWrap :: [a] -> [a] -> [[a]] -> [a]Source

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

splitWhile :: (a -> Bool) -> [a] -> [[a]]Source

Group a list into sublists whereever a predicate holds. The matched element is the first in the sublist.

splitWhile isSpace "foo bar baz" ===> ["foo"," bar"," baz"] splitWhile (> 3) [1,5,4,7,0,1,2] ===> [[1],[5],[4],[7,0,1,2]]

category : List depends : base

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

Break up a list into parts of maximum length n, inserting the given list as separator.
Useful for breaking up strings, as in `breakList 80 n str`

.

category : List depends : base

mapIndexed :: (Int -> a -> b) -> [a] -> [b]Source

mapFTL :: (a -> b) -> (a -> b) -> (a -> b) -> [a] -> [b]Source

Map over first, middle and last elements of list. Biased on first, then on first and last for short lists.

category: List depends: base

filterOnce :: (a -> Bool) -> [a] -> [a]Source

retainUpdates :: Eq a => [a] -> [Maybe a]Source

mapWithNext :: (a -> Maybe a -> b) -> [a] -> [b]Source