logict-0.6.0.2: A backtracking logic-programming monad.

Copyright | (c) Dan Doel
License | BSD3
Maintainer | dan.doel@gmail.com
Stability | experimental
Portability | non-portable (multi-parameter type classes)
Safe Haskell | Safe
Language | Haskell98

Control.Monad.Logic.Class

Description

A backtracking, logic programming monad.

Adapted from the paper /Backtracking, Interleaving, and Terminating Monad Transformers/, by Oleg Kiselyov, Chung-chieh Shan, Daniel P. Friedman, Amr Sabry (http://www.cs.rutgers.edu/~ccshan/logicprog/LogicT-icfp2005.pdf)

Synopsis

- class MonadPlus m => MonadLogic m where
- reflect :: MonadLogic m => Maybe (a, m a) -> m a
- lnot :: MonadLogic m => m a -> m ()

# Documentation

class MonadPlus m => MonadLogic m where #

Minimal implementation: msplit

Minimal complete definition

msplit

Methods

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

Attempts to split the computation, giving access to the first result. Satisfies the following laws:

    msplit mzero                == return Nothing
    msplit (return a `mplus` m) == return (Just (a, m))

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

Fair disjunction. It is possible for a logical computation to have an infinite number of potential results, for instance:

    odds = return 1 `mplus` liftM (2+) odds

Such computations can cause problems in some circumstances. Consider:

    do x <- odds `mplus` return 2
       if even x then return x else mzero

Such a computation may never consider the 'return 2', and will therefore never terminate. By contrast, interleave ensures fair consideration of both branches of a disjunction

(>>-) :: m a -> (a -> m b) -> m b infixl 1 #

Fair conjunction. Similarly to the previous function, consider the distributivity law for MonadPlus:

    (mplus a b) >>= k = (a >>= k) `mplus` (b >>= k)

If 'a >>= k' can backtrack arbitrarily many tmes, (b >>= k) may never be considered. (>>-) takes similar care to consider both branches of a disjunctive computation.

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

Logical conditional. The equivalent of Prolog's soft-cut. If its first argument succeeds at all, then the results will be fed into the success branch. Otherwise, the failure branch is taken. satisfies the following laws:

    ifte (return a) th el           == th a
    ifte mzero th el                == el
    ifte (return a `mplus` m) th el == th a `mplus` (m >>= th)

once :: m a -> m a #

Pruning. Selects one result out of many. Useful for when multiple results of a computation will be equivalent, or should be treated as such.

Instances

MonadLogic [] # |
Methods msplit :: [a] -> [Maybe (a, [a])] # interleave :: [a] -> [a] -> [a] # (>>-) :: [a] -> (a -> [b]) -> [b] # ifte :: [a] -> (a -> [b]) -> [b] -> [b] # once :: [a] -> [a] #
Monad m => MonadLogic (LogicT m) # |
Methods msplit :: LogicT m a -> LogicT m (Maybe (a, LogicT m a)) # interleave :: LogicT m a -> LogicT m a -> LogicT m a # (>>-) :: LogicT m a -> (a -> LogicT m b) -> LogicT m b # ifte :: LogicT m a -> (a -> LogicT m b) -> LogicT m b -> LogicT m b # once :: LogicT m a -> LogicT m a #
MonadLogic m => MonadLogic (StateT s m) # |
Methods msplit :: StateT s m a -> StateT s m (Maybe (a, StateT s m a)) # interleave :: StateT s m a -> StateT s m a -> StateT s m a # (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # ifte :: StateT s m a -> (a -> StateT s m b) -> StateT s m b -> StateT s m b # once :: StateT s m a -> StateT s m a #
MonadLogic m => MonadLogic (StateT s m) # |
Methods msplit :: StateT s m a -> StateT s m (Maybe (a, StateT s m a)) # interleave :: StateT s m a -> StateT s m a -> StateT s m a # (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # ifte :: StateT s m a -> (a -> StateT s m b) -> StateT s m b -> StateT s m b # once :: StateT s m a -> StateT s m a #
(MonadLogic m, Monoid w) => MonadLogic (WriterT w m) # |
Methods msplit :: WriterT w m a -> WriterT w m (Maybe (a, WriterT w m a)) # interleave :: WriterT w m a -> WriterT w m a -> WriterT w m a # (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # ifte :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b -> WriterT w m b # once :: WriterT w m a -> WriterT w m a #
(MonadLogic m, Monoid w) => MonadLogic (WriterT w m) # |
Methods msplit :: WriterT w m a -> WriterT w m (Maybe (a, WriterT w m a)) # interleave :: WriterT w m a -> WriterT w m a -> WriterT w m a # (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # ifte :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b -> WriterT w m b # once :: WriterT w m a -> WriterT w m a #
MonadLogic m => MonadLogic (ReaderT * e m) # |
Methods msplit :: ReaderT * e m a -> ReaderT * e m (Maybe (a, ReaderT * e m a)) # interleave :: ReaderT * e m a -> ReaderT * e m a -> ReaderT * e m a # (>>-) :: ReaderT * e m a -> (a -> ReaderT * e m b) -> ReaderT * e m b # ifte :: ReaderT * e m a -> (a -> ReaderT * e m b) -> ReaderT * e m b -> ReaderT * e m b # once :: ReaderT * e m a -> ReaderT * e m a #

reflect :: MonadLogic m => Maybe (a, m a) -> m a #

The inverse of msplit. Satisfies the following law:

    msplit m >>= reflect == m

lnot :: MonadLogic m => m a -> m () #

Inverts a logic computation. If `m` succeeds with at least one value, `lnot m` fails. If `m` fails, then `lnot m` succeeds the value `()`.