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


-- | Constraint Programming
--   
--   Monadic Constraint Programming framework
@package monadiccp
@version 0.6

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.Mixin
type Mixin a = a -> a -> a
(<@>) :: Mixin a -> Mixin a -> Mixin a
mixin :: Mixin a -> a
mixinConst :: a -> a -> a -> a
mixinId :: Mixin 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 where { type family Help solver term; }
newvar :: (Term solver term) => solver term
help :: (Term solver term) => solver () -> term -> Help solver term
instance (Monoid w, Term s t) => Term (WriterT w s) t
instance (Monoid w, Solver s) => Solver (WriterT w s)


-- | This module provides a Herbrand solver.
--   
--   The type of terms is parameterized by the <a>HTerm</a> type class.
module Control.CP.Herbrand.Herbrand

-- | Herbrand terms
class (Ord (VarId t)) => HTerm t where { type family VarId t :: *; data family VarSupply t :: *; }
varSupply :: (HTerm t) => VarSupply t
supplyVar :: (HTerm t) => VarSupply t -> (t, VarSupply t)
mkVar :: (HTerm t) => VarId t -> t
isVar :: (HTerm t) => t -> Maybe (VarId t)
children :: (HTerm t) => t -> ([t], [t] -> t)
nonvar_unify :: (HTerm t, MonadState (HState t m) m) => t -> t -> m Bool

-- | Herbrand monad
data Herbrand t a
Herbrand :: State (HState t (Herbrand t)) a -> Herbrand t a
unH :: Herbrand t a -> State (HState t (Herbrand t)) a
failure :: (Monad m) => m Bool
success :: (Monad m) => m Bool

-- | unify two arbitrary terms
unify :: (HTerm t, MonadState (HState t m) m) => t -> t -> m Bool
shallow_normalize :: (HTerm t, MonadState (HState t m) m) => t -> m t
registerAction :: (HTerm t, MonadState (HState t m) m) => t -> m Bool -> m ()
data HState t m
data Unify t
initState :: (HTerm t) => HState t m
addH :: (HTerm t, MonadState (HState t m) m) => Unify t -> m Bool
newvarH :: (HTerm t, MonadState (HState t m) m) => m t
instance (HTerm t) => Term (Herbrand t) t
instance (HTerm t) => Solver (Herbrand t)
instance Applicative (Herbrand t)
instance Functor (Herbrand t)
instance MonadState (HState t (Herbrand t)) (Herbrand t)
instance Monad (Herbrand t)

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

module Control.CP.Herbrand.Prolog
data Prolog a
data PConstraint
(:=) :: PrologTerm -> PrologTerm -> PConstraint
NotFunctor :: PrologTerm -> String -> PConstraint
(:/=) :: PrologTerm -> PrologTerm -> PConstraint
instance Monad Prolog
instance Term Prolog PrologTerm
instance Solver Prolog


-- | 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 s a
HerbrandT :: StateT (HState t (HerbrandT t s)) s a -> HerbrandT t s a
unHT :: HerbrandT t s a -> StateT (HState t (HerbrandT t s)) s a
data L a
L :: a -> L a
data R a
R :: a -> R a
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)
instance (Solver s) => MonadState (HState t (HerbrandT t s)) (HerbrandT t s)
instance MonadTrans (HerbrandT t)
instance (Monad s) => Monad (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
transformTree :: (Solver s) => Mixin (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
(/\) :: (MonadTree tree) => tree a -> tree b -> tree b
true :: (MonadTree tree) => tree ()
disj :: (MonadTree tree) => [tree a] -> tree a
conj :: (MonadTree tree) => [tree ()] -> tree ()
disj2 :: (MonadTree tree) => [tree a] -> tree a
prim :: (MonadTree tree) => TreeSolver tree a -> tree a
addC :: (MonadTree tree) => Constraint (TreeSolver tree) -> tree ()
addT :: (MonadTree tree) => Constraint (TreeSolver tree) -> tree Bool
exist :: (MonadTree tree, Term (TreeSolver tree) t) => Int -> ([t] -> tree a) -> tree a
forall :: (MonadTree tree, Term (TreeSolver tree) t) => [t] -> (t -> tree ()) -> tree ()

-- | show
indent :: Int -> String
showTree :: (Show (Constraint s), Show a, Solver s) => Int -> Tree s a -> s String

-- | Generalization of the search tree data type, allowing monad
--   transformer decoration.
class (Monad m, Solver (TreeSolver m)) => MonadTree m
addTo :: (MonadTree m) => Constraint (TreeSolver m) -> m a -> m a
false :: (MonadTree m) => m a
(\/) :: (MonadTree m) => m a -> m a -> m a
exists :: (MonadTree m, Term (TreeSolver m) t) => (t -> m a) -> m a
label :: (MonadTree m) => (TreeSolver m) (m a) -> m a
untree :: (Solver s) => v -> Tree s v -> s v
instance (MonadTree t) => MonadTree (StateT s t)
instance (Monoid w, MonadTree t) => MonadTree (WriterT w t)
instance (MonadTree t) => MonadTree (ReaderT env t)
instance Show (Tree s a)
instance (Solver solver) => MonadTree (Tree solver)
instance (Solver s) => Monad (Tree s)
instance (Solver s) => Functor (Tree s)

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)
data NodeBoundedST solver :: (* -> *) a
data DepthBoundedST solver :: (* -> *) 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)
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])
type NewBound solver = solver (Bound solver)
class (Solver (CForSolver c)) => CTransformer c where { type family CTreeState c :: *; type family CForSolver c :: * -> *; type family CForResult c :: *; { completeCT _ _ = True returnCT = continueCT nextCT = evalCT rightCT = leftCT leftCT _ = id } }
data RestartST es ts solver :: (* -> *) a
RestartST :: [SealedCST es ts solver a] -> (Tree solver a -> solver (Tree solver a)) -> RestartST es ts a
data SealedCST es ts solver a
Seal :: c -> SealedCST (CEvalState c) (CTreeState c) (CForSolver c) (CForResult c)
newtype CNodeBoundedST solver :: (* -> *) a
CNBST :: Int -> CNodeBoundedST a
newtype CDepthBoundedST solver :: (* -> *) a
CDBST :: Int -> CDepthBoundedST a
newtype CBranchBoundST solver :: (* -> *) a
CBBST :: (NewBound solver) -> CBranchBoundST a
data CFirstSolutionST solver :: (* -> *) a
CFSST :: CFirstSolutionST a
data CIdentityCST solver :: (* -> *) a
CIST :: CIdentityCST a
newtype CRandomST solver :: (* -> *) a
CRST :: Int -> CRandomST a
newtype CLimitedDiscrepancyST solver :: (* -> *) a
CLDST :: Int -> CLimitedDiscrepancyST 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.EnumTerm
class (Term s t, Enum (TermDomain s t)) => EnumTerm s t where { type family TermDomain s t :: *; { enumerate l = label firstfail l label o l = Label $ do { x <- o l; split_domains x } split_domains [] = return $ return () split_domains [a] = split_domain a split_domains (a : b) = do { ta <- split_domain a; tb <- split_domains b; return $ ta /\ tb } split_domain v = do { let rec tree = do { tree; Label $ do { x <- get_value v; case x of { Nothing -> split_domain v Just _ -> return $ return () } } }; lst <- split_domain_partial v; return $ levelList $ map rec lst } } }
get_domain_size :: (EnumTerm s t) => t -> s Int
get_value :: (EnumTerm s t) => t -> s (Maybe (TermDomain s t))
split_domain_partial :: (EnumTerm s t) => t -> s [Tree s ()]
split_domain :: (EnumTerm s t) => t -> s (Tree s ())
split_domains :: (EnumTerm s t) => [t] -> s (Tree s ())
label :: (EnumTerm s t) => ([t] -> s [t]) -> [t] -> Tree s ()
enumerate :: (EnumTerm s t) => [t] -> Tree s ()
in_order :: (Monad m) => a -> m a
firstfail :: (EnumTerm m a) => [a] -> m [a]
middleout :: [a] -> [a]
endsout :: [a] -> [a]
interleave :: [t] -> [t] -> [t]
assignment :: (EnumTerm s t) => t -> Tree s (TermDomain s t)
assignments :: (EnumTerm s t) => [t] -> Tree s [TermDomain s t]

module Control.CP.FD.Expr
data Expr t
Term :: t -> Expr t
Const :: Integer -> Expr t
Plus :: (Expr t) -> (Expr t) -> Expr t
Minus :: (Expr t) -> (Expr t) -> Expr t
Mult :: (Expr t) -> (Expr t) -> Expr t
Div :: (Expr t) -> (Expr t) -> Expr t
Mod :: (Expr t) -> (Expr t) -> Expr t
Abs :: (Expr t) -> Expr t
class ToExpr tt t
toExpr :: (ToExpr tt t) => t -> Expr tt
newtype ExprKey s
ExprKey :: (Expr s) -> ExprKey s
unExprKey :: ExprKey s -> Expr s
instance (Eq s) => Eq (ExprKey s)
instance (Show s) => Show (ExprKey s)
instance (Show t) => Show (Expr t)
instance (Eq t) => Eq (Expr t)
instance (Ord s) => Ord (ExprKey s)
instance ToExpr t t
instance ToExpr t (Expr t)
instance ToExpr tt Int
instance ToExpr tt Integer
instance (Eq s, Show s) => Integral (Expr s)
instance (Eq s, Show s) => Enum (Expr s)
instance (Eq s, Show s) => Real (Expr s)
instance (Eq s, Show s) => Ord (Expr s)
instance (Eq s, Show s) => Num (Expr s)

module Control.CP.FD.FD
class (Show (FDTerm s), Eq (FDTerm s), Term s (FDTerm s)) => FDSolver s where { type family FDTerm s :: *; { specific_fresh_var = mixinId specific_decompose = mixinId } }
specific_compile_constraint :: (FDSolver s) => Mixin (FDConstraint s -> Tree s Bool)
specific_decompose :: (FDSolver s) => Mixin (Expr (FDTerm s) -> Tree s (FDTerm s))
specific_fresh_var :: (FDSolver s) => Mixin (Tree s (FDTerm s))
fresh_var :: (FDSolver s) => Tree s (FDTerm s)
decompose :: (FDSolver s) => Expr (FDTerm s) -> Tree s (FDTerm s)
compile_constraint :: (FDSolver s) => FDConstraint s -> Tree s Bool
type FDExpr s = Expr (FDTerm s)
data (Show (FDTerm s)) => FDConstraint s
Less :: (Expr (FDTerm s)) -> (Expr (FDTerm s)) -> FDConstraint s
Diff :: (Expr (FDTerm s)) -> (Expr (FDTerm s)) -> FDConstraint s
Same :: (Expr (FDTerm s)) -> (Expr (FDTerm s)) -> FDConstraint s
Dom :: (Expr (FDTerm s)) -> Integer -> Integer -> FDConstraint s
AllDiff :: [Expr (FDTerm s)] -> FDConstraint s
Sorted :: [Expr (FDTerm s)] -> Bool -> FDConstraint s
newtype FDWrapper s a
FDWrapper :: s a -> FDWrapper s a
subFD :: FDWrapper s a -> s a
type FDTree s a = Tree (FDWrapper s) a
newtype FDLabel s
FDLabel :: (Label s) -> FDLabel s
wrap :: (FDSolver s) => Tree s a -> Tree (FDWrapper s) a
unwrap :: (FDSolver s) => Tree (FDWrapper s) a -> Tree s a
(@:) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Integral t, Integral t1, Show (FDTerm s)) => Expr (FDTerm s) -> (t, t1) -> tree ()
(@<) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@>) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@<=) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Eq (FDTerm s), Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@>=) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Eq (FDTerm s), Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@=) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@/=) :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => Expr (FDTerm s) -> Expr (FDTerm s) -> tree ()
(@+) :: (ToExpr tt t, ToExpr tt t1, Eq tt, Show tt) => t -> t1 -> Expr tt
(@-) :: (ToExpr tt t, ToExpr tt t1, Eq tt, Show tt) => t -> t1 -> Expr tt
(@*) :: (ToExpr tt t, ToExpr tt t1, Eq tt, Show tt) => t -> t1 -> Expr tt
(@/) :: (ToExpr tt t, ToExpr tt t1, Eq tt, Show tt) => t -> t1 -> Expr tt
(@%) :: (ToExpr tt t, ToExpr tt t1, Eq tt, Show tt) => t -> t1 -> Expr tt
cte :: (Num a, Integral a1) => a1 -> a
allDiff :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => [Expr (FDTerm s)] -> tree ()
sorted :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => [Expr (FDTerm s)] -> tree ()
sSorted :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Show (FDTerm s)) => [Expr (FDTerm s)] -> tree ()
allin :: ((FDConstraint s) ~ (Constraint (TreeSolver tree)), MonadTree tree, Integral t, Integral t1, Show (FDTerm s)) => [Expr (FDTerm s)] -> (t, t1) -> tree ()
instance (Show (FDTerm s)) => Show (FDConstraint s)
instance (FDTerm s ~ t, FDSolver s, Eq t, EnumTerm s t, Integral (TermDomain s t)) => EnumTerm (FDWrapper s) (Expr t)
instance (t ~ Expr (FDTerm s), FDSolver s) => Term (FDWrapper s) t
instance (FDSolver s) => Solver (FDWrapper s)
instance (FDSolver s) => Monad (FDWrapper s)

module Control.CP.FD.Gecode.Common

-- | Gecode terms
class GTerm t
getVarId :: (GTerm t) => t -> Maybe Int
getIntValue :: (GTerm t) => t -> Maybe Integer
getDefBounds :: (GTerm t) => t -> (Integer, Integer)
data GType
TypeInt :: GType
TypeBool :: GType

-- | integer terms
data IntTerm
IntVar :: Int -> IntTerm
IntConst :: Integer -> IntTerm

-- | boolean terms
data BoolTerm
BoolVar :: Int -> BoolTerm
BoolConst :: Bool -> BoolTerm

-- | Gecode constraints
data GConstraint
CDiff :: t -> t -> GConstraint
CSame :: t -> t -> GConstraint
CRel :: IntTerm -> GOperator -> IntTerm -> GConstraint
CMult :: IntTerm -> IntTerm -> IntTerm -> GConstraint
CAbs :: IntTerm -> IntTerm -> GConstraint
CDiv :: IntTerm -> IntTerm -> IntTerm -> GConstraint
CMod :: IntTerm -> IntTerm -> IntTerm -> GConstraint
CValue :: IntTerm -> Integer -> GConstraint
CDom :: IntTerm -> Integer -> Integer -> GConstraint
CLinear :: [(IntTerm, Integer)] -> GOperator -> Integer -> GConstraint
CAllDiff :: [IntTerm] -> GConstraint
CSorted :: [IntTerm] -> Bool -> GConstraint
data GOperator
OEqual :: GOperator
ODiff :: GOperator
OLess :: GOperator

-- | Gecode FDSolver instance
class (Solver s, Term s IntTerm) => GecodeSolver s
setVarImplicit :: (GecodeSolver s) => IntTerm -> Bool -> s ()
caching_decompose :: (GecodeSolver s, GecodeSolver s) => Mixin (Expr (FDTerm s) -> Tree s IntTerm)

-- | utility
orElse :: Maybe a -> Maybe a -> Maybe a

-- | linear constraint compilation
linearCompile :: (FDSolver s, (Constraint s) ~ GConstraint, (FDTerm s) ~ IntTerm) => Mixin (FDConstraint s -> Tree s Bool)

-- | basic compilation
basicCompile :: (FDSolver s, (Constraint s) ~ GConstraint, (FDTerm s) ~ IntTerm) => Mixin (FDConstraint s -> Tree s Bool)
instance Eq BoolTerm
instance Eq IntTerm
instance Show GType
instance Eq GType
instance Show GOperator
instance Show GConstraint
instance GTerm BoolTerm
instance Show BoolTerm
instance GTerm IntTerm
instance Show IntTerm
instance Ord IntTerm

module Control.CP.FD.Gecode.CodegenSolver

-- | CodegenSolver monad definition
newtype CodegenSolver a
CodegenSolver :: State Store a -> CodegenSolver a
state :: CodegenSolver a -> State Store a

-- | CodegenSolver compilation
compile :: Tree CodegenSolver a -> Store
data Store
Store :: Int -> [VarData] -> StoreNode -> [Bool] -> Map (ExprKey (FDTerm CodegenSolver)) Int -> Store
vars :: Store -> Int
vardata :: Store -> [VarData]
ctree :: Store -> StoreNode
cpath :: Store -> [Bool]
cexpr :: Store -> Map (ExprKey (FDTerm CodegenSolver)) Int

-- | StoreNode represents a node in the search tree. * Each node adds new
--   constraints and variables. * A node is a leaf node or an internal node
data StoreNode
StoreNode :: [GConstraint] -> [VarBoundPropagator] -> [Int] -> StoreNodeType -> StoreNode

-- | new constraints added in this node
cons :: StoreNode -> [GConstraint]

-- | new bound-generator functions in this node
nbounds :: StoreNode -> [VarBoundPropagator]

-- | id's of variables added in this node
nvars :: StoreNode -> [Int]

-- | either no children, or one left and one right child
dis :: StoreNode -> StoreNodeType
data StoreNodeType
SNLeaf :: StoreNodeType
SNIntl :: StoreNode -> StoreNode -> StoreNodeType
getVarType :: Store -> Int -> GType
isVarImplicit :: Store -> Int -> Bool
data VarBound
VarBound :: VarId -> LowerBound -> UpperBound -> VarBound
varid :: VarBound -> VarId
lbound :: VarBound -> LowerBound
ubound :: VarBound -> UpperBound
getAllBounds :: Store -> VarBoundMap
instance Show Store
instance Show VarData
instance Show StoreNodeType
instance Show VarBound
instance Eq VarBound
instance Monad CodegenSolver
instance MonadState Store CodegenSolver
instance FDSolver CodegenSolver
instance GecodeSolver CodegenSolver
instance Show StoreNode
instance Term CodegenSolver BoolTerm
instance Term CodegenSolver IntTerm
instance Solver CodegenSolver

module Control.CP.FD.Gecode.Translate
generate_gecode :: Tree CodegenSolver a -> String

module Control.CP.FD.OvertonFD.OvertonFD
data OvertonFD a
fd_objective :: OvertonFD FDVar
fd_domain :: FDVar -> OvertonFD [Int]
data FDVar
data OConstraint
OHasValue :: FDVar -> Int -> OConstraint
OSame :: FDVar -> FDVar -> OConstraint
ODiff :: FDVar -> FDVar -> OConstraint
OLess :: FDVar -> FDVar -> OConstraint
OAdd :: FDVar -> FDVar -> FDVar -> OConstraint
OSub :: FDVar -> FDVar -> FDVar -> OConstraint
OMult :: FDVar -> FDVar -> FDVar -> OConstraint
OAbs :: FDVar -> FDVar -> OConstraint
instance Show FDState
instance Ord FDVar
instance Eq FDVar
instance Show FDVar
instance Monad OvertonFD
instance MonadState FDState OvertonFD
instance MonadPlus OvertonFD
instance Ord FDState
instance Eq FDState
instance Show VarInfo
instance EnumTerm OvertonFD FDVar
instance Term OvertonFD FDVar
instance Solver OvertonFD

module Control.CP.FD.OvertonFD.Sugar
newBound :: NewBound OvertonFD
newBoundBis :: NewBound OvertonFD
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) ~ OvertonFD, (Elem q) ~ (Label OvertonFD, Tree OvertonFD (CForResult c), CTreeState c)) => q -> [c] -> Tree OvertonFD (CForResult c) -> (Int, [CForResult c])
instance FDSolver OvertonFD

module Control.CP.FD.Solvers
as_overtonfd :: Tree (FDWrapper OvertonFD) a -> Tree (FDWrapper OvertonFD) a
as_gecode_codegen :: Tree (FDWrapper CodegenSolver) a -> Tree CodegenSolver a
pfs :: (Ord a) => PriorityQueue a (a, b, c)
nb :: Int -> CNodeBoundedST s a
db :: Int -> CDepthBoundedST s a
bb :: NewBound s -> CBranchBoundST s a
fs :: CFirstSolutionST s a
it :: CIdentityCST s a
ra :: Int -> CRandomST s a
ld :: Int -> CLimitedDiscrepancyST s a

module Control.CP.FD.Example.Example
example_main :: (forall s. (FDSolver s) => [String] -> FDTree s [FDExpr s]) -> IO ()
example_main_void :: (forall s. (FDSolver s) => FDTree s [FDExpr s]) -> IO ()
example_main_single :: (Read n) => (forall s. (FDSolver s) => n -> FDTree s [FDExpr s]) -> IO ()
type FDModel = (FDSolver s) => Tree (FDWrapper s) [FDExpr s]