Safe Haskell	None
Language	Haskell2010

Control.SetAlgebra

Synopsis

data List k v
data BiMap v a b
type Bimap k v = BiMap v k v
data Single k v where
- Single :: k -> v -> Single k v
- Fail :: Single k v
- SetSingle :: k -> Single k ()
class Basic f where
- addpair :: Ord k => k -> v -> f k v -> f k v
- addkv :: Ord k => (k, v) -> f k v -> (v -> v -> v) -> f k v
- removekey :: Ord k => k -> f k v -> f k v
- domain :: Ord k => f k v -> Set k
- range :: Ord v => f k v -> Set v
class Iter f where
- nxt :: f a b -> Collect (a, b, f a b)
- lub :: Ord k => k -> f k b -> Collect (k, b, f k b)
- hasNxt :: f a b -> Maybe (a, b, f a b)
- hasLub :: Ord k => k -> f k b -> Maybe (k, b, f k b)
- haskey :: Ord key => key -> f key b -> Bool
- isnull :: f k v -> Bool
- lookup :: Ord key => key -> f key rng -> Maybe rng
- element :: Ord k => k -> f k v -> Collect ()
class Embed concrete base | concrete -> base where
- toBase :: concrete -> base
- fromBase :: base -> concrete
class HasExp s t | s -> t where
- toExp :: s -> Exp t
data BaseRep f k v where
- MapR :: Basic Map => BaseRep Map k v
- SetR :: Basic Sett => BaseRep Sett k ()
- ListR :: Basic List => BaseRep List k v
- SingleR :: Basic Single => BaseRep Single k v
- BiMapR :: ( Basic ( BiMap v), Ord v) => BaseRep ( BiMap v) k v
- ViewR :: ( Monoid coin, Ord cred, Ord ptr, Ord coin, Ord pool) => Tag coin cred pool ptr k v -> BaseRep ( View coin cred pool ptr) 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 ())
dexclude :: ( Ord k, Iter g, HasExp s1 (g 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)
rexclude :: ( 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)
unionleft :: ( Show k, Show 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)
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 ())
intersect :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp ( Sett k ())
subset :: ( 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
(◁) :: ( 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)
(▷) :: ( 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)
(∈) :: ( 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
(∪) :: ( 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)
(∪+) :: ( Ord k, Monoid n, HasExp s1 (f k n), HasExp s2 (g k n)) => s1 -> s2 -> Exp (f k n)
(∩) :: ( 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
(≍) :: ( Ord k, Iter f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp Bool
(<|) :: ( Ord k, HasExp s1 ( Sett 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 f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v)
data Exp t where
- Base :: ( Ord k, Basic f, Iter f) => BaseRep f k v -> f k v -> Exp (f k v)
eval :: Embed s t => Exp t -> s
materialize :: Ord k => BaseRep f k v -> Collect (k, v) -> f k v
biMapToMap :: BiMap v a b -> Map a b
biMapFromMap :: ( Ord k, Ord v) => Map k v -> BiMap v k v
biMapFromList :: ( Ord k, Ord v) => (v -> v -> v) -> [(k, v)] -> BiMap v k v
biMapEmpty :: BiMap v k v
fromList :: Ord k => BaseRep f k v -> (v -> v -> v) -> [(k, v)] -> f k v
keysEqual :: Ord k => Map k v1 -> Map k v2 -> Bool
forwards :: BiMap v k v -> Map k v
backwards :: BiMap v k v -> Map v ( Set k)

Documentation

data List k v Source #

Instances

Instances details

Basic List Source #	The constructor for List is hidden, since it requires some invariants. Use fromPairs to build an initial List.
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> List k v -> List k v Source # addkv :: Ord k => (k, v) -> List k v -> (v -> v -> v) -> List k v Source # removekey :: Ord k => k -> List k v -> List k v Source # domain :: Ord k => List k v -> Set k Source # range :: Ord v => List k v -> Set v Source #
Iter List Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: List a b -> Collect (a, b, List a b) Source # lub :: Ord k => k -> List k b -> Collect (k, b, List k b) Source # hasNxt :: List a b -> Maybe (a, b, List a b) Source # hasLub :: Ord k => k -> List k b -> Maybe (k, b, List k b) Source # haskey :: Ord key => key -> List key b -> Bool Source # isnull :: List k v -> Bool Source # lookup :: Ord key => key -> List key rng -> Maybe rng Source # element :: Ord k => k -> List k v -> Collect () Source #
Ord k => Embed [(k, v)] ( List k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: [(k, v)] -> List k v Source # fromBase :: List k v -> [(k, v)] 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 #
( Eq k, Eq v) => Eq ( List k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods (==) :: List k v -> List k v -> Bool Source # (/=) :: List k v -> List k v -> Bool Source #
( Show k, Show v) => Show ( List k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods showsPrec :: Int -> List k v -> ShowS Source # show :: List k v -> String Source # showList :: [ List k v] -> ShowS Source #

data BiMap v a b Source #

Instances

Instances details

Ord v => Basic ( BiMap v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v0 -> BiMap v k v0 -> BiMap v k v0 Source # addkv :: Ord k => (k, v0) -> BiMap v k v0 -> (v0 -> v0 -> v0) -> BiMap v k v0 Source # removekey :: Ord k => k -> BiMap v k v0 -> BiMap v k v0 Source # domain :: Ord k => BiMap v k v0 -> Set k Source # range :: Ord v0 => BiMap v k v0 -> Set v0 Source #
Ord v => Iter ( BiMap v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: BiMap v a b -> Collect (a, b, BiMap v a b) Source # lub :: Ord k => k -> BiMap v k b -> Collect (k, b, BiMap v k b) Source # hasNxt :: BiMap v a b -> Maybe (a, b, BiMap v a b) Source # hasLub :: Ord k => k -> BiMap v k b -> Maybe (k, b, BiMap v k b) Source # haskey :: Ord key => key -> BiMap v key b -> Bool Source # isnull :: BiMap v k v0 -> Bool Source # lookup :: Ord key => key -> BiMap v key rng -> Maybe rng Source # element :: Ord k => k -> BiMap v k v0 -> Collect () 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 #
( Eq k, Eq v) => Eq ( BiMap u k v)
Instance details Defined in Data.BiMap Methods (==) :: BiMap u k v -> BiMap u k v -> Bool Source # (/=) :: BiMap u k v -> BiMap u k v -> Bool Source #
( Show k, Show v) => Show ( BiMap u k v)
Instance details Defined in Data.BiMap Methods showsPrec :: Int -> BiMap u k v -> ShowS Source # show :: BiMap u k v -> String Source # showList :: [ BiMap u k v] -> ShowS Source #
( Ord a, Ord b, ToCBOR a, ToCBOR b) => ToCBOR ( BiMap b a b)
Instance details Defined in Data.BiMap Methods toCBOR :: BiMap b a b -> Encoding Source # encodedSizeExpr :: ( forall t. ToCBOR t => Proxy t -> Size ) -> Proxy ( BiMap b a b) -> Size Source # encodedListSizeExpr :: ( forall t. ToCBOR t => Proxy t -> Size ) -> Proxy [ BiMap b a b] -> Size Source #
( Ord a, Ord b, FromCBOR a, FromCBOR b) => FromCBOR ( BiMap b a b)
Instance details Defined in Data.BiMap Methods fromCBOR :: Decoder s ( BiMap b a b) Source # label :: Proxy ( BiMap b a b) -> Text Source #
NFData ( BiMap v a b)
Instance details Defined in Data.BiMap Methods rnf :: BiMap v a b -> () Source #
( NoThunks a, NoThunks b) => NoThunks ( BiMap v a b)
Instance details Defined in Data.BiMap Methods noThunks :: Context -> BiMap v a b -> IO ( Maybe ThunkInfo ) Source # wNoThunks :: Context -> BiMap v a b -> IO ( Maybe ThunkInfo ) Source # showTypeOf :: Proxy ( BiMap v a b) -> String 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 #
Embed ( BiMap v k v) ( BiMap v k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: BiMap v k v -> BiMap v k v Source # fromBase :: BiMap v k v -> BiMap v k v Source #

type Bimap k v = BiMap v k v Source #

data Single k v where Source #

Constructors

Single :: k -> v -> Single k v
Fail :: Single k v
SetSingle :: k -> Single k ()

Instances

Instances details

Basic Single Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> Single k v -> Single k v Source # addkv :: Ord k => (k, v) -> Single k v -> (v -> v -> v) -> Single k v Source # removekey :: Ord k => k -> Single k v -> Single k v Source # domain :: Ord k => Single k v -> Set k Source # range :: Ord v => Single k v -> Set v Source #
Iter Single Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: Single a b -> Collect (a, b, Single a b) Source # lub :: Ord k => k -> Single k b -> Collect (k, b, Single k b) Source # hasNxt :: Single a b -> Maybe (a, b, Single a b) Source # hasLub :: Ord k => k -> Single k b -> Maybe (k, b, Single k b) Source # haskey :: Ord key => key -> Single key b -> Bool Source # isnull :: Single k v -> Bool Source # lookup :: Ord key => key -> Single key rng -> Maybe rng Source # element :: Ord k => k -> Single k v -> Collect () Source #
( Eq k, Eq v) => Eq ( Single k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods (==) :: Single k v -> Single k v -> Bool Source # (/=) :: Single k v -> Single k v -> Bool Source #
( Show k, Show v) => Show ( Single k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods showsPrec :: Int -> Single k v -> ShowS Source # show :: Single k v -> String Source # showList :: [ Single k v] -> ShowS 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 #
Embed ( Single k v) ( Single k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: Single k v -> Single k v Source # fromBase :: Single k v -> Single 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 #

class Basic f where Source #

In order to build typed Exp (which are a typed deep embedding) of Set operations, we need to know what kind of basic types of Maps and Sets can be used this way. Every Basic type has a few operations for creating one from a list, for adding and removing key-value pairs, looking up a value given a key. Instances of this algebra are functional in that every key has exactly one value associated with it.

Minimal complete definition

addkv , removekey , domain , range

Methods

addpair :: Ord k => k -> v -> f k v -> f k v Source #

in addpair the new value always prevails, to make a choice use addkv which has a combining function that allows choice.

addkv :: Ord k => (k, v) -> f k v -> (v -> v -> v) -> f k v Source #

use ( old new -> old) if you want the v in (f k v) to prevail, and use ( old new -> new) if you want the v in (k,v) to prevail

removekey :: Ord k => k -> f k v -> f k v Source #

domain :: Ord k => f k v -> Set k Source #

range :: Ord v => f k v -> Set v Source #

Instances

Instances details

Basic Map Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> Map k v -> Map k v Source # addkv :: Ord k => (k, v) -> Map k v -> (v -> v -> v) -> Map k v Source # removekey :: Ord k => k -> Map k v -> Map k v Source # domain :: Ord k => Map k v -> Set k Source # range :: Ord v => Map k v -> Set v Source #
Basic Sett Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> Sett k v -> Sett k v Source # addkv :: Ord k => (k, v) -> Sett k v -> (v -> v -> v) -> Sett k v Source # removekey :: Ord k => k -> Sett k v -> Sett k v Source # domain :: Ord k => Sett k v -> Set k Source # range :: Ord v => Sett k v -> Set v Source #
Basic Single Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> Single k v -> Single k v Source # addkv :: Ord k => (k, v) -> Single k v -> (v -> v -> v) -> Single k v Source # removekey :: Ord k => k -> Single k v -> Single k v Source # domain :: Ord k => Single k v -> Set k Source # range :: Ord v => Single k v -> Set v Source #
Basic List Source #	The constructor for List is hidden, since it requires some invariants. Use fromPairs to build an initial List.
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> List k v -> List k v Source # addkv :: Ord k => (k, v) -> List k v -> (v -> v -> v) -> List k v Source # removekey :: Ord k => k -> List k v -> List k v Source # domain :: Ord k => List k v -> Set k Source # range :: Ord v => List k v -> Set v Source #
Ord v => Basic ( BiMap v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v0 -> BiMap v k v0 -> BiMap v k v0 Source # addkv :: Ord k => (k, v0) -> BiMap v k v0 -> (v0 -> v0 -> v0) -> BiMap v k v0 Source # removekey :: Ord k => k -> BiMap v k v0 -> BiMap v k v0 Source # domain :: Ord k => BiMap v k v0 -> Set k Source # range :: Ord v0 => BiMap v k v0 -> Set v0 Source #
( Monoid coin, Ord coin, Ord cred, Ord ptr, Ord pool) => Basic ( View coin cred pool ptr) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods addpair :: Ord k => k -> v -> View coin cred pool ptr k v -> View coin cred pool ptr k v Source # addkv :: Ord k => (k, v) -> View coin cred pool ptr k v -> (v -> v -> v) -> View coin cred pool ptr k v Source # removekey :: Ord k => k -> View coin cred pool ptr k v -> View coin cred pool ptr k v Source # domain :: Ord k => View coin cred pool ptr k v -> Set k Source # range :: Ord v => View coin cred pool ptr k v -> Set v Source #

class Iter f where Source #

Minimal complete definition

nxt , lub

Methods

nxt :: f a b -> Collect (a, b, f a b) Source #

lub :: Ord k => k -> f k b -> Collect (k, b, f k b) Source #

hasNxt :: f a b -> Maybe (a, b, f a b) Source #

hasLub :: Ord k => k -> f k b -> Maybe (k, b, f k b) Source #

haskey :: Ord key => key -> f key b -> Bool Source #

isnull :: f k v -> Bool Source #

lookup :: Ord key => key -> f key rng -> Maybe rng Source #

element :: Ord k => k -> f k v -> Collect () Source #

Instances

Instances details

Iter Map Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: Map a b -> Collect (a, b, Map a b) Source # lub :: Ord k => k -> Map k b -> Collect (k, b, Map k b) Source # hasNxt :: Map a b -> Maybe (a, b, Map a b) Source # hasLub :: Ord k => k -> Map k b -> Maybe (k, b, Map k b) Source # haskey :: Ord key => key -> Map key b -> Bool Source # isnull :: Map k v -> Bool Source # lookup :: Ord key => key -> Map key rng -> Maybe rng Source # element :: Ord k => k -> Map k v -> Collect () Source #
Iter Sett Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: Sett a b -> Collect (a, b, Sett a b) Source # lub :: Ord k => k -> Sett k b -> Collect (k, b, Sett k b) Source # hasNxt :: Sett a b -> Maybe (a, b, Sett a b) Source # hasLub :: Ord k => k -> Sett k b -> Maybe (k, b, Sett k b) Source # haskey :: Ord key => key -> Sett key b -> Bool Source # isnull :: Sett k v -> Bool Source # lookup :: Ord key => key -> Sett key rng -> Maybe rng Source # element :: Ord k => k -> Sett k v -> Collect () Source #
Iter Single Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: Single a b -> Collect (a, b, Single a b) Source # lub :: Ord k => k -> Single k b -> Collect (k, b, Single k b) Source # hasNxt :: Single a b -> Maybe (a, b, Single a b) Source # hasLub :: Ord k => k -> Single k b -> Maybe (k, b, Single k b) Source # haskey :: Ord key => key -> Single key b -> Bool Source # isnull :: Single k v -> Bool Source # lookup :: Ord key => key -> Single key rng -> Maybe rng Source # element :: Ord k => k -> Single k v -> Collect () Source #
Iter List Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: List a b -> Collect (a, b, List a b) Source # lub :: Ord k => k -> List k b -> Collect (k, b, List k b) Source # hasNxt :: List a b -> Maybe (a, b, List a b) Source # hasLub :: Ord k => k -> List k b -> Maybe (k, b, List k b) Source # haskey :: Ord key => key -> List key b -> Bool Source # isnull :: List k v -> Bool Source # lookup :: Ord key => key -> List key rng -> Maybe rng Source # element :: Ord k => k -> List k v -> Collect () Source #
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 #
Ord v => Iter ( BiMap v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: BiMap v a b -> Collect (a, b, BiMap v a b) Source # lub :: Ord k => k -> BiMap v k b -> Collect (k, b, BiMap v k b) Source # hasNxt :: BiMap v a b -> Maybe (a, b, BiMap v a b) Source # hasLub :: Ord k => k -> BiMap v k b -> Maybe (k, b, BiMap v k b) Source # haskey :: Ord key => key -> BiMap v key b -> Bool Source # isnull :: BiMap v k v0 -> Bool Source # lookup :: Ord key => key -> BiMap v key rng -> Maybe rng Source # element :: Ord k => k -> BiMap v k v0 -> Collect () Source #
( Ord coin, Ord cred, Ord ptr) => Iter ( View coin cred pool ptr) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods nxt :: View coin cred pool ptr a b -> Collect (a, b, View coin cred pool ptr a b) Source # lub :: Ord k => k -> View coin cred pool ptr k b -> Collect (k, b, View coin cred pool ptr k b) Source # hasNxt :: View coin cred pool ptr a b -> Maybe (a, b, View coin cred pool ptr a b) Source # hasLub :: Ord k => k -> View coin cred pool ptr k b -> Maybe (k, b, View coin cred pool ptr k b) Source # haskey :: Ord key => key -> View coin cred pool ptr key b -> Bool Source # isnull :: View coin cred pool ptr k v -> Bool Source # lookup :: Ord key => key -> View coin cred pool ptr key rng -> Maybe rng Source # element :: Ord k => k -> View coin cred pool ptr k v -> Collect () Source #

class Embed concrete base | concrete -> base where Source #

Methods

toBase :: concrete -> base Source #

fromBase :: base -> concrete Source #

Instances

Instances details

Embed Bool Bool Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: Bool -> Bool Source # fromBase :: Bool -> Bool Source #
Ord k => Embed [(k, v)] ( List k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: [(k, v)] -> List k v Source # fromBase :: List k v -> [(k, v)] Source #
Embed ( Set k) ( Sett k ()) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: Set k -> Sett k () Source # fromBase :: Sett k () -> Set k Source #
Embed ( Map k v) ( Map k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: Map k v -> Map k v Source # fromBase :: Map k v -> Map k v Source #
Embed ( Single k v) ( Single k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: Single k v -> Single k v Source # fromBase :: Single k v -> Single k v Source #
Embed ( BiMap v k v) ( BiMap v k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: BiMap v k v -> BiMap v k v Source # fromBase :: BiMap v k v -> BiMap v k v Source #
Embed ( View coin cred pool ptr k v) ( View coin cred pool ptr k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods toBase :: View coin cred pool ptr k v -> View coin cred pool ptr k v Source # fromBase :: View coin cred pool ptr k v -> View coin cred pool ptr k v 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 #

data BaseRep f k v where Source #

BaseRep witnesses Basic types. I.e. those types that are instances of both Basic and Iter. Pattern matching against a constructor of type BaseRep, determines which base type. For example data Tag f k v = Tag (BaseRep f k v) (f k v) case Tag MapR x -> -- here we know x :: Map.Map k v

Constructors

MapR :: Basic Map => BaseRep Map k v
SetR :: Basic Sett => BaseRep Sett k ()
ListR :: Basic List => BaseRep List k v
SingleR :: Basic Single => BaseRep Single k v
BiMapR :: ( Basic ( BiMap v), Ord v) => BaseRep ( BiMap v) k v
ViewR :: ( Monoid coin, Ord cred, Ord ptr, Ord coin, Ord pool) => Tag coin cred pool ptr k v -> BaseRep ( View coin cred pool ptr) k v

Instances

Instances details

Show ( BaseRep f k v) Source #
Instance details Defined in Control.Iterate.BaseTypes Methods showsPrec :: Int -> BaseRep f k v -> ShowS Source # show :: BaseRep f k v -> String Source # showList :: [ BaseRep f k v] -> ShowS 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 #

dexclude :: ( Ord k, Iter g, HasExp s1 (g 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 #

rexclude :: ( 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 #

unionleft :: ( Show k, Show v, 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 #

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 #

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

subset :: ( 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 #

(◁) :: ( 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 #

(▷) :: ( 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 #

(∈) :: ( 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 #

(∪) :: ( 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 #

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

(∩) :: ( 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 #

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

(<|) :: ( Ord k, HasExp s1 ( Sett 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 f, Iter g, HasExp s1 (f k v), HasExp s2 (g k u)) => s1 -> s2 -> Exp (f k v) Source #

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)

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 #

eval :: Embed s t => Exp t -> s Source #

materialize :: Ord k => BaseRep f k v -> Collect (k, v) -> f k v Source #

A witness (BaseRep) can be used to materialize a (Collect k v) into the type witnessed by the BaseRep. Recall a (Collect k v) has no intrinsic type (it is just an ABSTRACT sequence of tuples), so the witness describes how to turn them into the chosen datatype. Note that materialize is meant to be applied to a collection built by iterating over a Query. This produces the keys in ascending order, with no duplicate keys. So we do not need to specify how to merge duplicate values.

biMapToMap :: BiMap v a b -> Map a b Source #

biMapFromMap :: ( Ord k, Ord v) => Map k v -> BiMap v k v Source #

biMapFromList :: ( Ord k, Ord v) => (v -> v -> v) -> [(k, v)] -> BiMap v k v Source #

biMapEmpty :: BiMap v k v Source #

fromList :: Ord k => BaseRep f k v -> (v -> v -> v) -> [(k, v)] -> f k v Source #

keysEqual :: Ord k => Map k v1 -> Map k v2 -> Bool Source #

forwards :: BiMap v k v -> Map k v Source #

backwards :: BiMap v k v -> Map v ( Set k) Source #