Control.Monad.Logic.Sequence

Documentation

data SeqT m a where

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

MonadTrans SeqT

Defined in Control.Monad.Logic.Sequence.Internal

Methods

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

MFunctor SeqT

hoist is hoistPre.

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)

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)

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)

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)

Defined in Control.Monad.Logic.Sequence.Internal

Methods

fail :: String -> SeqT m a

MonadIO m => MonadIO (SeqT m)

Defined in Control.Monad.Logic.Sequence.Internal

Methods

liftIO :: IO a -> SeqT m a

MonadZip m => MonadZip (SeqT m)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

getSeq :: Seq a -> View a

data ViewT m a

A view of the front end of a SeqT.

Constructors

Empty

a :< (SeqT m a) infixl 5

Instances

(Monad m, Foldable m) => Foldable (ViewT m)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Logic.Sequence.Internal

Methods

readsPrec :: Int -> ReadS (ViewT m a)

readList :: ReadS [ViewT m a]

readPrec :: ReadPrec (ViewT m a)

readListPrec :: ReadPrec [ViewT m a]

(Show a, Show (SeqT m a)) => Show (ViewT m a)

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)

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)

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)

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.2-7cNyMP86HzmGU2N4KULIVf" '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))))

type View = ViewT Identity

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

A catamorphism for ViewTs

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

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)

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

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

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

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

cons a s = pure a | s

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

consM m s = lift m | s

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

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

chooseM = foldr (ma s -> lift ma | s) empty

chooseM :: Monad m => [m a] -> SeqT m a

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

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

observeAll :: Seq a -> [a]

Get all the results in a Seq.

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

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]

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

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

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

observe :: Seq a -> Maybe a

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

module Control.Monad

module Control.Monad.Trans