CFLP

Documentation

class (Strategy (Ctx s) s, MonadPlus s, MonadUpdate (Ctx s) s, Update (Ctx s) s s, Update (Ctx s) s (Res s), MonadPlus (Res s), Enumerable (Res s)) => CFLP s

Instances

(MonadPlus m, Enumerable m) => CFLP (Monadic (UpdateT () m))

(MonadPlus m, Enumerable m) => CFLP (CTC (Monadic (UpdateT (StoreCTC ()) m)))

(MonadPlus m, Enumerable m) => CFLP (CTC (Depth (DepthLim (Monadic (UpdateT (StoreCTC (DepthCtx (DepthLimCtx ()))) m)))))

(MonadPlus m, Enumerable m) => CFLP (CTC (Rnd (Monadic (UpdateT (StoreCTC (RndCtx ())) m))))

class Enumerable s where

Methods

enumeration :: s a -> [a]

Instances

Enumerable []

Enumerable Omega

Enumerable Logic

Enumerable m => Enumerable (Monadic m)

Enumerable s => Enumerable (CTC s)

Enumerable s => Enumerable (Depth s)

Enumerable s => Enumerable (DepthLim s)

Enumerable s => Enumerable (Rnd s)

type family Ctx s

type Data s a = Nondet (Ctx s) s a

type Computation a = forall s. CFLP s => Context (Ctx s) -> ID -> Data s a

eval :: (Monad s, CFLP s, Generic a) => [s (Ctx s)] -> Computation a -> IO [a]

evalPartial :: (Monad s, CFLP s, Generic a) => [s (Ctx s)] -> Computation a -> IO [a]

evalPrint :: (Monad s, CFLP s, Generic a) => [s (Ctx s)] -> Computation a -> IO ()

data Monadic m a

Instances

MonadUpdate c m => MonadUpdate c (Monadic m)

MonadPlus m => Strategy c (Monadic m)

Update s m m' => Update s (Monadic m) (Monadic m')

Monad m => Monad (Monadic m)

MonadPlus m => MonadPlus (Monadic m)

Enumerable m => Enumerable (Monadic m)

(MonadPlus m, Enumerable m) => CFLP (Monadic (UpdateT () m))

(MonadPlus m, Enumerable m) => CFLP (CTC (Monadic (UpdateT (StoreCTC ()) m)))

(MonadPlus m, Enumerable m) => CFLP (CTC (Depth (DepthLim (Monadic (UpdateT (StoreCTC (DepthCtx (DepthLimCtx ()))) m)))))

(MonadPlus m, Enumerable m) => CFLP (CTC (Rnd (Monadic (UpdateT (StoreCTC (RndCtx ())) m))))

monadic :: Monad m => Monadic (UpdateT c m) ()

data UpdateT s m a

Instances

MonadPlus m => MonadUpdate s (UpdateT s m)

MonadPlus m => Update s (UpdateT s m) m

MonadPlus m => Update s (UpdateT s m) (UpdateT s m)

MonadTrans (UpdateT s)

(MonadPlus m, Enumerable m) => CFLP (Monadic (UpdateT () m))

(MonadPlus m, Enumerable m) => CFLP (CTC (Monadic (UpdateT (StoreCTC ()) m)))

(MonadPlus m, Enumerable m) => CFLP (CTC (Depth (DepthLim (Monadic (UpdateT (StoreCTC (DepthCtx (DepthLimCtx ()))) m)))))

(MonadPlus m, Enumerable m) => CFLP (CTC (Rnd (Monadic (UpdateT (StoreCTC (RndCtx ())) m))))

Monad m => Monad (UpdateT s m)

Show (HeadNormalForm cs (UpdateT cs []))

MonadPlus m => MonadPlus (UpdateT s m)

Show a => Show (UpdateT s [] a)

Show (Nondet cs (UpdateT cs []) a)

data NormalForm

Instances

Show NormalForm

data Nondet cs m a

Instances

NestLambda cs m t (Nondet cs m b -> f) => NestLambda cs m (a -> t) (Nondet cs m a -> Nondet cs m b -> f)

NestLambda cs m (a -> b) (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

With x (Nondet cs m a)

(cs ~ Ctx b, m ~ Mon b, MkCons b) => MkCons (Nondet cs m a -> b)

(cs ~ C a, m ~ M a, WithUntyped a) => WithUntyped (Nondet cs m b -> a)

LiftFun (Nondet cs m b -> f) => LiftFun (Nondet cs m a -> Nondet cs m b -> f)

LiftFun (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

LiftFun (Nondet cs m a -> ID -> Nondet cs m b)

LiftFun (Nondet cs m a -> Context cs -> Nondet cs m b)

LiftFun (Nondet cs m a -> Nondet cs m b)

Show (Nondet cs (UpdateT cs []) a)

Show (Nondet cs [] a)

Monad m => MkCons (Nondet cs m a)

WithUntyped (Nondet cs m a)

newtype Context cs

Constructors

Context cs

Instances

NestLambda cs m (a -> b) (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

(cs ~ C a, m ~ M a, b ~ T a, WithUntyped a, PatternList p) => PatternList (ConsPatList ((Context cs -> a) -> Match t cs m b) p)

LiftFun (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

LiftFun (Nondet cs m a -> Context cs -> Nondet cs m b)

data ID

Instances

NestLambda cs m (a -> b) (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

With ID a => With ID (ID -> a)

LiftFun (Nondet cs m a -> Context cs -> ID -> Nondet cs m b)

LiftFun (Nondet cs m a -> ID -> Nondet cs m b)

initID :: IO ID

withUnique :: With ID a => a -> ID -> Nondet (C ID a) (M ID a) (T ID a)

class Narrow a where

Methods

narrow :: (Monad s, Strategy c s, MonadUpdate c s) => Context c -> ID -> Nondet c s a

Instances

Narrow Bool

(Narrow a, Generic a) => Narrow [a]

unknown :: (Monad s, Strategy c s, MonadUpdate c s, Narrow a) => ID -> Nondet c s a

failure :: MonadPlus m => Nondet cs m a

oneOf :: (Strategy c s, MonadUpdate c s) => [Nondet c s a] -> Context c -> ID -> Nondet c s a

(?) :: (Monad s, Strategy c s, MonadUpdate c s) => Nondet c s a -> Nondet c s a -> ID -> Nondet c s a

withHNF :: (Monad m, Update cs m m) => Nondet cs m a -> (HeadNormalForm cs m -> Context cs -> Nondet cs m b) -> Context cs -> Nondet cs m b

caseOf :: (MonadPlus m, Update cs m m) => Nondet cs m a -> [Match a cs m b] -> Context cs -> Nondet cs m b

caseOf_ :: (Monad m, Update cs m m) => Nondet cs m a -> [Match a cs m b] -> Nondet cs m b -> Context cs -> Nondet cs m b

data Match a cs m b

Instances

(cs ~ C a, m ~ M a, b ~ T a, WithUntyped a, PatternList p) => PatternList (ConsPatList ((Context cs -> a) -> Match t cs m b) p)

class Generic a where

Methods

genericOps :: GenericOps a

constr :: Int -> GenericOps a

Instances

Generic Bool

Generic a => Generic [a]

(Generic a, Generic b) => Generic (a -> b)

primitive :: Generic a => NormalForm -> a

generic :: Generic a => a -> NormalForm

nondet :: (Monad m, Update cs m m, Generic a) => a -> Nondet cs m a

type Decons a = ([NormalForm] -> NormalForm) -> Result a -> Maybe NormalForm

class ApplyCons a where

Associated Types

type Result a

Methods

applyCons :: a -> [NormalForm] -> Result a

Instances

ApplyCons Bool

ApplyCons [a]

(Generic a, ApplyCons b) => ApplyCons (a -> b)

(!) :: (Int -> GenericOps a) -> (Int -> GenericOps a) -> Int -> GenericOps a

cons :: ApplyCons a => String -> a -> Decons a -> Int -> GenericOps (Result a)

groundNormalForm :: (Monad s, Monad m, Update c s m) => s c -> Nondet c s a -> m NormalForm

partialNormalForm :: (Monad s, Strategy c s, Monad m, Update c s m) => s c -> Nondet c s a -> m NormalForm

data ConsPatList a b

Constructors

a :! b

Instances

(cs ~ C a, m ~ M a, b ~ T a, WithUntyped a, PatternList p) => PatternList (ConsPatList ((Context cs -> a) -> Match t cs m b) p)

(MkCons a, ConsList b) => ConsList (ConsPatList a b)

constructors :: (ConsList a, Generic (CData a)) => a

patterns :: (PatternList a, Generic (PData a)) => a

apply :: (Monad m, Update cs m m) => Nondet cs m (a -> b) -> Nondet cs m a -> Context cs -> ID -> Nondet cs m b

fun :: (Monad m, LiftFun f, NestLambda cs m t (Lift f)) => f -> Nondet cs m t