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


-- | Beautiful Folding
--   
--   This package is a playground full of comonadic folds.
--   
--   This style of fold is documented in <a>"Cellular Automata, Part II:
--   PNGs and Moore"</a>
--   
--   This package can be seen as what happens if you chase Max Rabkin's
--   <a>"Beautiful Folding"</a> to its logical conclusion.
--   
--   More information on this approach can be found in the <a>"Another
--   lovely example of type class morphisms"</a> and <a>"More beautiful
--   fold zipping"</a> posts by Conal Elliott, as well as in Gabriel
--   Gonzales' <a>"Composable Streaming Folds"</a>
@package folds
@version 0.7

module Data.Fold.Internal

-- | Reversed '[]'
data SnocList a
Snoc :: (SnocList a) -> a -> SnocList a
Nil :: SnocList a
data SnocList1 a
Snoc1 :: (SnocList1 a) -> a -> SnocList1 a
First :: a -> SnocList1 a
data List1 a
Cons1 :: a -> (List1 a) -> List1 a
Last :: a -> List1 a

-- | Strict <a>Maybe</a>
data Maybe' a
Nothing' :: Maybe' a
Just' :: !a -> Maybe' a
maybe' :: b -> (a -> b) -> Maybe' a -> b

-- | Strict Pair
data Pair' a b
Pair' :: !a -> !b -> Pair' a b

-- | A reified <a>Monoid</a>.
newtype N a s
N :: a -> N a s
[runN] :: N a s -> a

-- | A reified <a>Semigroup</a>.
newtype S a s
S :: a -> S a s
[runS] :: S a s -> a

-- | The shape of a <a>foldMap</a>
data Tree a
Zero :: Tree a
One :: a -> Tree a
Two :: (Tree a) -> (Tree a) -> Tree a
data Tree1 a
Bin1 :: (Tree1 a) -> (Tree1 a) -> Tree1 a
Tip1 :: a -> Tree1 a
newtype An a
An :: a -> An a
data Box a
Box :: a -> Box a
newtype FreeMonoid a
FreeMonoid :: (forall m. Monoid m => (a -> m) -> m) -> FreeMonoid a
[runFreeMonoid] :: FreeMonoid a -> forall m. Monoid m => (a -> m) -> m
foldDeRef :: (MuRef1 f, Bifoldable (DeRef1 f)) => f a -> FreeMonoid a
newtype FreeSemigroup a
FreeSemigroup :: (forall m. Semigroup m => (a -> m) -> m) -> FreeSemigroup a
[runFreeSemigroup] :: FreeSemigroup a -> forall m. Semigroup m => (a -> m) -> m
foldDeRef1 :: (MuRef1 f, Bifoldable1 (DeRef1 f)) => f a -> FreeSemigroup a
instance Data.Traversable.Traversable (Data.Fold.Internal.T1 a)
instance Data.Foldable.Foldable (Data.Fold.Internal.T1 a)
instance GHC.Base.Functor (Data.Fold.Internal.T1 a)
instance Data.Traversable.Traversable (Data.Fold.Internal.T a)
instance Data.Foldable.Foldable (Data.Fold.Internal.T a)
instance GHC.Base.Functor (Data.Fold.Internal.T a)
instance GHC.Base.Functor Data.Fold.Internal.FreeSemigroup
instance GHC.Base.Functor Data.Fold.Internal.FreeMonoid
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.Box a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.Box a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.Box a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.Box a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.Box a)
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.An a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.An a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.An a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.An a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.An a)
instance (Data.Data.Data a, Data.Data.Data b) => Data.Data.Data (Data.Fold.Internal.Pair' a b)
instance (GHC.Read.Read a, GHC.Read.Read b) => GHC.Read.Read (Data.Fold.Internal.Pair' a b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Data.Fold.Internal.Pair' a b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Data.Fold.Internal.Pair' a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Data.Fold.Internal.Pair' a b)
instance (Data.Data.Data a, Data.Data.Data s) => Data.Data.Data (Data.Fold.Internal.S a s)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.S a s)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.S a s)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.S a s)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.S a s)
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.Tree a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.Tree a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.Tree a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.Tree a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.Tree a)
instance (Data.Data.Data a, Data.Data.Data s) => Data.Data.Data (Data.Fold.Internal.N a s)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.N a s)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.N a s)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.N a s)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.N a s)
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.Maybe' a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.Maybe' a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.Maybe' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.Maybe' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.Maybe' a)
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.SnocList1 a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.SnocList1 a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.SnocList1 a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.SnocList1 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.SnocList1 a)
instance Data.Data.Data a => Data.Data.Data (Data.Fold.Internal.SnocList a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Fold.Internal.SnocList a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Fold.Internal.SnocList a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Fold.Internal.SnocList a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Fold.Internal.SnocList a)
instance GHC.Base.Functor Data.Fold.Internal.SnocList
instance Data.Foldable.Foldable Data.Fold.Internal.SnocList
instance Data.Traversable.Traversable Data.Fold.Internal.SnocList
instance GHC.Base.Functor Data.Fold.Internal.SnocList1
instance Data.Foldable.Foldable Data.Fold.Internal.SnocList1
instance Data.Traversable.Traversable Data.Fold.Internal.SnocList1
instance Data.Foldable.Foldable Data.Fold.Internal.Maybe'
instance Data.Reflection.Reifies s (a -> a -> a, a) => GHC.Base.Monoid (Data.Fold.Internal.N a s)
instance GHC.Base.Functor Data.Fold.Internal.Tree
instance Data.Foldable.Foldable Data.Fold.Internal.Tree
instance Data.Traversable.Traversable Data.Fold.Internal.Tree
instance Data.Reflection.Reifies s (a -> a -> a) => Data.Semigroup.Semigroup (Data.Fold.Internal.S a s)
instance (GHC.Base.Monoid a, GHC.Base.Monoid b) => GHC.Base.Monoid (Data.Fold.Internal.Pair' a b)
instance GHC.Base.Functor Data.Fold.Internal.An
instance Data.Foldable.Foldable Data.Fold.Internal.An
instance Data.Traversable.Traversable Data.Fold.Internal.An
instance GHC.Base.Functor Data.Fold.Internal.Box
instance Data.Foldable.Foldable Data.Fold.Internal.Box
instance Data.Traversable.Traversable Data.Fold.Internal.Box
instance GHC.Base.Functor Data.Fold.Internal.List1
instance Data.Foldable.Foldable Data.Fold.Internal.List1
instance Data.Traversable.Traversable Data.Fold.Internal.List1
instance GHC.Base.Functor Data.Fold.Internal.Tree1
instance Data.Foldable.Foldable Data.Fold.Internal.Tree1
instance Data.Traversable.Traversable Data.Fold.Internal.Tree1
instance Data.Foldable.Foldable Data.Fold.Internal.FreeMonoid
instance Data.Foldable.Foldable Data.Fold.Internal.FreeSemigroup
instance Data.Semigroup.Foldable.Class.Foldable1 Data.Fold.Internal.FreeSemigroup
instance Data.Reify.MuRef (Data.Fold.Internal.Tree a)
instance Data.Fold.Internal.MuRef1 Data.Fold.Internal.Tree
instance Data.Bifunctor.Bifunctor Data.Fold.Internal.T
instance Data.Bifoldable.Bifoldable Data.Fold.Internal.T
instance Data.Bitraversable.Bitraversable Data.Fold.Internal.T
instance Data.Reify.MuRef (Data.Fold.Internal.Tree1 a)
instance Data.Fold.Internal.MuRef1 Data.Fold.Internal.Tree1
instance Data.Bifunctor.Bifunctor Data.Fold.Internal.T1
instance Data.Bifoldable.Bifoldable Data.Fold.Internal.T1
instance Data.Bitraversable.Bitraversable Data.Fold.Internal.T1
instance Data.Semigroup.Foldable.Class.Bifoldable1 Data.Fold.Internal.T1
instance Data.Semigroup.Traversable.Class.Bitraversable1 Data.Fold.Internal.T1

module Data.Fold.Class
class Choice p => Scan p where prefix1 = prefix . An postfix1 p = postfix p . An run1 = run . An
prefix1 :: Scan p => a -> p a b -> p a b
postfix1 :: Scan p => p a b -> a -> p a b

-- | Apply a <a>Folding</a> to a single element of input
run1 :: Scan p => a -> p a b -> b
interspersing :: Scan p => a -> p a b -> p a b
class Scan p => Folding p where prefix = prefixOf folded postfix = postfixOf folded run = runOf folded

-- | Partially apply a <a>Folding</a> to some initial input on the left.
prefix :: (Folding p, Foldable t) => t a -> p a b -> p a b
prefixOf :: Folding p => Fold s a -> s -> p a b -> p a b
postfix :: (Folding p, Foldable t) => p a b -> t a -> p a b
postfixOf :: Folding p => Fold s a -> p a b -> s -> p a b

-- | Apply a <a>Folding</a> to a container full of input:
--   
--   <pre>
--   &gt;&gt;&gt; run ["hello","world"] $ L id (++) []
--   "helloworld"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run [1,2,3] $ L id (+) 0
--   6
--   </pre>
run :: (Folding p, Foldable t) => t a -> p a b -> b
runOf :: Folding p => Fold s a -> s -> p a b -> b
filtering :: Folding p => (a -> Bool) -> p a b -> p a b

-- | Lift a <a>Folding</a> into a <a>Prism</a>.
--   
--   This acts like a generalized notion of "costrength", when applied to a
--   <a>Folding</a>, causing it to return the left-most value that fails to
--   match the Prism, or the result of accumulating rewrapped in the
--   <a>Prism</a> if everything matches.
--   
--   <pre>
--   &gt;&gt;&gt; run [Left 1, Left 2, Left 3] $ beneath _Left $ R id (+) 0
--   Left 6
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run [Left 1, Right 2, Right 3] $ beneath _Left $ R id (+) 0
--   Right 2
--   </pre>
--   
--   <pre>
--   beneath :: Prism s t a b -&gt; p a b -&gt; p s t
--   beneath :: Iso s t a b   -&gt; p a b -&gt; p s t
--   </pre>
beneath :: Profunctor p => Optic p Identity s t a b -> p a b -> p s t

module Data.Fold.L

-- | A Moore Machine
data L a b
L :: (r -> b) -> (r -> a -> r) -> r -> L a b

-- | Construct a Moore machine from a state valuation and transition
--   function
unfoldL :: (s -> (b, a -> s)) -> s -> L a b
instance Data.Fold.Class.Scan Data.Fold.L.L
instance Data.Fold.Class.Folding Data.Fold.L.L
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.L.L
instance Data.Profunctor.Choice Data.Fold.L.L
instance GHC.Base.Functor (Data.Fold.L.L a)
instance Control.Comonad.Comonad (Data.Fold.L.L a)
instance GHC.Base.Applicative (Data.Fold.L.L a)
instance Data.Functor.Bind.Class.Bind (Data.Fold.L.L a)
instance GHC.Base.Monad (Data.Fold.L.L a)
instance Control.Monad.Zip.MonadZip (Data.Fold.L.L a)
instance Data.Functor.Extend.Extend (Data.Fold.L.L a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.L.L a)
instance Control.Comonad.ComonadApply (Data.Fold.L.L a)
instance Data.Distributive.Distributive (Data.Fold.L.L a)
instance Data.Functor.Rep.Representable (Data.Fold.L.L a)
instance Control.Monad.Reader.Class.MonadReader [a] (Data.Fold.L.L a)
instance Data.Profunctor.Costrong Data.Fold.L.L
instance Data.Profunctor.Sieve.Cosieve Data.Fold.L.L []
instance Data.Profunctor.Closed.Closed Data.Fold.L.L
instance Data.Profunctor.Rep.Corepresentable Data.Fold.L.L
instance Control.Monad.Fix.MonadFix (Data.Fold.L.L a)

module Data.Fold.L'

-- | A strict left fold / strict Moore machine
data L' a b
L' :: (r -> b) -> (r -> a -> r) -> r -> L' a b

-- | Construct a strict Moore machine from a state valuation and transition
--   function
unfoldL' :: (s -> (b, a -> s)) -> s -> L' a b
instance Data.Fold.Class.Scan Data.Fold.L'.L'
instance Data.Fold.Class.Folding Data.Fold.L'.L'
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.L'.L'
instance Data.Profunctor.Choice Data.Fold.L'.L'
instance GHC.Base.Functor (Data.Fold.L'.L' a)
instance Control.Comonad.Comonad (Data.Fold.L'.L' a)
instance GHC.Base.Applicative (Data.Fold.L'.L' a)
instance Data.Functor.Bind.Class.Bind (Data.Fold.L'.L' a)
instance GHC.Base.Monad (Data.Fold.L'.L' a)
instance Control.Monad.Zip.MonadZip (Data.Fold.L'.L' a)
instance Data.Functor.Extend.Extend (Data.Fold.L'.L' a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.L'.L' a)
instance Control.Comonad.ComonadApply (Data.Fold.L'.L' a)
instance Data.Distributive.Distributive (Data.Fold.L'.L' a)
instance Data.Functor.Rep.Representable (Data.Fold.L'.L' a)
instance Data.Profunctor.Costrong Data.Fold.L'.L'
instance Data.Profunctor.Closed.Closed Data.Fold.L'.L'
instance Data.Profunctor.Rep.Corepresentable Data.Fold.L'.L'
instance Data.Profunctor.Sieve.Cosieve Data.Fold.L'.L' []
instance Control.Monad.Reader.Class.MonadReader [a] (Data.Fold.L'.L' a)
instance Control.Monad.Fix.MonadFix (Data.Fold.L'.L' a)

module Data.Fold.L1

-- | A Mealy Machine
data L1 a b
L1 :: (c -> b) -> (c -> a -> c) -> (a -> c) -> L1 a b
instance Data.Fold.Class.Scan Data.Fold.L1.L1
instance GHC.Base.Functor (Data.Fold.L1.L1 a)
instance Data.Pointed.Pointed (Data.Fold.L1.L1 a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.L1.L1 a)
instance GHC.Base.Applicative (Data.Fold.L1.L1 a)
instance GHC.Base.Monad (Data.Fold.L1.L1 a)
instance Control.Monad.Zip.MonadZip (Data.Fold.L1.L1 a)
instance Data.Semigroupoid.Semigroupoid Data.Fold.L1.L1
instance Control.Category.Category Data.Fold.L1.L1
instance Control.Arrow.Arrow Data.Fold.L1.L1
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.L1.L1
instance Data.Profunctor.Strong Data.Fold.L1.L1
instance Data.Profunctor.Choice Data.Fold.L1.L1
instance Control.Arrow.ArrowChoice Data.Fold.L1.L1
instance Data.Profunctor.Sieve.Cosieve Data.Fold.L1.L1 Data.List.NonEmpty.NonEmpty
instance Data.Profunctor.Costrong Data.Fold.L1.L1
instance Data.Profunctor.Rep.Corepresentable Data.Fold.L1.L1
instance Data.Distributive.Distributive (Data.Fold.L1.L1 a)
instance Data.Functor.Rep.Representable (Data.Fold.L1.L1 a)
instance Data.Profunctor.Closed.Closed Data.Fold.L1.L1
instance Control.Monad.Reader.Class.MonadReader (Data.List.NonEmpty.NonEmpty a) (Data.Fold.L1.L1 a)
instance Control.Monad.Fix.MonadFix (Data.Fold.L1.L1 a)

module Data.Fold.L1'

-- | A strict Mealy Machine
data L1' a b
L1' :: (c -> b) -> (c -> a -> c) -> (a -> c) -> L1' a b
instance Data.Fold.Class.Scan Data.Fold.L1'.L1'
instance GHC.Base.Functor (Data.Fold.L1'.L1' a)
instance Data.Pointed.Pointed (Data.Fold.L1'.L1' a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.L1'.L1' a)
instance GHC.Base.Applicative (Data.Fold.L1'.L1' a)
instance GHC.Base.Monad (Data.Fold.L1'.L1' a)
instance Data.Semigroupoid.Semigroupoid Data.Fold.L1'.L1'
instance Control.Category.Category Data.Fold.L1'.L1'
instance Control.Arrow.Arrow Data.Fold.L1'.L1'
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.L1'.L1'
instance Data.Profunctor.Strong Data.Fold.L1'.L1'
instance Data.Profunctor.Choice Data.Fold.L1'.L1'
instance Control.Arrow.ArrowChoice Data.Fold.L1'.L1'
instance Data.Profunctor.Sieve.Cosieve Data.Fold.L1'.L1' Data.List.NonEmpty.NonEmpty
instance Data.Profunctor.Costrong Data.Fold.L1'.L1'
instance Data.Profunctor.Rep.Corepresentable Data.Fold.L1'.L1'
instance Data.Distributive.Distributive (Data.Fold.L1'.L1' a)
instance Data.Functor.Rep.Representable (Data.Fold.L1'.L1' a)
instance Data.Profunctor.Closed.Closed Data.Fold.L1'.L1'
instance Control.Monad.Reader.Class.MonadReader (Data.List.NonEmpty.NonEmpty a) (Data.Fold.L1'.L1' a)
instance Control.Monad.Fix.MonadFix (Data.Fold.L1'.L1' a)


-- | Unlike <a>L</a> and <a>R</a> this <a>Comonad</a> is based on a
--   <tt>(-&gt;) r</tt> <a>Comonad</a> for a <a>Monoid</a> <tt>r</tt>
--   rather than than on the <tt><tt>Store</tt> r</tt> <a>Comonad</a>.
module Data.Fold.M

-- | A <a>foldMap</a> caught in amber. a.k.a. a monoidal reducer
data M a b
M :: (m -> b) -> (a -> m) -> (m -> m -> m) -> m -> M a b
instance Data.Fold.Class.Scan Data.Fold.M.M
instance Data.Fold.Class.Folding Data.Fold.M.M
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.M.M
instance Data.Profunctor.Choice Data.Fold.M.M
instance GHC.Base.Functor (Data.Fold.M.M a)
instance Control.Comonad.Comonad (Data.Fold.M.M a)
instance GHC.Base.Applicative (Data.Fold.M.M a)
instance Data.Functor.Bind.Class.Bind (Data.Fold.M.M a)
instance GHC.Base.Monad (Data.Fold.M.M a)
instance Control.Monad.Zip.MonadZip (Data.Fold.M.M a)
instance Data.Functor.Extend.Extend (Data.Fold.M.M a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.M.M a)
instance Control.Comonad.ComonadApply (Data.Fold.M.M a)
instance Data.Distributive.Distributive (Data.Fold.M.M a)
instance Data.Profunctor.Closed.Closed Data.Fold.M.M
instance Data.Profunctor.Sieve.Cosieve Data.Fold.M.M Data.Fold.Internal.FreeMonoid
instance Data.Profunctor.Rep.Corepresentable Data.Fold.M.M
instance Control.Monad.Reader.Class.MonadReader (Data.Fold.Internal.FreeMonoid a) (Data.Fold.M.M a)
instance Data.Functor.Rep.Representable (Data.Fold.M.M a)
instance Data.Profunctor.Costrong Data.Fold.M.M
instance Control.Monad.Fix.MonadFix (Data.Fold.M.M a)

module Data.Fold.M1

-- | A semigroup reducer
data M1 a b
M1 :: (m -> b) -> (a -> m) -> (m -> m -> m) -> M1 a b
runM1 :: Foldable1 f => f a -> M1 a b -> b
instance Data.Fold.Class.Scan Data.Fold.M1.M1
instance GHC.Base.Functor (Data.Fold.M1.M1 a)
instance Data.Pointed.Pointed (Data.Fold.M1.M1 a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.M1.M1 a)
instance GHC.Base.Applicative (Data.Fold.M1.M1 a)
instance GHC.Base.Monad (Data.Fold.M1.M1 a)
instance Control.Monad.Zip.MonadZip (Data.Fold.M1.M1 a)
instance Data.Semigroupoid.Semigroupoid Data.Fold.M1.M1
instance Control.Category.Category Data.Fold.M1.M1
instance Control.Arrow.Arrow Data.Fold.M1.M1
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.M1.M1
instance Data.Profunctor.Strong Data.Fold.M1.M1
instance Data.Profunctor.Choice Data.Fold.M1.M1
instance Control.Arrow.ArrowChoice Data.Fold.M1.M1
instance Data.Profunctor.Closed.Closed Data.Fold.M1.M1
instance Data.Distributive.Distributive (Data.Fold.M1.M1 a)
instance Data.Profunctor.Sieve.Cosieve Data.Fold.M1.M1 Data.Fold.Internal.FreeSemigroup
instance Data.Profunctor.Rep.Corepresentable Data.Fold.M1.M1
instance Data.Functor.Rep.Representable (Data.Fold.M1.M1 a)
instance Data.Profunctor.Costrong Data.Fold.M1.M1
instance Control.Monad.Reader.Class.MonadReader (Data.Fold.Internal.FreeSemigroup a) (Data.Fold.M1.M1 a)
instance Control.Monad.Fix.MonadFix (Data.Fold.M1.M1 a)

module Data.Fold.R

-- | right folds / a reversed Moore machine
data R a b
R :: (r -> b) -> (a -> r -> r) -> r -> R a b
instance Data.Fold.Class.Scan Data.Fold.R.R
instance Data.Fold.Class.Folding Data.Fold.R.R
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.R.R
instance Data.Profunctor.Choice Data.Fold.R.R
instance GHC.Base.Functor (Data.Fold.R.R a)
instance Control.Comonad.Comonad (Data.Fold.R.R a)
instance Data.Functor.Bind.Class.Bind (Data.Fold.R.R a)
instance GHC.Base.Monad (Data.Fold.R.R a)
instance Control.Monad.Zip.MonadZip (Data.Fold.R.R a)
instance GHC.Base.Applicative (Data.Fold.R.R a)
instance Data.Functor.Extend.Extend (Data.Fold.R.R a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.R.R a)
instance Control.Comonad.ComonadApply (Data.Fold.R.R a)
instance Data.Distributive.Distributive (Data.Fold.R.R a)
instance Data.Functor.Rep.Representable (Data.Fold.R.R a)
instance Data.Profunctor.Costrong Data.Fold.R.R
instance Data.Profunctor.Rep.Corepresentable Data.Fold.R.R
instance Data.Profunctor.Sieve.Cosieve Data.Fold.R.R []
instance Control.Monad.Reader.Class.MonadReader [a] (Data.Fold.R.R a)
instance Data.Profunctor.Closed.Closed Data.Fold.R.R
instance Control.Monad.Fix.MonadFix (Data.Fold.R.R a)

module Data.Fold.R1

-- | A reversed Mealy machine
data R1 a b
R1 :: (c -> b) -> (a -> c -> c) -> (a -> c) -> R1 a b
instance Data.Fold.Class.Scan Data.Fold.R1.R1
instance GHC.Base.Functor (Data.Fold.R1.R1 a)
instance Data.Pointed.Pointed (Data.Fold.R1.R1 a)
instance Data.Functor.Bind.Class.Apply (Data.Fold.R1.R1 a)
instance GHC.Base.Applicative (Data.Fold.R1.R1 a)
instance GHC.Base.Monad (Data.Fold.R1.R1 a)
instance Control.Monad.Zip.MonadZip (Data.Fold.R1.R1 a)
instance Data.Semigroupoid.Semigroupoid Data.Fold.R1.R1
instance Control.Category.Category Data.Fold.R1.R1
instance Control.Arrow.Arrow Data.Fold.R1.R1
instance Data.Profunctor.Unsafe.Profunctor Data.Fold.R1.R1
instance Data.Profunctor.Strong Data.Fold.R1.R1
instance Data.Profunctor.Choice Data.Fold.R1.R1
instance Control.Arrow.ArrowChoice Data.Fold.R1.R1
instance Data.Profunctor.Closed.Closed Data.Fold.R1.R1
instance Data.Profunctor.Sieve.Cosieve Data.Fold.R1.R1 Data.List.NonEmpty.NonEmpty
instance Data.Profunctor.Costrong Data.Fold.R1.R1
instance Data.Profunctor.Rep.Corepresentable Data.Fold.R1.R1
instance Data.Distributive.Distributive (Data.Fold.R1.R1 a)
instance Data.Functor.Rep.Representable (Data.Fold.R1.R1 a)
instance Control.Monad.Reader.Class.MonadReader (Data.List.NonEmpty.NonEmpty a) (Data.Fold.R1.R1 a)
instance Control.Monad.Fix.MonadFix (Data.Fold.R1.R1 a)


module Data.Fold
class Choice p => Scan p where prefix1 = prefix . An postfix1 p = postfix p . An run1 = run . An
prefix1 :: Scan p => a -> p a b -> p a b
postfix1 :: Scan p => p a b -> a -> p a b

-- | Apply a <a>Folding</a> to a single element of input
run1 :: Scan p => a -> p a b -> b
interspersing :: Scan p => a -> p a b -> p a b
class Scan p => Folding p where prefix = prefixOf folded postfix = postfixOf folded run = runOf folded

-- | Partially apply a <a>Folding</a> to some initial input on the left.
prefix :: (Folding p, Foldable t) => t a -> p a b -> p a b
prefixOf :: Folding p => Fold s a -> s -> p a b -> p a b
postfix :: (Folding p, Foldable t) => p a b -> t a -> p a b
postfixOf :: Folding p => Fold s a -> p a b -> s -> p a b

-- | Apply a <a>Folding</a> to a container full of input:
--   
--   <pre>
--   &gt;&gt;&gt; run ["hello","world"] $ L id (++) []
--   "helloworld"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run [1,2,3] $ L id (+) 0
--   6
--   </pre>
run :: (Folding p, Foldable t) => t a -> p a b -> b
runOf :: Folding p => Fold s a -> s -> p a b -> b
filtering :: Folding p => (a -> Bool) -> p a b -> p a b

-- | Lift a <a>Folding</a> into a <a>Prism</a>.
--   
--   This acts like a generalized notion of "costrength", when applied to a
--   <a>Folding</a>, causing it to return the left-most value that fails to
--   match the Prism, or the result of accumulating rewrapped in the
--   <a>Prism</a> if everything matches.
--   
--   <pre>
--   &gt;&gt;&gt; run [Left 1, Left 2, Left 3] $ beneath _Left $ R id (+) 0
--   Left 6
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; run [Left 1, Right 2, Right 3] $ beneath _Left $ R id (+) 0
--   Right 2
--   </pre>
--   
--   <pre>
--   beneath :: Prism s t a b -&gt; p a b -&gt; p s t
--   beneath :: Iso s t a b   -&gt; p a b -&gt; p s t
--   </pre>
beneath :: Profunctor p => Optic p Identity s t a b -> p a b -> p s t

-- | A Mealy Machine
data L1 a b
L1 :: (c -> b) -> (c -> a -> c) -> (a -> c) -> L1 a b

-- | A strict Mealy Machine
data L1' a b
L1' :: (c -> b) -> (c -> a -> c) -> (a -> c) -> L1' a b

-- | A semigroup reducer
data M1 a b
M1 :: (m -> b) -> (a -> m) -> (m -> m -> m) -> M1 a b

-- | A reversed Mealy machine
data R1 a b
R1 :: (c -> b) -> (a -> c -> c) -> (a -> c) -> R1 a b

-- | A Moore Machine
data L a b
L :: (r -> b) -> (r -> a -> r) -> r -> L a b

-- | A strict left fold / strict Moore machine
data L' a b
L' :: (r -> b) -> (r -> a -> r) -> r -> L' a b

-- | A <a>foldMap</a> caught in amber. a.k.a. a monoidal reducer
data M a b
M :: (m -> b) -> (a -> m) -> (m -> m -> m) -> m -> M a b

-- | right folds / a reversed Moore machine
data R a b
R :: (r -> b) -> (a -> r -> r) -> r -> R a b
class AsRM1 p where asM1 = asM1 . asR1 asR1 = asR1 . asM1

-- | <a>asM1</a> is a scan homomorphism to a semigroup reducer
asM1 :: AsRM1 p => p a b -> M1 a b

-- | <a>asM1</a> is a scan homomorphism to a right scan
asR1 :: AsRM1 p => p a b -> R1 a b
class AsRM1 p => AsL1' p where asL1' = asL1' . asL'

-- | Scan homomorphism to a strict Mealy machine
asL1' :: AsL1' p => p a b -> L1' a b
class AsRM1 p => AsRM p where asM = asM . asR asR = asR . asM

-- | <a>asM</a> is a folding homomorphism to a monoidal folding
--   
--   <pre>
--   <a>run</a> xs (<a>asM</a> φ)         ≡ <a>run</a> xs φ
--   <a>prefix</a> xs (<a>asM</a> φ)      ≡ <a>asM</a> (<a>prefix</a> xs φ)
--   <a>prefixOf</a> l xs (<a>asM</a> φ)  ≡ <a>asM</a> (<a>prefixOf</a> l xs φ)
--   <a>postfix</a> (<a>asM</a> φ) xs     ≡ <a>asM</a> (<a>postfix</a> φ xs)
--   <a>postfixOf</a> l (<a>asM</a> φ) xs ≡ <a>asM</a> (<a>postfixOf</a> l φ xs)
--   <tt>left'</tt> (<a>asM</a> φ)          ≡ <a>asM</a> (<tt>left'</tt> φ)
--   <tt>right'</tt> (<a>asM</a> φ)         ≡ <a>asM</a> (<tt>right'</tt> φ)
--   <tt>dimap</tt> l r (<a>asM</a> φ)      ≡ <a>asM</a> (<tt>dimap</tt> l r φ)
--   <tt>extract</tt> (<a>asM</a> φ)        ≡ <tt>extract</tt> φ
--   <a>pure</a> a                  ≡ <a>asM</a> (<a>pure</a> a)
--   <a>asM</a> φ <a>&lt;*&gt;</a> <a>asM</a> ψ        ≡ <a>asM</a> (φ <a>&lt;*&gt;</a> ψ)
--   <a>return</a> a                ≡ <a>asM</a> (<a>return</a> a)
--   <a>asM</a> φ <a>&gt;&gt;=</a> <a>asM</a> . k      ≡ <a>asM</a> (φ <a>&gt;&gt;=</a> k)
--   <a>filtering</a> p (<a>asM</a> φ)     ≡ <a>asM</a> (<a>filtering</a> p φ)
--   <a>interspersing</a> a (<a>asM</a> φ) ≡ <a>asM</a> (<a>interspersing</a> a φ)
--   </pre>
asM :: AsRM p => p a b -> M a b

-- | <a>asR</a> is a folding homomorphism to a right folding
--   
--   <pre>
--   <a>run</a> xs (<a>asR</a> φ)         ≡ <a>run</a> xs φ
--   <a>prefix</a> xs (<a>asR</a> φ)      ≡ <a>asR</a> (<a>prefix</a> xs φ)
--   <a>prefixOf</a> l xs (<a>asR</a> φ)  ≡ <a>asR</a> (<a>prefixOf</a> l xs φ)
--   <a>postfix</a> (<a>asR</a> φ) xs     ≡ <a>asR</a> (<a>postfix</a> φ xs)
--   <a>postfixOf</a> l (<a>asR</a> φ) xs ≡ <a>asR</a> (<a>postfixOf</a> l φ xs)
--   <tt>left'</tt> (<a>asR</a> φ)          ≡ <a>asR</a> (<tt>left'</tt> φ)
--   <tt>right'</tt> (<a>asR</a> φ)         ≡ <a>asR</a> (<tt>right'</tt> φ)
--   <tt>dimap</tt> l r (<a>asR</a> φ)      ≡ <a>asR</a> (<tt>dimap</tt> l r φ)
--   <tt>extract</tt> (<a>asR</a> φ)        ≡ <tt>extract</tt> φ
--   <a>pure</a> a                  ≡ <a>asR</a> (<a>pure</a> a)
--   <a>asR</a> φ <a>&lt;*&gt;</a> <a>asR</a> ψ        ≡ <a>asR</a> (φ <a>&lt;*&gt;</a> ψ)
--   <a>return</a> a                ≡ <a>asR</a> (<a>return</a> a)
--   <a>asR</a> φ <a>&gt;&gt;=</a> <a>asR</a> . k      ≡ <a>asR</a> (φ <a>&gt;&gt;=</a> k)
--   <a>filtering</a> p (<a>asR</a> φ)     ≡ <a>asR</a> (<a>filtering</a> p φ)
--   <a>interspersing</a> a (<a>asR</a> φ) ≡ <a>asR</a> (<a>interspersing</a> a φ)
--   </pre>
asR :: AsRM p => p a b -> R a b
class (AsRM p, AsL1' p) => AsL' p

-- | <a>asL'</a> is a folding homomorphism to a strict left folding
--   
--   <pre>
--   <a>run</a> xs (<a>asL'</a> φ)         ≡ <a>run</a> xs φ
--   <a>prefix</a> xs (<a>asL'</a> φ)      ≡ <a>asL'</a> (<a>prefix</a> xs φ)
--   <a>prefixOf</a> l xs (<a>asL'</a> φ)  ≡ <a>asL'</a> (<a>prefixOf</a> l xs φ)
--   <a>postfix</a> (<a>asL'</a> φ) xs     ≡ <a>asL'</a> (<a>postfix</a> φ xs)
--   <a>postfixOf</a> l (<a>asL'</a> φ) xs ≡ <a>asL'</a> (<a>postfixOf</a> l φ xs)
--   <tt>left'</tt> (<a>asL'</a> φ)          ≡ <a>asL'</a> (<tt>left'</tt> φ)
--   <tt>right'</tt> (<a>asL'</a> φ)         ≡ <a>asL'</a> (<tt>right'</tt> φ)
--   <tt>dimap</tt> l r (<a>asL'</a> φ)      ≡ <a>asL'</a> (<tt>dimap</tt> l r φ)
--   <tt>extract</tt> (<a>asL'</a> φ)        ≡ <tt>extract</tt> φ
--   <a>pure</a> a                   ≡ <a>asL'</a> (<a>pure</a> a)
--   <a>asL'</a> φ <a>&lt;*&gt;</a> <a>asL'</a> ψ       ≡ <a>asL'</a> (φ <a>&lt;*&gt;</a> ψ)
--   <a>return</a> a                 ≡ <a>asL'</a> (<a>return</a> a)
--   <a>asL'</a> φ <a>&gt;&gt;=</a> <a>asL'</a> . k     ≡ <a>asL'</a> (φ <a>&gt;&gt;=</a> k)
--   <a>filtering</a> p (<a>asL'</a> φ)     ≡ <a>asL'</a> (<a>filtering</a> p φ)
--   <a>interspersing</a> a (<a>asL'</a> φ) ≡ <a>asL'</a> (<a>interspersing</a> a φ)
--   </pre>
asL' :: AsL' p => p a b -> L' a b
instance Data.Fold.AsRM1 Data.Fold.L.L
instance Data.Fold.AsRM1 Data.Fold.L'.L'
instance Data.Fold.AsRM1 Data.Fold.L1.L1
instance Data.Fold.AsRM1 Data.Fold.L1'.L1'
instance Data.Fold.AsRM1 Data.Fold.M.M
instance Data.Fold.AsRM1 Data.Fold.M1.M1
instance Data.Fold.AsRM1 Data.Fold.R.R
instance Data.Fold.AsRM1 Data.Fold.R1.R1
instance Data.Fold.AsRM Data.Fold.R.R
instance Data.Fold.AsRM Data.Fold.M.M
instance Data.Fold.AsRM Data.Fold.L.L
instance Data.Fold.AsRM Data.Fold.L'.L'
instance Data.Fold.AsL1' Data.Fold.L1'.L1'
instance Data.Fold.AsL1' Data.Fold.L1.L1
instance Data.Fold.AsL1' Data.Fold.L.L
instance Data.Fold.AsL1' Data.Fold.L'.L'
instance Data.Fold.AsL' Data.Fold.L'.L'
instance Data.Fold.AsL' Data.Fold.L.L