logict-sequence-0.2.0.1: A backtracking logic-programming monad with asymptotic improvements to msplit
Safe HaskellSafe
LanguageHaskell2010

Control.Monad.Logic.Sequence

Synopsis

Documentation

data SeqT m a where Source #

An asymptotically efficient logic monad transformer. It is generally best to think of this as being defined

newtype SeqT m a = MkSeqT { getSeqT :: m (ViewT m a) }

Using the MkSeqT pattern synonym with getSeqT, 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 <|> or mplus applications.

Bundled Patterns

pattern MkSeqT :: Monad m => m (ViewT m a) -> SeqT m a 

Instances

Instances details
MonadTrans SeqT Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

lift :: Monad m => m a -> SeqT m a #

MFunctor SeqT Source #

hoist is hoistPre.

Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> SeqT m b -> SeqT n b #

MonadError e m => MonadError e (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

throwError :: e -> SeqT m a #

catchError :: SeqT m a -> (e -> SeqT m a) -> SeqT m a #

MonadReader e m => MonadReader e (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

ask :: SeqT m e #

local :: (e -> e) -> SeqT m a -> SeqT m a #

reader :: (e -> a) -> SeqT m a #

MonadState s m => MonadState s (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

get :: SeqT m s #

put :: s -> SeqT m () #

state :: (s -> (a, s)) -> SeqT m a #

Monad m => MonadFail (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fail :: String -> SeqT m a #

MonadIO m => MonadIO (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftIO :: IO a -> SeqT m a #

MonadZip m => MonadZip (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

mzip :: SeqT m a -> SeqT m b -> SeqT m (a, b) #

mzipWith :: (a -> b -> c) -> SeqT m a -> SeqT m b -> SeqT m c #

munzip :: SeqT m (a, b) -> (SeqT m a, SeqT m b) #

(Monad m, Foldable m) => Foldable (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fold :: Monoid m0 => SeqT m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> SeqT m a -> m0 #

foldMap' :: Monoid m0 => (a -> m0) -> SeqT m a -> m0 #

foldr :: (a -> b -> b) -> b -> SeqT m a -> b #

foldr' :: (a -> b -> b) -> b -> SeqT m a -> b #

foldl :: (b -> a -> b) -> b -> SeqT m a -> b #

foldl' :: (b -> a -> b) -> b -> SeqT m a -> b #

foldr1 :: (a -> a -> a) -> SeqT m a -> a #

foldl1 :: (a -> a -> a) -> SeqT m a -> a #

toList :: SeqT m a -> [a] #

null :: SeqT m a -> Bool #

length :: SeqT m a -> Int #

elem :: Eq a => a -> SeqT m a -> Bool #

maximum :: Ord a => SeqT m a -> a #

minimum :: Ord a => SeqT m a -> a #

sum :: Num a => SeqT m a -> a #

product :: Num a => SeqT m a -> a #

(Eq1 m, Monad m) => Eq1 (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftEq :: (a -> b -> Bool) -> SeqT m a -> SeqT m b -> Bool #

(Ord1 m, Monad m) => Ord1 (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftCompare :: (a -> b -> Ordering) -> SeqT m a -> SeqT m b -> Ordering #

(Show1 m, Monad m) => Show1 (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SeqT m a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SeqT m a] -> ShowS #

(Monad m, Traversable m) => Traversable (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> SeqT m a -> f (SeqT m b) #

sequenceA :: Applicative f => SeqT m (f a) -> f (SeqT m a) #

mapM :: Monad m0 => (a -> m0 b) -> SeqT m a -> m0 (SeqT m b) #

sequence :: Monad m0 => SeqT m (m0 a) -> m0 (SeqT m a) #

Monad m => Alternative (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

empty :: SeqT m a #

(<|>) :: SeqT m a -> SeqT m a -> SeqT m a #

some :: SeqT m a -> SeqT m [a] #

many :: SeqT m a -> SeqT m [a] #

Monad m => Applicative (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

pure :: a -> SeqT m a #

(<*>) :: SeqT m (a -> b) -> SeqT m a -> SeqT m b #

liftA2 :: (a -> b -> c) -> SeqT m a -> SeqT m b -> SeqT m c #

(*>) :: SeqT m a -> SeqT m b -> SeqT m b #

(<*) :: SeqT m a -> SeqT m b -> SeqT m a #

Monad m => Functor (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fmap :: (a -> b) -> SeqT m a -> SeqT m b #

(<$) :: a -> SeqT m b -> SeqT m a #

Monad m => Monad (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

(>>=) :: SeqT m a -> (a -> SeqT m b) -> SeqT m b #

(>>) :: SeqT m a -> SeqT m b -> SeqT m b #

return :: a -> SeqT m a #

Monad m => MonadPlus (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

mzero :: SeqT m a #

mplus :: SeqT m a -> SeqT m a -> SeqT m a #

Monad m => MonadLogic (SeqT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

msplit :: SeqT m a -> SeqT m (Maybe (a, SeqT m a)) #

interleave :: SeqT m a -> SeqT m a -> SeqT m a #

(>>-) :: SeqT m a -> (a -> SeqT m b) -> SeqT m b #

once :: SeqT m a -> SeqT m a #

lnot :: SeqT m a -> SeqT m () #

ifte :: SeqT m a -> (a -> SeqT m b) -> SeqT m b -> SeqT m b #

Monad m => Monoid (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

mempty :: SeqT m a #

mappend :: SeqT m a -> SeqT m a -> SeqT m a #

mconcat :: [SeqT m a] -> SeqT m a #

Monad m => Semigroup (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

(<>) :: SeqT m a -> SeqT m a -> SeqT m a #

sconcat :: NonEmpty (SeqT m a) -> SeqT m a #

stimes :: Integral b => b -> SeqT m a -> SeqT m a #

Read (m (ViewT m a)) => Read (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

readsPrec :: Int -> ReadS (SeqT m a) #

readList :: ReadS [SeqT m a] #

readPrec :: ReadPrec (SeqT m a) #

readListPrec :: ReadPrec [SeqT m a] #

(Show (m (ViewT m a)), Monad m) => Show (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

showsPrec :: Int -> SeqT m a -> ShowS #

show :: SeqT m a -> String #

showList :: [SeqT m a] -> ShowS #

(Eq a, Eq (m (ViewT m a)), Monad m) => Eq (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

(==) :: SeqT m a -> SeqT m a -> Bool #

(/=) :: SeqT m a -> SeqT m a -> Bool #

(Ord a, Ord (m (ViewT m a)), Monad m) => Ord (SeqT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

compare :: SeqT m a -> SeqT m a -> Ordering #

(<) :: SeqT m a -> SeqT m a -> Bool #

(<=) :: SeqT m a -> SeqT m a -> Bool #

(>) :: SeqT m a -> SeqT m a -> Bool #

(>=) :: SeqT m a -> SeqT m a -> Bool #

max :: SeqT m a -> SeqT m a -> SeqT m a #

min :: SeqT m a -> SeqT m a -> SeqT m a #

type Seq = SeqT Identity Source #

A specialization of SeqT to the Identity monad. You can imagine that this is defined

newtype Seq a = MkSeq { getSeq :: ViewT Identity a }

Using the MkSeq pattern synonym with getSeq, 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 <|> or mplus applications.

pattern MkSeq :: View a -> Seq a Source #

getSeq :: Seq a -> View a Source #

data ViewT m a Source #

A view of the front end of a SeqT.

Constructors

Empty 
a :< (SeqT m a) infixl 5 

Instances

Instances details
(Monad m, Foldable m) => Foldable (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fold :: Monoid m0 => ViewT m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> ViewT m a -> m0 #

foldMap' :: Monoid m0 => (a -> m0) -> ViewT m a -> m0 #

foldr :: (a -> b -> b) -> b -> ViewT m a -> b #

foldr' :: (a -> b -> b) -> b -> ViewT m a -> b #

foldl :: (b -> a -> b) -> b -> ViewT m a -> b #

foldl' :: (b -> a -> b) -> b -> ViewT m a -> b #

foldr1 :: (a -> a -> a) -> ViewT m a -> a #

foldl1 :: (a -> a -> a) -> ViewT m a -> a #

toList :: ViewT m a -> [a] #

null :: ViewT m a -> Bool #

length :: ViewT m a -> Int #

elem :: Eq a => a -> ViewT m a -> Bool #

maximum :: Ord a => ViewT m a -> a #

minimum :: Ord a => ViewT m a -> a #

sum :: Num a => ViewT m a -> a #

product :: Num a => ViewT m a -> a #

(Eq1 m, Monad m) => Eq1 (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftEq :: (a -> b -> Bool) -> ViewT m a -> ViewT m b -> Bool #

(Ord1 m, Monad m) => Ord1 (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftCompare :: (a -> b -> Ordering) -> ViewT m a -> ViewT m b -> Ordering #

(Show1 m, Monad m) => Show1 (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ViewT m a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ViewT m a] -> ShowS #

(Monad m, Traversable m) => Traversable (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

traverse :: Applicative f => (a -> f b) -> ViewT m a -> f (ViewT m b) #

sequenceA :: Applicative f => ViewT m (f a) -> f (ViewT m a) #

mapM :: Monad m0 => (a -> m0 b) -> ViewT m a -> m0 (ViewT m b) #

sequence :: Monad m0 => ViewT m (m0 a) -> m0 (ViewT m a) #

Monad m => Functor (ViewT m) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewT m a -> ViewT m b #

(<$) :: a -> ViewT m b -> ViewT m a #

Generic (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Associated Types

type Rep (ViewT m a) :: Type -> Type #

Methods

from :: ViewT m a -> Rep (ViewT m a) x #

to :: Rep (ViewT m a) x -> ViewT m a #

(Read a, Read (SeqT m a)) => Read (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

(Show a, Show (SeqT m a)) => Show (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

showsPrec :: Int -> ViewT m a -> ShowS #

show :: ViewT m a -> String #

showList :: [ViewT m a] -> ShowS #

(Eq a, Eq (SeqT m a)) => Eq (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

(==) :: ViewT m a -> ViewT m a -> Bool #

(/=) :: ViewT m a -> ViewT m a -> Bool #

(Ord a, Ord (SeqT m a)) => Ord (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

Methods

compare :: ViewT m a -> ViewT m a -> Ordering #

(<) :: ViewT m a -> ViewT m a -> Bool #

(<=) :: ViewT m a -> ViewT m a -> Bool #

(>) :: ViewT m a -> ViewT m a -> Bool #

(>=) :: ViewT m a -> ViewT m a -> Bool #

max :: ViewT m a -> ViewT m a -> ViewT m a #

min :: ViewT m a -> ViewT m a -> ViewT m a #

type Rep (ViewT m a) Source # 
Instance details

Defined in Control.Monad.Logic.Sequence.Internal

type Rep (ViewT m a) = D1 ('MetaData "ViewT" "Control.Monad.Logic.Sequence.Internal" "logict-sequence-0.2.0.1-4fqFdbP4tNv6bY7HLdCqTR" 'False) (C1 ('MetaCons "Empty" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons ":<" ('InfixI 'LeftAssociative 5) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SeqT m a))))

viewT :: b -> (a -> SeqT m a -> b) -> ViewT m a -> b Source #

A catamorphism for ViewTs

view :: b -> (a -> Seq a -> b) -> View a -> b Source #

A catamorphism for Views. Note that this is just a type-restricted version of viewT.

toViewT :: Monad m => SeqT m a -> m (ViewT m a) Source #

toView :: forall a. Seq a -> View a Source #

fromViewT :: m (ViewT m a) -> SeqT m a Source #

fromView :: forall a. View a -> Seq a Source #

cons :: Monad m => a -> SeqT m a -> SeqT m a Source #

cons a s = pure a | s

consM :: Monad m => m a -> SeqT m a -> SeqT m a Source #

consM m s = lift m | s

choose :: (Foldable t, Monad m) => t a -> SeqT m a Source #

choose = foldr (a s -> pure a | s) empty
choose :: Monad m => [a] -> SeqT m a

chooseM :: (Foldable t, Monad m) => t (m a) -> SeqT m a Source #

chooseM = foldr (ma s -> lift ma | s) empty
chooseM :: Monad m => [m a] -> SeqT m a

observeAllT :: Monad m => SeqT m a -> m [a] Source #

Perform all the actions in a SeqT and gather the results.

observeAll :: Seq a -> [a] Source #

Get all the results in a Seq.

observeManyT :: Monad m => Int -> SeqT m a -> m [a] Source #

observeManyT n s performs actions in s until it produces n results or terminates. All the gathered results are returned.

observeMany :: Int -> Seq a -> [a] Source #

observeMany n s gets up to n results from a Seq.

observeT :: Monad m => SeqT m a -> m (Maybe a) Source #

Perform actions in a SeqT until one of them produces a result. Returns Nothing if there are no results.

observe :: Seq a -> Maybe a Source #

Get the first result in a Seq, if there is one.