FP.Core

Documentation

module Prelude

data P a

Constructors

P

data W c where

Constructors

W :: c => W c

with :: W c -> (c => a) -> a

class Universal a

Instances

Universal k a

class (c1 a, c2 a) => (c1 ::*:: c2) a

Instances

(c1 a, c2 a) => (::*::) k c1 c2 a

class t (u a) => (t ::.:: u) a

Instances

t (u a) => (::.::) k k t u a

class c1 ::=>:: c2 where

Methods

impl :: c1 => W c2

class Functorial c t where

Methods

functorial :: c a => W (c (t a))

Instances

Functorial * Eq []

Functorial * Eq PreCall

Functorial * Eq Cτ

Functorial * Ord []

Functorial * Ord PreCall

Functorial * Ord Cτ

Functorial * JoinLattice ID

Functorial * Top ID

Functorial * Join ID

Functorial * Bot ID

Functorial * Monoid []

Functorial * Monoid ID

Functorial * Pretty []

Functorial * Pretty Set

Functorial * Pretty ID

Functorial * Pretty PreCall

Functorial * Pretty Cτ

Functorial * Eq (Zτ *)

Functorial * Eq (Kτ k)

Functorial * Ord (Zτ *)

Functorial * Ord (Kτ k)

JoinLattice a => Functorial * JoinLattice ((,) a)

Functorial * Monoid m => Functorial * Monoid (ListT m)

Pretty n => Functorial * Pretty (PreExp n)

Pretty n => Functorial * Pretty (PreCall n)

Functorial * Pretty (Zτ *)

Functorial * Pretty (Kτ k)

(Functorial * Bot m, Functorial * Join m, JoinLattice s) => Functorial * JoinLattice (StateT s m)

(Functorial * Monoid m, Monoid s) => Functorial * Monoid (StateT s m)

(Functorial * JoinLattice t, Functorial * JoinLattice u) => Functorial * JoinLattice ((:.:) * * t u)

class Bifunctorial c t where

Methods

bifunctorial :: (c a, c b) => W (c (t a b))

Instances

Bifunctorial * Eq (,)

Bifunctorial * Ord (,)

Bifunctorial * Pretty (,)

class ToInteger a where

Methods

toInteger :: a -> Integer

Instances

ToInteger Int

ToInteger Integer

ToInteger Color256

class FromInteger a where

Methods

fromInteger :: Integer -> a

Instances

FromInteger Double

FromInteger Int

FromInteger Integer

FromInteger Rational

FromInteger Color256

class ToInt a where

Methods

toInt :: a -> Int

Instances

ToInt Int

ToInt Integer

class FromInt a where

Methods

fromInt :: Int -> a

Instances

FromInt Double

FromInt Int

FromInt Integer

FromInt Rational

class ToRational a where

Methods

toRational :: a -> Rational

Instances

ToRational Double

ToRational Int

ToRational Integer

ToRational Rational

class FromRational a where

Methods

fromRational :: Rational -> a

Instances

FromRational Double

FromRational Rational

class ToDouble a where

Methods

toDouble :: a -> Double

Instances

ToDouble Double

ToDouble Int

ToDouble Integer

ToDouble Rational

class FromDouble a where

Methods

fromDouble :: Double -> a

Instances

FromDouble Double

FromDouble Rational

class ToString a where

Methods

toString :: a -> String

Instances

ToString Bool

ToString Char

ToString Double

ToString Int

ToString Integer

ToString Rational

ToString String

ToString Color256

class Peano a where

Methods

zer :: a

suc :: a -> a

Instances

Peano Double

Peano Int

Peano Integer

Peano Rational

Peano BdrNum

Peano LocNum

piter :: (Eq a, Peano a) => (b -> b) -> b -> a -> b

piterOn :: (Eq a, Peano a) => a -> b -> (b -> b) -> b

class Peano a => Additive a where

Methods

zero :: a

(+) :: a -> a -> a infixr 6

Instances

Additive Double

Additive Int

Additive Integer

Additive Rational

class Additive a => Subtractive a where

Methods

(-) :: a -> a -> a infix 6

Instances

Subtractive Double

Subtractive Int

Subtractive Integer

Subtractive Rational

class Additive a => Multiplicative a where

Methods

one :: a

(*) :: a -> a -> a infixr 7

Instances

Multiplicative Double

Multiplicative Int

Multiplicative Integer

Multiplicative Rational

class Multiplicative a => Divisible a where

Methods

(/) :: a -> a -> a infix 7

Instances

Divisible Double

Divisible Rational

class Multiplicative a => TruncateDivisible a where

Methods

(//) :: a -> a -> a infix 7

Instances

TruncateDivisible Int

TruncateDivisible Integer

class (TruncateDivisible a, ToInteger a, FromInteger a, ToInt a, FromInt a, ToRational a, ToDouble a) => Integral a

Instances

Integral Int

Integral Integer

class (Divisible a, ToRational a, FromRational a, ToDouble a, FromDouble a, FromInteger a, FromInt a) => Fractional a

Instances

Fractional Double

Fractional Rational

negate :: Subtractive a => a -> a

inverse :: Divisible a => a -> a

data POrdering

Constructors

PEQ

PLT

PGT

PUN

class PartialOrder a where

Minimal complete definition

Nothing

Methods

pcompare :: a -> a -> POrdering

(⊑) :: a -> a -> Bool infix 4

(⊏) :: a -> a -> Bool infix 4

Instances

PartialOrder Double

PartialOrder Int

PartialOrder Integer

PartialOrder Rational

PartialOrder Lit

PartialOrder BdrNum

PartialOrder LocNum

PartialOrder BinOp

Ord a => PartialOrder (SetWithTop a)

Ord a => PartialOrder (ListSetWithTop a)

Ord a => PartialOrder (ListSet a)

PartialOrder (Set a)

PartialOrder a => PartialOrder (ID a)

(PartialOrder a, PartialOrder b) => PartialOrder (a, b)

PartialOrder a => PartialOrder (StampedFix a f)

(Ord k, PartialOrder v) => PartialOrder (Map k v)

(Eq n, Eq c) => PartialOrder (PreCall n c)

(Eq n, Eq c) => PartialOrder (PreAtom n c)

(Eq lτ, Eq dτ) => PartialOrder (CVal lτ dτ)

(Eq lτ, Eq dτ) => PartialOrder (AVal lτ dτ)

(PartialOrder a, PartialOrder b, PartialOrder c) => PartialOrder (a, b, c)

(Ord lτ, Ord dτ, Ord a, Ord (ν lτ dτ)) => PartialOrder (PSΣ𝒫 ν lτ dτ a)

(Ord lτ, Ord dτ, Ord a, Ord (ν lτ dτ)) => PartialOrder (PSΣ ν lτ dτ a)

(Ord lτ, Ord dτ, PartialOrder val) => PartialOrder (FIΣ𝒫 val lτ dτ a)

(Ord lτ, Ord dτ, Ord a, PartialOrder val) => PartialOrder (FIΣ val lτ dτ a)

(Ord lτ, Ord dτ, Ord a, PartialOrder val) => PartialOrder (FSΣ𝒫 val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => PartialOrder (FSΣ val lτ dτ a)

PartialOrder (PSΣ𝒫 val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => PartialOrder (PSΣ val lτ dτ a)

(PartialOrder a, PartialOrder b, PartialOrder c, PartialOrder d, PartialOrder e) => PartialOrder (a, b, c, d, e)

PartialOrder (t (u a)) => PartialOrder ((:.:) k k t u a)

PartialOrder (Power k k val lτ dτ)

(⋚) :: Ord a => a -> a -> Ordering

(⋈) :: PartialOrder a => a -> a -> POrdering

(⊒) :: PartialOrder a => a -> a -> Bool

(⊐) :: PartialOrder a => a -> a -> Bool

fromOrdering :: Ordering -> POrdering

discreteOrder :: Eq a => a -> a -> POrdering

findMax :: (Iterable a t, PartialOrder b) => (a -> b) -> a -> t -> a

findMaxFrom :: (Iterable a t, PartialOrder b) => a -> (a -> b) -> t -> a

poiter :: PartialOrder a => (a -> a) -> a -> a

poiterHistory :: PartialOrder a => (a -> a) -> a -> [a]

class Category t where

Methods

catid :: t a a

(<.>) :: t b c -> t a b -> t a c infixr 9

Instances

Category * (->)

Category * Prism

Category * Lens

type (~>) m n = forall a. m a -> n a infixr 1

type (~~>) t u = forall m. t m ~> u m

class Morphism a b where

Methods

morph :: a -> b

Instances

Morphism (𝒮Cxt lτ dτ, Store val lτ dτ) (𝒮 val lτ dτ)

Morphism (𝒮 val lτ dτ) (𝒮Cxt lτ dτ, Store val lτ dτ)

(Ord (ν lτ dτ), Ord lτ, Ord dτ, Ord a) => Morphism (PSΣ𝒫 ν lτ dτ a) (PSΣ ν lτ dτ a)

(Ord (ν lτ dτ), Ord lτ, Ord dτ, Ord a) => Morphism (PSΣ ν lτ dτ a) (PSΣ𝒫 ν lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Morphism (FIΣ𝒫 val lτ dτ a) (FIΣ val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Morphism (FIΣ val lτ dτ a) (FIΣ𝒫 val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Morphism (FSΣ𝒫 val lτ dτ a) (FSΣ val lτ dτ a)

(Ord val, Join val, Ord lτ, Ord dτ, Ord a) => Morphism (FSΣ val lτ dτ a) (FSΣ𝒫 val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Morphism (PSΣ𝒫 val lτ dτ a) (PSΣ val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Morphism (PSΣ val lτ dτ a) (PSΣ𝒫 val lτ dτ a)

class Morphism2 m n where

Methods

morph2 :: m ~> n

Instances

Morphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Morphism2 * (PSΣ' ν lτ dτ) (PSΣ ν lτ dτ)

Morphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Morphism2 * (FIΣ' val lτ dτ) (FIΣ val lτ dτ)

Morphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Morphism2 * (FSΣ' val lτ dτ) (FSΣ val lτ dτ)

Morphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

Morphism2 * (PSΣ' val lτ dτ) (PSΣ val lτ dτ)

class Morphism3 t u where

Methods

morph3 :: t ~~> u

Instances

Morphism3 * (* -> *) (CPSKon r) (ContFun * r)

Morphism3 * (* -> *) (CPSKon r) (ContFun * r)

Morphism3 * (* -> *) (ContFun * r) (CPSKon r)

Morphism3 * (* -> *) (ContFun * r) (CPSKon r)

class (Morphism a b, Morphism b a) => Isomorphism a b

Instances

Isomorphism (𝒮 val lτ dτ) (𝒮Cxt lτ dτ, Store val lτ dτ)

(Ord (ν lτ dτ), Ord lτ, Ord dτ, Ord a) => Isomorphism (PSΣ ν lτ dτ a) (PSΣ𝒫 ν lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Isomorphism (FIΣ val lτ dτ a) (FIΣ𝒫 val lτ dτ a)

(Ord val, Join val, Ord lτ, Ord dτ, Ord a) => Isomorphism (FSΣ val lτ dτ a) (FSΣ𝒫 val lτ dτ a)

(Ord val, Ord lτ, Ord dτ, Ord a) => Isomorphism (PSΣ val lτ dτ a) (PSΣ𝒫 val lτ dτ a)

isoto :: Isomorphism a b => a -> b

isofrom :: Isomorphism a b => b -> a

class (Morphism2 t u, Morphism2 u t) => Isomorphism2 t u

Instances

Isomorphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Isomorphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Isomorphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Isomorphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

isoto2 :: Isomorphism2 t u => t ~> u

isofrom2 :: Isomorphism2 t u => u ~> t

onIso2 :: Isomorphism2 t u => (u a -> u b) -> t a -> t b

class (Morphism3 v w, Morphism3 w v) => Isomorphism3 v w

Instances

Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r)

Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r)

isoto3 :: Isomorphism3 v w => v ~~> w

isofrom3 :: Isomorphism3 v w => w ~~> v

class Monoid a where

Methods

null :: a

(++) :: a -> a -> a infixr 6

Instances

Monoid Bool

Monoid Double

Monoid Int

Monoid Integer

Monoid Rational

Monoid String

(Monoid (Maybe Color256), Monoid Bool) => Monoid Format

Monoid Doc

Functorial * Monoid []

Functorial * Monoid ID

Functorial * Monoid m => Functorial * Monoid (ListT m)

(Functorial * Monoid m, Monoid s) => Functorial * Monoid (StateT s m)

Monoid [a]

Monoid (Maybe a)

Monoid (ListSetWithTop a)

Monoid (ListSet a)

Monoid (Set a)

Monoid (Endo a)

Monoid (FreeMonoid a)

Monoid a => Monoid (ID a)

Monoid (ParserState t)

Monoid b => Monoid (a -> b)

(Monoid a, Monoid b) => Monoid (a, b)

Monoid v => Monoid (Map k v)

Monad m => Monoid (KleisliEndo m a)

Monoid (FreeMonoidFunctor f a)

Functorial * Monoid m => Monoid (ListT m a)

(Functorial * Monoid m, Monoid s, Monoid a) => Monoid (StateT s m a)

iterAppend :: (Monoid a, Eq n, Peano n) => n -> a -> a

concat :: (Iterable a t, Monoid a) => t -> a

class Bot a where

Methods

bot :: a

Instances

Bot Bool

Bot Int

Functorial * Bot ID

Bot (SumOfProd a)

Bot (SetWithTop a)

Bot (ListSetWithTop a)

Bot (ListSet a)

Bot (Set a)

Bot a => Bot (ID a)

Bot (Cτ ψ)

Bot (Cτ ψ)

Bot b => Bot (a -> b)

(Bot a, Bot b) => Bot (a, b)

Bot (Map k v)

Bot (Zτ k ψ)

Bot (Kτ k ψ)

(Time ψ lτ, Time ψ dτ) => Bot (Moment lτ dτ)

(Bot lτ, Bot dτ) => Bot (𝒮Cxt lτ dτ)

Bot (Zτ k ψ)

Bot (Kτ k ψ)

(Bot a, Bot b, Bot c) => Bot (a, b, c)

(Functorial * Bot m, Bot s, Bot a) => Bot (StateT s m a)

(Time ψ lτ, Time ψ dτ) => Bot (𝒮 ν lτ dτ)

(Bot lτ, Bot dτ) => Bot (𝒮 val lτ dτ)

Bot (PSΣ𝒫 ν lτ dτ a)

Bot (PSΣ ν lτ dτ a)

Bot (FIΣ𝒫 val lτ dτ a)

Bot (FIΣ val lτ dτ a)

Bot (FSΣ𝒫 val lτ dτ a)

Bot (FSΣ val lτ dτ a)

Bot (PSΣ𝒫 val lτ dτ a)

Bot (PSΣ val lτ dτ a)

(Bot a, Bot b, Bot c, Bot d, Bot e) => Bot (a, b, c, d, e)

Bot (t (u a)) => Bot ((:.:) k k t u a)

Bot (SumOfProdVal k k ν lτ dτ)

Bot (Power k k val lτ dτ)

class Join a where

Methods

(\/) :: a -> a -> a infixr 6

Instances

Join Bool

Join Double

Join Int

Join Integer

Join Rational

Functorial * Join ID

Join (SumOfProd a)

Join (SetWithTop a)

Join (ListSetWithTop a)

Join (ListSet a)

Join (Set a)

Join a => Join (ID a)

Join b => Join (a -> b)

(Join a, Join b) => Join (a, b)

Join v => Join (Map k v)

(Join a, Join b, Join c) => Join (a, b, c)

(Functorial * Join m, Join s, Join a) => Join (StateT s m a)

Join (PSΣ𝒫 ν lτ dτ a)

Join (PSΣ ν lτ dτ a)

Join val => Join (FIΣ𝒫 val lτ dτ a)

Join val => Join (FIΣ val lτ dτ a)

Join val => Join (FSΣ𝒫 val lτ dτ a)

Join (FSΣ val lτ dτ a)

Join (PSΣ𝒫 val lτ dτ a)

Join (PSΣ val lτ dτ a)

(Join a, Join b, Join c, Join d, Join e) => Join (a, b, c, d, e)

Join (t (u a)) => Join ((:.:) k k t u a)

Join (SumOfProdVal k k ν lτ dτ)

Join (Power k k val lτ dτ)

class Top a where

Methods

top :: a

Instances

Top Bool

Top Int

Functorial * Top ID

Top (SetWithTop a)

Top (ListSetWithTop a)

Top a => Top (ID a)

Top b => Top (a -> b)

Top (t (u a)) => Top ((:.:) k k t u a)

class Meet a where

Methods

(/\) :: a -> a -> a infixr 7

Instances

Meet Bool

Meet Double

Meet Int

Meet Integer

Meet Rational

Meet (SumOfProd a)

Meet (SetWithTop a)

Meet (ListSetWithTop a)

Meet (Set a)

Meet b => Meet (a -> b)

Meet (t (u a)) => Meet ((:.:) k k t u a)

Meet (SumOfProdVal k k ν lτ dτ)

class Neg a where

Methods

neg :: a -> a

Instances

Neg Double

Neg Int

Neg Integer

Neg Rational

(Ord a, Neg a) => Neg (SumOfProd a)

Neg b => Neg (a -> b)

Neg (OCVal lτ dτ)

(Ord (ν lτ dτ), Neg (ν lτ dτ)) => Neg (SumOfProdVal k k ν lτ dτ)

class Difference a where

Methods

(\\) :: a -> a -> a infix 6

Instances

Difference (SetWithTop a)

Ord a => Difference (ListSetWithTop a)

Difference (Set a)

(Difference a, Difference b) => Difference (a, b)

Difference v => Difference (Map k v)

Difference (PSΣ𝒫 ν lτ dτ a)

Difference val => Difference (FIΣ𝒫 val lτ dτ a)

Difference val => Difference (FSΣ𝒫 val lτ dτ a)

Difference (PSΣ𝒫 val lτ dτ a)

Difference (Power k k val lτ dτ)

class (Bot a, Join a) => JoinLattice a

Instances

JoinLattice Bool

JoinLattice Int

Functorial * JoinLattice ID

JoinLattice a => Functorial * JoinLattice ((,) a)

(Functorial * Bot m, Functorial * Join m, JoinLattice s) => Functorial * JoinLattice (StateT s m)

(Functorial * JoinLattice t, Functorial * JoinLattice u) => Functorial * JoinLattice ((:.:) * * t u)

JoinLattice (SumOfProd a)

JoinLattice (SetWithTop a)

JoinLattice (ListSetWithTop a)

JoinLattice (ListSet a)

JoinLattice (Set a)

JoinLattice a => JoinLattice (ID a)

JoinLattice b => JoinLattice (a -> b)

(JoinLattice a, JoinLattice b) => JoinLattice (a, b)

JoinLattice v => JoinLattice (Map k v)

(JoinLattice a, JoinLattice b, JoinLattice c) => JoinLattice (a, b, c)

(Functorial * Bot m, Functorial * Join m, JoinLattice s, JoinLattice a) => JoinLattice (StateT s m a)

JoinLattice (PSΣ𝒫 ν lτ dτ a)

JoinLattice (PSΣ ν lτ dτ a)

JoinLattice val => JoinLattice (FIΣ𝒫 val lτ dτ a)

JoinLattice val => JoinLattice (FIΣ val lτ dτ a)

JoinLattice val => JoinLattice (FSΣ𝒫 val lτ dτ a)

JoinLattice (FSΣ val lτ dτ a)

JoinLattice (PSΣ𝒫 val lτ dτ a)

JoinLattice (PSΣ val lτ dτ a)

(JoinLattice a, JoinLattice b, JoinLattice c, JoinLattice d, JoinLattice e) => JoinLattice (a, b, c, d, e)

JoinLattice (t (u a)) => JoinLattice ((:.:) k k t u a)

JoinLattice (SumOfProdVal k k ν lτ dτ)

JoinLattice (Power k k val lτ dτ)

class (Top a, Meet a) => MeetLattice a

Instances

MeetLattice Bool

MeetLattice Int

MeetLattice (SetWithTop a)

MeetLattice (ListSetWithTop a)

MeetLattice b => MeetLattice (a -> b)

MeetLattice (t (u a)) => MeetLattice ((:.:) k k t u a)

class (JoinLattice a, MeetLattice a) => Lattice a

Instances

Lattice Bool

Lattice Int

Lattice b => Lattice (a -> b)

Lattice (t (u a)) => Lattice ((:.:) k k t u a)

class (Lattice a, Neg a) => NegLattice a

Instances

NegLattice Int

NegLattice b => NegLattice (a -> b)

joins :: (Iterable a t, JoinLattice a) => t -> a

meets :: (Iterable a t, MeetLattice a) => t -> a

collect :: (Join a, PartialOrder a) => (a -> a) -> a -> a

collectN :: (Join a, PartialOrder a, Eq n, Peano n) => n -> (a -> a) -> a -> a

collectHistory :: (Join a, PartialOrder a) => (a -> a) -> a -> [a]

diffs :: forall a. (JoinLattice a, Difference a) => [a] -> [a]

collectDiffs :: (PartialOrder a, JoinLattice a, Difference a) => (a -> a) -> a -> [a]

class Commute t u where

Methods

commute :: t (u a) -> u (t a)

Instances

Commute ID ListSet

JoinLattice 𝓈 => Commute ((,) 𝓈) ListSet

(Commute t ListSet, Commute u ListSet, Functor t) => Commute ((:.:) * * t u) ListSet

class Unit t where

Methods

unit :: a -> t a

Instances

Unit []

Unit IO

Unit Q

Unit Maybe

Unit CoreM

Unit ListSetWithTop

Unit ListSet

Unit FreeMonoid

Unit ID

Unit DocM

Unit ((:+:) a)

Unit m => Unit (MaybeT m)

Unit (FreeMonoidFunctor f)

Unit (FreeFunctor f)

Unit m => Unit (ListSetWithTopT m)

Unit m => Unit (ListSetT m)

Unit m => Unit (ListT m)

Unit (Parser t)

Unit m => Unit (StateT s m)

(Unit m, Monoid o) => Unit (WriterT o m)

Unit m => Unit (ErrorT e m)

Unit m => Unit (ContT * r m)

Unit m => Unit (ReaderT * r m)

Unit (PS ν lτ dτ)

Unit (FI val lτ dτ)

Unit (FS val lτ dτ)

Unit (PS val lτ dτ)

(Unit m, Monoid o) => Unit (RWST r o s m)

Unit m => Unit (AddStateT k s12 s1 m)

Morphism3 * (k -> *) (k1 r) (ContFun k r) => Unit (OpaqueContT * k k r m)

Unit m => Unit (IsoMonadStep k k * ς1 ς2 m)

class Functor t where

Methods

map :: (a -> b) -> t a -> t b

Instances

Functor []

Functor IO

Functor Q

Functor Maybe

Functor CoreM

Functor ListSetWithTop

Functor ListSet

Functor FreeMonoid

Functor ID

Functor DocM

Functor ((->) a)

Functor (Map k)

Functor ((:+:) a)

Functor m => Functor (MaybeT m)

Functor f => Functor (FreeMonoidFunctor f)

Functor f => Functor (FreeFunctor f)

Functor m => Functor (ListSetWithTopT m)

Functor m => Functor (ListSetT m)

Functor m => Functor (ListT m)

Functor (Parser t)

Functor m => Functor (StateT s m)

Functor m => Functor (WriterT o m)

Functor m => Functor (ErrorT e m)

Unit m => Functor (ContT * r m)

Functor m => Functor (ReaderT * r m)

Functor (PS ν lτ dτ)

Functor (FI val lτ dτ)

Functor (FS val lτ dτ)

Functor (PS val lτ dτ)

(Functor t, Functor u) => Functor ((:.:) * * t u)

Functor m => Functor (RWST r o s m)

Functor m => Functor (AddStateT k s12 s1 m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Functor (OpaqueContT * * k r m)

Functor m => Functor (IsoMonadStep k k * ς1 ς2 m)

mapOn :: Functor t => t a -> (a -> b) -> t b

(^@) :: Functor t => (a -> b) -> t a -> t b infixl 9

(^$) :: Functor t => (a -> b) -> t a -> t b infixr 0

(^.) :: Functor t => (b -> c) -> (a -> t b) -> a -> t c infixr 9

(.^) :: Functor t => (t b -> c) -> (a -> b) -> t a -> c infixr 9

(^.:) :: Functor t => (c -> d) -> (a -> b -> t c) -> a -> b -> t d infixr 9

(^..:) :: Functor t => (d -> e) -> (a -> b -> c -> t d) -> a -> b -> c -> t e

(^^.) :: (Functor t, Functor u) => (b -> c) -> (a -> t (u b)) -> a -> t (u c) infixr 9

class FunctorM t where

Methods

mapM :: Monad m => (a -> m b) -> t a -> m (t b)

Instances

FunctorM []

FunctorM ListSet

FunctorM ID

mapOnM :: (FunctorM t, Monad m) => t a -> (a -> m b) -> m (t b)

sequence :: (FunctorM t, Monad m) => t (m a) -> m (t a)

(^*@) :: (FunctorM t, Monad m) => (a -> m b) -> t a -> m (t b) infixl 9

(^*$) :: (FunctorM t, Monad m) => (a -> m b) -> t a -> m (t b) infixr 0

(^*.) :: (FunctorM t, Monad m) => (b -> m c) -> (a -> m b) -> t a -> m (t c) infixr 9

class (Unit t, Functor t) => Applicative t where

Methods

(<@>) :: t (a -> b) -> t a -> t b infixl 9

Instances

Applicative []

Applicative IO

Applicative Q

Applicative Maybe

Applicative CoreM

Applicative ListSetWithTop

Applicative ListSet

Applicative ID

Applicative DocM

Applicative ((:+:) a)

(Functor m, Applicative m) => Applicative (MaybeT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Applicative (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m) => Applicative (ListSetT m)

(Monad m, Functorial * Monoid m) => Applicative (ListT m)

Applicative (Parser t)

Monad m => Applicative (StateT s m)

(Functor m, Applicative m, Monoid o) => Applicative (WriterT o m)

(Functor m, Applicative m) => Applicative (ErrorT e m)

Unit m => Applicative (ContT * r m)

Applicative m => Applicative (ReaderT * r m)

Applicative (PS ν lτ dτ)

JoinLattice val => Applicative (FI val lτ dτ)

Applicative (FS val lτ dτ)

Applicative (PS val lτ dτ)

(Monad m, Monoid o) => Applicative (RWST r o s m)

Monad m => Applicative (AddStateT k s12 s1 m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Applicative (OpaqueContT * * k r m)

Applicative m => Applicative (IsoMonadStep k k * ς1 ς2 m)

pure :: Applicative t => a -> t a

(<$>) :: Applicative t => t (a -> b) -> t a -> t b infixr 0

apair :: Applicative t => t a -> t b -> t (a, b)

class Product t where

Methods

(<*>) :: t a -> t b -> t (a, b) infixr 7

Instances

Product []

Product IO

Product Q

Product Maybe

Product CoreM

Product SetWithTop

Product ListSetWithTop

Product ListSet

Product Set

Product ID

Product DocM

Product ((:+:) a)

(Functor m, Product m) => Product (MaybeT m)

(Functor m, Product m) => Product (SetT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Product (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m) => Product (ListSetT m)

(Monad m, Functorial * Monoid m) => Product (ListT m)

Product (Parser t)

Monad m => Product (StateT s m)

(Functor m, Product m, Monoid o) => Product (WriterT o m)

(Functor m, Product m) => Product (ErrorT e m)

Unit m => Product (ContT * r m)

Product m => Product (ReaderT * r m)

Product (PS ν lτ dτ)

JoinLattice val => Product (FI val lτ dτ)

Product (FS val lτ dτ)

Product (PS val lτ dτ)

(Monad m, Monoid o) => Product (RWST r o s m)

Monad m => Product (AddStateT k s12 s1 m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Product (OpaqueContT * * k r m)

Product m => Product (IsoMonadStep k k * ς1 ς2 m)

class Product m => Bind m where

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1

Instances

Bind []

Bind IO

Bind Q

Bind Maybe

Bind CoreM

Bind SetWithTop

Bind ListSetWithTop

Bind ListSet

Bind Set

Bind ID

Bind DocM

Bind ((:+:) a)

Monad m => Bind (MaybeT m)

(Functorial * JoinLattice m, Monad m) => Bind (SetT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Bind (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m) => Bind (ListSetT m)

(Monad m, Functorial * Monoid m) => Bind (ListT m)

Bind (Parser t)

Monad m => Bind (StateT s m)

(Monad m, Monoid o) => Bind (WriterT o m)

(Unit m, Functor m, Bind m) => Bind (ErrorT e m)

Unit m => Bind (ContT * r m)

Bind m => Bind (ReaderT * r m)

Bind (PS ν lτ dτ)

JoinLattice val => Bind (FI val lτ dτ)

Bind (FS val lτ dτ)

Bind (PS val lτ dτ)

(Monad m, Monoid o) => Bind (RWST r o s m)

Monad m => Bind (AddStateT k s12 s1 m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Bind (OpaqueContT * * k r m)

Bind m => Bind (IsoMonadStep k k * ς1 ς2 m)

class (Applicative m, Bind m) => Monad m

Instances

Monad []

Monad IO

Monad Q

Monad Maybe

Monad CoreM

Monad ListSetWithTop

Monad ListSet

Monad ID

Monad DocM

Monad ((:+:) a)

Monad m => Monad (MaybeT m)

(Monad m, Functorial * JoinLattice m, Functorial * Top m) => Monad (ListSetWithTopT m)

(Monad m, Functorial * JoinLattice m) => Monad (ListSetT m)

(Monad m, Functorial * Monoid m) => Monad (ListT m)

Monad (Parser t)

Monad m => Monad (StateT s m)

(Monad m, Monoid o) => Monad (WriterT o m)

Monad m => Monad (ErrorT e m)

Unit m => Monad (ContT * r m)

Monad m => Monad (ReaderT * r m)

Monad (PS ν lτ dτ)

JoinLattice val => Monad (FI val lτ dτ)

Monad (FS val lτ dτ)

Monad (PS val lτ dτ)

(Monad m, Monoid o) => Monad (RWST r o s m)

Monad m => Monad (AddStateT k s12 s1 m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Monad (OpaqueContT * * k r m)

Monad m => Monad (IsoMonadStep k k * ς1 ς2 m)

fail :: Chars -> m a

return :: Monad m => a -> m a

kleisli :: Monad m => (a -> b) -> a -> m b

(>>) :: Bind m => m a -> m b -> m b infixl 1

extend :: Bind m => (a -> m b) -> m a -> m b

void :: Functor m => m a -> m ()

(*@) :: Bind m => (a -> m b) -> m a -> m b infixl 9

(*$) :: Bind m => (a -> m b) -> m a -> m b infixr 0

(*.) :: Bind m => (b -> m c) -> (a -> m b) -> a -> m c infixr 9

mjoin :: Bind m => m (m a) -> m a

mmap :: Monad m => (a -> b) -> m a -> m b

mpair :: Monad m => m a -> m b -> m (a, b)

mapply :: Monad m => m (a -> b) -> m a -> m b

when :: Monad m => Bool -> m () -> m ()

traverse :: (Iterable a t, Monad m) => (a -> m ()) -> t -> m ()

traverseOn :: (Iterable a t, Monad m) => t -> (a -> m ()) -> m ()

exec :: (Iterable (m ()) t, Monad m) => t -> m ()

class Unit2 t where

Methods

unit2 :: m ~> t m

class Join2 t where

Methods

join2 :: t (t m) ~> t m

class Functor2 t where

Methods

map2 :: (m ~> n) -> t m ~> t n

class IsoFunctor2 t where

Methods

isoMap2 :: (m ~> n, n ~> m) -> t m ~> t n

class FunctorUnit2 t where

Methods

funit2 :: Functor m => m ~> t m

Instances

FunctorUnit2 MaybeT

FunctorUnit2 ListSetWithTopT

FunctorUnit2 ListSetT

FunctorUnit2 ListT

FunctorUnit2 (StateT s)

Monoid w => FunctorUnit2 (WriterT w)

FunctorUnit2 (ErrorT e)

FunctorUnit2 (ReaderT * r)

class FunctorJoin2 t where

Methods

fjoin2 :: Functor m => t (t m) ~> t m

Instances

FunctorJoin2 MaybeT

FunctorJoin2 ListSetWithTopT

FunctorJoin2 ListSetT

FunctorJoin2 ListT

FunctorJoin2 (StateT s)

FunctorJoin2 (WriterT w)

FunctorJoin2 (ErrorT e)

FunctorJoin2 (ReaderT * r)

class FunctorFunctor2 t where

Methods

fmap2 :: (Functor m, Functor n) => (m ~> n) -> t m ~> t n

Instances

FunctorFunctor2 MaybeT

FunctorFunctor2 ListSetWithTopT

FunctorFunctor2 ListSetT

FunctorFunctor2 ListT

FunctorFunctor2 (StateT s)

FunctorFunctor2 (WriterT w)

FunctorFunctor2 (ErrorT e)

FunctorFunctor2 (ReaderT * r)

class FunctorIsoFunctor2 t where

Methods

fisoMap2 :: (Functor m, Functor n) => (m ~> n, n ~> m) -> t m ~> t n

class MonadUnit2 t where

Methods

munit2 :: Monad m => m ~> t m

Instances

Monoid o => MonadUnit2 (RWST r o s)

class MonadJoin2 t where

Methods

mjoin2 :: Monad m => t (t m) ~> t m

Instances

Monoid o => MonadJoin2 (RWST r o s)

class MonadFunctor2 t where

Methods

mmap2 :: (Monad m, Monad n) => (m ~> n) -> t m ~> t n

Instances

Monoid o => MonadFunctor2 (RWST r o s)

class MonadIsoFunctor2 t where

Methods

misoMap2 :: (Monad m, Monad n) => (m ~> n, n ~> m) -> t m ~> t n

Instances

MonadIsoFunctor2 (ContT * r)

Isomorphism3 * (* -> *) (k r) (ContFun * r) => MonadIsoFunctor2 (OpaqueContT * * k r)

class MonadIO m where

Methods

io :: IO ~> m

Instances

MonadIO IO

MonadIO CoreM

class MonadQ m where

Methods

liftQ :: Q ~> m

Instances

MonadQ Q

class MonadBot m where

Methods

mbot :: m a

Instances

MonadBot []

MonadBot Q

MonadBot Maybe

MonadBot SetWithTop

MonadBot ListSetWithTop

MonadBot ListSet

MonadBot Set

Functorial * JoinLattice m => MonadBot (SetT m)

Functorial * JoinLattice m => MonadBot (ListSetWithTopT m)

Functorial * JoinLattice m => MonadBot (ListSetT m)

Functorial * Monoid m => MonadBot (ListT m)

MonadBot (Parser t)

MonadBot m => MonadBot (StateT s m)

(MonadBot m, Monoid o) => MonadBot (WriterT o m)

MonadBot m => MonadBot (ReaderT * r m)

MonadBot (PS ν lτ dτ)

JoinLattice val => MonadBot (FI val lτ dτ)

MonadBot (FS val lτ dτ)

MonadBot (PS val lτ dτ)

(MonadBot m, Monoid o) => MonadBot (RWST r o s m)

MonadBot m => MonadBot (AddStateT k s12 s1 m)

MonadBot m => MonadBot (IsoMonadStep k k * ς1 ς2 m)

class MonadTop m where

Methods

mtop :: m a

Instances

MonadTop SetWithTop

MonadTop ListSetWithTop

Functorial * Top m => MonadTop (ListSetWithTopT m)

MonadTop m => MonadTop (StateT s m)

MonadTop (PS ν lτ dτ)

MonadTop m => MonadTop (IsoMonadStep k k * ς1 ς2 m)

class MonadBot m => MonadAppend m where

Methods

(<++>) :: m a -> m a -> m a

Instances

MonadAppend []

MonadAppend Maybe

MonadAppend ListSetWithTop

MonadAppend Set

Functorial * Monoid m => MonadAppend (ListT m)

MonadAppend (Parser t)

MonadAppend m => MonadAppend (StateT s m)

MonadAppend m => MonadAppend (ReaderT * r m)

MonadAppend m => MonadAppend (AddStateT k s12 s1 m)

class MonadBot m => MonadPlus m where

Methods

(<+>) :: m a -> m a -> m a infixr 6

Instances

MonadPlus SetWithTop

MonadPlus ListSetWithTop

MonadPlus ListSet

MonadPlus Set

Functorial * JoinLattice m => MonadPlus (SetT m)

Functorial * JoinLattice m => MonadPlus (ListSetWithTopT m)

Functorial * JoinLattice m => MonadPlus (ListSetT m)

MonadPlus m => MonadPlus (StateT s m)

MonadPlus (PS ν lτ dτ)

JoinLattice val => MonadPlus (FI val lτ dτ)

MonadPlus (FS val lτ dτ)

MonadPlus (PS val lτ dτ)

MonadPlus m => MonadPlus (AddStateT k s12 s1 m)

MonadPlus m => MonadPlus (IsoMonadStep k k * ς1 ς2 m)

guard :: (Monad m, MonadBot m) => Bool -> m ()

maybeZero :: (Monad m, MonadBot m) => Maybe a -> m a

mconcat :: (Iterable (m a) t, MonadAppend m) => t -> m a

mlist :: (Iterable a t, Monad m, MonadAppend m) => t -> m a

msum :: (Iterable (m a) t, MonadPlus m) => t -> m a

mset :: (Iterable a t, Monad m, MonadPlus m) => t -> m a

many :: (Monad m, MonadAppend m) => m a -> m [a]

oneOrMore :: (Monad m, MonadAppend m) => m a -> m (a, [a])

twoOrMore :: (Monad m, MonadAppend m) => m a -> m (a, a, [a])

oneOrMoreList :: (Monad m, MonadAppend m) => m a -> m [a]

newtype MaybeT m a

Constructors

MaybeT

Fields

unMaybeT :: m (Maybe a)

Instances

FunctorFunctor2 MaybeT

FunctorJoin2 MaybeT

FunctorUnit2 MaybeT

(Functor m, MonadState s m) => MonadState s (MaybeT m)

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (MaybeT m)

(Functor m, MonadReader r m) => MonadReader r (MaybeT m)

Functor m => MonadMaybe (MaybeT m)

Monad m => Monad (MaybeT m)

Monad m => Bind (MaybeT m)

(Functor m, Product m) => Product (MaybeT m)

(Functor m, Applicative m) => Applicative (MaybeT m)

Functor m => Functor (MaybeT m)

Unit m => Unit (MaybeT m)

class MonadMaybe m where

Methods

maybeI :: m ~> MaybeT m

maybeE :: MaybeT m ~> m

Instances

MonadMaybe Maybe

MonadMaybe DocM

Functor m => MonadMaybe (MaybeT m)

(Functor m, MonadMaybe m) => MonadMaybe (StateT s m)

(Monoid w, Functor m, MonadMaybe m) => MonadMaybe (WriterT w m)

(Functor m, MonadMaybe m) => MonadMaybe (ReaderT * r m)

(Functor m, MonadMaybe m, Monoid o) => MonadMaybe (RWST r o s m)

obsMaybe :: MonadMaybe m => m a -> m (Maybe a)

effMaybe :: MonadMaybe m => m (Maybe a) -> m a

abort :: (Monad m, MonadMaybe m) => m a

mtry :: (Monad m, MonadMaybe m, Iterable (m a) t) => t -> m a

(<|>) :: (Monad m, MonadMaybe m) => m a -> m a -> m a

newtype ErrorT e m a

Constructors

ErrorT

Fields

unErrorT :: m (e :+: a)

Instances

(Functor m, MonadState s m) => MonadState s (ErrorT e m)

(Functor m, MonadReader r m) => MonadReader r (ErrorT e m)

Functor m => MonadError e (ErrorT e m)

FunctorFunctor2 (ErrorT e)

FunctorJoin2 (ErrorT e)

FunctorUnit2 (ErrorT e)

Monad m => Monad (ErrorT e m)

(Unit m, Functor m, Bind m) => Bind (ErrorT e m)

(Functor m, Product m) => Product (ErrorT e m)

(Functor m, Applicative m) => Applicative (ErrorT e m)

Functor m => Functor (ErrorT e m)

Unit m => Unit (ErrorT e m)

(Functorial * Pretty m, Pretty e, Pretty a) => Pretty (ErrorT e m a)

class MonadError e m | m -> e where

Methods

errorI :: m ~> ErrorT e m

errorE :: ErrorT e m ~> m

Instances

MonadError a ((:+:) a)

(Functor m, MonadError e m) => MonadError e (StateT s m)

Functor m => MonadError e (ErrorT e m)

(Functor m, MonadError e m) => MonadError e (ReaderT * r m)

obsError :: MonadError e m => m a -> m (e :+: a)

effError :: MonadError e m => m (e :+: a) -> m a

sumError :: (Monad m, MonadError e m) => (e :+: a) -> m a

throw :: (Monad m, MonadError e m) => e -> m a

catch :: (Monad m, MonadError e m) => m a -> (e -> m a) -> m a

newtype ReaderT r m a

Constructors

ReaderT

Fields

unReaderT :: r -> m a

Instances

(Functor m, MonadState s m) => MonadState s (ReaderT * r m)

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (ReaderT * r m)

Functor m => MonadReader r (ReaderT * r m)

(Functor m, MonadError e m) => MonadError e (ReaderT * r m)

FunctorFunctor2 (ReaderT * r)

FunctorJoin2 (ReaderT * r)

FunctorUnit2 (ReaderT * r)

(Functor m, MonadMaybe m) => MonadMaybe (ReaderT * r m)

MonadAppend m => MonadAppend (ReaderT * r m)

MonadBot m => MonadBot (ReaderT * r m)

Monad m => Monad (ReaderT * r m)

Bind m => Bind (ReaderT * r m)

Product m => Product (ReaderT * r m)

Applicative m => Applicative (ReaderT * r m)

Functor m => Functor (ReaderT * r m)

Unit m => Unit (ReaderT * r m)

class MonadReader r m | m -> r where

Methods

readerI :: m ~> ReaderT r m

readerE :: ReaderT r m ~> m

Instances

MonadReader PEnv DocM

(Functor m, MonadReader r m) => MonadReader r (MaybeT m)

(Functor m, MonadReader r m) => MonadReader r (StateT s m)

(Monoid w, Functor m, MonadReader r m) => MonadReader r (WriterT w m)

(Functor m, MonadReader r m) => MonadReader r (ErrorT e m)

Functor m => MonadReader r (ReaderT * r m)

(Monad m, Monoid o) => MonadReader r (RWST r o s m)

(MonadReader r m, Functor m) => MonadReader r (AddStateT k s12 s1 m)

runReaderT :: r -> ReaderT r m a -> m a

obsReader :: MonadReader r m => m a -> r -> m a

effReader :: MonadReader r m => (r -> m a) -> m a

ask :: (Monad m, MonadReader r m) => m r

local :: MonadReader r m => (r -> r) -> m a -> m a

localSet :: MonadReader r m => r -> m a -> m a

askL :: (Monad m, MonadReader r m) => Lens r a -> m a

localL :: MonadReader r m => Lens r b -> (b -> b) -> m a -> m a

localSetL :: MonadReader r m => Lens r b -> b -> m a -> m a

newtype WriterT o m a

Constructors

WriterT

Fields

unWriterT :: m (o, a)

Instances

(Functor m, Monoid w, MonadState s m) => MonadState s (WriterT w m)

(Functor m, Monoid o) => MonadWriter o (WriterT o m)

(Monoid w, Functor m, MonadReader r m) => MonadReader r (WriterT w m)

FunctorFunctor2 (WriterT w)

FunctorJoin2 (WriterT w)

Monoid w => FunctorUnit2 (WriterT w)

(Monoid w, Functor m, MonadMaybe m) => MonadMaybe (WriterT w m)

(MonadBot m, Monoid o) => MonadBot (WriterT o m)

(Monad m, Monoid o) => Monad (WriterT o m)

(Monad m, Monoid o) => Bind (WriterT o m)

(Functor m, Product m, Monoid o) => Product (WriterT o m)

(Functor m, Applicative m, Monoid o) => Applicative (WriterT o m)

Functor m => Functor (WriterT o m)

(Unit m, Monoid o) => Unit (WriterT o m)

class MonadWriter o m | m -> o where

Methods

writerI :: m ~> WriterT o m

writerE :: WriterT o m ~> m

Instances

MonadWriter POut DocM

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (MaybeT m)

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (StateT s m)

(Functor m, Monoid o) => MonadWriter o (WriterT o m)

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (ReaderT * r m)

(Monad m, Monoid o) => MonadWriter o (RWST r o s m)

(MonadWriter o m, Functor m, Monoid o) => MonadWriter o (AddStateT k s12 s1 m)

obsWriter :: MonadWriter o m => m a -> m (o, a)

effWriter :: MonadWriter o m => m (o, a) -> m a

tell :: (Monad m, MonadWriter o m) => o -> m ()

hijack :: MonadWriter o m => m a -> m (o, a)

newtype StateT s m a

Constructors

StateT

Fields

unStateT :: s -> m (s, a)

Instances

(Functorial * Bot m, Functorial * Join m, JoinLattice s) => Functorial * JoinLattice (StateT s m)

(Functorial * Monoid m, Monoid s) => Functorial * Monoid (StateT s m)

Functor m => MonadState s (StateT s m)

(Monoid w, Functor m, MonadWriter w m) => MonadWriter w (StateT s m)

(Functor m, MonadReader r m) => MonadReader r (StateT s m)

(Functor m, MonadError e m) => MonadError e (StateT s m)

FunctorFunctor2 (StateT s)

FunctorJoin2 (StateT s)

FunctorUnit2 (StateT s)

(Functor m, MonadMaybe m) => MonadMaybe (StateT s m)

MonadPlus m => MonadPlus (StateT s m)

MonadAppend m => MonadAppend (StateT s m)

MonadTop m => MonadTop (StateT s m)

MonadBot m => MonadBot (StateT s m)

Monad m => Monad (StateT s m)

Monad m => Bind (StateT s m)

Monad m => Product (StateT s m)

Monad m => Applicative (StateT s m)

Functor m => Functor (StateT s m)

Unit m => Unit (StateT s m)

(Functorial * Bot m, Functorial * Join m, JoinLattice s, JoinLattice a) => JoinLattice (StateT s m a)

(Functorial * Join m, Join s, Join a) => Join (StateT s m a)

(Functorial * Bot m, Bot s, Bot a) => Bot (StateT s m a)

(Functorial * Monoid m, Monoid s, Monoid a) => Monoid (StateT s m a)

(MonadStep ς m, Functor m) => MonadStep ((:.:) * * ς ((,) 𝓈)) (StateT 𝓈 m)

class MonadState s m | m -> s where

Methods

stateI :: m ~> StateT s m

stateE :: StateT s m ~> m

Instances

MonadState PState DocM

(Functor m, MonadState s m, Functorial * JoinLattice m, JoinLattice s) => MonadState s (ListSetT m)

(Functor m, MonadState s m, Functorial * Monoid m, Monoid s) => MonadState s (ListT m)

(Functor m, MonadState s m) => MonadState s (MaybeT m)

(Functor m, Monoid w, MonadState s m) => MonadState s (WriterT w m)

(Functor m, MonadState s m) => MonadState s (ErrorT e m)

Functor m => MonadState s (StateT s m)

(Monad m, MonadState s m) => MonadState s (ContT * r m)

(Functor m, MonadState s m) => MonadState s (ReaderT * r m)

(Functor m, MonadState s2 m, Isomorphism s12 (s1, s2)) => MonadState s12 (AddStateT * s12 s1 m)

(Monad m, Monoid o) => MonadState s (RWST r o s m)

(Monad m, MonadState s m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => MonadState s (OpaqueContT * * k r m)

MonadState s m => MonadState s (IsoMonadStep k k * ς1 ς2 m)

MonadState (ParserState t) (Parser t)

MonadState (𝒮 ν lτ dτ) (PS ν lτ dτ)

MonadState (𝒮 val lτ dτ) (PS val lτ dτ)

MonadState (𝒮 val lτ dτ) (FS val lτ dτ)

JoinLattice val => MonadState (𝒮 val lτ dτ) (FI val lτ dτ)

obsState :: MonadState s m => m a -> s -> m (s, a)

effState :: MonadState s m => (s -> m (s, a)) -> m a

get :: (Monad m, MonadState s m) => m s

put :: (Monad m, MonadState s m) => s -> m ()

modify :: (Monad m, MonadState s m) => (s -> s) -> m ()

modifyM :: (Monad m, MonadState s m) => (s -> m s) -> m ()

getL :: (Monad m, MonadState s m) => Lens s a -> m a

putL :: (Monad m, MonadState s m) => Lens s a -> a -> m ()

modifyL :: (Monad m, MonadState s m) => Lens s a -> (a -> a) -> m ()

modifyLM :: (Monad m, MonadState s m) => Lens s a -> (a -> m a) -> m ()

next :: (Monad m, MonadState s m, Peano s) => m s

nextL :: (Monad m, MonadState s m, Peano a) => Lens s a -> m a

bumpL :: (Monad m, MonadState s m, Peano a) => Lens s a -> m ()

newtype RWST r o s m a

Constructors

RWST

Fields

unRWST :: ReaderT r (WriterT o (StateT s m)) a

Instances

(Monad m, Monoid o) => MonadRWS r o s (RWST r o s m)

(Monad m, Monoid o) => MonadState s (RWST r o s m)

(Monad m, Monoid o) => MonadWriter o (RWST r o s m)

(Monad m, Monoid o) => MonadReader r (RWST r o s m)

Monoid o => MonadFunctor2 (RWST r o s)

Monoid o => MonadJoin2 (RWST r o s)

Monoid o => MonadUnit2 (RWST r o s)

(Functor m, MonadMaybe m, Monoid o) => MonadMaybe (RWST r o s m)

(MonadBot m, Monoid o) => MonadBot (RWST r o s m)

(Monad m, Monoid o) => Monad (RWST r o s m)

(Monad m, Monoid o) => Bind (RWST r o s m)

(Monad m, Monoid o) => Product (RWST r o s m)

(Monad m, Monoid o) => Applicative (RWST r o s m)

Functor m => Functor (RWST r o s m)

(Unit m, Monoid o) => Unit (RWST r o s m)

class (MonadReader r m, MonadWriter o m, MonadState s m) => MonadRWS r o s m where

Methods

rwsI :: m ~> RWST r o s m

rwsE :: RWST r o s m ~> m

Instances

(Monad m, Monoid o) => MonadRWS r o s (RWST r o s m)

newtype ContT r m a

Constructors

ContT

Fields

unContT :: (a -> m r) -> m r

Instances

Monad m => MonadCont r (ContT * r m)

(Monad m, MonadState s m) => MonadState s (ContT * r m)

MonadIsoFunctor2 (ContT * r)

Unit m => Monad (ContT * r m)

Unit m => Bind (ContT * r m)

Unit m => Product (ContT * r m)

Unit m => Applicative (ContT * r m)

Unit m => Functor (ContT * r m)

Unit m => Unit (ContT * r m)

class MonadCont r m | m -> r where

Methods

contI :: m ~> ContT r m

contE :: ContT r m ~> m

Instances

Monad m => MonadCont r (ContT * r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => MonadCont r (OpaqueContT * * k r m)

obsCont :: MonadCont r m => m a -> (a -> m r) -> m r

effCont :: MonadCont r m => ((a -> m r) -> m r) -> m a

callCC :: MonadCont r m => ((a -> m r) -> m r) -> m a

withC :: MonadCont r m => (a -> m r) -> m a -> m r

reset :: (Monad m, MonadCont r m) => m r -> m r

modifyC :: (Monad m, MonadCont r m) => (r -> m r) -> m a -> m a

newtype OpaqueContT k r m a

Constructors

OpaqueContT

Fields

unOpaqueContT :: k r m a -> m r

Instances

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r), Balloon k r) => MonadOpaqueCont * k r (OpaqueContT * * k r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => MonadCont r (OpaqueContT * * k r m)

(Monad m, MonadState s m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => MonadState s (OpaqueContT * * k r m)

Isomorphism3 * (* -> *) (k r) (ContFun * r) => MonadIsoFunctor2 (OpaqueContT * * k r)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Monad (OpaqueContT * * k r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Bind (OpaqueContT * * k r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Product (OpaqueContT * * k r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Applicative (OpaqueContT * * k r m)

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => Functor (OpaqueContT * * k r m)

Morphism3 * (k -> *) (k1 r) (ContFun k r) => Unit (OpaqueContT * k k r m)

class MonadOpaqueCont k r m | m -> k, m -> r where

Methods

opaqueContI :: m ~> OpaqueContT k r m

opaqueContE :: OpaqueContT k r m ~> m

Instances

(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r), Balloon k r) => MonadOpaqueCont * k r (OpaqueContT * * k r m)

obsOpaqueCont :: MonadOpaqueCont k r m => m a -> k r m a -> m r

effOpaqueCont :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a

opaqueWithC :: MonadOpaqueCont k r m => k r m a -> m a -> m r

opaqueCallCC :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a

class Container e t | t -> e where

Methods

(?) :: t -> e -> Bool infix 9

Instances

Container Char String

Container a (Set a)

Eq a => Container a [a]

Eq a => Container a (ListSet a)

Eq ψ => Container ψ (Cτ ψ)

Eq ψ => Container ψ (Cτ ψ)

Eq ψ => Container ψ (Kτ k ψ)

Eq ψ => Container ψ (Kτ k ψ)

Eq v => Container (k, v) (Map k v)

Container (val lτ dτ) (Power k k val lτ dτ)

elem :: Container e t => e -> t -> Bool

class Indexed k v t | t -> k, t -> v where

Methods

(#) :: t -> k -> Maybe v infixl 9

Instances

Eq k => Indexed k v [(k, v)]

Indexed k v (Map k v)

index :: Indexed k v t => t -> k -> Maybe v

(#!) :: Indexed k v t => t -> k -> v infixl 9

lookup :: Indexed k v t => k -> t -> Maybe v

class Iterable a t | t -> a where

Minimal complete definition

Nothing

Methods

foldlk :: (b -> a -> (b -> b) -> b) -> b -> t -> b

foldl :: (b -> a -> b) -> b -> t -> b

foldr :: (a -> b -> b) -> b -> t -> b

iter :: (a -> b -> b) -> b -> t -> b

size :: Integral n => t -> n

Instances

Iterable Char String

Iterable a (Set a)

Iterable a [a]

Iterable a (ListSet a)

Iterable ψ (Cτ ψ)

Iterable ψ (Cτ ψ)

Iterable ψ (Kτ k ψ)

Iterable ψ (Kτ k ψ)

Iterable (k, v) (Map k v)

Iterable (val lτ dτ) (Power k k val lτ dτ)

foldlOn :: Iterable a t => t -> b -> (b -> a -> b) -> b

foldlFrom :: Iterable a t => b -> (b -> a -> b) -> t -> b

foldrOn :: Iterable a t => t -> b -> (a -> b -> b) -> b

foldrFrom :: Iterable a t => b -> (a -> b -> b) -> t -> b

iterOn :: Iterable a t => t -> b -> (a -> b -> b) -> b

iterFrom :: Iterable a t => b -> (a -> b -> b) -> t -> b

isElem :: (Iterable a t, Eq a) => a -> t -> Bool

elemAtN :: (Iterable a t, Peano n, Eq n) => n -> t -> Maybe a

toList :: Iterable a t => t -> [a]

toSet :: (Ord a, Iterable a t) => t -> Set a

toMap :: (Ord k, Iterable (k, v) t) => t -> Map k v

toMapJoin :: (Ord k, Iterable (k, v) t, Join v) => t -> Map k v

class Buildable a t | t -> a where

Methods

nil :: t

(&) :: a -> t -> t

Instances

Ord a => Buildable a (SumOfProd a)

Ord a => Buildable a (SetWithTop a)

Buildable a (ListSetWithTop a)

Ord a => Buildable a (Set a)

Buildable a [a]

Buildable a (ListSet a)

Buildable ψ (Cτ ψ)

Buildable ψ (Cτ ψ)

Buildable ψ (Kτ k ψ)

Buildable ψ (Kτ k ψ)

Ord k => Buildable (k, v) (Map k v)

Ord (ν lτ dτ) => Buildable (ν lτ dτ) (SumOfProdVal k k ν lτ dτ)

Ord (val lτ dτ) => Buildable (val lτ dτ) (Power k k val lτ dτ)

build :: Buildable a t => [a] -> t

single :: Buildable a t => a -> t

filter :: (Iterable a t, Buildable a t) => (a -> Bool) -> t -> t

reverse :: (Iterable a t, Buildable a t) => t -> t

uniques :: (Eq a, Iterable a t, Buildable a t) => t -> t

replicate :: (Eq n, Peano n, Iterable a t, Buildable a t) => n -> a -> t

fromList :: Buildable a t => [a] -> t

fromSet :: Buildable a t => Set a -> t

fromMap :: Buildable (k, v) t => Map k v -> t

applyTo :: a -> (a -> b) -> b

(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 9

(..:) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 9

(...:) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f

(....:) :: (f -> g) -> (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> g

rotateR :: (a -> b -> c -> d) -> c -> a -> b -> d

rotateL :: (a -> b -> c -> d) -> b -> c -> a -> d

mirror :: (a -> b -> c -> d) -> c -> b -> a -> d

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

composition :: [a -> a] -> a -> a

data Endo a

Constructors

Endo

Fields

unEndo :: a -> a

Instances

Monoid (Endo a)

runEndo :: a -> Endo a -> a

data KleisliEndo m a

Constructors

KleisliEndo

Fields

unKleisliEndo :: a -> m a

Instances

Monad m => Monoid (KleisliEndo m a)

runKleisliEndo :: a -> KleisliEndo m a -> m a

ifThenElse :: Bool -> a -> a -> a

fif :: Bool -> a -> a -> a

cond :: (a -> Bool) -> c -> c -> a -> c

type String = Text

type Chars = [Char]

fromChars :: Chars -> String

fromString :: Chars -> String

toChars :: String -> Chars

error :: String -> a

show :: Show a => a -> String

read :: Read a => String -> a

data Cursor a b

Constructors

Cursor

Fields

focus :: a

construct :: a -> b

data Lens a b

Constructors

Lens

Fields

unLens :: a -> Cursor b a

Instances

Category * Lens

lens :: (a -> b) -> (a -> b -> a) -> Lens a b

isoLens :: (a -> b) -> (b -> a) -> Lens a b

update :: Lens a b -> (b -> b) -> a -> a

updateM :: Monad m => Lens a b -> (b -> m b) -> a -> m a

access :: Lens a b -> a -> b

(~:) :: Lens a b -> (b -> b) -> a -> a infixr 0

set :: Lens a b -> b -> a -> a

(=:) :: Lens a b -> b -> a -> a infixr 0

(|:) :: a -> (a -> a) -> a infixr 0

data Prism a b

Constructors

Prism

Fields

inject :: b -> a

view :: a -> Maybe b

Instances

Category * Prism

prism :: (b -> a) -> (a -> Maybe b) -> Prism a b

isoPrism :: (b -> a) -> (a -> b) -> Prism a b

unsafe_coerce :: Prism a b -> a -> b

is :: Prism a b -> a -> Bool

alter :: Prism a b -> (b -> b) -> a -> a

(~^) :: Prism a b -> (b -> b) -> a -> a

pset :: Prism a b -> b -> a -> a

(=^) :: Prism a b -> b -> a -> a

newtype (t :.: u) a infixr 9

Constructors

Compose

Fields

unCompose :: t (u a)

Instances

(Functorial * JoinLattice t, Functorial * JoinLattice u) => Functorial * JoinLattice ((:.:) * * t u)

Isomorphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Isomorphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Isomorphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Isomorphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

Morphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Morphism2 * (PSΣ' ν lτ dτ) (PSΣ ν lτ dτ)

Morphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Morphism2 * (FIΣ' val lτ dτ) (FIΣ val lτ dτ)

Morphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Morphism2 * (FSΣ' val lτ dτ) (FSΣ val lτ dτ)

Morphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

Morphism2 * (PSΣ' val lτ dτ) (PSΣ val lτ dτ)

(Functor t, Functor u) => Functor ((:.:) * * t u)

(Inject t, Inject u) => Inject ((:.:) * * t u)

(Commute t ListSet, Commute u ListSet, Functor t) => Commute ((:.:) * * t u) ListSet

(MonadStep ς m, Functorial * JoinLattice m, Functorial * Top m) => MonadStep ((:.:) * * ς ListSetWithTop) (ListSetWithTopT m)

(MonadStep ς m, Functorial * JoinLattice m) => MonadStep ((:.:) * * ς ListSet) (ListSetT m)

(MonadStep ς m, Functor m) => MonadStep ((:.:) * * ς ((,) 𝓈)) (StateT 𝓈 m)

(MonadStep ς m, Functor m) => MonadStep ((:.:) * * ς ((,) 𝓈1)) (AddStateT k 𝓈12 𝓈1 m)

Eq (t (u a)) => Eq ((:.:) k k t u a)

Ord (t (u a)) => Ord ((:.:) k k t u a)

Lattice (t (u a)) => Lattice ((:.:) k k t u a)

MeetLattice (t (u a)) => MeetLattice ((:.:) k k t u a)

JoinLattice (t (u a)) => JoinLattice ((:.:) k k t u a)

Meet (t (u a)) => Meet ((:.:) k k t u a)

Top (t (u a)) => Top ((:.:) k k t u a)

Join (t (u a)) => Join ((:.:) k k t u a)

Bot (t (u a)) => Bot ((:.:) k k t u a)

PartialOrder (t (u a)) => PartialOrder ((:.:) k k t u a)

onComposeIso :: (t (u a) -> t (u b)) -> (t :.: u) a -> (t :.: u) b

swap :: (a, b) -> (b, a)

fstL :: Lens (a, b) a

sndL :: Lens (a, b) b

mapFst :: (a -> a') -> (a, b) -> (a', b)

mapSnd :: (b -> b') -> (a, b) -> (a, b')

data a :+: b infixr 6

Constructors

Inl a

Inr b

Instances

MonadError a ((:+:) a)

Monad ((:+:) a)

Bind ((:+:) a)

Product ((:+:) a)

Applicative ((:+:) a)

Functor ((:+:) a)

Unit ((:+:) a)

(Eq a, Eq b) => Eq ((:+:) a b)

(Ord a, Ord b) => Ord ((:+:) a b)

(Pretty a, Pretty b) => Pretty ((:+:) a b)

sumElim :: (a -> c) -> (b -> c) -> (a :+: b) -> c

inlL :: Prism (a :+: b) a

inrL :: Prism (a :+: b) b

mapInl :: (a -> a') -> (a :+: b) -> a' :+: b

mapInr :: (b -> b') -> (a :+: b) -> a :+: b'

mapSum :: (a -> a') -> (b -> b') -> (a :+: b) -> a' :+: b'

maybeElim :: b -> (a -> b) -> Maybe a -> b

nothingL :: Prism (Maybe a) ()

justL :: Prism (Maybe a) a

maybeElimOn :: Maybe a -> b -> (a -> b) -> b

maybeNot :: a -> Maybe a -> a

nilL :: Prism [a] ()

consL :: Prism [a] (a, [a])

singleL :: Prism [a] a

length :: Peano n => [a] -> n

mapHead :: (a -> a) -> [a] -> [a]

mapTail :: (a -> a) -> [a] -> [a]

head :: [a] -> Maybe a

tail :: [a] -> Maybe [a]

zip :: [a] -> [b] -> Maybe [(a, b)]

unzip :: [(a, b)] -> ([a], [b])

firstN :: (Eq n, Integral n) => n -> [a] -> [a]

intersperse :: a -> [a] -> [a]

pluck :: [a] -> [[a]] -> Maybe ([a], [[a]])

transpose :: [[a]] -> [[a]]

bigProduct :: [[a]] -> [[a]]

data Set a where

Constructors

EmptySet :: Set a

Set :: Ord a => Set a -> Set a

Instances

MonadPlus Set

MonadAppend Set

MonadBot Set

Bind Set

Product Set

Functorial * Pretty Set

Ord a => Buildable a (Set a)

Iterable a (Set a)

Container a (Set a)

Eq (Set a)

Ord (Set a)

JoinLattice (Set a)

Difference (Set a)

Meet (Set a)

Join (Set a)

Bot (Set a)

Monoid (Set a)

PartialOrder (Set a)

Pretty a => Pretty (Set a)

setPrimElim :: b -> (Ord a => Set a -> b) -> Set a -> b

setPrimElimOn :: Set a -> b -> (Ord a => Set a -> b) -> b

setPrimElim2 :: b -> (Ord a => Set a -> b) -> (Ord a => Set a -> b) -> (Ord a => Set a -> Set a -> b) -> Set a -> Set a -> b

setPrimElim2' :: b -> (Ord a => Set a -> b) -> (Ord a => Set a -> Set a -> b) -> Set a -> Set a -> b

toPrimSet :: Set a -> Set a

learnSet :: Set a -> b -> (Ord a => b) -> b

empty :: Set a

isEmpty :: Set a -> Bool

insert :: Ord a => a -> Set a -> Set a

union :: Set a -> Set a -> Set a

intersection :: Set a -> Set a -> Set a

remove :: Set a -> Maybe (a, Set a)

setDiff :: Set a -> Set a -> Set a

setMap :: Ord b => (a -> b) -> Set a -> Set b

setMapOn :: Ord b => Set a -> (a -> b) -> Set b

maybeSet :: Ord a => Maybe a -> Set a

setTranspose :: Set (Set a) -> Set (Set a)

setBigProduct :: Set (Set a) -> Set (Set a)

data Map k v where

Constructors

EmptyMap :: Map k v

Map :: Ord k => Map k v -> Map k v

Instances

Indexed k v (Map k v)

Isomorphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Morphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Morphism2 * (FIΣ' val lτ dτ) (FIΣ val lτ dτ)

Functor (Map k)

(Eq k, Eq v) => Eq (Map k v)

(Ord k, Ord v) => Ord (Map k v)

JoinLattice v => JoinLattice (Map k v)

Difference v => Difference (Map k v)

Join v => Join (Map k v)

Bot (Map k v)

Monoid v => Monoid (Map k v)

(Ord k, PartialOrder v) => PartialOrder (Map k v)

(Pretty k, Pretty v) => Pretty (Map k v)

Ord k => Buildable (k, v) (Map k v)

Iterable (k, v) (Map k v)

Eq v => Container (k, v) (Map k v)

Morphism (𝒮Cxt lτ dτ, Store val lτ dτ) (𝒮 val lτ dτ)

Isomorphism (𝒮 val lτ dτ) (𝒮Cxt lτ dτ, Store val lτ dτ)

Morphism (𝒮 val lτ dτ) (𝒮Cxt lτ dτ, Store val lτ dτ)

type Old v = v

type New v = v

mapPrimElim :: b -> (Ord k => Map k v -> b) -> Map k v -> b

mapPrimElimOn :: Map k v -> b -> (Ord k => Map k v -> b) -> b

mapPrimElim2 :: b -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> Map k v -> b) -> Map k v -> Map k v -> b

mapPrimElim2' :: b -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> Map k v -> b) -> Map k v -> Map k v -> b

toPrimMap :: Map k v -> Map k v

learnMap :: Map k v -> b -> (Ord k => b) -> b

mapEmpty :: Map k v

mapIsEmpty :: Map k v -> Bool

mapKeys :: Map k v -> Set k

mapInsert :: Ord k => k -> v -> Map k v -> Map k v

mapSingleton :: Ord k => k -> v -> Map k v

mapInsertWith :: Ord k => (Old v -> New v -> v) -> k -> v -> Map k v -> Map k v

mapRemove :: Map k v -> Maybe ((k, v), Map k v)

mapUnionWith :: (Old v -> New v -> v) -> Map k v -> Map k v -> Map k v

mapIntersectionWith :: (Old v -> New v -> v) -> Map k v -> Map k v -> Map k v

mapModify :: (v -> v) -> k -> Map k v -> Map k v

onlyKeys :: Ord k => Set k -> Map k v -> Map k v

mapFilter :: (v -> Bool) -> Map k v -> Map k v

mapNoBot :: (Bot v, Eq v) => Map k v -> Map k v

newtype ListSet a

Constructors

ListSet

Fields

unListSet :: [a]

Instances

MonadPlus ListSet

MonadBot ListSet

Monad ListSet

Bind ListSet

Product ListSet

Applicative ListSet

FunctorM ListSet

Functor ListSet

Unit ListSet

Inject ListSet

Commute ID ListSet

Buildable a (ListSet a)

Iterable a (ListSet a)

Eq a => Container a (ListSet a)

Isomorphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Isomorphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Isomorphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

Morphism2 * (FIΣ val lτ dτ) (FIΣ' val lτ dτ)

Morphism2 * (FIΣ' val lτ dτ) (FIΣ val lτ dτ)

Morphism2 * (FSΣ val lτ dτ) (FSΣ' val lτ dτ)

Morphism2 * (FSΣ' val lτ dτ) (FSΣ val lτ dτ)

Morphism2 * (PSΣ val lτ dτ) (PSΣ' val lτ dτ)

Morphism2 * (PSΣ' val lτ dτ) (PSΣ val lτ dτ)

JoinLattice (ListSet a)

Join (ListSet a)

Bot (ListSet a)

Monoid (ListSet a)

Ord a => PartialOrder (ListSet a)

(Ord a, Pretty a) => Pretty (ListSet a)

JoinLattice 𝓈 => Commute ((,) 𝓈) ListSet

(Commute t ListSet, Commute u ListSet, Functor t) => Commute ((:.:) * * t u) ListSet

(MonadStep ς m, Functorial * JoinLattice m) => MonadStep ((:.:) * * ς ListSet) (ListSetT m)

listSetTranspose :: forall a. ListSet (ListSet a) -> ListSet (ListSet a)

print :: MonadIO m => String -> m ()

failIO :: MonadIO m => String -> m a

data Stamped a f

Constructors

Stamped

Fields

stampedID :: a

stamped :: f

Instances

Balloon CPSKon Call

Eq a => Eq (Stamped a f)

Ord a => Ord (Stamped a f)

(Pretty a, Pretty f) => Pretty (Stamped a f)

newtype Fix f

Constructors

Fix

Fields

unFix :: f (Fix f)

Instances

Functorial * Eq f => Eq (Fix f)

(Functorial * Eq f, Functorial * Ord f) => Ord (Fix f)

Functorial * Pretty f => Pretty (Fix f)

data StampedFix a f

Constructors

StampedFix

Fields

stampedFixID :: a

stampedFix :: f (StampedFix a f)

Instances

Balloon CPSKon Call

Balloon CPSKon Call

Eq a => Eq (StampedFix a f)

Ord a => Ord (StampedFix a f)

PartialOrder a => PartialOrder (StampedFix a f)

(Pretty a, Functorial * Pretty f) => Pretty (StampedFix a f)

stripStampedFix :: Functor f => StampedFix a f -> Fix f

data Annotated ann a

Constructors

Annotated

Fields

annotation :: ann

annValue :: a

data ListSetWithTop a

Constructors

ListSetTop

ListSetNotTop (ListSet a)

Instances

MonadPlus ListSetWithTop

MonadAppend ListSetWithTop

MonadTop ListSetWithTop

MonadBot ListSetWithTop

Monad ListSetWithTop

Bind ListSetWithTop

Product ListSetWithTop

Applicative ListSetWithTop

Functor ListSetWithTop

Unit ListSetWithTop

Inject ListSetWithTop

Buildable a (ListSetWithTop a)

Isomorphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Morphism2 * (PSΣ ν lτ dτ) (PSΣ' ν lτ dτ)

Morphism2 * (PSΣ' ν lτ dτ) (PSΣ ν lτ dτ)

MeetLattice (ListSetWithTop a)

JoinLattice (ListSetWithTop a)

Ord a => Difference (ListSetWithTop a)

Meet (ListSetWithTop a)

Top (ListSetWithTop a)

Join (ListSetWithTop a)

Bot (ListSetWithTop a)

Monoid (ListSetWithTop a)

Ord a => PartialOrder (ListSetWithTop a)

(Ord a, Pretty a) => Pretty (ListSetWithTop a)

(MonadStep ς m, Functorial * JoinLattice m, Functorial * Top m) => MonadStep ((:.:) * * ς ListSetWithTop) (ListSetWithTopT m)

listSetWithTopElim :: b -> (ListSet a -> b) -> ListSetWithTop a -> b

listSetWithTopTranspose :: ListSetWithTop (ListSetWithTop a) -> ListSetWithTop (ListSetWithTop a)

data SetWithTop a

Constructors

SetTop

SetNotTop (Set a)

Instances

MonadPlus SetWithTop

MonadTop SetWithTop

MonadBot SetWithTop

Bind SetWithTop

Product SetWithTop

(Ord lτ, Ord dτ, Ord (ν lτ dτ), Val lτ dτ ConstructiveClassical ν) => Val lτ dτ SetWithTop (SumOfProdVal * * ν)

Ord a => Buildable a (SetWithTop a)

Eq (SetWithTop a)

Ord (SetWithTop a)

MeetLattice (SetWithTop a)

JoinLattice (SetWithTop a)

Difference (SetWithTop a)

Meet (SetWithTop a)

Top (SetWithTop a)

Join (SetWithTop a)

Bot (SetWithTop a)

Ord a => PartialOrder (SetWithTop a)

Pretty a => Pretty (SetWithTop a)

setWithTopElim :: b -> (Set a -> b) -> SetWithTop a -> b

setFromListWithTop :: Ord a => ListSetWithTop a -> SetWithTop a

listFromSetWithTop :: SetWithTop a -> ListSetWithTop a

data ConstructiveClassical a

Constructors

Constructive (Set a)

Classical (a -> Bool)

Instances

(Ord lτ, Ord dτ) => Val lτ dτ ConstructiveClassical OCVal

conClaPartition :: [ConstructiveClassical a] -> ([Set a], [a -> Bool])

conClaBigProduct :: Ord a => [ConstructiveClassical a] -> ListSetWithTop a

newtype SumOfProd a

Constructors

SumOfProd

Fields

unSumOfProd :: Set (Set a)

Instances

Ord a => Buildable a (SumOfProd a)

Eq (SumOfProd a)

Ord (SumOfProd a)

JoinLattice (SumOfProd a)

(Ord a, Neg a) => Neg (SumOfProd a)

Meet (SumOfProd a)

Join (SumOfProd a)

Bot (SumOfProd a)

Pretty a => Pretty (SumOfProd a)

sumOfProdMap :: Ord b => (a -> b) -> SumOfProd a -> SumOfProd b

sumOfProdConcretize :: Ord b => (a -> ConstructiveClassical b) -> SumOfProd a -> SetWithTop b

module GHC.Exts

module Data.Char

module Language.Haskell.TH

module Data.Coerce