| Maintainer | bastiaan.heeren@ou.nl |
|---|---|
| Stability | provisional |
| Portability | portable (depends on ghc) |
| Safe Haskell | None |
| Language | Haskell98 |
Ideas.Common.Strategy
Contents
Description
A strategy is a context-free grammar with rules as symbols. Strategies can be
labeled with strings. The type class IsStrategy is introduced to lift
functions and combinators that work on strategies to also accept rules and
labeled strategies. This module re-exports the most important functionality
of the underlying modules.
- data Strategy a
- data LabeledStrategy a
- class IsStrategy f where
- derivationList :: IsStrategy f => (Rule a -> Rule a -> Ordering) -> f a -> a -> [Derivation (Rule a, Environment) a]
- (.*.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- (.|.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- (.%.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- (.@.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- (!~>) :: IsStrategy f => Rule a -> f a -> Strategy a
- succeed :: Strategy a
- fail :: Strategy a
- atomic :: IsStrategy f => f a -> Strategy a
- label :: (IsId l, IsStrategy f) => l -> f a -> LabeledStrategy a
- inits :: IsStrategy f => f a -> Strategy a
- sequence :: IsStrategy f => [f a] -> Strategy a
- choice :: IsStrategy f => [f a] -> Strategy a
- alternatives :: IsStrategy f => [f a] -> Strategy a
- interleave :: IsStrategy f => [f a] -> Strategy a
- permute :: IsStrategy f => [f a] -> Strategy a
- many :: IsStrategy f => f a -> Strategy a
- many1 :: IsStrategy f => f a -> Strategy a
- replicate :: IsStrategy f => Int -> f a -> Strategy a
- option :: IsStrategy f => f a -> Strategy a
- check :: (a -> Bool) -> Strategy a
- not :: IsStrategy f => f a -> Strategy a
- repeat :: IsStrategy f => f a -> Strategy a
- repeat1 :: IsStrategy f => f a -> Strategy a
- try :: IsStrategy f => f a -> Strategy a
- (|>) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- (./.) :: (IsStrategy f, IsStrategy g) => f a -> g a -> Strategy a
- exhaustive :: IsStrategy f => [f a] -> Strategy a
- while :: IsStrategy f => (a -> Bool) -> f a -> Strategy a
- until :: IsStrategy f => (a -> Bool) -> f a -> Strategy a
- dynamic :: (IsId n, IsStrategy f, IsTerm a) => n -> (a -> f a) -> Strategy a
- type DependencyGraph node key = [(node, key, [key])]
- dependencyGraph :: (IsStrategy f, Ord key) => DependencyGraph (f a) key -> Strategy a
- module Ideas.Common.Strategy.Traversal
- module Ideas.Common.Strategy.Configuration
- strategyLocations :: LabeledStrategy a -> [([Int], Id)]
- checkLocation :: Id -> LabeledStrategy a -> Bool
- subTaskLocation :: LabeledStrategy a -> Id -> Id -> Id
- nextTaskLocation :: LabeledStrategy a -> Id -> Id -> Id
- data Prefix a
- emptyPrefix :: IsStrategy f => f a -> a -> Prefix a
- noPrefix :: Prefix a
- replayPath :: IsStrategy f => Path -> f a -> a -> ([Rule a], Prefix a)
- replayPaths :: IsStrategy f => [Path] -> f a -> a -> Prefix a
- replayStrategy :: (Monad m, IsStrategy f) => Path -> f a -> a -> m (a, Prefix a)
- data Path
- emptyPath :: Path
- readPath :: Monad m => String -> m Path
- readPaths :: Monad m => String -> m [Path]
- prefixPaths :: Prefix a -> [Path]
- majorPrefix :: Prefix a -> Prefix a
- isEmptyPrefix :: Prefix a -> Bool
- cleanUpStrategy :: (a -> a) -> LabeledStrategy a -> LabeledStrategy a
- cleanUpStrategyAfter :: (a -> a) -> LabeledStrategy a -> LabeledStrategy a
- rulesInStrategy :: IsStrategy f => f a -> [Rule a]
Data types and type classes
Abstract data type for strategies
class IsStrategy f where Source #
Type class to turn values into strategies
Minimal complete definition
Methods
toStrategy :: f a -> Strategy a Source #
Running strategies
derivationList :: IsStrategy f => (Rule a -> Rule a -> Ordering) -> f a -> a -> [Derivation (Rule a, Environment) a] Source #
Strategy combinators
Basic combinators
(.*.) :: (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
atomic :: IsStrategy f => f a -> Strategy a Source #
Makes a strategy atomic (w.r.t. parallel composition)
label :: (IsId l, IsStrategy f) => l -> f a -> LabeledStrategy a Source #
inits :: IsStrategy f => f a -> Strategy a Source #
Initial prefixes (allows the strategy to stop succesfully at any time)
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
alternatives :: IsStrategy f => [f a] -> Strategy a Source #
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
EBNF combinators
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)
Negation and greedy combinators
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 #
Left-biased choice: if the left-operand strategy can be applied, do so. Otherwise, try the right-operand strategy
(./.) :: (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.
exhaustive :: IsStrategy f => [f a] -> Strategy a Source #
Apply the strategies from the list exhaustively (until this is no longer possible)
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
dynamic :: (IsId n, IsStrategy f, IsTerm a) => n -> (a -> f a) -> Strategy a Source #
The structure of a dynamic strategy depends on the current term
Graph
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
Traversal combinators
Configuration combinators
Strategy locations
strategyLocations :: LabeledStrategy a -> [([Int], Id)] Source #
Returns a list of all strategy locations, paired with the label
checkLocation :: Id -> LabeledStrategy a -> Bool Source #
subTaskLocation :: LabeledStrategy a -> Id -> Id -> Id Source #
nextTaskLocation :: LabeledStrategy a -> Id -> Id -> Id Source #
Prefixes
emptyPrefix :: IsStrategy f => f a -> a -> Prefix a Source #
Construct the empty prefix for a labeled strategy
replayPath :: IsStrategy f => Path -> f a -> a -> ([Rule a], Prefix a) Source #
Construct a prefix for a path and a labeled strategy. The third argument is the current term.
replayPaths :: IsStrategy f => [Path] -> f a -> a -> Prefix a Source #
Construct a prefix for a list of paths and a labeled strategy. The third argument is the current term.
replayStrategy :: (Monad m, IsStrategy f) => Path -> f a -> a -> m (a, Prefix a) Source #
Construct a prefix for a path and a labeled strategy. The third argument is the initial term.
A path encodes a location in a strategy. Paths are represented as a list of integers and terms (the latter act as input for the dynamic strategies).
prefixPaths :: Prefix a -> [Path] Source #
Returns the current Path.
majorPrefix :: Prefix a -> Prefix a Source #
Transforms the prefix such that only major steps are kept in the remaining strategy.
isEmptyPrefix :: Prefix a -> Bool Source #
Misc
cleanUpStrategy :: (a -> a) -> LabeledStrategy a -> LabeledStrategy a Source #
Use a function as do-after hook for all rules in a labeled strategy, but also use the function beforehand
cleanUpStrategyAfter :: (a -> a) -> LabeledStrategy a -> LabeledStrategy a Source #
Use a function as do-after hook for all rules in a labeled strategy
rulesInStrategy :: IsStrategy f => f a -> [Rule a] Source #
Returns a list of all major rules that are part of a labeled strategy