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


-- | Package for Constraint Programming
--   
--   Monadic Constraint Programming framework
@package monadiccp
@version 0.4

module Control.CP.FD.Domain
data Domain
class ToDomain a
toDomain :: (ToDomain a) => a -> Domain
member :: Int -> Domain -> Bool
isSubsetOf :: Domain -> Domain -> Bool
elems :: Domain -> [Int]
intersection :: Domain -> Domain -> Domain
difference :: Domain -> Domain -> Domain
union :: Domain -> Domain -> Domain
empty :: Domain
null :: Domain -> Bool
singleton :: Int -> Domain
isSingleton :: Domain -> Bool
filterLessThan :: Int -> Domain -> Domain
filterGreaterThan :: Int -> Domain -> Domain
findMax :: Domain -> Int
findMin :: Domain -> Int
size :: Domain -> Int
shiftDomain :: Domain -> Int -> Domain
instance [incoherent] Show Domain
instance [incoherent] Eq Domain
instance [incoherent] (Integral a) => ToDomain a
instance [incoherent] ToDomain ()
instance [incoherent] (Integral a, Integral b) => ToDomain (a, b)
instance [incoherent] (Integral a) => ToDomain [a]
instance [incoherent] ToDomain IntSet
instance [incoherent] ToDomain Domain

module Control.CP.PriorityQueue
data (Ord k) => PriorityQueue k a
empty :: (Ord k) => PriorityQueue k a
is_empty :: PriorityQueue t t1 -> Bool
minKey :: (Ord k) => PriorityQueue k a -> k
minKeyValue :: (Ord k) => PriorityQueue k a -> (k, a)
insert :: (Ord k) => k -> a -> PriorityQueue k a -> PriorityQueue k a
deleteMin :: (Ord k) => PriorityQueue k a -> ((k, a), PriorityQueue k a)
deleteMinAndInsert :: (Ord k) => k -> a -> PriorityQueue k a -> PriorityQueue k a

module Control.CP.Queue
class Queue q where { type family Elem q :: *; }
emptyQ :: (Queue q) => q -> q
isEmptyQ :: (Queue q) => q -> Bool
popQ :: (Queue q) => q -> (Elem q, q)
pushQ :: (Queue q) => Elem q -> q -> q
instance (Ord a) => Queue (PriorityQueue a (a, b, c))
instance Queue (Seq a)
instance Queue [a]

module Control.CP.Solver
class (Monad solver) => Solver solver where { type family Constraint solver :: *; type family Label solver :: *; }
add :: (Solver solver) => Constraint solver -> solver Bool
run :: (Solver solver) => solver a -> a
mark :: (Solver solver) => solver (Label solver)
goto :: (Solver solver) => Label solver -> solver ()
class (Solver solver) => Term solver term
newvar :: (Term solver term) => solver term

module Control.CP.FD.FD
data FD_Term
FD_Var :: FDVar -> FD_Term
data FD_Constraint
FD_Diff :: FD_Term -> FD_Term -> FD_Constraint
FD_Same :: FD_Term -> FD_Term -> FD_Constraint
FD_Less :: FD_Term -> FD_Term -> FD_Constraint
FD_LT :: FD_Term -> Int -> FD_Constraint
FD_GT :: FD_Term -> Int -> FD_Constraint
FD_HasValue :: FD_Term -> Int -> FD_Constraint
FD_Eq :: a -> b -> FD_Constraint
FD_NEq :: a -> b -> FD_Constraint
FD_AllDiff :: [FD_Term] -> FD_Constraint
FD_Dom :: FD_Term -> (Int, Int) -> FD_Constraint
(#<) :: (To_FD_Term a, To_FD_Term b) => a -> b -> FD Bool
in_range :: FD_Term -> (Int, Int) -> FD Bool
fd_domain :: FD_Term -> FD [Int]
fd_objective :: FD FD_Term
class To_FD_Term a
to_fd_term :: (To_FD_Term a) => a -> FD FD_Term
newtype FD a
FD :: StateT FDState Maybe a -> FD a
unFD :: FD a -> StateT FDState Maybe a
newtype FDVar
FDVar :: Int -> FDVar
unFDVar :: FDVar -> Int
type VarSupply = FDVar
data VarInfo
VarInfo :: FD Bool -> Domain -> VarInfo
delayedConstraints :: VarInfo -> FD Bool
domain :: VarInfo -> Domain
type VarMap = Map FDVar VarInfo
data FDState
FDState :: VarSupply -> VarMap -> FDVar -> FDState
varSupply :: FDState -> VarSupply
varMap :: FDState -> VarMap
objective :: FDState -> FDVar
consistentFD :: FD Bool
runFD :: FD a -> a
initState :: FDState
newVar :: (ToDomain a) => a -> FD FDVar
newVars :: (ToDomain a) => Int -> a -> FD [FDVar]
lookup :: FDVar -> FD Domain
update :: FDVar -> Domain -> FD Bool
addConstraint :: FDVar -> FD Bool -> FD ()
type BinaryConstraint = FDVar -> FDVar -> FD Bool
addBinaryConstraint :: BinaryConstraint -> BinaryConstraint
hasValue :: FDVar -> Int -> FD Bool
same :: FDVar -> FDVar -> FD Bool
different :: FDVar -> FDVar -> FD Bool
allDifferent :: [FDVar] -> FD ()
(.<.) :: FDVar -> FDVar -> FD Bool
dump :: [FDVar] -> FD [Domain]
newtype Expr
Expr :: FD (FDVar) -> Expr
unExpr :: Expr -> FD (FDVar)
class ToExpr a
toExpr :: (ToExpr a) => a -> Expr
exprVar :: (ToExpr a) => a -> FD FDVar
addArithmeticConstraint :: (ToExpr a, ToExpr b) => (Domain -> Domain -> Domain) -> (Domain -> Domain -> Domain) -> (Domain -> Domain -> Domain) -> a -> b -> Expr
(.+.) :: (ToExpr a, ToExpr b) => a -> b -> Expr
(.-.) :: (ToExpr a, ToExpr b) => a -> b -> Expr
(.*.) :: (ToExpr a, ToExpr b) => a -> b -> Expr
getDomainPlus :: Domain -> Domain -> Domain
getDomainMinus :: Domain -> Domain -> Domain
getDomainMult :: Domain -> Domain -> Domain
getDomainDiv :: Domain -> Domain -> Domain
(.==.) :: (ToExpr a, ToExpr b) => a -> b -> FD Bool
(./=.) :: (ToExpr a, ToExpr b) => a -> b -> FD Bool
instance [overlap ok] Show FDState
instance [overlap ok] Ord FDVar
instance [overlap ok] Eq FDVar
instance [overlap ok] Show FDVar
instance [overlap ok] Monad FD
instance [overlap ok] MonadState FDState FD
instance [overlap ok] MonadPlus FD
instance [overlap ok] Show FD_Term
instance [overlap ok] (Integral i) => ToExpr i
instance [overlap ok] ToExpr Expr
instance [overlap ok] ToExpr FDVar
instance [overlap ok] Ord FDState
instance [overlap ok] Eq FDState
instance [overlap ok] Show VarInfo
instance [overlap ok] To_FD_Term Expr
instance [overlap ok] To_FD_Term Int
instance [overlap ok] To_FD_Term FD_Term
instance [overlap ok] ToExpr FD_Term
instance [overlap ok] Term FD FD_Term
instance [overlap ok] Solver FD

module Control.CP.Herbrand.Herbrand
type VarId = Int
class HTerm t
mkVar :: (HTerm t) => VarId -> t
isVar :: (HTerm t) => t -> Maybe VarId
children :: (HTerm t) => t -> ([t], [t] -> t)
nonvar_unify :: (HTerm t, MonadState (HState t) m) => t -> t -> m Bool
newtype Herbrand t a
Herbrand :: State (HState t) a -> Herbrand t a
unH :: Herbrand t a -> State (HState t) a
type Subst t = Map VarId t
data HState t
HState :: VarId -> Subst t -> HState t
var_supply :: HState t -> VarId
subst :: HState t -> Subst t
updateState :: (HTerm t, MonadState (HState t) m) => (HState t -> HState t) -> m ()
newvarH :: (HTerm t, MonadState (HState t) m) => m t
data Unify t
Unify :: t -> t -> Unify t
addH :: (HTerm t, MonadState (HState t) m) => Unify t -> m Bool
unify :: (HTerm t, MonadState (HState t) m) => t -> t -> m Bool
failure :: (Monad m) => m Bool
success :: (Monad m) => m Bool
bind :: (HTerm t, MonadState (HState t) m) => VarId -> t -> m ()
shallow_normalize :: (HTerm t, MonadState (HState t) m) => t -> m t
normalize :: (HTerm t, MonadState (HState t) m) => t -> m t
instance Monad (Herbrand t)
instance MonadState (HState t) (Herbrand t)
instance (HTerm t) => Term (Herbrand t) t
instance (HTerm t) => Solver (Herbrand t)
instance Applicative (Herbrand t)
instance Functor (Herbrand t)

module Control.CP.Herbrand.PrologTerm
data PrologTerm
PTerm :: String -> [PrologTerm] -> PrologTerm
PVar :: VarId -> PrologTerm
instance Show PrologTerm
instance HTerm PrologTerm


-- | This module provides a Herbrand solver as a monad transformer.
--   
--   The constraints offered are <a>Either (Unify t) (Constraint m)</a>
--   where <a>m</a> is the transformed solver. Hence, both unification and
--   the underlying solver's constraints are available.
--   
--   The terms offered are <a>L t1</a> where <a>t1</a> is the Herbrand
--   solver's terms and <a>R t2</a> where <a>t2</a> are the underlying
--   solver's types.
module Control.CP.Herbrand.HerbrandT
newtype HerbrandT t m a
HerbrandT :: StateT (HState t) m a -> HerbrandT t m a
unHT :: HerbrandT t m a -> StateT (HState t) m a
data L a
L :: a -> L a
data R a
R :: a -> R a
instance MonadTrans (HerbrandT t)
instance (Monad m) => Monad (HerbrandT t m)
instance (Monad m) => MonadState (HState t) (HerbrandT t m)
instance (HTerm t, Solver s, Term s st) => Term (HerbrandT t s) (R st)
instance (HTerm t, Solver s) => Term (HerbrandT t s) (L t)
instance (Solver s, HTerm t) => Solver (HerbrandT t s)

module Control.CP.SearchTree
data Tree s a
Fail :: Tree s a
Return :: a -> Tree s a
Try :: Tree s a -> Tree s a -> Tree s a
Add :: Constraint s -> Tree s a -> Tree s a
NewVar :: (t -> Tree s a) -> Tree s a
Label :: s (Tree s a) -> Tree s a
bindTree :: (Solver s) => Tree s a -> (a -> Tree s b) -> Tree s b
insertTree :: (Solver s) => Tree s a -> Tree s () -> Tree s a
(/\) :: (Solver s) => Tree s a -> Tree s b -> Tree s b
(\/) :: (Solver s) => Tree s a -> Tree s a -> Tree s a
false :: Tree s a
true :: Tree s ()
disj :: (Solver s) => [Tree s a] -> Tree s a
conj :: (Solver s) => [Tree s ()] -> Tree s ()
disj2 :: (Solver s) => [Tree s a] -> Tree s a
exists :: (Term s t) => (t -> Tree s a) -> Tree s a
exist :: (Solver s, Term s t) => Int -> ([t] -> Tree s a) -> Tree s a
forall :: (Solver s, Term s t) => [t] -> (t -> Tree s ()) -> Tree s ()
label :: (Solver s) => s (Tree s a) -> Tree s a
prim :: (Solver s) => (s a) -> Tree s a
add :: (Solver s) => Constraint s -> Tree s ()
instance (Solver s) => Monad (Tree s)
instance (Solver s) => Functor (Tree s)
instance Show (Tree s a)

module Control.CP.Transformers
eval :: (Solver solver, Queue q, (Elem q) ~ (Label solver, Tree solver (ForResult t), TreeState t), Transformer t, (ForSolver t) ~ solver) => Tree solver (ForResult t) -> q -> t -> solver (Int, [ForResult t])
eval' :: SearchSig solver q t (ForResult t)
continue :: ContinueSig solver q t (ForResult t)
type SearchSig solver q t a = (Solver solver, Queue q, Transformer t, (Elem q) ~ (Label solver, Tree solver a, TreeState t), (ForSolver t) ~ solver) => Int -> Tree solver a -> q -> t -> EvalState t -> TreeState t -> solver (Int, [a])
type ContinueSig solver q t a = (Solver solver, Queue q, Transformer t, (Elem q) ~ (Label solver, Tree solver a, TreeState t), (ForSolver t) ~ solver) => Int -> q -> t -> EvalState t -> solver (Int, [a])
class Transformer t where { type family EvalState t :: *; type family TreeState t :: *; type family ForSolver t :: * -> *; type family ForResult t :: *; { endT i wl t es = return (i, []) returnT i wl t es = continue i wl t es nextT = eval' rightT = leftT leftT _ _ = id } }
leftT :: (Transformer t) => t -> EvalState t -> TreeState t -> TreeState t
rightT :: (Transformer t) => t -> EvalState t -> TreeState t -> TreeState t
nextT :: (Transformer t) => SearchSig (ForSolver t) q t (ForResult t)
initT :: (Transformer t) => t -> Tree (ForSolver t) (ForResult t) -> (ForSolver t) (EvalState t, TreeState t)
returnT :: (Transformer t) => ContinueSig solver q t (ForResult t)
endT :: (Transformer t) => ContinueSig solver q t (ForResult t)
newtype DepthBoundedST solver :: (* -> *) a
DBST :: Int -> DepthBoundedST a
newtype NodeBoundedST solver :: (* -> *) a
NBST :: Int -> NodeBoundedST a
instance (Solver solver) => Transformer (NodeBoundedST solver a)
instance (Solver solver) => Transformer (DepthBoundedST solver a)

module Control.CP.ComposableTransformers
solve :: (Queue q, Solver solver, CTransformer c, (CForSolver c) ~ solver, (Elem q) ~ (Label solver, Tree solver (CForResult c), CTreeState c)) => q -> c -> Tree solver (CForResult c) -> (Int, [CForResult c])
data TStack es ts solver :: (* -> *) a
TStack :: c -> TStack (CEvalState c) (CTreeState c) solver a
nextTStack :: (Solver solver, Queue q, (Elem q) ~ (Label solver, Tree solver a, ts)) => Int -> Tree solver a -> q -> (TStack es ts solver a) -> es -> ts -> solver (Int, [a])
type CSearchSig c a = (Solver (CForSolver c), CTransformer c) => Tree (CForSolver c) a -> c -> CEvalState c -> CTreeState c -> (EVAL c a) -> (CONTINUE c a) -> (EXIT c a) -> (CForSolver c) (Int, [a])
type CContinueSig c a = (Solver (CForSolver c), CTransformer c) => c -> CEvalState c -> (CONTINUE c a) -> (EXIT c a) -> (CForSolver c) (Int, [a])
type EVAL c a = Tree (CForSolver c) a -> CEvalState c -> CTreeState c -> (CForSolver c) (Int, [a])
type CONTINUE c a = CEvalState c -> (CForSolver c) (Int, [a])
type EXIT c a = (CEvalState c) -> (CForSolver c) (Int, [a])
class (Solver (CForSolver c)) => CTransformer c where { type family CEvalState c :: *; type family CTreeState c :: *; type family CForSolver c :: * -> *; type family CForResult c :: *; { completeCT _ _ = True returnCT = continueCT nextCT = evalCT rightCT = leftCT leftCT _ = id } }
initCT :: (CTransformer c) => c -> (CEvalState c, CTreeState c)
leftCT :: (CTransformer c) => c -> CTreeState c -> CTreeState c
rightCT :: (CTransformer c) => c -> CTreeState c -> CTreeState c
nextCT :: (CTransformer c) => CSearchSig c (CForResult c)
returnCT :: (CTransformer c) => CContinueSig c (CForResult c)
completeCT :: (CTransformer c) => c -> CEvalState c -> Bool
evalCT :: CSearchSig c a
continueCT :: CContinueSig c a
exitCT :: CContinueSig c a
newtype CNodeBoundedST solver :: (* -> *) a
CNBST :: Int -> CNodeBoundedST a
newtype CDepthBoundedST solver :: (* -> *) a
CDBST :: Int -> CDepthBoundedST a
newtype CLimitedDiscrepancyST solver :: (* -> *) a
CLDST :: Int -> CLimitedDiscrepancyST a
newtype CRandomST solver :: (* -> *) a
CRST :: Int -> CRandomST a
data CIdentityCST solver :: (* -> *) a
CIST :: CIdentityCST a
data CFirstSolutionST solver :: (* -> *) a
CFSST :: CFirstSolutionST a
data Composition es ts solver a
(:-) :: c1 -> c2 -> Composition (CEvalState c1, CEvalState c2) (CTreeState c1, CTreeState c2) solver a
newtype CBranchBoundST solver :: (* -> *) a
CBBST :: (NewBound solver) -> CBranchBoundST a
data BBEvalState solver
BBP :: Int -> (Bound solver) -> BBEvalState solver
type Bound solver = forall a. Tree solver a -> Tree solver a
type NewBound solver = solver (Bound solver)
data SealedCST es ts solver a
Seal :: c -> SealedCST (CEvalState c) (CTreeState c) (CForSolver c) (CForResult c)
data RestartST es ts solver :: (* -> *) a
RestartST :: [SealedCST es ts solver a] -> (Tree solver a -> solver (Tree solver a)) -> RestartST es ts a
instance (Solver solver) => Transformer (RestartST es ts solver a)
instance (Solver solver) => CTransformer (SealedCST es ts solver a)
instance (Solver solver) => CTransformer (CBranchBoundST solver a)
instance (Solver solver) => CTransformer (Composition es ts solver a)
instance (Solver solver) => CTransformer (CFirstSolutionST solver a)
instance (Solver solver) => CTransformer (CIdentityCST solver a)
instance (Solver solver) => CTransformer (CRandomST solver a)
instance (Solver solver) => CTransformer (CLimitedDiscrepancyST solver a)
instance (Solver solver) => CTransformer (CDepthBoundedST solver a)
instance (Solver solver) => CTransformer (CNodeBoundedST solver a)
instance (Solver solver) => Transformer (TStack es ts solver a)

module Control.CP.FD.FDSugar
pfs :: (Ord a) => PriorityQueue a (a, b, c)
nb :: Int -> CNodeBoundedST FD a
db :: Int -> CDepthBoundedST FD a
bb :: NewBound FD -> CBranchBoundST FD a
fs :: CFirstSolutionST FD a
it :: CIdentityCST FD a
ra :: Int -> CRandomST FD a
ld :: Int -> CLimitedDiscrepancyST FD a
newBound :: NewBound FD
newBoundBis :: NewBound FD
restart :: (Queue q, Solver solver, CTransformer c, (CForSolver c) ~ solver, (Elem q) ~ (Label solver, Tree solver (CForResult c), CTreeState c)) => q -> [c] -> Tree solver (CForResult c) -> (Int, [CForResult c])
restartOpt :: (Queue q, CTransformer c, (CForSolver c) ~ FD, (Elem q) ~ (Label FD, Tree FD (CForResult c), CTreeState c)) => q -> [c] -> Tree FD (CForResult c) -> (Int, [CForResult c])
in_order :: (Monad m) => a -> m a
(@\=) :: FD_Term -> FD_Term -> Tree FD ()
(@=) :: FD_Term -> Int -> Tree FD ()
data Plus
(:+) :: FD_Term -> Int -> Plus
(@\==) :: FD_Term -> Plus -> Tree FD ()
(@<) :: FD_Term -> Int -> Tree FD ()
(@>) :: FD_Term -> Int -> Tree FD ()