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


-- | A backtracking logic-programming monad with asymptotic improvements to msplit
--   
--   Adapted from the paper <a>http://okmij.org/ftp/Haskell/zseq.pdf</a> by
--   Atze van der Ploeg and Oleg Kiselyov
@package logict-sequence
@version 0.2


-- | It's safe to coerce <i>to</i> <a>Any</a> as long as you don't coerce
--   back. We define our own <a>Any</a> instead of using the one in
--   <a>GHC.Exts</a> directly to ensure that this module doesn't clash with
--   one making the opposite assumption. We use a newtype rather than a
--   closed type family with no instances because the latter weren't
--   supported until 8.0.
module Control.Monad.Logic.Sequence.Internal.Any
data Any

-- | Convert a list of anything to a list of <a>Any</a>.
toAnyList :: [a] -> [Any]


-- | A sequence, a queue, with worst case constant time: <tt>|&gt;</tt>,
--   and <tt>viewl</tt>.
--   
--   Based on: "Simple and Efficient Purely Functional Queues and Deques",
--   Chris Okasaki, Journal of Functional Programming 1995
module Control.Monad.Logic.Sequence.Internal.ScheduledQueue

-- | A scheduled Banker's Queue, as described by Okasaki.
data Queue a
instance GHC.Base.Functor Control.Monad.Logic.Sequence.Internal.ScheduledQueue.SL
instance GHC.Base.Functor Control.Monad.Logic.Sequence.Internal.ScheduledQueue.Queue
instance Data.SequenceClass.Sequence Control.Monad.Logic.Sequence.Internal.ScheduledQueue.Queue
instance Data.Foldable.Foldable Control.Monad.Logic.Sequence.Internal.ScheduledQueue.Queue
instance Data.Traversable.Traversable Control.Monad.Logic.Sequence.Internal.ScheduledQueue.Queue

module Control.Monad.Logic.Sequence.Internal.Queue

-- | Based on the LogicT improvements in the paper, Reflection without
--   Remorse. Code is based on the code provided in:
--   <a>https://github.com/atzeus/reflectionwithoutremorse</a>
--   
--   Note: that code is provided under an MIT license, so we use that as
--   well.
data Queue a
instance Data.Traversable.Traversable Control.Monad.Logic.Sequence.Internal.Queue.Queue
instance Data.Foldable.Foldable Control.Monad.Logic.Sequence.Internal.Queue.Queue
instance GHC.Base.Functor Control.Monad.Logic.Sequence.Internal.Queue.Queue
instance Data.SequenceClass.Sequence Control.Monad.Logic.Sequence.Internal.Queue.Queue
instance GHC.Base.Semigroup (Control.Monad.Logic.Sequence.Internal.Queue.Queue a)
instance GHC.Base.Monoid (Control.Monad.Logic.Sequence.Internal.Queue.Queue a)


-- | Based on the LogicT improvements in the paper, Reflection without
--   Remorse. Code is based on the code provided in:
--   <a>https://github.com/atzeus/reflectionwithoutremorse</a>
--   
--   Note: that code is provided under an MIT license, so we use that as
--   well.
module Control.Monad.Logic.Sequence.Internal

-- | An asymptotically efficient logic monad transformer. It is generally
--   best to think of this as being defined
--   
--   <pre>
--   newtype SeqT m a = <a>MkSeqT</a> { <a>getSeqT</a> :: m (<a>ViewT</a> m a) }
--   </pre>
--   
--   Using the <a>MkSeqT</a> pattern synonym with <a>getSeqT</a>, you can
--   (almost) pretend it's really defined this way! However, the real
--   implementation is different, so as to be more efficient in the face of
--   deeply left-associated <a>&lt;|&gt;</a> or <a>mplus</a> applications.
newtype SeqT m a
SeqT :: Queue (m (ViewT m a)) -> SeqT m a
pattern MkSeqT :: Monad m => m (ViewT m a) -> SeqT m a

-- | A specialization of <a>SeqT</a> to the <a>Identity</a> monad. You can
--   imagine that this is defined
--   
--   <pre>
--   newtype Seq a = MkSeq { getSeq :: ViewT Identity a }
--   </pre>
--   
--   Using the <a>MkSeq</a> pattern synonym with <a>getSeq</a>, you can
--   pretend it's really defined this way! However, the real implementation
--   is different, so as to be more efficient in the face of deeply
--   left-associated <a>&lt;|&gt;</a> or <a>mplus</a> applications.
type Seq = SeqT Identity
pattern MkSeq :: View a -> Seq a
getSeq :: Seq a -> View a

-- | A view of the front end of a <a>SeqT</a>.
data ViewT m a
Empty :: ViewT m a
(:<) :: a -> SeqT m a -> ViewT m a
infixl 5 :<
type View = ViewT Identity

-- | A catamorphism for <a>ViewT</a>s
viewT :: b -> (a -> SeqT m a -> b) -> ViewT m a -> b

-- | A catamorphism for <a>View</a>s. Note that this is just a
--   type-restricted version of <a>viewT</a>.
view :: b -> (a -> Seq a -> b) -> View a -> b
toViewT :: Monad m => SeqT m a -> m (ViewT m a)
toView :: forall a. Seq a -> View a
fromViewT :: m (ViewT m a) -> SeqT m a
fromView :: forall a. View a -> Seq a

-- | Perform all the actions in a <a>SeqT</a> and gather the results.
observeAllT :: Monad m => SeqT m a -> m [a]

-- | Get all the results in a <a>Seq</a>.
observeAll :: Seq a -> [a]

-- | <tt>observeManyT n s</tt> performs actions in <tt>s</tt> until it
--   produces <tt>n</tt> results or terminates. All the gathered results
--   are returned.
observeManyT :: Monad m => Int -> SeqT m a -> m [a]

-- | <tt>observeMany n s</tt> gets up to <tt>n</tt> results from a
--   <a>Seq</a>.
observeMany :: Int -> Seq a -> [a]

-- | Perform actions in a <a>SeqT</a> until one of them produces a result.
--   Returns <a>Nothing</a> if there are no results.
observeT :: Monad m => SeqT m a -> m (Maybe a)

-- | Get the first result in a <a>Seq</a>, if there is one.
observe :: Seq a -> Maybe a

-- | Convert <tt><a>SeqT</a> m a</tt> to <tt>t m a</tt> when <tt>t</tt> is
--   some other logic monad transformer.
fromSeqT :: (Monad m, Monad (t m), MonadTrans t, Alternative (t m)) => SeqT m a -> t m a

-- | This function is the implementation of <a>hoist</a> for <a>SeqT</a>.
--   The passed function is required to be a monad morphism.
hoistPre :: Monad m => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | A version of <a>hoist</a> that uses the <a>Monad</a> instance for
--   <tt>n</tt> rather than for <tt>m</tt>. Like <tt>hoist</tt>, the passed
--   function is required to be a monad morphism.
hoistPost :: Monad n => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | A version of <a>hoist</a> that works for arbitrary functions, rather
--   than just monad morphisms.
hoistPreUnexposed :: forall m n a. Monad m => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | A version of <a>hoistPost</a> that works for arbitrary functions,
--   rather than just monad morphisms. This should be preferred when the
--   <a>Monad</a> instance for <tt>n</tt> is less expensive than that for
--   <tt>m</tt>.
hoistPostUnexposed :: forall m n a. (Monad m, Monad n) => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | Convert <tt><a>SeqT</a> m a</tt> to <tt><a>LogicT</a> m a</tt>.
--   
--   <pre>
--   toLogicT = <a>fromSeqT</a>
--   </pre>
toLogicT :: Monad m => SeqT m a -> LogicT m a
fromLogicT :: Monad m => LogicT m a -> SeqT m a

-- | <pre>
--   cons a s = pure a <a>|</a> s
--   </pre>
cons :: Monad m => a -> SeqT m a -> SeqT m a

-- | <pre>
--   consM m s = lift m <a>|</a> s
--   </pre>
consM :: Monad m => m a -> SeqT m a -> SeqT m a

-- | <pre>
--   choose = foldr (a s -&gt; pure a <a>|</a> s) empty
--   </pre>
--   
--   <pre>
--   choose :: Monad m =&gt; [a] -&gt; SeqT m a
--   </pre>
choose :: (Foldable t, Monad m) => t a -> SeqT m a

-- | <pre>
--   chooseM = foldr (ma s -&gt; lift ma <a>|</a> s) empty
--   </pre>
--   
--   <pre>
--   chooseM :: Monad m =&gt; [m a] -&gt; SeqT m a
--   </pre>
chooseM :: (Foldable t, Monad m) => t (m a) -> SeqT m a
instance GHC.Generics.Generic (Control.Monad.Logic.Sequence.Internal.ViewT m a)
instance (GHC.Show.Show a, GHC.Show.Show (Control.Monad.Logic.Sequence.Internal.SeqT m a)) => GHC.Show.Show (Control.Monad.Logic.Sequence.Internal.ViewT m a)
instance (GHC.Read.Read a, GHC.Read.Read (Control.Monad.Logic.Sequence.Internal.SeqT m a)) => GHC.Read.Read (Control.Monad.Logic.Sequence.Internal.ViewT m a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (Control.Monad.Logic.Sequence.Internal.SeqT m a)) => GHC.Classes.Eq (Control.Monad.Logic.Sequence.Internal.ViewT m a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord (Control.Monad.Logic.Sequence.Internal.SeqT m a)) => GHC.Classes.Ord (Control.Monad.Logic.Sequence.Internal.ViewT m a)
instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (GHC.Base.Monad m, Data.Foldable.Foldable m) => Data.Foldable.Foldable (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (GHC.Base.Monad m, Data.Traversable.Traversable m) => Data.Traversable.Traversable (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (Data.Functor.Classes.Eq1 m, GHC.Base.Monad m) => Data.Functor.Classes.Eq1 (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (Data.Functor.Classes.Ord1 m, GHC.Base.Monad m) => Data.Functor.Classes.Ord1 (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (Data.Functor.Classes.Show1 m, GHC.Base.Monad m) => Data.Functor.Classes.Show1 (Control.Monad.Logic.Sequence.Internal.ViewT m)
instance (GHC.Show.Show (m (Control.Monad.Logic.Sequence.Internal.ViewT m a)), GHC.Base.Monad m) => GHC.Show.Show (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance GHC.Read.Read (m (Control.Monad.Logic.Sequence.Internal.ViewT m a)) => GHC.Read.Read (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (m (Control.Monad.Logic.Sequence.Internal.ViewT m a)), GHC.Base.Monad m) => GHC.Classes.Eq (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord (m (Control.Monad.Logic.Sequence.Internal.ViewT m a)), GHC.Base.Monad m) => GHC.Classes.Ord (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance (Data.Functor.Classes.Eq1 m, GHC.Base.Monad m) => Data.Functor.Classes.Eq1 (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance (Data.Functor.Classes.Ord1 m, GHC.Base.Monad m) => Data.Functor.Classes.Ord1 (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance (Data.Functor.Classes.Show1 m, GHC.Base.Monad m) => Data.Functor.Classes.Show1 (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.Alternative (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.MonadPlus (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance GHC.Base.Monad m => GHC.Base.Semigroup (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance GHC.Base.Monad m => GHC.Base.Monoid (Control.Monad.Logic.Sequence.Internal.SeqT m a)
instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Logic.Sequence.Internal.SeqT
instance GHC.Base.Monad m => Control.Monad.Logic.Class.MonadLogic (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance (GHC.Base.Monad m, Data.Foldable.Foldable m) => Data.Foldable.Foldable (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance (GHC.Base.Monad m, Data.Traversable.Traversable m) => Data.Traversable.Traversable (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance Control.Monad.Morph.MFunctor Control.Monad.Logic.Sequence.Internal.SeqT
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance Control.Monad.Reader.Class.MonadReader e m => Control.Monad.Reader.Class.MonadReader e (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Logic.Sequence.Internal.SeqT m)
instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Logic.Sequence.Internal.SeqT m)

module Control.Monad.Logic.Sequence.Compat

-- | Convert <tt><a>SeqT</a> m a</tt> to <tt>t m a</tt> when <tt>t</tt> is
--   some other logic monad transformer.
fromSeqT :: (Monad m, Monad (t m), MonadTrans t, Alternative (t m)) => SeqT m a -> t m a

-- | Convert <tt><a>SeqT</a> m a</tt> to <tt><a>LogicT</a> m a</tt>.
--   
--   <pre>
--   toLogicT = <a>fromSeqT</a>
--   </pre>
toLogicT :: Monad m => SeqT m a -> LogicT m a
fromLogicT :: Monad m => LogicT m a -> SeqT m a
observeT :: MonadFail m => SeqT m a -> m a
observe :: Seq a -> a

module Control.Monad.Logic.Sequence

-- | An asymptotically efficient logic monad transformer. It is generally
--   best to think of this as being defined
--   
--   <pre>
--   newtype SeqT m a = <a>MkSeqT</a> { <a>getSeqT</a> :: m (<a>ViewT</a> m a) }
--   </pre>
--   
--   Using the <a>MkSeqT</a> pattern synonym with <a>getSeqT</a>, you can
--   (almost) pretend it's really defined this way! However, the real
--   implementation is different, so as to be more efficient in the face of
--   deeply left-associated <a>&lt;|&gt;</a> or <a>mplus</a> applications.
data SeqT m a
pattern MkSeqT :: Monad m => m (ViewT m a) -> SeqT m a

-- | A specialization of <a>SeqT</a> to the <a>Identity</a> monad. You can
--   imagine that this is defined
--   
--   <pre>
--   newtype Seq a = MkSeq { getSeq :: ViewT Identity a }
--   </pre>
--   
--   Using the <a>MkSeq</a> pattern synonym with <a>getSeq</a>, you can
--   pretend it's really defined this way! However, the real implementation
--   is different, so as to be more efficient in the face of deeply
--   left-associated <a>&lt;|&gt;</a> or <a>mplus</a> applications.
type Seq = SeqT Identity
pattern MkSeq :: View a -> Seq a
getSeq :: Seq a -> View a

-- | A view of the front end of a <a>SeqT</a>.
data ViewT m a
Empty :: ViewT m a
(:<) :: a -> SeqT m a -> ViewT m a
infixl 5 :<
type View = ViewT Identity

-- | A catamorphism for <a>ViewT</a>s
viewT :: b -> (a -> SeqT m a -> b) -> ViewT m a -> b

-- | A catamorphism for <a>View</a>s. Note that this is just a
--   type-restricted version of <a>viewT</a>.
view :: b -> (a -> Seq a -> b) -> View a -> b
toViewT :: Monad m => SeqT m a -> m (ViewT m a)
toView :: forall a. Seq a -> View a
fromViewT :: m (ViewT m a) -> SeqT m a
fromView :: forall a. View a -> Seq a

-- | <pre>
--   cons a s = pure a <a>|</a> s
--   </pre>
cons :: Monad m => a -> SeqT m a -> SeqT m a

-- | <pre>
--   consM m s = lift m <a>|</a> s
--   </pre>
consM :: Monad m => m a -> SeqT m a -> SeqT m a

-- | <pre>
--   choose = foldr (a s -&gt; pure a <a>|</a> s) empty
--   </pre>
--   
--   <pre>
--   choose :: Monad m =&gt; [a] -&gt; SeqT m a
--   </pre>
choose :: (Foldable t, Monad m) => t a -> SeqT m a

-- | <pre>
--   chooseM = foldr (ma s -&gt; lift ma <a>|</a> s) empty
--   </pre>
--   
--   <pre>
--   chooseM :: Monad m =&gt; [m a] -&gt; SeqT m a
--   </pre>
chooseM :: (Foldable t, Monad m) => t (m a) -> SeqT m a

-- | Perform all the actions in a <a>SeqT</a> and gather the results.
observeAllT :: Monad m => SeqT m a -> m [a]

-- | Get all the results in a <a>Seq</a>.
observeAll :: Seq a -> [a]

-- | <tt>observeManyT n s</tt> performs actions in <tt>s</tt> until it
--   produces <tt>n</tt> results or terminates. All the gathered results
--   are returned.
observeManyT :: Monad m => Int -> SeqT m a -> m [a]

-- | <tt>observeMany n s</tt> gets up to <tt>n</tt> results from a
--   <a>Seq</a>.
observeMany :: Int -> Seq a -> [a]

-- | Perform actions in a <a>SeqT</a> until one of them produces a result.
--   Returns <a>Nothing</a> if there are no results.
observeT :: Monad m => SeqT m a -> m (Maybe a)

-- | Get the first result in a <a>Seq</a>, if there is one.
observe :: Seq a -> Maybe a


-- | This module provides functions for changing the underlying monad of a
--   <a>SeqT</a>, just like <a>Control.Monad.Morph</a>.<a>hoist</a>.
--   
--   The functions with the word "Pre" in their names lean on the
--   <a>Monad</a> instance of the original monad. The ones with the word
--   "Post" in their names lean on the <a>Monad</a> instance of the target
--   monad. The ones with the word "Unexposed" in their names are
--   reasonably well-behaved when the passed function is not a monad
--   morphism (as described in the <a>Control.Monad.Morph</a>
--   documentation). The others are typically a little more efficient, but
--   may behave strangely when passed non-monad-morphisms. In particular,
--   if <tt>f</tt> is not a monad morphism, and <tt>s1 == s2</tt>, we do
--   not even guarantee that <tt><a>hoistPre</a> f s1 == <a>hoistPre</a> f
--   s2</tt>.
module Control.Monad.Logic.Sequence.Morph

-- | A version of <a>hoist</a> that works for arbitrary functions, rather
--   than just monad morphisms.
hoistPreUnexposed :: forall m n a. Monad m => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | A version of <a>hoist</a> that uses the <a>Monad</a> instance for
--   <tt>n</tt> rather than for <tt>m</tt>. Like <tt>hoist</tt>, the passed
--   function is required to be a monad morphism.
hoistPost :: Monad n => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | A version of <a>hoistPost</a> that works for arbitrary functions,
--   rather than just monad morphisms. This should be preferred when the
--   <a>Monad</a> instance for <tt>n</tt> is less expensive than that for
--   <tt>m</tt>.
hoistPostUnexposed :: forall m n a. (Monad m, Monad n) => (forall x. m x -> n x) -> SeqT m a -> SeqT n a

-- | This function is the implementation of <a>hoist</a> for <a>SeqT</a>.
--   The passed function is required to be a monad morphism.
hoistPre :: Monad m => (forall x. m x -> n x) -> SeqT m a -> SeqT n a