Safe Haskell	None
Language	Haskell2010

Control.Iterate.Exp

Description

This module provides deep embeddings of three things 1) Exp is a deep embedding of expressions over Sets and Maps as a typed data structure. 2) Fun is a deep embedding of symbolic functions 3) Query is a deep embedding of queries over Sets and Maps. It can be thought of as a low-level compiled form of Exp

Synopsis

data Exp t where
- Base :: ( Ord k, Basic f, Iter f) => BaseRep f k v -> f k v -> Exp (f k v)
- Dom :: Ord k => Exp (f k v) -> Exp ( Sett k ())
- Rng :: ( Ord k, Ord v) => Exp (f k v) -> Exp ( Sett v ())
- DRestrict :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
- DExclude :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
- RRestrict :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
- RExclude :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
- Elem :: ( Ord k, Iter g, Show k) => k -> Exp (g k ()) -> Exp Bool
- NotElem :: ( Ord k, Iter g, Show k) => k -> Exp (g k ()) -> Exp Bool
- Intersect :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp ( Sett k ())
- Subset :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp Bool
- SetDiff :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp (f k v)
- UnionOverrideLeft :: ( Show k, Show v, Ord k) => Exp (f k v) -> Exp (g k v) -> Exp (f k v)
- UnionPlus :: ( Ord k, Monoid n) => Exp (f k n) -> Exp (g k n) -> Exp (f k n)
- UnionOverrideRight :: Ord k => Exp (f k v) -> Exp (g k v) -> Exp (f k v)
- Singleton :: Ord k => k -> v -> Exp ( Single k v)
- SetSingleton :: Ord k => k -> Exp ( Single k ())
- KeyEqual :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp Bool
class HasExp s t | s -> t where
- toExp :: s -> Exp t
dRestrict :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
rRestrict :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
dExclude :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
rExclude :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
dom :: ( Ord k, HasExp s (f k v)) => s -> Exp ( Sett k ())
rng :: ( Ord k, Ord v) => HasExp s (f k v) => s -> Exp ( Sett v ())
(◁) :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v)
(<|) :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v)
drestrict :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v)
(⋪) :: ( Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v)
dexclude :: ( Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v)
(▷) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v)
(|>) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v)
rrestrict :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v)
(⋫) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v)
rexclude :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v)
(∈) :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool
(∉) :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool
notelem :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool
(∪) :: ( Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v)
unionleft :: ( Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v)
(⨃) :: ( Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v)
unionright :: ( Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v)
(∪+) :: ( Ord k, Monoid n, HasExp s1 (f k n), HasExp s2 (g k n)) => s1 -> s2 -> Exp (f k n)
unionplus :: ( Ord k, Monoid n, HasExp s1 (f k n), HasExp s2 (g k n)) => s1 -> s2 -> Exp (f k n)
singleton :: Ord k => k -> v -> Exp ( Single k v)
setSingleton :: Ord k => k -> Exp ( Single k ())
(∩) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp ( Sett k ())
intersect :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp ( Sett k ())
(⊆) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool
subset :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool
(➖) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v)
setdiff :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v)
(≍) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool
keyeq :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool
data Fun t = Fun ( Lam t) t
data Pat env t where
- P1 :: Pat (d, c, b, a) d
- P2 :: Pat (d, c, b, a) c
- P3 :: Pat (d, c, b, a) b
- P4 :: Pat (d, c, b, a) a
- PPair :: Pat (d, c, b, a) a -> Pat (d, c, b, a) b -> Pat (d, c, b, a) (a, b)
data Expr env t where
- X1 :: Expr (d, c, b, a) d
- X2 :: Expr (d, c, b, a) c
- X3 :: Expr (d, c, b, a) b
- X4 :: Expr (d, c, b, a) a
- HasKey :: ( Iter f, Ord k) => Expr e k -> f k v -> Expr e Bool
- Neg :: Expr e Bool -> Expr e Bool
- Ap :: Lam (a -> b -> c) -> Expr e a -> Expr e b -> Expr e c
- EPair :: Expr e a -> Expr e b -> Expr e (a, b)
- FST :: Expr e (a, b) -> Expr e a
- SND :: Expr e (a, b) -> Expr e b
- Lit :: Show t => t -> Expr env t
data Lam t where
- Lam :: Pat (d, c, b, a) t -> Pat (d, c, b, a) s -> Expr (d, c, b, a) v -> Lam (t -> s -> v)
- Add :: Num n => Lam (n -> n -> n)
- Cat :: Monoid m => Lam (m -> m -> m)
- Eql :: Eq t => Lam (t -> t -> Bool )
- Both :: Lam ( Bool -> Bool -> Bool )
- Lift :: (a -> b -> c) -> Lam (a -> b -> c)
type StringEnv = ( String , String , String , String )
bindE :: Pat (a, b, c, d) t -> Expr (w, x, y, z) t -> StringEnv -> StringEnv
showE :: StringEnv -> Expr (a, b, c, d) t -> String
showL :: StringEnv -> Lam t -> String
showP :: StringEnv -> Pat any t -> String
apply :: Fun t -> t
first :: Fun (v -> s -> v)
second :: Fun (v -> s -> s)
plus :: Monoid t => Fun (t -> t -> t)
eql :: Eq t => Fun (t -> t -> Bool )
constant :: Show c => c -> Fun (a -> b -> c)
rngElem :: ( Ord rng, Iter f) => f rng v -> Fun (dom -> rng -> Bool )
domElem :: ( Ord dom, Iter f) => f dom v -> Fun (dom -> rng -> Bool )
rngFst :: Fun (x -> (a, b) -> a)
rngSnd :: Fun (x -> (a, b) -> b)
compose1 :: Fun (t1 -> t2 -> t3) -> Fun (t1 -> t4 -> t2) -> Fun (t1 -> t4 -> t3)
compSndL :: Fun (k -> (a, b) -> c) -> Fun (k -> d -> a) -> Fun (k -> (d, b) -> c)
compSndR :: Fun (k -> (a, b) -> c) -> Fun (k -> d -> b) -> Fun (k -> (a, d) -> c)
compCurryR :: Fun (k -> (a, b) -> d) -> Fun (a -> c -> b) -> Fun (k -> (a, c) -> d)
nEgate :: Fun (k -> v -> Bool ) -> Fun (k -> v -> Bool )
always :: Fun (a -> b -> Bool )
both :: Fun (a -> b -> Bool ) -> Fun (a -> b -> Bool ) -> Fun (a -> b -> Bool )
lift :: (a -> b -> c) -> Fun (a -> b -> c)
data Query k v where
- BaseD :: ( Iter f, Ord k) => BaseRep f k v -> f k v -> Query k v
- ProjectD :: Ord k => Query k v -> Fun (k -> v -> u) -> Query k u
- AndD :: Ord k => Query k v -> Query k w -> Query k (v, w)
- ChainD :: ( Ord k, Ord v) => Query k v -> Query v w -> Fun (k -> (v, w) -> u) -> Query k u
- AndPD :: Ord k => Query k v -> Query k u -> Fun (k -> (v, u) -> w) -> Query k w
- OrD :: Ord k => Query k v -> Query k v -> Fun (v -> v -> v) -> Query k v
- GuardD :: Ord k => Query k v -> Fun (k -> v -> Bool ) -> Query k v
- DiffD :: Ord k => Query k v -> Query k u -> Query k v
smart :: Bool
projD :: Ord k => Query k v -> Fun (k -> v -> u) -> Query k u
andD :: Ord k => Query k v1 -> Query k v2 -> Query k (v1, v2)
andPD :: Ord k => Query k v1 -> Query k u -> Fun (k -> (v1, u) -> v) -> Query k v
chainD :: ( Ord k, Ord v) => Query k v -> Query v w -> Fun (k -> (v, w) -> u) -> Query k u
guardD :: Ord k => Query k v -> Fun (k -> v -> Bool ) -> Query k v
projectQ :: ( Ord k, HasQuery c k v) => c -> Fun (k -> v -> u) -> Query k u
andQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k w) => concrete1 -> concrete2 -> Query k (v, w)
orQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k v) => concrete1 -> concrete2 -> Fun (v -> v -> v) -> Query k v
chainQ :: ( Ord k, Ord v, HasQuery concrete1 k v, HasQuery concrete2 v w) => concrete1 -> concrete2 -> Fun (k -> (v, w) -> u) -> Query k u
andPQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k u) => concrete1 -> concrete2 -> Fun (k -> (v, u) -> w) -> Query k w
guardQ :: ( Ord k, HasQuery concrete k v) => concrete -> Fun (k -> v -> Bool ) -> Query k v
diffQ :: forall k v u concrete1 concrete2. ( Ord k, HasQuery (concrete1 k v) k v, HasQuery (concrete2 k u) k u) => concrete1 k v -> concrete2 k u -> Query k v
class HasQuery concrete k v where
- query :: concrete -> Query k v
ppQuery :: Query k v -> Doc
nxtQuery :: Query a b -> Collect (a, b, Query a b)
lubQuery :: Ord a => a -> Query a b -> Collect (a, b, Query a b)
projStep :: Ord k => (t -> Collect (k, v, Query k v)) -> Fun (k -> v -> u) -> t -> Collect (k, u, Query k u)
andStep :: Ord a => (a, b1, Query a b1) -> (a, b2, Query a b2) -> Collect (a, (b1, b2), Query a (b1, b2))
chainStep :: ( Ord b, Ord a) => (a, b, Query a b) -> Query b w -> Fun (a -> (b, w) -> u) -> Collect (a, u, Query a u)
andPstep :: Ord a => (a, b1, Query a b1) -> (a, b2, Query a b2) -> Fun (a -> (b1, b2) -> w) -> Collect (a, w, Query a w)
orStep :: ( Ord k, Ord a) => ( Query k v -> Collect (a, v, Query k v)) -> Query k v -> Query k v -> Fun (v -> v -> v) -> Collect (a, v, Query k v)
guardStep :: Ord a => ( Query a b -> Collect (a, b, Query a b)) -> Fun (a -> b -> Bool ) -> Query a b -> Collect (a, b, Query a b)
diffStep :: Ord k => (k, v, Query k v) -> Query k u -> Collect (k, v, Query k v)

Documentation

data Exp t where Source #

The self typed GADT: Exp, that encodes the shape of Set expressions. A deep embedding. Exp is a typed Symbolic representation of queries we may ask. It allows us to introspect a query The strategy is to 1) Define Exp so all queries can be represented. 2) Define smart constructors that "parse" the surface syntax, and build a typed Exp 3) Write an evaluate function: eval:: Exp t -> t 4) "eval" can introspect the code and apply efficient domain and type specific translations 5) Use the (Iter f) class to evaluate some Exp that can benefit from its efficient nature.

Constructors

Base :: ( Ord k, Basic f, Iter f) => BaseRep f k v -> f k v -> Exp (f k v)
Dom :: Ord k => Exp (f k v) -> Exp ( Sett k ())
Rng :: ( Ord k, Ord v) => Exp (f k v) -> Exp ( Sett v ())
DRestrict :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
DExclude :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v)
RRestrict :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
RExclude :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v)
Elem :: ( Ord k, Iter g, Show k) => k -> Exp (g k ()) -> Exp Bool
NotElem :: ( Ord k, Iter g, Show k) => k -> Exp (g k ()) -> Exp Bool
Intersect :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp ( Sett k ())
Subset :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp Bool
SetDiff :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp (f k v)
UnionOverrideLeft :: ( Show k, Show v, Ord k) => Exp (f k v) -> Exp (g k v) -> Exp (f k v)
UnionPlus :: ( Ord k, Monoid n) => Exp (f k n) -> Exp (g k n) -> Exp (f k n)
UnionOverrideRight :: Ord k => Exp (f k v) -> Exp (g k v) -> Exp (f k v)
Singleton :: Ord k => k -> v -> Exp ( Single k v)
SetSingleton :: Ord k => k -> Exp ( Single k ())
KeyEqual :: ( Ord k, Iter f, Iter g) => Exp (f k v) -> Exp (g k u) -> Exp Bool

Instances

Instances details

Show ( Exp t) Source #
Instance details Defined in Control.Iterate.Exp Methods showsPrec :: Int -> Exp t -> ShowS Source # show :: Exp t -> String Source # showList :: [ Exp t] -> ShowS Source #
HasExp ( Exp t) t Source #	The simplest Base type is one that is already an Exp
Instance details Defined in Control.Iterate.Exp Methods toExp :: Exp t -> Exp t Source #

class HasExp s t | s -> t where Source #

Basic types are those that can be embedded into Exp. The HasExp class, encodes how to lift a Basic type into an Exp. The function toExp will build a typed Exp for that Basic type. This will be really usefull in the smart constructors.

Methods

toExp :: s -> Exp t Source #

Instances

Instances details

HasExp ( Exp t) t Source #	The simplest Base type is one that is already an Exp
Instance details Defined in Control.Iterate.Exp Methods toExp :: Exp t -> Exp t Source #
Ord k => HasExp [(k, v)] ( List k v) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: [(k, v)] -> Exp ( List k v) Source #
Ord k => HasExp ( Set k) ( Sett k ()) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: Set k -> Exp ( Sett k ()) Source #
Ord k => HasExp ( Map k v) ( Map k v) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: Map k v -> Exp ( Map k v) Source #
( Ord k, Ord v) => HasExp ( Bimap k v) ( Bimap k v) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: Bimap k v -> Exp ( Bimap k v) Source #
Ord k => HasExp ( Single k v) ( Single k v) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: Single k v -> Exp ( Single k v) Source #
( UnifiedView coin cred pool ptr k v, Ord k, Monoid coin, Ord coin, Ord cred, Ord ptr, Ord pool) => HasExp ( View coin cred pool ptr k v) ( View coin cred pool ptr k v) Source #
Instance details Defined in Control.Iterate.Exp Methods toExp :: View coin cred pool ptr k v -> Exp ( View coin cred pool ptr k v) Source #

dRestrict :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v) Source #

rRestrict :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v) Source #

dExclude :: ( Ord k, Iter g) => Exp (g k ()) -> Exp (f k v) -> Exp (f k v) Source #

rExclude :: ( Ord k, Iter g, Ord v) => Exp (f k v) -> Exp (g v ()) -> Exp (f k v) Source #

dom :: ( Ord k, HasExp s (f k v)) => s -> Exp ( Sett k ()) Source #

rng :: ( Ord k, Ord v) => HasExp s (f k v) => s -> Exp ( Sett v ()) Source #

(◁) :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v) Source #

(<|) :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v) Source #

drestrict :: ( Ord k, HasExp s1 ( Sett k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v) Source #

(⋪) :: ( Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v) Source #

dexclude :: ( Ord k, Iter g, HasExp s1 (g k ()), HasExp s2 (f k v)) => s1 -> s2 -> Exp (f k v) Source #

(▷) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v) Source #

(|>) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v) Source #

rrestrict :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v) Source #

(⋫) :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v) Source #

rexclude :: ( Ord k, Iter g, Ord v, HasExp s1 (f k v), HasExp s2 (g v ())) => s1 -> s2 -> Exp (f k v) Source #

(∈) :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool Source #

(∉) :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool Source #

notelem :: ( Show k, Ord k, Iter g, HasExp s (g k ())) => k -> s -> Exp Bool Source #

(∪) :: ( Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v) Source #

unionleft :: ( Show k, Show v, Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v) Source #

(⨃) :: ( Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v) Source #

unionright :: ( Ord k, HasExp s1 (f k v), HasExp s2 (g k v)) => s1 -> s2 -> Exp (f k v) Source #

(∪+) :: ( Ord k, Monoid n, HasExp s1 (f k n), HasExp s2 (g k n)) => s1 -> s2 -> Exp (f k n) Source #

unionplus :: ( Ord k, Monoid n, HasExp s1 (f k n), HasExp s2 (g k n)) => s1 -> s2 -> Exp (f k n) Source #

singleton :: Ord k => k -> v -> Exp ( Single k v) Source #

setSingleton :: Ord k => k -> Exp ( Single k ()) Source #

(∩) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp ( Sett k ()) Source #

intersect :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp ( Sett k ()) Source #

(⊆) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool Source #

subset :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool Source #

(➖) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v) Source #

setdiff :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v) Source #

(≍) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool Source #

keyeq :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool Source #

data Fun t Source #

An symbolic function Fun has two parts, a Lam that can be analyzed, and real function that can be applied

Constructors

Fun ( Lam t) t

Instances

Instances details

Show ( Fun t) Source #	We can observe a Fun by showing the Lam part.
Instance details Defined in Control.Iterate.Exp Methods showsPrec :: Int -> Fun t -> ShowS Source # show :: Fun t -> String Source # showList :: [ Fun t] -> ShowS Source #

data Pat env t where Source #

Symbolc functions (Fun) are data, that can be pattern matched over. They 1) Represent a wide class of binary functions that are used in translating the SetAlgebra 2) Turned into a String so they can be printed 3) Turned into the function they represent. 4) Composed into bigger functions 5) Symbolically symplified Here we implement Symbolic Binary functions with upto 4 variables, which is enough for this use =================================================================================================

Constructors

P1 :: Pat (d, c, b, a) d
P2 :: Pat (d, c, b, a) c
P3 :: Pat (d, c, b, a) b
P4 :: Pat (d, c, b, a) a
PPair :: Pat (d, c, b, a) a -> Pat (d, c, b, a) b -> Pat (d, c, b, a) (a, b)

data Expr env t where Source #

Constructors

X1 :: Expr (d, c, b, a) d
X2 :: Expr (d, c, b, a) c
X3 :: Expr (d, c, b, a) b
X4 :: Expr (d, c, b, a) a
HasKey :: ( Iter f, Ord k) => Expr e k -> f k v -> Expr e Bool
Neg :: Expr e Bool -> Expr e Bool
Ap :: Lam (a -> b -> c) -> Expr e a -> Expr e b -> Expr e c
EPair :: Expr e a -> Expr e b -> Expr e (a, b)
FST :: Expr e (a, b) -> Expr e a
SND :: Expr e (a, b) -> Expr e b
Lit :: Show t => t -> Expr env t

Instances

Instances details

Show ( Expr (a, b, c, d) t) Source #
Instance details Defined in Control.Iterate.Exp Methods showsPrec :: Int -> Expr (a, b, c, d) t -> ShowS Source # show :: Expr (a, b, c, d) t -> String Source # showList :: [ Expr (a, b, c, d) t] -> ShowS Source #

data Lam t where Source #

Constructors

Lam :: Pat (d, c, b, a) t -> Pat (d, c, b, a) s -> Expr (d, c, b, a) v -> Lam (t -> s -> v)
Add :: Num n => Lam (n -> n -> n)
Cat :: Monoid m => Lam (m -> m -> m)
Eql :: Eq t => Lam (t -> t -> Bool )
Both :: Lam ( Bool -> Bool -> Bool )
Lift :: (a -> b -> c) -> Lam (a -> b -> c)

Instances

Instances details

Show ( Lam t) Source #
Instance details Defined in Control.Iterate.Exp Methods showsPrec :: Int -> Lam t -> ShowS Source # show :: Lam t -> String Source # showList :: [ Lam t] -> ShowS Source #

type StringEnv = ( String , String , String , String ) Source #

bindE :: Pat (a, b, c, d) t -> Expr (w, x, y, z) t -> StringEnv -> StringEnv Source #

showE :: StringEnv -> Expr (a, b, c, d) t -> String Source #

showL :: StringEnv -> Lam t -> String Source #

showP :: StringEnv -> Pat any t -> String Source #

apply :: Fun t -> t Source #

first :: Fun (v -> s -> v) Source #

second :: Fun (v -> s -> s) Source #

plus :: Monoid t => Fun (t -> t -> t) Source #

eql :: Eq t => Fun (t -> t -> Bool ) Source #

constant :: Show c => c -> Fun (a -> b -> c) Source #

rngElem :: ( Ord rng, Iter f) => f rng v -> Fun (dom -> rng -> Bool ) Source #

domElem :: ( Ord dom, Iter f) => f dom v -> Fun (dom -> rng -> Bool ) Source #

rngFst :: Fun (x -> (a, b) -> a) Source #

rngSnd :: Fun (x -> (a, b) -> b) Source #

compose1 :: Fun (t1 -> t2 -> t3) -> Fun (t1 -> t4 -> t2) -> Fun (t1 -> t4 -> t3) Source #

compSndL :: Fun (k -> (a, b) -> c) -> Fun (k -> d -> a) -> Fun (k -> (d, b) -> c) Source #

compSndR :: Fun (k -> (a, b) -> c) -> Fun (k -> d -> b) -> Fun (k -> (a, d) -> c) Source #

compCurryR :: Fun (k -> (a, b) -> d) -> Fun (a -> c -> b) -> Fun (k -> (a, c) -> d) Source #

nEgate :: Fun (k -> v -> Bool ) -> Fun (k -> v -> Bool ) Source #

always :: Fun (a -> b -> Bool ) Source #

both :: Fun (a -> b -> Bool ) -> Fun (a -> b -> Bool ) -> Fun (a -> b -> Bool ) Source #

lift :: (a -> b -> c) -> Fun (a -> b -> c) Source #

data Query k v where Source #

Constructors

BaseD :: ( Iter f, Ord k) => BaseRep f k v -> f k v -> Query k v
ProjectD :: Ord k => Query k v -> Fun (k -> v -> u) -> Query k u
AndD :: Ord k => Query k v -> Query k w -> Query k (v, w)
ChainD :: ( Ord k, Ord v) => Query k v -> Query v w -> Fun (k -> (v, w) -> u) -> Query k u
AndPD :: Ord k => Query k v -> Query k u -> Fun (k -> (v, u) -> w) -> Query k w
OrD :: Ord k => Query k v -> Query k v -> Fun (v -> v -> v) -> Query k v
GuardD :: Ord k => Query k v -> Fun (k -> v -> Bool ) -> Query k v
DiffD :: Ord k => Query k v -> Query k u -> Query k v

Instances

Instances details

Iter Query Source #
Instance details Defined in Control.Iterate.Exp Methods nxt :: Query a b -> Collect (a, b, Query a b) Source # lub :: Ord k => k -> Query k b -> Collect (k, b, Query k b) Source # hasNxt :: Query a b -> Maybe (a, b, Query a b) Source # hasLub :: Ord k => k -> Query k b -> Maybe (k, b, Query k b) Source # haskey :: Ord key => key -> Query key b -> Bool Source # isnull :: Query k v -> Bool Source # lookup :: Ord key => key -> Query key rng -> Maybe rng Source # element :: Ord k => k -> Query k v -> Collect () Source #
Show ( Query k v) Source #
Instance details Defined in Control.Iterate.Exp Methods showsPrec :: Int -> Query k v -> ShowS Source # show :: Query k v -> String Source # showList :: [ Query k v] -> ShowS Source #
HasQuery ( Query k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: Query k v -> Query k v Source #

smart :: Bool Source #

projD :: Ord k => Query k v -> Fun (k -> v -> u) -> Query k u Source #

andD :: Ord k => Query k v1 -> Query k v2 -> Query k (v1, v2) Source #

andPD :: Ord k => Query k v1 -> Query k u -> Fun (k -> (v1, u) -> v) -> Query k v Source #

chainD :: ( Ord k, Ord v) => Query k v -> Query v w -> Fun (k -> (v, w) -> u) -> Query k u Source #

guardD :: Ord k => Query k v -> Fun (k -> v -> Bool ) -> Query k v Source #

projectQ :: ( Ord k, HasQuery c k v) => c -> Fun (k -> v -> u) -> Query k u Source #

andQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k w) => concrete1 -> concrete2 -> Query k (v, w) Source #

orQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k v) => concrete1 -> concrete2 -> Fun (v -> v -> v) -> Query k v Source #

chainQ :: ( Ord k, Ord v, HasQuery concrete1 k v, HasQuery concrete2 v w) => concrete1 -> concrete2 -> Fun (k -> (v, w) -> u) -> Query k u Source #

andPQ :: ( Ord k, HasQuery concrete1 k v, HasQuery concrete2 k u) => concrete1 -> concrete2 -> Fun (k -> (v, u) -> w) -> Query k w Source #

guardQ :: ( Ord k, HasQuery concrete k v) => concrete -> Fun (k -> v -> Bool ) -> Query k v Source #

diffQ :: forall k v u concrete1 concrete2. ( Ord k, HasQuery (concrete1 k v) k v, HasQuery (concrete2 k u) k u) => concrete1 k v -> concrete2 k u -> Query k v Source #

class HasQuery concrete k v where Source #

Methods

query :: concrete -> Query k v Source #

Instances

Instances details

Ord k => HasQuery [(k, v)] k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: [(k, v)] -> Query k v Source #
Ord k => HasQuery ( Set k) k () Source #
Instance details Defined in Control.Iterate.Exp Methods query :: Set k -> Query k () Source #
Ord k => HasQuery ( Map k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: Map k v -> Query k v Source #
Ord k => HasQuery ( Single k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: Single k v -> Query k v Source #
HasQuery ( Query k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: Query k v -> Query k v Source #
( Ord v, Ord k) => HasQuery ( BiMap v k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: BiMap v k v -> Query k v Source #
( UnifiedView coin cred pool ptr k v, Monoid coin, Ord k, Ord coin, Ord cred, Ord ptr, Ord pool) => HasQuery ( View coin cred pool ptr k v) k v Source #
Instance details Defined in Control.Iterate.Exp Methods query :: View coin cred pool ptr k v -> Query k v Source #

ppQuery :: Query k v -> Doc Source #

nxtQuery :: Query a b -> Collect (a, b, Query a b) Source #

lubQuery :: Ord a => a -> Query a b -> Collect (a, b, Query a b) Source #

projStep :: Ord k => (t -> Collect (k, v, Query k v)) -> Fun (k -> v -> u) -> t -> Collect (k, u, Query k u) Source #

andStep :: Ord a => (a, b1, Query a b1) -> (a, b2, Query a b2) -> Collect (a, (b1, b2), Query a (b1, b2)) Source #

chainStep :: ( Ord b, Ord a) => (a, b, Query a b) -> Query b w -> Fun (a -> (b, w) -> u) -> Collect (a, u, Query a u) Source #

andPstep :: Ord a => (a, b1, Query a b1) -> (a, b2, Query a b2) -> Fun (a -> (b1, b2) -> w) -> Collect (a, w, Query a w) Source #

orStep :: ( Ord k, Ord a) => ( Query k v -> Collect (a, v, Query k v)) -> Query k v -> Query k v -> Fun (v -> v -> v) -> Collect (a, v, Query k v) Source #

guardStep :: Ord a => ( Query a b -> Collect (a, b, Query a b)) -> Fun (a -> b -> Bool ) -> Query a b -> Collect (a, b, Query a b) Source #

diffStep :: Ord k => (k, v, Query k v) -> Query k u -> Collect (k, v, Query k v) Source #