Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell98 |
- unionMapSet :: Ord b => (a -> Set b) -> Set a -> Set b
- inverseMap :: (Ord k, Ord v') => (k -> v -> (v', k')) -> Map k v -> Map v' k'
- showStringMapKeys :: Map String x -> String -> String
- hdAndTl' :: a -> [a] -> (a, [a])
- hdAndTl :: [a] -> (a, [a])
- maybeNull :: r -> ([a] -> r) -> [a] -> r
- maybeHd :: r -> (a -> r) -> [a] -> r
- wordsBy :: (a -> Bool) -> [a] -> [[a]]
- initlast :: [a] -> Maybe ([a], a)
- last' :: a -> [a] -> a
- initlast2 :: [a] -> Maybe ([a], a, a)
- firstNotEmpty :: [[x]] -> [x]
- listSaturate :: (Enum a, Ord a) => a -> a -> (x -> a) -> (a -> x) -> [x] -> [x]
- listSaturateWith :: (Enum a, Ord a) => a -> a -> (x -> a) -> [(a, x)] -> [x] -> [x]
- spanOnRest :: ([a] -> Bool) -> [a] -> ([a], [a])
- tup123to1 :: (t, t1, t2) -> t
- tup123to2 :: (t, t1, t2) -> t1
- tup123to12 :: (t1, t2, t) -> (t1, t2)
- tup123to23 :: (t, t1, t2) -> (t1, t2)
- tup12to123 :: t2 -> (t, t1) -> (t, t1, t2)
- strWhite :: Int -> String
- strPad :: String -> Int -> String
- strCapitalize :: String -> String
- strToInt :: String -> Int
- splitForQualified :: String -> [String]
- panic :: [Char] -> t
- isSortedByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> Bool
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- sortByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> [a]
- groupOn :: Eq b => (a -> b) -> [a] -> [[a]]
- groupSortOn :: Ord b => (a -> b) -> [a] -> [[a]]
- groupByOn :: (b -> b -> Bool) -> (a -> b) -> [a] -> [[a]]
- groupSortByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> [[a]]
- nubOn :: Eq b => (a -> b) -> [a] -> [a]
- consecutiveBy :: (a -> a -> Bool) -> [a] -> [[a]]
- partitionAndRebuild :: (v -> Bool) -> [v] -> ([v], [v], [v'] -> [v'] -> [v'])
- orderingLexic :: [Ordering] -> Ordering
- panicJust :: String -> Maybe a -> a
- ($?) :: (a -> Maybe b) -> Maybe a -> Maybe b
- orMb :: Maybe a -> Maybe a -> Maybe a
- maybeAnd :: x -> (a -> b -> x) -> Maybe a -> Maybe b -> x
- maybeOr :: x -> (a -> x) -> (b -> x) -> Maybe a -> Maybe b -> x
- scc :: Ord n => [(n, [n])] -> [[n]]
- mapLookup2' :: (Ord k1, Ord k2) => (v1 -> Map k2 v2) -> k1 -> k2 -> Map k1 v1 -> Maybe (Map k2 v2, v2)
- mapLookup2 :: (Ord k1, Ord k2) => k1 -> k2 -> Map k1 (Map k2 v2) -> Maybe v2
- firstMaybeM :: Monad m => a -> [a -> m (Maybe a)] -> m a
Documentation
firstNotEmpty :: [[x]] -> [x] Source
listSaturate :: (Enum a, Ord a) => a -> a -> (x -> a) -> (a -> x) -> [x] -> [x] Source
listSaturateWith :: (Enum a, Ord a) => a -> a -> (x -> a) -> [(a, x)] -> [x] -> [x] Source
spanOnRest :: ([a] -> Bool) -> [a] -> ([a], [a]) Source
tup123to12 :: (t1, t2, t) -> (t1, t2) Source
tup123to23 :: (t, t1, t2) -> (t1, t2) Source
tup12to123 :: t2 -> (t, t1) -> (t, t1, t2) Source
strCapitalize :: String -> String Source
splitForQualified :: String -> [String] Source
isSortedByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> Bool Source
groupSortOn :: Ord b => (a -> b) -> [a] -> [[a]] Source
groupSortByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> [[a]] Source
consecutiveBy :: (a -> a -> Bool) -> [a] -> [[a]] Source
The consecutiveBy
function groups like groupBy, but based on a function which says whether 2 elements are consecutive
partitionAndRebuild :: (v -> Bool) -> [v] -> ([v], [v], [v'] -> [v'] -> [v']) Source
Partition, but also return a function which will rebuild according to the original ordering of list elements
orderingLexic :: [Ordering] -> Ordering Source
mapLookup2' :: (Ord k1, Ord k2) => (v1 -> Map k2 v2) -> k1 -> k2 -> Map k1 v1 -> Maybe (Map k2 v2, v2) Source
double lookup, with transformer for 2nd map
firstMaybeM :: Monad m => a -> [a -> m (Maybe a)] -> m a Source
loop over monads yielding a Maybe from a start value, yielding the first Just or the start (when no Just is returned)