Safe Haskell	None
Language	Haskell2010

Control.State.Transition.Simple

Description

Simple state transition system over the Identity monad.

Synopsis

applySTSIndifferently :: forall s rtype. ( STS s, RuleTypeRep rtype, Identity ~ BaseM s) => RuleContext rtype s -> ( State s, [ PredicateFailure s])
applySTS :: forall s rtype. ( STS s, RuleTypeRep rtype, BaseM s ~ Identity ) => RuleContext rtype s -> Either [ PredicateFailure s] ( State s)
data STUB (e :: Type ) (st :: Type ) (si :: Type ) (f :: Type ) (m :: Type -> Type )
newtype Threshold a = Threshold a
type RuleInterpreter ep = forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> Rule s rtype ( State s) -> m ( EventReturnType ep s ( State s, [ PredicateFailure s]))
type STSInterpreter ep = forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> m ( EventReturnType ep s ( State s, [ PredicateFailure s]))
data ApplySTSOpts ep = ApplySTSOpts {
- asoAssertions :: AssertionPolicy
- asoValidation :: ValidationPolicy
- asoEvents :: SingEP ep
}
data ValidationPolicy
- = ValidateAll
- | ValidateNone
- | ValidateSuchThat ([ Label ] -> Bool )
data AssertionPolicy
- = AssertionsAll
- | AssertionsPre
- | AssertionsPost
- | AssertionsOff
type Label = String
type Rule sts rtype = F (Clause sts rtype)
class EventReturnTypeRep ert
type family EventReturnType ep sts a :: Type where ...
data SingEP ep where
- EPReturn :: SingEP ' EventPolicyReturn
- EPDiscard :: SingEP ' EventPolicyDiscard
data EventPolicy
- = EventPolicyReturn
- | EventPolicyDiscard
class ( STS sub, BaseM sub ~ BaseM super) => Embed sub super where
- wrapFailed :: PredicateFailure sub -> PredicateFailure super
- wrapEvent :: Event sub -> Event super
class ( Eq ( PredicateFailure a), Show ( PredicateFailure a), Monad ( BaseM a), Typeable a) => STS a where
- type State a :: Type
- type Signal a :: Type
- type Environment a :: Type
- type BaseM a :: Type -> Type
- type Event a :: Type
- type PredicateFailure a :: Type
- initialRules :: [ InitialRule a]
- transitionRules :: [ TransitionRule a]
- assertions :: [ Assertion a]
- renderAssertionViolation :: AssertionViolation a -> String
data AssertionException where
- AssertionException :: forall sts. STS sts => AssertionViolation sts -> AssertionException
data AssertionViolation sts = AssertionViolation {
- avSTS :: String
- avMsg :: String
- avCtx :: TRC sts
- avState :: Maybe ( State sts)
}
data Assertion sts
- = PreCondition String ( TRC sts -> Bool )
- | PostCondition String ( TRC sts -> State sts -> Bool )
type TransitionRule sts = Rule sts ' Transition ( State sts)
type InitialRule sts = Rule sts ' Initial ( State sts)
type family RuleContext (t :: RuleType ) = (ctx :: Type -> Type ) | ctx -> t where ...
newtype TRC sts = TRC ( Environment sts, State sts, Signal sts)
newtype IRC sts = IRC ( Environment sts)
class RuleTypeRep t
data RuleType
- = Initial
- | Transition
mapEventReturn :: forall ep sts a b. EventReturnTypeRep ep => (a -> b) -> EventReturnType ep sts a -> EventReturnType ep sts b
validate :: Validation ( NonEmpty ( PredicateFailure sts)) () -> Rule sts ctx ()
validateTrans :: (e -> PredicateFailure sts) -> Validation ( NonEmpty e) () -> Rule sts ctx ()
validateTransLabeled :: (e -> PredicateFailure sts) -> NonEmpty Label -> Validation ( NonEmpty e) () -> Rule sts ctx ()
(?!) :: Bool -> PredicateFailure sts -> Rule sts ctx ()
failBecause :: PredicateFailure sts -> Rule sts ctx ()
(?!:) :: Either e () -> (e -> PredicateFailure sts) -> Rule sts ctx ()
labeledPred :: NonEmpty Label -> Bool -> PredicateFailure sts -> Rule sts ctx ()
labeledPredE :: NonEmpty Label -> Either e () -> (e -> PredicateFailure sts) -> Rule sts ctx ()
labeled :: NonEmpty Label -> Rule sts ctx () -> Rule sts ctx ()
trans :: Embed sub super => RuleContext rtype sub -> Rule super rtype ( State sub)
ifFailureFree :: Rule sts rtype a -> Rule sts rtype a -> Rule sts rtype a
whenFailureFree :: Rule sts rtype () -> Rule sts rtype ()
liftSTS :: STS sts => BaseM sts a -> Rule sts ctx a
judgmentContext :: Rule sts rtype ( RuleContext rtype sts)
applySTSOpts :: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => ApplySTSOpts ep -> RuleContext rtype s -> m ( EventReturnType ep s ( State s, [ PredicateFailure s]))
applySTSOptsEither :: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => ApplySTSOpts ep -> RuleContext rtype s -> m ( Either [ PredicateFailure s] ( EventReturnType ep s ( State s)))
globalAssertionPolicy :: AssertionPolicy
reapplySTS :: forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> m ( State s)
applyRuleInternal :: forall (ep :: EventPolicy ) s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => IsFailing -> SingEP ep -> ValidationPolicy -> (IsFailing -> STSInterpreter ep) -> RuleContext rtype s -> Rule s rtype ( State s) -> m ( EventReturnType ep s ( State s, [ PredicateFailure s]))
applySTSInternal :: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => SingEP ep -> AssertionPolicy -> RuleInterpreter ep -> RuleContext rtype s -> ExceptT ( AssertionViolation s) m ( EventReturnType ep s ( State s, [ PredicateFailure s]))
sfor_ :: ( Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
tellEvent :: Event sts -> Rule sts ctx ()
tellEvents :: [ Event sts] -> Rule sts ctx ()

Documentation

applySTSIndifferently :: forall s rtype. ( STS s, RuleTypeRep rtype, Identity ~ BaseM s) => RuleContext rtype s -> ( State s, [ PredicateFailure s]) Source #

applySTS :: forall s rtype. ( STS s, RuleTypeRep rtype, BaseM s ~ Identity ) => RuleContext rtype s -> Either [ PredicateFailure s] ( State s) Source #

data STUB (e :: Type ) (st :: Type ) (si :: Type ) (f :: Type ) (m :: Type -> Type ) Source #

A stub rule with no transitions to use as a placeholder

Instances

Instances details

( Eq f, Monad m, Show f, Typeable e, Typeable f, Typeable si, Typeable st, Typeable m) => STS ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended Associated Types type State ( STUB e st si f m) Source # type Signal ( STUB e st si f m) Source # type Environment ( STUB e st si f m) Source # type BaseM ( STUB e st si f m) :: Type -> Type Source # type Event ( STUB e st si f m) Source # type PredicateFailure ( STUB e st si f m) Source # Methods initialRules :: [ InitialRule ( STUB e st si f m)] Source # transitionRules :: [ TransitionRule ( STUB e st si f m)] Source # assertions :: [ Assertion ( STUB e st si f m)] Source # renderAssertionViolation :: AssertionViolation ( STUB e st si f m) -> String Source #
type State ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type State ( STUB e st si f m) = st
type Signal ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type Signal ( STUB e st si f m) = si
type Environment ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type Environment ( STUB e st si f m) = e
type BaseM ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type BaseM ( STUB e st si f m) = m
type Event ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type Event ( STUB e st si f m) = Void
type PredicateFailure ( STUB e st si f m) Source #
Instance details Defined in Control.State.Transition.Extended type PredicateFailure ( STUB e st si f m) = f

newtype Threshold a Source #

This can be used to specify predicate failures in STS rules where a value is beyond a certain threshold.

TODO move this somewhere more sensible

Constructors

Threshold a

Instances

Instances details

Eq a => Eq ( Threshold a) Source #
Instance details Defined in Control.State.Transition.Extended Methods (==) :: Threshold a -> Threshold a -> Bool Source # (/=) :: Threshold a -> Threshold a -> Bool Source #
Data a => Data ( Threshold a) Source #
Instance details Defined in Control.State.Transition.Extended Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Threshold a -> c ( Threshold a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Threshold a) Source # toConstr :: Threshold a -> Constr Source # dataTypeOf :: Threshold a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Threshold a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Threshold a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Threshold a -> Threshold a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Threshold a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Threshold a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Threshold a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Threshold a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Threshold a -> m ( Threshold a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Threshold a -> m ( Threshold a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Threshold a -> m ( Threshold a) Source #
Ord a => Ord ( Threshold a) Source #
Instance details Defined in Control.State.Transition.Extended Methods compare :: Threshold a -> Threshold a -> Ordering Source # (<) :: Threshold a -> Threshold a -> Bool Source # (<=) :: Threshold a -> Threshold a -> Bool Source # (>) :: Threshold a -> Threshold a -> Bool Source # (>=) :: Threshold a -> Threshold a -> Bool Source # max :: Threshold a -> Threshold a -> Threshold a Source # min :: Threshold a -> Threshold a -> Threshold a Source #
Show a => Show ( Threshold a) Source #
Instance details Defined in Control.State.Transition.Extended Methods showsPrec :: Int -> Threshold a -> ShowS Source # show :: Threshold a -> String Source # showList :: [ Threshold a] -> ShowS Source #
NoThunks a => NoThunks ( Threshold a) Source #
Instance details Defined in Control.State.Transition.Extended Methods noThunks :: Context -> Threshold a -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> Threshold a -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( Threshold a) -> String Source #

type RuleInterpreter ep = forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> Rule s rtype ( State s) -> m ( EventReturnType ep s ( State s, [ PredicateFailure s])) Source #

type STSInterpreter ep = forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> m ( EventReturnType ep s ( State s, [ PredicateFailure s])) Source #

data ApplySTSOpts ep Source #

Constructors

ApplySTSOpts
Fields asoAssertions :: AssertionPolicy Enable assertions during STS processing. If this option is enabled, STS processing will terminate on violation of an assertion. asoValidation :: ValidationPolicy Validation policy asoEvents :: SingEP ep Event policy

data ValidationPolicy Source #

Control which predicates are evaluated during rule processing.

Constructors

ValidateAll
ValidateNone
ValidateSuchThat ([ Label ] -> Bool )

data AssertionPolicy Source #

Control which assertions are enabled.

Constructors

AssertionsAll
AssertionsPre	Only run preconditions
AssertionsPost	Only run postconditions
AssertionsOff

Instances

Instances details

Eq AssertionPolicy Source #
Instance details Defined in Control.State.Transition.Extended Methods (==) :: AssertionPolicy -> AssertionPolicy -> Bool Source # (/=) :: AssertionPolicy -> AssertionPolicy -> Bool Source #
Show AssertionPolicy Source #
Instance details Defined in Control.State.Transition.Extended Methods showsPrec :: Int -> AssertionPolicy -> ShowS Source # show :: AssertionPolicy -> String Source # showList :: [ AssertionPolicy ] -> ShowS Source #

type Label = String Source #

Label for a predicate. This can be used to control which predicates get run.

type Rule sts rtype = F (Clause sts rtype) Source #

class EventReturnTypeRep ert Source #

Minimal complete definition

eventReturnTypeRep

Instances

Instances details

EventReturnTypeRep ' EventPolicyReturn Source #
Instance details Defined in Control.State.Transition.Extended Methods eventReturnTypeRep :: SingEP ' EventPolicyReturn
EventReturnTypeRep ' EventPolicyDiscard Source #
Instance details Defined in Control.State.Transition.Extended Methods eventReturnTypeRep :: SingEP ' EventPolicyDiscard

type family EventReturnType ep sts a :: Type where ... Source #

Equations

EventReturnType ' EventPolicyReturn sts a = (a, [ Event sts])
EventReturnType _ _ a = a

data SingEP ep where Source #

Constructors

EPReturn :: SingEP ' EventPolicyReturn
EPDiscard :: SingEP ' EventPolicyDiscard

data EventPolicy Source #

Constructors

EventPolicyReturn
EventPolicyDiscard

class ( STS sub, BaseM sub ~ BaseM super) => Embed sub super where Source #

Embed one STS within another.

Minimal complete definition

wrapFailed

Methods

wrapFailed :: PredicateFailure sub -> PredicateFailure super Source #

Wrap a predicate failure of the subsystem in a failure of the super-system.

wrapEvent :: Event sub -> Event super Source #

default wrapEvent :: Coercible ( Event sub) ( Event super) => Event sub -> Event super Source #

Instances

Instances details

STS sts => Embed sts sts Source #
Instance details Defined in Control.State.Transition.Extended Methods wrapFailed :: PredicateFailure sts -> PredicateFailure sts Source # wrapEvent :: Event sts -> Event sts Source #

class ( Eq ( PredicateFailure a), Show ( PredicateFailure a), Monad ( BaseM a), Typeable a) => STS a where Source #

State transition system.

Minimal complete definition

transitionRules

Associated Types

type State a :: Type Source #

Type of the state which the system transitions between.

type Signal a :: Type Source #

Signal triggering a state change.

type Environment a :: Type Source #

Environment type.

type BaseM a :: Type -> Type Source #

Monad into which to interpret the rules.

type BaseM a = Identity

type Event a :: Type Source #

Event type.

type Event a = Void

type PredicateFailure a :: Type Source #

Descriptive type for the possible failures which might cause a transition to fail.

As a convention, PredicateFailure s which are "structural" (meaning that they are not "throwable" in practice, and are used to pass control from one transition rule to another) are prefixed with S_ .

Structural PredicateFailure s represent conditions between rules where the disjunction of all rules' preconditions is equal to True . That is, either one rule will throw a structural PredicateFailure and the other will succeed, or vice-versa.

Methods

initialRules :: [ InitialRule a] Source #

Rules governing transition under this system.

default initialRules :: Default ( State a) => [ InitialRule a] Source #

transitionRules :: [ TransitionRule a] Source #

assertions :: [ Assertion a] Source #

Assertions about the transition system.

renderAssertionViolation :: AssertionViolation a -> String Source #

Render an assertion violation.

Defaults to using show , but note that this does not know how to render the context. So for more information you should define your own renderer here.

Instances

Instances details

( Eq f, Monad m, Show f, Typeable e, Typeable f, Typeable si, Typeable st, Typeable m) => STS ( STUB e st si f m) Source #

Instance details

Defined in Control.State.Transition.Extended

Associated Types

type State ( STUB e st si f m) Source #

type Signal ( STUB e st si f m) Source #

type Environment ( STUB e st si f m) Source #

type BaseM ( STUB e st si f m) :: Type -> Type Source #

type Event ( STUB e st si f m) Source #

type PredicateFailure ( STUB e st si f m) Source #

Methods

initialRules :: [ InitialRule ( STUB e st si f m)] Source #

transitionRules :: [ TransitionRule ( STUB e st si f m)] Source #

assertions :: [ Assertion ( STUB e st si f m)] Source #

renderAssertionViolation :: AssertionViolation ( STUB e st si f m) -> String Source #

data AssertionException where Source #

Constructors

AssertionException :: forall sts. STS sts => AssertionViolation sts -> AssertionException

Instances

Instances details

Show AssertionException Source #
Instance details Defined in Control.State.Transition.Extended Methods showsPrec :: Int -> AssertionException -> ShowS Source # show :: AssertionException -> String Source # showList :: [ AssertionException ] -> ShowS Source #
Exception AssertionException Source #
Instance details Defined in Control.State.Transition.Extended Methods toException :: AssertionException -> SomeException Source # fromException :: SomeException -> Maybe AssertionException Source # displayException :: AssertionException -> String Source #

data AssertionViolation sts Source #

Constructors

AssertionViolation
Fields avSTS :: String avMsg :: String avCtx :: TRC sts avState :: Maybe ( State sts)

Instances

Instances details

STS sts => Show ( AssertionViolation sts) Source #
Instance details Defined in Control.State.Transition.Extended Methods showsPrec :: Int -> AssertionViolation sts -> ShowS Source # show :: AssertionViolation sts -> String Source # showList :: [ AssertionViolation sts] -> ShowS Source #

data Assertion sts Source #

An assertion is a validation condition for the STS system in question. It should be used to define properties of the system as a whole that cannot be violated under normal circumstances - e.g. a violation implies a failing in the rule logic.

Assertions should not check for conditions that may differ between different rules in a system, since the interpreter may stop the system upon presence of a failed assertion.

Whether assertions are checked is a matter for the STS interpreter.

Constructors

PreCondition String ( TRC sts -> Bool )	Pre-condition. Checked before the rule fires.
PostCondition String ( TRC sts -> State sts -> Bool )	Post-condition. Checked after the rule fires, and given access to the resultant state as well as the initial context.

type TransitionRule sts = Rule sts ' Transition ( State sts) Source #

type InitialRule sts = Rule sts ' Initial ( State sts) Source #

type family RuleContext (t :: RuleType ) = (ctx :: Type -> Type ) | ctx -> t where ... Source #

Equations

RuleContext ' Initial = IRC
RuleContext ' Transition = TRC

newtype TRC sts Source #

Context available to transition rules.

Constructors

TRC ( Environment sts, State sts, Signal sts)

Instances

Instances details

( Show ( Environment sts), Show ( State sts), Show ( Signal sts)) => Show ( TRC sts) Source #
Instance details Defined in Control.State.Transition.Extended Methods showsPrec :: Int -> TRC sts -> ShowS Source # show :: TRC sts -> String Source # showList :: [ TRC sts] -> ShowS Source #

newtype IRC sts Source #

Context available to initial rules.

Constructors

IRC ( Environment sts)

class RuleTypeRep t Source #

Minimal complete definition

rTypeRep

Instances

Instances details

RuleTypeRep ' Initial Source #
Instance details Defined in Control.State.Transition.Extended Methods rTypeRep :: SRuleType ' Initial
RuleTypeRep ' Transition Source #
Instance details Defined in Control.State.Transition.Extended Methods rTypeRep :: SRuleType ' Transition

data RuleType Source #

Constructors

Initial
Transition

mapEventReturn :: forall ep sts a b. EventReturnTypeRep ep => (a -> b) -> EventReturnType ep sts a -> EventReturnType ep sts b Source #

Map over an arbitrary EventReturnType .

validate :: Validation ( NonEmpty ( PredicateFailure sts)) () -> Rule sts ctx () Source #

Fail with PredicateFailure 's in STS if Validation was unsuccessful.

validateTrans Source #

Arguments

:: (e -> PredicateFailure sts)	Transformation function for all errors
-> Validation ( NonEmpty e) ()
-> Rule sts ctx ()

Same as validation , except with ability to transform opaque failures into PredicateFailure s with a help of supplied function.

validateTransLabeled Source #

Arguments

:: (e -> PredicateFailure sts)	Transformation function for all errors
-> NonEmpty Label	Supply a list of labels to be used as filters when STS is executed
-> Validation ( NonEmpty e) ()	Actual validations to be executed
-> Rule sts ctx ()

Same as validation , except with ability to translate opaque failures into PredicateFailure s with a help of supplied function.

(?!) :: Bool -> PredicateFailure sts -> Rule sts ctx () infix 1 Source #

Oh noes!

This takes a condition (a boolean expression) and a failure and results in a clause which will throw that failure if the condition fails.

failBecause :: PredicateFailure sts -> Rule sts ctx () Source #

(?!:) :: Either e () -> (e -> PredicateFailure sts) -> Rule sts ctx () Source #

Oh noes with an explanation

We interpret this as "What?" "No!" "Because:"

labeledPred :: NonEmpty Label -> Bool -> PredicateFailure sts -> Rule sts ctx () Source #

Labeled predicate. This may be used to control which predicates are run using ValidateSuchThat .

labeledPredE :: NonEmpty Label -> Either e () -> (e -> PredicateFailure sts) -> Rule sts ctx () Source #

Labeled predicate with an explanation

labeled :: NonEmpty Label -> Rule sts ctx () -> Rule sts ctx () Source #

Labeled clause. This will only be executed if the interpreter is set to execute clauses with this label.

trans :: Embed sub super => RuleContext rtype sub -> Rule super rtype ( State sub) Source #

ifFailureFree :: Rule sts rtype a -> Rule sts rtype a -> Rule sts rtype a Source #

whenFailureFree :: Rule sts rtype () -> Rule sts rtype () Source #

liftSTS :: STS sts => BaseM sts a -> Rule sts ctx a Source #

judgmentContext :: Rule sts rtype ( RuleContext rtype sts) Source #

Get the judgment context

applySTSOpts :: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => ApplySTSOpts ep -> RuleContext rtype s -> m ( EventReturnType ep s ( State s, [ PredicateFailure s])) Source #

Apply an STS with options. Note that this returns both the final state and the list of predicate failures.

applySTSOptsEither :: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => ApplySTSOpts ep -> RuleContext rtype s -> m ( Either [ PredicateFailure s] ( EventReturnType ep s ( State s))) Source #

globalAssertionPolicy :: AssertionPolicy Source #

reapplySTS :: forall s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s) => RuleContext rtype s -> m ( State s) Source #

Re-apply an STS.

It is assumed that the caller of this function has previously applied this STS, and can guarantee that it completed successfully. No predicates or assertions will be checked when calling this function.

applyRuleInternal Source #

Arguments

:: forall (ep :: EventPolicy ) s m rtype. ( STS s, RuleTypeRep rtype, m ~ BaseM s)
=> IsFailing	We need to know if the current STS incurred at least one PredicateFailure. This is necessary because `applyRuleInternal` is called recursively through the `goSTS` argument, which will not have access to any of the predicate failures occured in other branches of STS rule execusion tree.
-> SingEP ep
-> ValidationPolicy
-> (IsFailing -> STSInterpreter ep)	Interpreter for subsystems
-> RuleContext rtype s
-> Rule s rtype ( State s)
-> m ( EventReturnType ep s ( State s, [ PredicateFailure s]))

Apply a rule even if its predicates fail.

If the rule successfully applied, the list of predicate failures will be empty.

applySTSInternal Source #

Arguments

:: forall s m rtype ep. ( STS s, RuleTypeRep rtype, m ~ BaseM s)
=> SingEP ep
-> AssertionPolicy
-> RuleInterpreter ep	Interpreter for rules
-> RuleContext rtype s
-> ExceptT ( AssertionViolation s) m ( EventReturnType ep s ( State s, [ PredicateFailure s]))

sfor_ :: ( Foldable t, Applicative f) => t a -> (a -> f b) -> f () Source #

sfor_ is straverse_ with its arguments flipped. For a version that doesn't ignore the results see for .

>>> sfor_ ([1..4] :: [Int]) print
1
2
3
4

tellEvent :: Event sts -> Rule sts ctx () Source #

tellEvents :: [ Event sts] -> Rule sts ctx () Source #