Test.StateMachine.Z

This module contains Z-inspried combinators for working with relations. The idea is that they can be used to define concise and showable models. This module is an experiment and will likely change or move to its own package.

Documentation

union :: Eq a => [a] -> [a] -> [a]

intersect :: Eq a => [a] -> [a] -> [a]

isSubsetOf :: Eq a => [a] -> [a] -> Bool

(~=) :: Eq a => [a] -> [a] -> Bool

type Rel a b = [(a, b)]

Relations.

type Fun a b = Rel a b

(Partial) functions.

empty :: Rel a b

identity :: [a] -> Rel a a

singleton :: a -> b -> Rel a b

domain :: Rel a b -> [a]

codomain :: Rel a b -> [b]

compose :: Eq b => Rel b c -> Rel a b -> Rel a c

fcompose :: Eq b => Rel a b -> Rel b c -> Rel a c

inverse :: Rel a b -> Rel b a

lookupDom :: Eq a => a -> Rel a b -> [b]

lookupCod :: Eq b => b -> Rel a b -> [a]

(<|) :: Eq a => [a] -> Rel a b -> Rel a b

Domain restriction.

>>> ['a'] <| [ ('a', "apa"), ('b', "bepa") ]
[('a',"apa")]

(|>) :: Eq b => Rel a b -> [b] -> Rel a b

Codomain restriction.

>>> [ ('a', "apa"), ('b', "bepa") ] |> ["apa"]
[('a',"apa")]

(<-|) :: Eq a => [a] -> Rel a b -> Rel a b

Domain substraction.

>>> ['a'] <-| [ ('a', "apa"), ('b', "bepa") ]
[('b',"bepa")]

(|->) :: Eq b => Rel a b -> [b] -> Rel a b

Codomain substraction.

>>> [ ('a', "apa"), ('b', "bepa") ] |-> ["apa"]
[('b',"bepa")]

image :: Eq a => Rel a b -> [a] -> [b]

The image of a relation.

(<+) :: (Eq a, Eq b) => Rel a b -> Rel a b -> Rel a b

Overriding.

>>> [('a', "apa")] <+ [('a', "bepa")]
[('a',"bepa")]

>>> [('a', "apa")] <+ [('b', "bepa")]
[('a',"apa"),('b',"bepa")]

(<**>) :: Eq a => Rel a b -> Rel a c -> Rel a (b, c)

Direct product.

(<||>) :: Rel a c -> Rel b d -> Rel (a, b) (c, d)

Parallel product.

isTotalRel :: Eq a => Rel a b -> [a] -> Bool

isSurjRel :: Eq b => Rel a b -> [b] -> Bool

isTotalSurjRel :: (Eq a, Eq b) => Rel a b -> [a] -> [b] -> Bool

isPartialFun :: (Eq a, Eq b) => Rel a b -> Bool

isTotalFun :: (Eq a, Eq b) => Rel a b -> [a] -> Bool

isPartialInj :: (Eq a, Eq b) => Rel a b -> Bool

isTotalInj :: (Eq a, Eq b) => Rel a b -> [a] -> Bool

isPartialSurj :: (Eq a, Eq b) => Rel a b -> [b] -> Bool

isTotalSurj :: (Eq a, Eq b) => Rel a b -> [a] -> [b] -> Bool

isBijection :: (Eq a, Eq b) => Rel a b -> [a] -> [b] -> Bool

(!) :: (Eq a, Show a, Show b) => Fun a b -> a -> b

Application.

(.%) :: (Eq a, Eq b, Show a, Show b) => (Fun a b, a) -> (b -> b) -> Fun a b

(.!) :: Rel a b -> a -> (Rel a b, a)

(.=) :: (Eq a, Eq b) => (Rel a b, a) -> b -> Rel a b

Assignment.

>>> singleton 'a' "apa" .! 'a' .= "bepa"
[('a',"bepa")]

>>> singleton 'a' "apa" .! 'b' .= "bepa"
[('a',"apa"),('b',"bepa")]