-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | FoldMap lists
--   
--   FoldMap lists are lists represented by their foldMap function. FoldMap
--   lists have O(1) cons, snoc and append, just like DLists, but other
--   operations might have favorable performance characteristics as well.
--   These wild claims are still completely unverified though.
@package fmlist
@version 0.9.4

-- | FoldMap lists: lists represented by their foldMap function.
--   
--   Examples:
--   
--   
--   -- A right-infinite list
--   c = 1 `cons` c
--   
--   
--   
--   -- A left-infinite list
--   d = d `snoc` 2
--   
--   
--   
--   -- A middle-infinite list ??
--   e = c `append` d
--   
--   
--   
--   *> head e
--   1
--   *> last e
--   2
--   
module Data.FMList

-- | FMList is a foldMap function wrapped up in a newtype.
newtype FMList a
FM :: (forall m. Monoid m => (a -> m) -> m) -> FMList a
[unFM] :: FMList a -> forall m. Monoid m => (a -> m) -> m

-- | The function transform transforms a list by changing the map
--   function that is passed to foldMap.
--   
--   It has the following property:
--   
--   
--   transform a . transform b = transform (b . a)
--   
--   
--   For example:
--   
--   
--   
- 
 m >>= g

--   
- 
= flatten (fmap g m)

--   
- 
= flatten . fmap g $ m

--   
- 
= transform foldMap . transform (. g) $ m

--   
- 
= transform ((. g) . foldMap) m

--   
- 
= transform (\f -> foldMap f . g) m

--   
transform :: (forall m. Monoid m => (a -> m) -> b -> m) -> FMList b -> FMList a

-- | The identity of <|>
--   
--   
--   empty <|> a     == a
--   a     <|> empty == a
--   
empty :: Alternative f => f a
singleton :: a -> FMList a
cons :: a -> FMList a -> FMList a
snoc :: FMList a -> a -> FMList a
pair :: a -> a -> FMList a
append :: FMList a -> FMList a -> FMList a
fromList :: [a] -> FMList a
fromFoldable :: Foldable f => f a -> FMList a
null :: FMList a -> Bool
length :: FMList a -> Int
genericLength :: Num b => FMList a -> b
head :: FMList a -> a
tail :: FMList a -> FMList a
last :: FMList a -> a
init :: FMList a -> FMList a
reverse :: FMList a -> FMList a

-- | List of elements of a structure, from left to right. If the entire
--   list is intended to be reduced via a fold, just fold the structure
--   directly bypassing the list.
--   
--   
Examples
--   
--   Basic usage:
--   
--   
--   >>> toList Nothing
--   []
--   
--   
--   
--   >>> toList (Just 42)
--   [42]
--   
--   
--   
--   >>> toList (Left "foo")
--   []
--   
--   
--   
--   >>> toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))
--   [5,17,12,8]
--   
--   
--   For lists, toList is the identity:
--   
--   
--   >>> toList [1, 2, 3]
--   [1,2,3]
--   
toList :: Foldable t => t a -> [a]
flatten :: Foldable t => FMList (t a) -> FMList a

-- | Map each element of a structure to an action, evaluate these actions
--   from left to right, and concat the monoid results.
foldMapA :: (Foldable t, Applicative f, Monoid m) => (a -> f m) -> t a -> f m
filter :: (a -> Bool) -> FMList a -> FMList a
take :: (Ord n, Num n) => n -> FMList a -> FMList a
drop :: (Ord n, Num n) => n -> FMList a -> FMList a
takeWhile :: (a -> Bool) -> FMList a -> FMList a
dropWhile :: (a -> Bool) -> FMList a -> FMList a
zip :: FMList a -> FMList b -> FMList (a, b)
zipWith :: (a -> b -> c) -> FMList a -> FMList b -> FMList c
iterate :: (a -> a) -> a -> FMList a

-- | repeat buids an infinite list of a single value. While
--   infinite, the result is still accessible from both the start and end.
repeat :: a -> FMList a

-- | cycle repeats a list to create an infinite list. It is also
--   accessible from the end, where last (cycle l) equals last
--   l.
cycle :: FMList a -> FMList a

-- | unfold builds a list from a seed value. The function takes the
--   seed and returns an FMList of values. If the value is
--   Right a, then a is appended to the result,
--   and if the value is Left b, then b is used as
--   seed value in a recursive call.
--   
--   A simple use of unfold (simulating unfoldl):
--   
--   
--   *> unfold (\b -> if b == 0 then empty else Left (b-1) `pair` Right b) 10
--   fromList [1,2,3,4,5,6,7,8,9,10]
--   
unfold :: (b -> FMList (Either b a)) -> b -> FMList a

-- | unfoldr builds an FMList from a seed value from left to
--   right. The function takes the element and returns Nothing if it
--   is done producing the list or returns Just (a,b), in
--   which case, a is a appended to the result and b is
--   used as the next seed value in a recursive call.
--   
--   A simple use of unfoldr:
--   
--   
--   *> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
--   fromList [10,9,8,7,6,5,4,3,2,1]
--   
unfoldr :: (b -> Maybe (a, b)) -> b -> FMList a
instance GHC.Internal.Base.Alternative Data.FMList.FMList
instance GHC.Internal.Base.Applicative Data.FMList.FMList
instance GHC.Internal.Data.Foldable.Foldable Data.FMList.FMList
instance GHC.Internal.Base.Functor Data.FMList.FMList
instance GHC.Internal.Base.Monad Data.FMList.FMList
instance GHC.Internal.Control.Monad.Fail.MonadFail Data.FMList.FMList
instance GHC.Internal.Base.MonadPlus Data.FMList.FMList
instance GHC.Internal.Base.Monoid (Data.FMList.FMList a)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Base.Monoid m) => GHC.Internal.Base.Monoid (Data.FMList.WrapApp f m)
instance GHC.Internal.Base.Semigroup (Data.FMList.FMList a)
instance (GHC.Internal.Base.Applicative f, GHC.Internal.Base.Semigroup m) => GHC.Internal.Base.Semigroup (Data.FMList.WrapApp f m)
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.FMList.FMList a)
instance GHC.Internal.Data.Traversable.Traversable Data.FMList.FMList
