-- 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 :: 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.Base.Applicative f, GHC.Base.Semigroup m) => GHC.Base.Semigroup (Data.FMList.WrapApp f m)
instance (GHC.Base.Applicative f, GHC.Base.Monoid m) => GHC.Base.Monoid (Data.FMList.WrapApp f m)
instance GHC.Base.Functor Data.FMList.FMList
instance Data.Foldable.Foldable Data.FMList.FMList
instance Data.Traversable.Traversable Data.FMList.FMList
instance GHC.Base.Monad Data.FMList.FMList
instance Control.Monad.Fail.MonadFail Data.FMList.FMList
instance GHC.Base.Applicative Data.FMList.FMList
instance GHC.Base.Semigroup (Data.FMList.FMList a)
instance GHC.Base.Monoid (Data.FMList.FMList a)
instance GHC.Base.MonadPlus Data.FMList.FMList
instance GHC.Base.Alternative Data.FMList.FMList
instance GHC.Show.Show a => GHC.Show.Show (Data.FMList.FMList a)
