Safe Haskell | None |
---|---|
Language | Haskell2010 |
Documentation
module Prelude
class Functorial c t where Source
functorial :: c a => W (c (t a)) Source
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 Source
bifunctorial :: (c a, c b) => W (c (t a b)) Source
Bifunctorial * Eq (,) | |
Bifunctorial * Ord (,) | |
Bifunctorial * Pretty (,) |
class FromInteger a where Source
fromInteger :: Integer -> a Source
class ToRational a where Source
toRational :: a -> Rational Source
class FromRational a where Source
fromRational :: Rational -> a Source
class FromDouble a where Source
fromDouble :: Double -> a Source
class Additive a => Subtractive a where Source
class Additive a => Multiplicative a where Source
class Multiplicative a => Divisible a where Source
class Multiplicative a => TruncateDivisible a where Source
class (TruncateDivisible a, ToInteger a, FromInteger a, ToInt a, FromInt a, ToRational a, ToDouble a) => Integral a Source
class (Divisible a, ToRational a, FromRational a, ToDouble a, FromDouble a, FromInteger a, FromInt a) => Fractional a Source
negate :: Subtractive a => a -> a Source
class PartialOrder a where Source
Nothing
(⋈) :: PartialOrder a => a -> a -> POrdering Source
(⊒) :: PartialOrder a => a -> a -> Bool Source
(⊐) :: PartialOrder a => a -> a -> Bool Source
fromOrdering :: Ordering -> POrdering Source
discreteOrder :: Eq a => a -> a -> POrdering Source
findMax :: (Iterable a t, PartialOrder b) => (a -> b) -> a -> t -> a Source
findMaxFrom :: (Iterable a t, PartialOrder b) => a -> (a -> b) -> t -> a Source
poiter :: PartialOrder a => (a -> a) -> a -> a Source
poiterHistory :: PartialOrder a => (a -> a) -> a -> [a] Source
class Morphism a b where Source
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 Source
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 (Morphism a b, Morphism b a) => Isomorphism a b Source
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 Source
isofrom :: Isomorphism a b => b -> a Source
class (Morphism2 t u, Morphism2 u t) => Isomorphism2 t u Source
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 Source
isofrom2 :: Isomorphism2 t u => u ~> t Source
onIso2 :: Isomorphism2 t u => (u a -> u b) -> t a -> t b Source
class (Morphism3 v w, Morphism3 w v) => Isomorphism3 v w Source
Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r) | |
Isomorphism3 * (* -> *) (ContFun * r) (CPSKon r) |
isoto3 :: Isomorphism3 v w => v ~~> w Source
isofrom3 :: Isomorphism3 v w => w ~~> v Source
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 Source
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τ) |
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 Difference a where Source
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 Source
class (Top a, Meet a) => MeetLattice a Source
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 Source
class (Lattice a, Neg a) => NegLattice a Source
NegLattice Int | |
NegLattice b => NegLattice (a -> b) |
joins :: (Iterable a t, JoinLattice a) => t -> a Source
meets :: (Iterable a t, MeetLattice a) => t -> a Source
collect :: (Join a, PartialOrder a) => (a -> a) -> a -> a Source
collectHistory :: (Join a, PartialOrder a) => (a -> a) -> a -> [a] Source
diffs :: forall a. (JoinLattice a, Difference a) => [a] -> [a] Source
collectDiffs :: (PartialOrder a, JoinLattice a, Difference a) => (a -> a) -> a -> [a] Source
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) |
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) |
class (Unit t, Functor t) => Applicative t where Source
pure :: Applicative t => a -> t a Source
(<$>) :: Applicative t => t (a -> b) -> t a -> t b infixr 0 Source
apair :: Applicative t => t a -> t b -> t (a, b) Source
class Product m => Bind m where Source
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 Source
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) |
traverseOn :: (Iterable a t, Monad m) => t -> (a -> m ()) -> m () Source
class FunctorUnit2 t where Source
class FunctorJoin2 t where Source
class FunctorFunctor2 t where Source
class FunctorIsoFunctor2 t where Source
class MonadUnit2 t where Source
Monoid o => MonadUnit2 (RWST r o s) |
class MonadJoin2 t where Source
Monoid o => MonadJoin2 (RWST r o s) |
class MonadFunctor2 t where Source
Monoid o => MonadFunctor2 (RWST r o s) |
class MonadIsoFunctor2 t where Source
MonadIsoFunctor2 (ContT * r) | |
Isomorphism3 * (* -> *) (k r) (ContFun * r) => MonadIsoFunctor2 (OpaqueContT * * k r) |
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) |
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 Source
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 Source
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) |
mconcat :: (Iterable (m a) t, MonadAppend m) => t -> m a Source
mlist :: (Iterable a t, Monad m, MonadAppend m) => t -> m a Source
many :: (Monad m, MonadAppend m) => m a -> m [a] Source
oneOrMore :: (Monad m, MonadAppend m) => m a -> m (a, [a]) Source
twoOrMore :: (Monad m, MonadAppend m) => m a -> m (a, a, [a]) Source
oneOrMoreList :: (Monad m, MonadAppend m) => m a -> m [a] Source
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 Source
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) Source
effMaybe :: MonadMaybe m => m (Maybe a) -> m a Source
abort :: (Monad m, MonadMaybe m) => m a Source
mtry :: (Monad m, MonadMaybe m, Iterable (m a) t) => t -> m a Source
(<|>) :: (Monad m, MonadMaybe m) => m a -> m a -> m a Source
(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 Source
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) Source
effError :: MonadError e m => m (e :+: a) -> m a Source
sumError :: (Monad m, MonadError e m) => (e :+: a) -> m a Source
throw :: (Monad m, MonadError e m) => e -> m a Source
catch :: (Monad m, MonadError e m) => m a -> (e -> m a) -> m a Source
(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 Source
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 Source
obsReader :: MonadReader r m => m a -> r -> m a Source
effReader :: MonadReader r m => (r -> m a) -> m a Source
ask :: (Monad m, MonadReader r m) => m r Source
local :: MonadReader r m => (r -> r) -> m a -> m a Source
localSet :: MonadReader r m => r -> m a -> m a Source
askL :: (Monad m, MonadReader r m) => Lens r a -> m a Source
localL :: MonadReader r m => Lens r b -> (b -> b) -> m a -> m a Source
localSetL :: MonadReader r m => Lens r b -> b -> m a -> m a Source
(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 Source
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) Source
effWriter :: MonadWriter o m => m (o, a) -> m a Source
tell :: (Monad m, MonadWriter o m) => o -> m () Source
hijack :: MonadWriter o m => m a -> m (o, a) Source
class MonadState s m | m -> s where Source
obsState :: MonadState s m => m a -> s -> m (s, a) Source
effState :: MonadState s m => (s -> m (s, a)) -> m a Source
get :: (Monad m, MonadState s m) => m s Source
put :: (Monad m, MonadState s m) => s -> m () Source
modify :: (Monad m, MonadState s m) => (s -> s) -> m () Source
modifyM :: (Monad m, MonadState s m) => (s -> m s) -> m () Source
getL :: (Monad m, MonadState s m) => Lens s a -> m a Source
putL :: (Monad m, MonadState s m) => Lens s a -> a -> m () Source
modifyL :: (Monad m, MonadState s m) => Lens s a -> (a -> a) -> m () Source
modifyLM :: (Monad m, MonadState s m) => Lens s a -> (a -> m a) -> m () Source
next :: (Monad m, MonadState s m, Peano s) => m s Source
(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 Source
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 Source
Monad m => MonadCont r (ContT * r m) | |
(Monad m, Isomorphism3 * (* -> *) (ContFun * r) (k r)) => MonadCont r (OpaqueContT * * k r m) |
newtype OpaqueContT k r m a Source
OpaqueContT | |
|
(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 Source
opaqueContI :: m ~> OpaqueContT k r m Source
opaqueContE :: OpaqueContT k r m ~> m Source
(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 Source
effOpaqueCont :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a Source
opaqueWithC :: MonadOpaqueCont k r m => k r m a -> m a -> m r Source
opaqueCallCC :: MonadOpaqueCont k r m => (k r m a -> m r) -> m a Source
class Iterable a t | t -> a where Source
Nothing
class Buildable a t | t -> a where Source
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τ) |
composition :: [a -> a] -> a -> a Source
data KleisliEndo m a Source
KleisliEndo | |
|
Monad m => Monoid (KleisliEndo m a) |
runKleisliEndo :: a -> KleisliEndo m a -> m a Source
ifThenElse :: Bool -> a -> a -> a Source
fromString :: Chars -> String Source
unsafe_coerce :: Prism a b -> a -> b Source
newtype (t :.: u) a infixr 9 Source
(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 Source
maybeElimOn :: Maybe a -> b -> (a -> b) -> b Source
intersperse :: a -> [a] -> [a] Source
bigProduct :: [[a]] -> [[a]] Source
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 Source
setPrimElimOn :: Set a -> b -> (Ord a => Set a -> b) -> b Source
setPrimElim2 :: b -> (Ord a => Set a -> b) -> (Ord a => Set a -> b) -> (Ord a => Set a -> Set a -> b) -> Set a -> Set a -> b Source
setPrimElim2' :: b -> (Ord a => Set a -> b) -> (Ord a => Set a -> Set a -> b) -> Set a -> Set a -> b Source
intersection :: Set a -> Set a -> Set a Source
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τ) |
mapPrimElim :: b -> (Ord k => Map k v -> b) -> Map k v -> b Source
mapPrimElimOn :: Map k v -> b -> (Ord k => Map k v -> b) -> b Source
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 Source
mapPrimElim2' :: b -> (Ord k => Map k v -> b) -> (Ord k => Map k v -> Map k v -> b) -> Map k v -> Map k v -> b Source
mapIsEmpty :: Map k v -> Bool Source
mapSingleton :: Ord k => k -> v -> Map k v Source
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 Source
StampedFix | |
|
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 Source
Annotated | |
|
data ListSetWithTop a Source
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 Source
listSetWithTopTranspose :: ListSetWithTop (ListSetWithTop a) -> ListSetWithTop (ListSetWithTop a) Source
data SetWithTop a Source
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 Source
setFromListWithTop :: Ord a => ListSetWithTop a -> SetWithTop a Source
listFromSetWithTop :: SetWithTop a -> ListSetWithTop a Source
data ConstructiveClassical a Source
Constructive (Set a) | |
Classical (a -> Bool) |
(Ord lτ, Ord dτ) => Val lτ dτ ConstructiveClassical OCVal |
conClaPartition :: [ConstructiveClassical a] -> ([Set a], [a -> Bool]) Source
conClaBigProduct :: Ord a => [ConstructiveClassical a] -> ListSetWithTop a Source
SumOfProd | |
|
sumOfProdMap :: Ord b => (a -> b) -> SumOfProd a -> SumOfProd b Source
sumOfProdConcretize :: Ord b => (a -> ConstructiveClassical b) -> SumOfProd a -> SetWithTop b Source
module GHC.Exts
module Data.Char
module Language.Haskell.TH
module Data.Coerce