Ideas.Common.Exercise

This module defines the concept of an exercise

Exercises

data Exercise a

Instances

Apply Exercise

Typed a (Some Exercise)

Typed a (Exercise a)

Eq (Exercise a)

Ord (Exercise a)

HasId (Exercise a)

makeExercise :: (Show a, Eq a, IsTerm a) => Exercise a

emptyExercise :: Exercise a

exerciseId :: Exercise a -> Id

status :: Exercise a -> Status

parser :: Exercise a -> String -> Either String a

prettyPrinter :: Exercise a -> a -> String

equivalence :: Exercise a -> Context a -> Context a -> Bool

similarity :: Exercise a -> Context a -> Context a -> Bool

ready :: Exercise a -> Predicate a

suitable :: Exercise a -> Predicate a

isReady :: Exercise a -> a -> Bool

isSuitable :: Exercise a -> a -> Bool

hasTermView :: Exercise a -> Maybe (View Term a)

strategy :: Exercise a -> LabeledStrategy (Context a)

navigation :: Exercise a -> a -> ContextNavigator a

canBeRestarted :: Exercise a -> Bool

extraRules :: Exercise a -> [Rule (Context a)]

ruleOrdering :: Exercise a -> Rule (Context a) -> Rule (Context a) -> Ordering

difference :: Exercise a -> a -> a -> Maybe (a, a)

differenceEqual :: Exercise a -> a -> a -> Maybe (a, a)

testGenerator :: Exercise a -> Maybe (Gen a)

randomExercise :: Exercise a -> Maybe (StdGen -> Maybe Difficulty -> a)

examples :: Exercise a -> [(Difficulty, a)]

getRule :: Monad m => Exercise a -> Id -> m (Rule (Context a))

simpleGenerator :: Gen a -> Maybe (StdGen -> Maybe Difficulty -> a)

useGenerator :: (a -> Bool) -> (Maybe Difficulty -> Gen a) -> Maybe (StdGen -> Maybe Difficulty -> a)

randomTerm :: Exercise a -> Maybe Difficulty -> IO a

randomTermWith :: StdGen -> Exercise a -> Maybe Difficulty -> Maybe a

ruleset :: Exercise a -> [Rule (Context a)]

makeContext :: Exercise a -> Environment -> a -> Context a

inContext :: Exercise a -> a -> Context a

Put a value into an empty environment

recognizeRule :: Exercise a -> Rule (Context a) -> Context a -> Context a -> [(Location, Environment)]

ruleOrderingWith :: [Rule a] -> Rule a -> Rule a -> Ordering

ruleOrderingWithId :: HasId b => [b] -> Rule a -> Rule a -> Ordering

type Examples a = [(Difficulty, a)]

mapExamples :: (a -> b) -> Examples a -> Examples b

examplesContext :: Exercise a -> Examples (Context a)

data Difficulty

Constructors

VeryEasy

Easy

Medium

Difficult

VeryDifficult

Instances

Enum Difficulty

Eq Difficulty

Ord Difficulty

Show Difficulty

Typed a Difficulty

readDifficulty :: String -> Maybe Difficulty

level :: Difficulty -> [a] -> Examples a

hasTypeable :: Exercise a -> Maybe (IsTypeable a)

useTypeable :: Typeable a => Maybe (IsTypeable a)

castFrom :: Typeable b => Exercise a -> a -> Maybe b

castTo :: Typeable b => Exercise a -> b -> Maybe a

Exercise status

data Status

Constructors

Stable

A released exercise that has undergone some thorough testing

Provisional

A released exercise, possibly with some deficiencies

Alpha

An exercise that is under development

Experimental

An exercise for experimentation purposes only

Instances

Eq Status

Show Status

isPublic :: Exercise a -> Bool

An exercise with the status Stable or Provisional

isPrivate :: Exercise a -> Bool

An exercise that is not public

Miscellaneous

withoutContext :: (a -> a -> Bool) -> Context a -> Context a -> Bool

Function for defining equivalence or similarity without taking the context into account.

simpleSimilarity :: Exercise a -> a -> a -> Bool

Similarity on terms without a context

simpleEquivalence :: Exercise a -> a -> a -> Bool

Equivalence on terms without a context

prettyPrinterContext :: Exercise a -> Context a -> String

restrictGenerator :: (a -> Bool) -> Gen a -> Gen a

showDerivation :: Exercise a -> a -> String

Shows a derivation for a given start term. The specified rule ordering is used for selection.

printDerivation :: Exercise a -> a -> IO ()

type ExerciseDerivation a = Derivation (Rule (Context a), Environment) (Context a)

defaultDerivation :: Exercise a -> a -> ExerciseDerivation a

derivationDiffEnv :: Derivation s (Context a) -> Derivation (s, Environment) (Context a)

checkExercise :: Exercise a -> IO ()

checkParserPretty :: (a -> a -> Bool) -> (String -> Either String a) -> (a -> String) -> a -> Bool

checkExamples :: Exercise a -> TestSuite

exerciseTestSuite :: Exercise a -> TestSuite