Control.Monad.Search

The Search monad and SearchT monad transformer allow computations to be associated with costs and cost estimates, and explore possible solutions in order of overall cost. The solution space is explored using the A* algorithm, or Dijkstra's if estimates are omitted. The order of exploring computations with equal cost is not defined.

Costs must be monotonic (i.e. positive) and underestimated. If the cost of a computation is overestimated or a negative cost is applied, sub-optimal solutions may be produced first.

Example:

import Control.Monad.Search
import Data.Monoid (Sum(..))

-- All naturals, weighted by the size of the number
naturals :: Search (Sum Integer) Integer
naturals = return 0 <|> (cost' (Sum 1) >> ((+ 1) <$> naturals))
  -- [ 0, 1, 2, 3, 4, 5, ... ]

-- All pairs of naturals
pairs :: Search (Sum Integer) (Integer, Integer)
pairs = (,) <$> naturals <*> naturals
  --    [ (0, 0), (1, 0), (0, 1), (1, 1), (2, 0), ... ]
  -- or [ (0, 0), (0, 1), (1, 0), (2, 0), (1, 1), ... ]
  -- or ...

The Search monad

type Search c = SearchT c Identity

The Search monad

runSearch :: (Ord c, Monoid c) => Search c a -> [(c, a)]

Generate all solutions in order of increasing cost.

The SearchT monad transformer

data SearchT c m a

The SearchT monad transformer

Instances

MonadRWS r w s m => MonadRWS r w s (SearchT c m)

MonadError e m => MonadError e (SearchT c m)

MonadReader r m => MonadReader r (SearchT c m)

MonadState s m => MonadState s (SearchT c m)

MonadWriter w m => MonadWriter w (SearchT c m)

(Ord c, Monoid c, Monad m) => MonadSearch c (SearchT c m)

MonadTrans (SearchT c)

Monad m => Monad (SearchT c m)

Monad m => Functor (SearchT c m)

Monad m => Applicative (SearchT c m)

(Ord c, Monoid c, Monad m) => Alternative (SearchT c m)

(Ord c, Monoid c, Monad m) => MonadPlus (SearchT c m)

MonadIO m => MonadIO (SearchT c m)

MonadCont m => MonadCont (SearchT c m)

runSearchT :: (Ord c, Monoid c, Monad m) => SearchT c m a -> m [(c, a)]

Generate all solutions in order of increasing cost.

MonadClass and search monad operations

class (Ord c, Monoid c, Monad m) => MonadSearch c m | m -> c where

Minimal definition is cost, junction, and abandon.

Methods

cost :: c -> c -> m ()

Mark a computation with a definitive cost and additional estimated cost. Definitive costs are accumulated and reported, while the estimate is reset with every call to cost and will not be included in the final result.

junction :: m a -> m a -> m a

Introduce an alternative computational path to be evaluated concurrently.

abandon :: m a

Abandon a computation.

seal :: m a -> m a

Limit the effect of collapse to alternatives within the sealed scope.

collapse :: m ()

Abandon all other computations within the current sealed scope.

Instances

MonadSearch c m => MonadSearch c (ExceptT e m)

MonadSearch c m => MonadSearch c (StateT s m)

MonadSearch c m => MonadSearch c (StateT s m)

(Monoid w, MonadSearch c m) => MonadSearch c (WriterT w m)

(Monoid w, MonadSearch c m) => MonadSearch c (WriterT w m)

MonadSearch c m => MonadSearch c (ReaderT r m)

(Ord c, Monoid c, Monad m) => MonadSearch c (SearchT c m)

(Monoid w, MonadSearch c m) => MonadSearch c (RWST r w s m)

(Monoid w, MonadSearch c m) => MonadSearch c (RWST r w s m)

cost' :: MonadSearch c m => c -> m ()

Mark an operation with a cost.

cost' c = cost c mempty

winner :: MonadSearch c m => m a -> m a

Limit a given computation to the first successful return.

winner m = seal (m <* collapse)