| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
Util
Synopsis
- (+?+) :: String -> String -> String
- (<.>) :: Functor m => (b -> c) -> (a -> m b) -> a -> m c
- (==<<) :: Monad m => (a -> b -> m c) -> (m a, m b) -> m c
- andLazy :: Monad m => m Bool -> m Bool -> m Bool
- andM :: Monad m => [m Bool] -> m Bool
- angleBrackets :: Doc -> Doc
- brackets :: String -> String
- bracketsIf :: Bool -> String -> String
- compAssoc :: Eq b => [(a, b)] -> [(b, c)] -> [(a, c)]
- compressMaybes :: [Maybe a] -> [a]
- findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
- firstJust :: [Maybe a] -> Maybe a
- firstJustM :: Monad m => [m (Maybe a)] -> m (Maybe a)
- for :: Functor f => f a -> (a -> b) -> f b
- fromAllWriter :: Writer All a -> (Bool, a)
- fwhen :: Bool -> (a -> a) -> a -> a
- fwords :: String -> Doc
- hasDuplicate :: Eq a => [a] -> Bool
- headMaybe :: [a] -> Maybe a
- hsepBy :: Doc -> [Doc] -> Doc
- ifJustM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b
- ifM :: Monad m => m Bool -> m a -> m a -> m a
- ifNothingM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b
- implies :: Bool -> Bool -> Bool
- mapAssoc :: (a -> b) -> [(n, a)] -> [(n, b)]
- mapAssocM :: (Applicative m, Monad m) => (a -> m b) -> [(n, a)] -> m [(n, b)]
- mapFst :: (a -> c) -> (a, d) -> (c, d)
- mapMapM :: (Monad m, Ord k) => (a -> m b) -> Map k a -> m (Map k b)
- mapOver :: Functor f => f a -> (a -> b) -> f b
- mapPair :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)
- mapSnd :: (b -> d) -> (a, b) -> (a, d)
- parens :: String -> String
- parensIf :: Bool -> Doc -> Doc
- pwords :: String -> [Doc]
- separate :: String -> String -> String -> String
- showList :: String -> (a -> String) -> [a] -> String
- traceM :: Monad m => String -> m ()
- unlessM :: Monad m => m Bool -> m () -> m ()
- whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
- whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- whenM :: Monad m => m Bool -> m () -> m ()
- whenNothing :: Monad m => Maybe a -> m () -> m ()
- zipPair :: (a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
- type List1 = NonEmpty
- class Null a where
- class Pretty a where
- pretty :: a -> Doc
- prettyPrec :: Int -> a -> Doc
- class Push a b where
- push :: a -> b -> b
- class Retrieve a b c | b -> c where
- class Size a where
- intercalate :: [a] -> [[a]] -> [a]
Documentation
(<.>) :: Functor m => (b -> c) -> (a -> m b) -> a -> m c infixr 9 Source #
Composition: pure function after monadic function.
angleBrackets :: Doc -> Doc Source #
compressMaybes :: [Maybe a] -> [a] Source #
hasDuplicate :: Eq a => [a] -> Bool Source #
ifNothingM :: Monad m => m (Maybe a) -> m b -> (a -> m b) -> m b Source #
mapAssocM :: (Applicative m, Monad m) => (a -> m b) -> [(n, a)] -> m [(n, b)] Source #
whenNothing :: Monad m => Maybe a -> m () -> m () Source #
Minimal complete definition
Nothing
Instances
| Pretty DefId Source # | |
| Pretty Expr Source # | |
| Pretty LtLe Source # | |
| Pretty Name Source # | |
| Pretty Pattern Source # | |
| Pretty PiSigma Source # | |
| Pretty QName Source # | |
| Pretty TBind Source # | |
| Pretty Telescope Source # | |
| Pretty Doc Source # | |
| Pretty (Bound Expr) Source # | |
| Pretty (Measure Expr) Source # | |
| Pretty (Sort Expr) Source # | |
| Pretty a => Pretty (Tagged a) Source # | |
intercalate :: [a] -> [[a]] -> [a] #
intercalate xs xss is equivalent to (.
It inserts the list concat (intersperse xs xss))xs in between the lists in xss and concatenates the
result.
Laziness
intercalate has the following properties:
>>>take 5 (intercalate undefined ("Lorem" : undefined))"Lorem"
>>>take 6 (intercalate ", " ("Lorem" : undefined))"Lorem*** Exception: Prelude.undefined
Examples
>>>intercalate ", " ["Lorem", "ipsum", "dolor"]"Lorem, ipsum, dolor"
>>>intercalate [0, 1] [[2, 3], [4, 5, 6], []][2,3,0,1,4,5,6,0,1]
>>>intercalate [1, 2, 3] [[], []][1,2,3]