-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Solve simple simultaneous equations
--   
--   Solve a number of equations simultaneously. This is not Computer
--   Algebra, better think of a kind of type inference algorithm or logic
--   programming with only one allowed solution.
--   
--   Only one solution is computed. Simultaneous equations with multiple
--   solutions are not allowed. However, variables may remain undefined. We
--   do not even check for consistency, since with floating point numbers
--   even simple rules may not be consistent.
--   
--   The modules ordered with respect to abstraction level:
--   
--   <ul>
--   <li><a>UniqueLogic.ST.System</a>: Construct and solve sets of
--   functional dependencies. Example: <tt>assignment3 (+) a b c</tt>
--   meaning dependency <tt>a+b -&gt; c</tt>.</li>
--   <li><a>UniqueLogic.ST.Rule</a>: Combine functional dependencies to
--   rules that can apply in multiple directions. Example: <tt>add a b
--   c</tt> means relation <tt>a+b = c</tt> which resolves to dependencies
--   <tt>a+b -&gt; c, c-a -&gt; b, c-b -&gt; a</tt>.</li>
--   <li><a>UniqueLogic.ST.Expression</a>: Allow to write rules using
--   arithmetic operators. It creates temporary variables automatically.
--   Example: <tt>(a+b)*c =:= d</tt> resolves to <tt>a+b = x, x*c =
--   d</tt>.</li>
--   </ul>
@package unique-logic
@version 0.2

module UniqueLogic.ST.System
data Variable s a
globalVariable :: ST s (Variable s a)
data M s a
localVariable :: M s (Variable s a)
constant :: a -> M s (Variable s a)
assignment2 :: String -> (a -> b) -> Variable s a -> Variable s b -> M s ()
assignment3 :: String -> (a -> b -> c) -> Variable s a -> Variable s b -> Variable s c -> M s ()
data Apply s a

-- | This function allows to generalize <a>assignment2</a> and
--   <a>assignment3</a> to more arguments. You could achieve the same with
--   nested applications of <tt>assignment3 (,)</tt>.
arg :: Variable s a -> Apply s a
runApply :: String -> Apply s a -> Variable s a -> M s ()
solve :: M s a -> ST s a
query :: Variable s a -> ST s (Maybe a)
instance Applicative (Apply s)
instance Functor (Apply s)
instance Monad (M s)
instance Applicative (M s)
instance Functor (M s)

module UniqueLogic.ST.Rule
generic2 :: String -> (b -> a) -> (a -> b) -> Variable s a -> Variable s b -> M s ()
generic3 :: String -> (b -> c -> a) -> (c -> a -> b) -> (a -> b -> c) -> Variable s a -> Variable s b -> Variable s c -> M s ()
equ :: Eq a => Variable s a -> Variable s a -> M s ()
pair :: Variable s a -> Variable s b -> Variable s (a, b) -> M s ()
max :: Ord a => Variable s a -> Variable s a -> Variable s a -> M s ()
add :: Num a => Variable s a -> Variable s a -> Variable s a -> M s ()
mul :: Fractional a => Variable s a -> Variable s a -> Variable s a -> M s ()
square :: Floating a => Variable s a -> Variable s a -> M s ()
pow :: Floating a => Variable s a -> Variable s a -> Variable s a -> M s ()

module UniqueLogic.ST.Expression

-- | 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.
data T s a

-- | Make a constant expression of a simple numeric value.
constant :: a -> T s a
fromVariable :: Variable s a -> T s a
fromRule1 :: (Variable s a -> M s ()) -> (T s a)
fromRule2 :: (Variable s a -> Variable s b -> M s ()) -> (T s a -> T s b)
fromRule3 :: (Variable s a -> Variable s b -> Variable s c -> M s ()) -> (T s a -> T s b -> T s c)
data Apply s f

-- | This function allows to generalize <a>fromRule2</a> and
--   <a>fromRule3</a> to more arguments using <a>Applicative</a>
--   combinators.
--   
--   Example:
--   
--   <pre>
--   fromRule3 rule x y
--      = runApply $ liftA2 rule (arg x) (arg y)
--      = runApply $ pure rule &lt;*&gt; arg x &lt;*&gt; arg y
--   </pre>
--   
--   Building rules with <a>arg</a> provides more granularity than using
--   auxiliary <a>pair</a> rules!
arg :: T s a -> Apply s (Variable s a)
runApply :: Apply s (Variable s a -> M s ()) -> T s a
(=:=) :: Eq a => T s a -> T s a -> M s ()
(=!=) :: Eq a => T s a -> T s a -> T s a
sqr :: Floating a => T s a -> T s a
sqrt :: Floating a => T s a -> T s a

-- | We are not able to implement a full Ord instance including Eq
--   superclass and comparisons, but we need to compute maxima.
max :: Ord a => T s a -> T s a -> T s a
maximum :: Ord a => [T s a] -> T s a

-- | Construct or decompose a pair.
pair :: T s a -> T s b -> T s (a, b)
instance Fractional a => Fractional (T s a)
instance Fractional a => Num (T s a)
instance Applicative (Apply s)
instance Functor (Apply s)