Advise-me-0.1: Assessment services for the Advise-Me project

Maintainer	bastiaan.heeren@ou.nl
Stability	provisional
Portability	portable (depends on ghc)
Safe Haskell	None
Language	Haskell98

Domain.Math.Power.Utils

Description

some of these help functions may have a broader scope and could be moved to other parts of the framework (eg. Common)

Synopsis

exhaustiveStrategy :: IsTerm a => [Rule a] -> Strategy (Context a)
exhaustiveUse :: (IsTerm a, IsTerm b) => [Rule a] -> Strategy (Context b)
exhaustiveSomewhere :: IsStrategy f => [f (Context a)] -> Strategy (Context a)
smartRule :: Rule Expr -> Rule Expr
mergeConstantsWith :: (Expr -> Bool) -> Expr -> Expr
mergeConstants :: Expr -> Expr
plainNatView :: View Expr Integer
myIntegerView :: View Expr Integer
plainRationalView :: View Rational (Integer, Integer)
eqView :: View a b -> View (Equation a) (b, b)
relationView :: View (Equation a) (Relation a)
naturalRules :: [Rule Expr]
rationalRules :: [Rule Expr]
coverUpRulesX :: [Rule (Equation Expr)]
sortExpr :: Expr -> Expr
sortEquation :: Equation Expr -> Equation Expr
sortOrList :: OrList (Equation Expr) -> OrList (Equation Expr)
class SemEq a where
- (===), (=/=) :: a -> a -> Bool
takeRoot :: Integer -> Integer -> Maybe Integer
swap :: (a, b) -> (b, a)
split :: Eq a => (a -> a -> t) -> [a] -> [(t, [a])]
toMaybe :: (a -> Bool) -> a -> Maybe a
joinBy :: Eq a => (a -> a -> Bool) -> [a] -> [[a]]
dropUntil :: (a -> a -> Bool) -> [a] -> [a]
holes :: [a] -> [(a, [a], a -> [a])]
twoNonAdjacentHoles :: [a] -> [((a, a), a -> [a])]

Documentation

exhaustiveStrategy :: IsTerm a => [Rule a] -> Strategy (Context a) Source #

Strategy functions -------------------------------------------------------

exhaustiveUse :: (IsTerm a, IsTerm b) => [Rule a] -> Strategy (Context b) Source #

exhaustiveSomewhere :: IsStrategy f => [f (Context a)] -> Strategy (Context a) Source #

smartRule :: Rule Expr -> Rule Expr Source #

Rule functions -----------------------------------------------------------

mergeConstantsWith :: (Expr -> Bool) -> Expr -> Expr Source #

mergeConstants :: Expr -> Expr Source #

plainNatView :: View Expr Integer Source #

View functions -----------------------------------------------------------

myIntegerView :: View Expr Integer Source #

plainRationalView :: View Rational (Integer, Integer) Source #

eqView :: View a b -> View (Equation a) (b, b) Source #

relationView :: View (Equation a) (Relation a) Source #

naturalRules :: [Rule Expr] Source #

Rule collections ---------------------------------------------------------

rationalRules :: [Rule Expr] Source #

coverUpRulesX :: [Rule (Equation Expr)] Source #

sortExpr :: Expr -> Expr Source #

Common functions ---------------------------------------------------------

sortEquation :: Equation Expr -> Equation Expr Source #

sortOrList :: OrList (Equation Expr) -> OrList (Equation Expr) Source #

class SemEq a where Source #

Minimal complete definition

Methods

(===) :: a -> a -> Bool infix 4 Source #

(=/=) :: a -> a -> Bool infix 4 Source #

Instances

SemEq Expr Source #
Instance details Defined in Domain.Math.Power.Utils Methods (===) :: Expr -> Expr -> Bool Source # (=/=) :: Expr -> Expr -> Bool Source #
SemEq a => SemEq (Equation a) Source #
Instance details Defined in Domain.Math.Power.Utils Methods (===) :: Equation a -> Equation a -> Bool Source # (=/=) :: Equation a -> Equation a -> Bool Source #
SemEq a => SemEq (OrList a) Source #
Instance details Defined in Domain.Math.Power.Utils Methods (===) :: OrList a -> OrList a -> Bool Source # (=/=) :: OrList a -> OrList a -> Bool Source #

takeRoot :: Integer -> Integer -> Maybe Integer Source #

swap :: (a, b) -> (b, a) Source #

split :: Eq a => (a -> a -> t) -> [a] -> [(t, [a])] Source #

toMaybe :: (a -> Bool) -> a -> Maybe a Source #

joinBy :: Eq a => (a -> a -> Bool) -> [a] -> [[a]] Source #

dropUntil :: (a -> a -> Bool) -> [a] -> [a] Source #

holes :: [a] -> [(a, [a], a -> [a])] Source #

twoNonAdjacentHoles :: [a] -> [((a, a), a -> [a])] Source #