ideas-1.5: Feedback services for intelligent tutoring systems

Maintainerbastiaan.heeren@ou.nl
Stabilityprovisional
Portabilityportable (depends on ghc)
Safe HaskellNone
LanguageHaskell98

Ideas.Common.Strategy.Combinators

Description

A collection of strategy combinators: all lifted to work on different data types

Synopsis

Documentation

(.*.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 5 Source

Put two strategies in sequence (first do this, then do that)

(.|.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 3 Source

Choose between the two strategies (either do this or do that)

(.%.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 2 Source

Interleave two strategies

(.@.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 2 Source

Alternate two strategies

(!~>) :: IsStrategy f => Rule a -> f a -> Strategy a infixr 5 Source

Prefixing a basic rule to a strategy atomically

inits :: IsStrategy f => f a -> Strategy a Source

Initial prefixes (allows the strategy to stop succesfully at any time)

succeed :: Strategy a Source

The strategy that always succeeds (without doing anything)

fail :: Strategy a Source

The strategy that always fails

atomic :: IsStrategy f => f a -> Strategy a Source

Makes a strategy atomic (w.r.t. parallel composition)

sequence :: IsStrategy f => [f a] -> Strategy a Source

Puts a list of strategies into a sequence

choice :: IsStrategy f => [f a] -> Strategy a Source

Combines a list of alternative strategies

interleave :: IsStrategy f => [f a] -> Strategy a Source

Merges a list of strategies (in parallel)

permute :: IsStrategy f => [f a] -> Strategy a Source

Allows all permutations of the list

many :: IsStrategy f => f a -> Strategy a Source

Repeat a strategy zero or more times (non-greedy)

many1 :: IsStrategy f => f a -> Strategy a Source

Apply a certain strategy at least once (non-greedy)

replicate :: IsStrategy f => Int -> f a -> Strategy a Source

Apply a strategy a certain number of times

option :: IsStrategy f => f a -> Strategy a Source

Apply a certain strategy or do nothing (non-greedy)

check :: (a -> Bool) -> Strategy a Source

Checks whether a predicate holds for the current term. The check is considered to be a minor step.

not :: IsStrategy f => f a -> Strategy a Source

Check whether or not the argument strategy cannot be applied: the result strategy only succeeds if this is not the case (otherwise it fails).

repeat :: IsStrategy f => f a -> Strategy a Source

Repeat a strategy zero or more times (greedy version of many)

repeat1 :: IsStrategy f => f a -> Strategy a Source

Apply a certain strategy at least once (greedy version of many1)

try :: IsStrategy f => f a -> Strategy a Source

Apply a certain strategy if this is possible (greedy version of option)

(./.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 4 Source

Choose between the two strategies, with a preference for steps from the left hand-side strategy.

(|>) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a infixr 4 Source

Left-biased choice: if the left-operand strategy can be applied, do so. Otherwise, try the right-operand strategy

while :: IsStrategy f => (a -> Bool) -> f a -> Strategy a Source

Repeat the strategy as long as the predicate holds

until :: IsStrategy f => (a -> Bool) -> f a -> Strategy a Source

Repeat the strategy until the predicate holds

exhaustive :: IsStrategy f => [f a] -> Strategy a Source

Apply the strategies from the list exhaustively (until this is no longer possible)

type DependencyGraph node key = [(node, key, [key])] Source

dependencyGraph :: (IsStrategy f, Ord key) => DependencyGraph (f a) key -> Strategy a Source

Create a strategy from a dependency graph with strategies as nodes Does not check for cycles