UniqueLogic.ST.Expression

Documentation

data T var w s a

An expression is defined by a set of equations and the variable at the top-level. The value of the expression equals the value of the top variable.

Instances

(Fractional a, Var var, Monoid w) => Fractional (T var w s a)

(Fractional a, Var var, Monoid w) => Num (T var w s a)

Construct primitive expressions

constant :: (Var var, Monoid w) => a -> T var w s a

Make a constant expression of a simple numeric value.

fromVariable :: var w s a -> T var w s a

Operators from rules with small numbers of arguments

fromRule1 :: (Var var, Monoid w) => (var w s a -> T w s ()) -> T var w s a

fromRule2 :: (Var var, Monoid w) => (var w s a -> var w s b -> T w s ()) -> T var w s a -> T var w s b

fromRule3 :: (Var var, Monoid w) => (var w s a -> var w s b -> var w s c -> T w s ()) -> T var w s a -> T var w s b -> T var w s c

Operators from rules with any number of arguments

data Apply w s f

Instances

Functor (Apply w s)

Applicative (Apply w s)

arg :: T var w s a -> Apply w s (var w s a)

This function allows to generalize fromRule2 and fromRule3 to more arguments using Applicative combinators.

Example:

 fromRule3 rule x y
    = runApply $ liftA2 rule (arg x) (arg y)
    = runApply $ pure rule <*> arg x <*> arg y

Building rules with arg provides more granularity than using auxiliary pair rules!

runApply :: (Var var, Monoid w) => Apply w s (var w s a -> T w s ()) -> T var w s a

Predicates on expressions

(=:=) :: (Var var, Monoid w) => T var w s a -> T var w s a -> T w s ()

Common operators (see also Num and Fractional instances)

(=!=) :: (Var var, Monoid w) => T var w s a -> T var w s a -> T var w s a

sqr :: (Floating a, Var var, Monoid w) => T var w s a -> T var w s a

sqrt :: (Floating a, Var var, Monoid w) => T var w s a -> T var w s a

max :: (Ord a, Var var, Monoid w) => T var w s a -> T var w s a -> T var w s a

We are not able to implement a full Ord instance including Eq superclass and comparisons, but we need to compute maxima.

maximum :: (Ord a, Var var, Monoid w) => [T var w s a] -> T var w s a

pair :: (Var var, Monoid w) => T var w s a -> T var w s b -> T var w s (a, b)

Construct or decompose a pair.