FP.Core

Documentation

module Prelude

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 Cτ

Functorial * Ord []

Functorial * Ord Cτ

Functorial * JoinLattice ID

Functorial * Monoid []

Functorial * Monoid ID

Functorial * Pretty []

Functorial * Pretty ID

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 (PreCall n)

Pretty n => Functorial * Pretty (PreExp n)

Functorial * Pretty (Zτ *)

Functorial * Pretty (Kτ k)

(Functorial * JoinLattice 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 (,)

bifunctorialP :: (Bifunctorial c t, c a, c b) => P c -> P t -> P a -> P b -> W (c (t a b))

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 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

class ToRational a where

Methods

toRational :: a -> Rational

Instances

ToRational Int

ToRational Integer

class FromRational a where

Methods

fromRational :: Rational -> a

class ToDouble a where

Methods

toDouble :: a -> Double

Instances

ToDouble Int

ToDouble Integer

class FromDouble a where

Methods

fromDouble :: Double -> a

class ToChars a where

Methods

toChars :: a -> Chars

Instances

ToChars String

class FromChars a where

Methods

fromChars :: Chars -> a

Instances

FromChars String

fromString :: Chars -> String

class ToString t where

Methods

toString :: t -> String

Instances

ToString Bool

ToString Char

ToString Double

ToString Int

ToString Integer

ToString String

ToString Color256

class FromString t where

Methods

fromString' :: String -> t

Instances

FromString Double

class Commute t u where

Methods

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

Instances

Commute ID ListSet

Commute ((,) 𝓈) ListSet

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

class Peano a where

Methods

zer :: a

suc :: a -> a

Instances

Peano Double

Peano Int

Peano Integer

Peano BdrNum

Peano LocNum

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

niterOn :: (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

class Additive a => Subtractive a where

Methods

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

Instances

Subtractive Double

Subtractive Int

Subtractive Integer

class Additive a => Multiplicative a where

Methods

one :: a

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

Instances

Multiplicative Double

Multiplicative Int

Multiplicative Integer

class Multiplicative a => Divisible a where

Methods

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

Instances

Divisible Double

class Multiplicative a => TruncateDivisible a where

Methods

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

Instances

TruncateDivisible Int

TruncateDivisible Integer

negate :: Subtractive a => a -> a

inverse :: Divisible a => a -> a

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) => Floating 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 a m. t m a -> u m a

class Morphism a b where

Methods

morph :: a -> b

Instances

Morphism (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ) (𝒮 val lτ dτ ψ)

Morphism (𝒮 val lτ dτ ψ) (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ)

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

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

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

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

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

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

class Morphism2 m n where

Methods

morph2 :: m ~> n

Instances

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

Morphism2 * (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τ ψ)

class Morphism3 t u where

Methods

morph3 :: t ~~> u

Instances

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

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

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

Instances

Isomorphism (𝒮 val lτ dτ ψ) (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ)

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

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

(Ord (val lτ dτ ψ), Ord (lτ ψ), Ord (dτ ψ), Ord a) => Isomorphism (FSΣ val lτ dτ ψ a) (FSΣ𝒫 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Σ val lτ dτ ψ) (PSΣ' val lτ dτ ψ)

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

Isomorphism2 * (FSΣ val lτ dτ ψ) (FSΣ' 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 (* -> *) * (KFun * r) (CPSKon r)

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

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

class HasLens a b where

Methods

view :: Lens a b

Instances

HasLens a a

HasLens CPSSt StampSt

viewP :: HasLens a b => P b -> Lens a b

data POrdering

Constructors

PEQ

PLT

PGT

PUN

fromOrdering :: Ordering -> POrdering

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 Int

PartialOrder Lit

PartialOrder BdrNum

PartialOrder LocNum

PartialOrder Op

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)

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

(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 (PSΣ𝒫 val lτ dτ ψ a)

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

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

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

PartialOrder (FSΣ𝒫 val lτ dτ ψ a)

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

PartialOrder (Power k 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

class PartialOrderF t where

Methods

partialOrderF :: PartialOrder a => W (PartialOrder (t a))

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

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

class Monoid a where

Methods

null :: a

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

Instances

Monoid Bool

Monoid Int

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 (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)

Monad m => Monoid (KleisliEndo m a)

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

Monoid (FreeMonoidFunctor f a)

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

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

class JoinLattice a where

Methods

bot :: a

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

Instances

JoinLattice Bool

JoinLattice Int

Functorial * JoinLattice ID

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

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

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

JoinLattice (ListSet a)

JoinLattice (Set a)

JoinLattice a => JoinLattice (ID a)

JoinLattice b => JoinLattice (a -> b)

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

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

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

(Functorial * JoinLattice m, JoinLattice s, JoinLattice a) => JoinLattice (StateT s m 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 (PSΣ𝒫 val lτ dτ ψ a)

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

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

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

JoinLattice (FSΣ𝒫 val lτ dτ ψ a)

JoinLattice (FSΣ val lτ dτ ψ a)

JoinLattice (Power k k k val lτ dτ ψ)

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

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

class MeetLattice a where

Methods

top :: a

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

Instances

MeetLattice Bool

MeetLattice b => MeetLattice (a -> b)

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

Instances

Lattice b => Lattice (a -> b)

class Unit t where

Methods

unit :: a -> t a

Instances

Unit []

Unit IO

Unit Q

Unit Maybe

Unit ListSet

Unit FreeMonoid

Unit ID

Unit DocM

Unit ((:+:) a)

Unit m => Unit (ListSetT m)

Unit m => Unit (ListT m)

Unit m => Unit (MaybeT m)

Unit (FreeMonoidFunctor f)

Unit (FreeFunctor f)

Unit (Parser t)

Unit m => Unit (StStateT m)

Unit m => Unit (StateT s m)

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

Unit m => Unit (ErrorT e m)

Unit m => Unit (KonT * r m)

Unit m => Unit (ReaderT * r m)

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

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

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

Unit (PS val lτ dτ ψ)

Unit (FI val lτ dτ ψ)

Unit (FS val lτ dτ ψ)

(Monad m, Morphism3 (* -> *) * (k r) (KFun * r)) => Unit (OpaqueKonT * * 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 ListSet

Functor FreeMonoid

Functor ID

Functor DocM

Functor ((->) a)

Functor ((:+:) a)

Functor m => Functor (ListSetT m)

Functor m => Functor (ListT m)

Functor m => Functor (MaybeT m)

Functor f => Functor (FreeMonoidFunctor f)

Functor f => Functor (FreeFunctor f)

Functor (Parser t)

Functor m => Functor (StStateT m)

Functor m => Functor (StateT s m)

Functor m => Functor (WriterT o m)

Functor m => Functor (ErrorT e m)

Unit m => Functor (KonT * r m)

Functor m => Functor (ReaderT * r m)

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

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

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

Functor (PS val lτ dτ ψ)

Functor (FI val lτ dτ ψ)

Functor (FS val lτ dτ ψ)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Functor (OpaqueKonT * * k r m)

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

(^@) :: 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

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

class FunctorM t where

Methods

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

Instances

FunctorM []

FunctorM ID

(^*@) :: (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

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

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

class Product t where

Methods

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

Instances

Product []

Product IO

Product Q

Product Maybe

Product ListSet

Product ID

Product DocM

Product ((:+:) a)

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

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

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

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

Product (Parser t)

Monad m => Product (StStateT m)

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 (KonT * r m)

Product m => Product (ReaderT * r m)

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

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

Product (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Product (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Product (FS val lτ dτ ψ)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Product (OpaqueKonT * * k r m)

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

class Applicative t where

Methods

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

Instances

Applicative []

Applicative IO

Applicative Q

Applicative Maybe

Applicative ListSet

Applicative ID

Applicative DocM

Applicative ((:+:) a)

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

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

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

Applicative (Parser t)

Monad m => Applicative (StStateT m)

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 (KonT * r m)

Applicative m => Applicative (ReaderT * r m)

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

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

Applicative (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Applicative (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Applicative (FS val lτ dτ ψ)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Applicative (OpaqueKonT * * k r m)

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

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

class Bind m where

Methods

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

Instances

Bind []

Bind IO

Bind Q

Bind Maybe

Bind ListSet

Bind Set

Bind ID

Bind DocM

Bind ((:+:) a)

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

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

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

Monad m => Bind (MaybeT m)

Bind (Parser t)

Bind m => Bind (StStateT m)

Bind m => Bind (StateT s m)

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

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

Unit m => Bind (KonT * r m)

Bind m => Bind (ReaderT * r m)

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

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

Bind (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Bind (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Bind (FS val lτ dτ ψ)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Bind (OpaqueKonT * * k r m)

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

class (Unit m, Functor m, Product m, Applicative m, Bind m) => Monad m

Instances

Monad []

Monad IO

Monad Q

Monad Maybe

Monad ListSet

Monad ID

Monad DocM

Monad ((:+:) a)

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

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

Monad m => Monad (MaybeT m)

Monad (Parser t)

Monad m => Monad (StStateT m)

Monad m => Monad (StateT s m)

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

Monad m => Monad (ErrorT e m)

Unit m => Monad (KonT * r m)

Monad m => Monad (ReaderT * r m)

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

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

Monad (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Monad (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => Monad (FS val lτ dτ ψ)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Monad (OpaqueKonT * * 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

mmap :: (Bind m, Unit m) => (a -> b) -> m a -> m b

mpair :: (Bind m, Unit m) => m a -> m b -> m (a, b)

mapply :: (Bind m, Unit m) => m (a -> b) -> m a -> m b

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

when :: Unit m => Bool -> m () -> 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 ListSetT

FunctorUnit2 ListT

FunctorUnit2 MaybeT

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 ListSetT

FunctorJoin2 ListT

FunctorJoin2 MaybeT

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 * ListSetT

FunctorFunctor2 * ListT

FunctorFunctor2 * MaybeT

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 * (KonT * r)

Isomorphism3 (* -> *) * (k r) (KFun * r) => MonadIsoFunctor2 * (OpaqueKonT * * k r)

class MonadZero m where

Methods

mzero :: m a

Instances

MonadZero []

MonadZero Q

MonadZero Maybe

MonadZero Set

Functorial * JoinLattice m => MonadZero (SetT m)

Functorial * JoinLattice m => MonadZero (ListSetT m)

Functorial * Monoid m => MonadZero (ListT m)

MonadZero (Parser t)

MonadZero m => MonadZero (StateT s m)

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

MonadZero m => MonadZero (ReaderT * r m)

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

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

MonadZero (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadZero (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadZero (FS val lτ dτ ψ)

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

guard :: (Unit m, MonadZero m) => Bool -> m ()

liftMaybeZero :: (Unit m, MonadZero m) => Maybe a -> m a

class MonadConcat m where

Methods

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

Instances

MonadConcat []

MonadConcat Set

Functorial * Monoid m => MonadConcat (ListT m)

MonadConcat (Parser t)

MonadConcat m => MonadConcat (StateT s m)

MonadConcat m => MonadConcat (ReaderT * r m)

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

class MonadPlus m where

Methods

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

Instances

MonadPlus ListSet

MonadPlus Set

Functorial * JoinLattice m => MonadPlus (SetT m)

Functorial * JoinLattice m => MonadPlus (ListSetT m)

MonadPlus m => MonadPlus (StateT s m)

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

MonadPlus (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadPlus (FI val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadPlus (FS val lτ dτ ψ)

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

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

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

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

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

newtype MaybeT m a

Constructors

MaybeT

Fields

runMaybeT :: m (Maybe a)

Instances

FunctorJoin2 MaybeT

FunctorUnit2 MaybeT

FunctorFunctor2 * MaybeT

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

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

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

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

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

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

MonadReader r m => MonadReader r (MaybeT m)

MonadReaderE r m => MonadReaderE r (MaybeT m)

MonadReaderI r m => MonadReaderI r (MaybeT m)

Monad m => MonadMaybeE (MaybeT m)

Monad m => MonadMaybeI (MaybeT m)

Monad m => Monad (MaybeT m)

Monad m => Bind (MaybeT m)

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

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

Functor m => Functor (MaybeT m)

Unit m => Unit (MaybeT m)

class Monad m => MonadMaybeI m where

Methods

maybeI :: m ~> MaybeT m

Instances

MonadMaybeI Maybe

MonadMaybeI DocM

Monad m => MonadMaybeI (MaybeT m)

MonadMaybeI m => MonadMaybeI (StateT s m)

(Monoid w, MonadMaybeI m) => MonadMaybeI (WriterT w m)

MonadMaybeI m => MonadMaybeI (ReaderT * r m)

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

class Monad m => MonadMaybeE m where

Methods

maybeE :: MaybeT m ~> m

Instances

MonadMaybeE Maybe

MonadMaybeE DocM

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

Monad m => MonadMaybeE (MaybeT m)

MonadMaybeE (Parser t)

MonadMaybeE m => MonadMaybeE (StateT s m)

(Monoid w, MonadMaybeE m) => MonadMaybeE (WriterT w m)

MonadMaybeE m => MonadMaybeE (ReaderT * r m)

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

class (MonadMaybeI m, MonadMaybeE m) => MonadMaybe m

Instances

MonadMaybe Maybe

MonadMaybe DocM

MonadMaybe m => MonadMaybe (StateT s m)

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

MonadMaybe m => MonadMaybe (ReaderT * r m)

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

maybeEM :: MonadMaybeE m => m (Maybe a) -> m a

lookMaybe :: MonadMaybeI m => m a -> m (Maybe a)

abort :: MonadMaybeE m => m a

(<|>) :: MonadMaybeI m => m a -> m a -> m a

newtype ErrorT e m a

Constructors

ErrorT

Fields

runErrorT :: m (e :+: a)

Instances

FunctorFunctor2 * (ErrorT e)

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

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

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

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

MonadReaderE r m => MonadReaderE r (ErrorT e m)

MonadReaderI r m => MonadReaderI r (ErrorT e m)

Monad m => MonadError e (ErrorT e m)

Monad m => MonadErrorI e (ErrorT e m)

Monad m => MonadErrorE e (ErrorT e m)

FunctorJoin2 (ErrorT e)

FunctorUnit2 (ErrorT e)

Monad m => Monad (ErrorT e m)

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

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

(Functor m, Product m) => Product (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 Monad m => MonadErrorE e m where

Methods

errorE :: ErrorT e m ~> m

Instances

MonadErrorE String IO

MonadErrorE String Q

MonadErrorE a ((:+:) a)

MonadErrorE e m => MonadErrorE e (StateT s m)

Monad m => MonadErrorE e (ErrorT e m)

MonadErrorE e m => MonadErrorE e (ReaderT * r m)

class Monad m => MonadErrorI e m where

Methods

errorI :: m ~> ErrorT e m

Instances

MonadErrorI a ((:+:) a)

MonadErrorI e m => MonadErrorI e (StateT s m)

Monad m => MonadErrorI e (ErrorT e m)

MonadErrorI e m => MonadErrorI e (ReaderT * r m)

class (MonadErrorE e m, MonadErrorI e m) => MonadError e m

Instances

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

Monad m => MonadError e (ErrorT e m)

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

liftSum :: MonadErrorE e m => (e :+: a) -> m a

throw :: MonadErrorE e m => e -> m a

catch :: MonadErrorI e m => m a -> (e -> m a) -> m a

catchP :: MonadErrorI e m => P e -> m a -> (e -> m a) -> m a

newtype ReaderT r m a

Constructors

ReaderT

Fields

unReaderT :: r -> m a

Instances

FunctorFunctor2 * (ReaderT * r)

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

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

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

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

(Monoid w, MonadWriterE w m) => MonadWriterE w (ReaderT * r m)

(Monoid w, MonadWriterI w m) => MonadWriterI w (ReaderT * r m)

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

Monad m => MonadReaderE r (ReaderT * r m)

Monad m => MonadReaderI r (ReaderT * r m)

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

MonadErrorI e m => MonadErrorI e (ReaderT * r m)

MonadErrorE e m => MonadErrorE e (ReaderT * r m)

FunctorJoin2 (ReaderT * r)

FunctorUnit2 (ReaderT * r)

MonadMaybe m => MonadMaybe (ReaderT * r m)

MonadMaybeE m => MonadMaybeE (ReaderT * r m)

MonadMaybeI m => MonadMaybeI (ReaderT * r m)

MonadConcat m => MonadConcat (ReaderT * r m)

MonadZero m => MonadZero (ReaderT * r m)

Monad m => Monad (ReaderT * r m)

Bind m => Bind (ReaderT * r m)

Applicative m => Applicative (ReaderT * r m)

Product m => Product (ReaderT * r m)

Functor m => Functor (ReaderT * r m)

Unit m => Unit (ReaderT * r m)

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

class Monad m => MonadReaderI r m where

Methods

readerI :: m ~> ReaderT r m

Instances

MonadReaderI PEnv DocM

MonadReaderI r m => MonadReaderI r (MaybeT m)

MonadReaderI r m => MonadReaderI r (StStateT m)

MonadReaderI r m => MonadReaderI r (StateT s m)

(Monoid w, MonadReaderI r m) => MonadReaderI r (WriterT w m)

MonadReaderI r m => MonadReaderI r (ErrorT e m)

Monad m => MonadReaderI r (ReaderT * r m)

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

MonadReaderI r m => MonadReaderI r (AddStateT k s12 s1 m)

class Monad m => MonadReaderE r m where

Methods

readerE :: ReaderT r m ~> m

Instances

MonadReaderE PEnv DocM

MonadReaderE r m => MonadReaderE r (MaybeT m)

MonadReaderE r m => MonadReaderE r (StStateT m)

MonadReaderE r m => MonadReaderE r (StateT s m)

(Monoid w, MonadReaderE r m) => MonadReaderE r (WriterT w m)

MonadReaderE r m => MonadReaderE r (ErrorT e m)

Monad m => MonadReaderE r (ReaderT * r m)

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

MonadReaderE r m => MonadReaderE r (AddStateT k s12 s1 m)

class (MonadReaderI r m, MonadReaderE r m) => MonadReader r m

Instances

MonadReader PEnv DocM

MonadReader r m => MonadReader r (MaybeT m)

MonadReader r m => MonadReader r (StStateT m)

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

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

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

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

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

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

ask :: MonadReaderE r m => m r

askP :: MonadReaderE r m => P r -> m r

askL :: MonadReaderE r m => Lens r a -> m a

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

localP :: MonadReader r m => P r -> (r -> r) -> m a -> m a

localSet :: MonadReader r m => r -> m 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

runWriterT :: m (a, o)

Instances

FunctorFunctor2 * (WriterT w)

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

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

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

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

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

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

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

(Monoid w, MonadReaderE r m) => MonadReaderE r (WriterT w m)

(Monoid w, MonadReaderI r m) => MonadReaderI r (WriterT w m)

FunctorJoin2 (WriterT w)

Monoid w => FunctorUnit2 (WriterT w)

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

(Monoid w, MonadMaybeE m) => MonadMaybeE (WriterT w m)

(Monoid w, MonadMaybeI m) => MonadMaybeI (WriterT w m)

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

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

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

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

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

Functor m => Functor (WriterT o m)

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

class Monad m => MonadWriterI o m | m -> o where

Methods

writerI :: m ~> WriterT o m

Instances

MonadWriterI POut DocM

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

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

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

(Monoid w, MonadWriterI w m) => MonadWriterI w (ReaderT * r m)

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

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

class Monad m => MonadWriterE o m | m -> o where

Methods

writerE :: WriterT o m ~> m

Instances

MonadWriterE POut DocM

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

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

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

(Monoid w, MonadWriterE w m) => MonadWriterE w (ReaderT * r m)

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

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

class (MonadWriterI o m, MonadWriterE o m) => MonadWriter o m | m -> o

Instances

MonadWriter POut DocM

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

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

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

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

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

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

tell :: MonadWriterE o m => o -> m ()

tellP :: MonadWriterE o m => P o -> o -> m ()

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

newtype StateT s m a

Constructors

StateT

Fields

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

Instances

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

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

FunctorFunctor2 * (StateT s)

Functor m => MonadState s (StateT s m)

Functor m => MonadStateE s (StateT s m)

Functor m => MonadStateI s (StateT s m)

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

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

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

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

MonadReaderE r m => MonadReaderE r (StateT s m)

MonadReaderI r m => MonadReaderI r (StateT s m)

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

MonadErrorI e m => MonadErrorI e (StateT s m)

MonadErrorE e m => MonadErrorE e (StateT s m)

FunctorJoin2 (StateT s)

FunctorUnit2 (StateT s)

(MonadListSet m, Functorial * JoinLattice m, JoinLattice s) => MonadListSet (StateT s m)

(MonadListSetE m, Functorial * JoinLattice m) => MonadListSetE (StateT s m)

(MonadListSetI m, Functorial * JoinLattice m, JoinLattice s) => MonadListSetI (StateT s m)

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

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

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

MonadMaybe m => MonadMaybe (StateT s m)

MonadMaybeE m => MonadMaybeE (StateT s m)

MonadMaybeI m => MonadMaybeI (StateT s m)

MonadPlus m => MonadPlus (StateT s m)

MonadConcat m => MonadConcat (StateT s m)

MonadZero m => MonadZero (StateT s m)

Monad m => Monad (StateT s m)

Bind m => Bind (StateT s m)

Monad m => Applicative (StateT s m)

Monad m => Product (StateT s m)

Functor m => Functor (StateT s m)

Unit m => Unit (StateT s m)

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

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

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

class MonadStateI s m | m -> s where

Methods

stateI :: m ~> StateT s m

Instances

MonadStateI PState DocM

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

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

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

Functor m => MonadStateI CPSSt (StStateT m)

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

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

Functor m => MonadStateI s (StateT s m)

(Monad m, MonadState s m) => MonadStateI s (KonT * r m)

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

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

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

(Monad m, MonadState s m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadStateI s (OpaqueKonT * * k r m)

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

MonadStateI (ParserState t) (Parser t)

MonadStateI (𝒮 val lτ dτ ψ) (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadStateI (𝒮 val lτ dτ ψ) (FS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadStateI (𝒮 val lτ dτ ψ) (FI val lτ dτ ψ)

class MonadStateE s m | m -> s where

Methods

stateE :: StateT s m ~> m

Instances

MonadStateE PState DocM

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

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

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

Functor m => MonadStateE CPSSt (StStateT m)

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

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

Functor m => MonadStateE s (StateT s m)

(Monad m, MonadState s m) => MonadStateE s (KonT * r m)

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

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

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

(Monad m, MonadState s m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadStateE s (OpaqueKonT * * k r m)

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

MonadStateE (ParserState t) (Parser t)

MonadStateE (𝒮 val lτ dτ ψ) (PS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadStateE (𝒮 val lτ dτ ψ) (FS val lτ dτ ψ)

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadStateE (𝒮 val lτ dτ ψ) (FI val lτ dτ ψ)

class (MonadStateI s m, MonadStateE s m) => MonadState s m | m -> s

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 => MonadState CPSSt (StStateT 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)

(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 (* -> *) * (KFun * r) (k r)) => MonadState s (OpaqueKonT * * k r m)

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

MonadState (ParserState t) (Parser t)

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

(Eq (val lτ dτ ψ), JoinLattice (val lτ dτ ψ)) => MonadState (𝒮 val lτ dτ ψ) (FS val lτ dτ ψ)

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

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

getP :: (Monad m, MonadStateE s m) => P s -> m s

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

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

putP :: (Monad m, MonadStateE s m) => P s -> s -> m ()

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

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

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

modifyP :: (Monad m, MonadStateE s m) => P s -> (s -> s) -> m ()

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

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

localStateSet :: (Monad m, MonadStateI s m) => s -> m a -> m (a, s)

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

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

bumpL :: (Monad m, MonadStateE 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) => MonadRWSE r o s (RWST r o s m)

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

Monoid o => MonadFunctor2 * (RWST r o s)

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

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

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

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

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

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

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

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

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

Monoid o => MonadJoin2 (RWST r o s)

Monoid o => MonadUnit2 (RWST r o s)

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

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

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

(MonadZero m, Monoid o) => MonadZero (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) => Applicative (RWST r o s m)

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

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

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

class (MonadReaderI r m, MonadWriterI o m, MonadStateI s m) => MonadRWSI r o s m where

Methods

rwsI :: m ~> RWST r o s m

Instances

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

class (MonadReaderE r m, MonadWriterE o m, MonadStateE s m) => MonadRWSE r o s m where

Methods

rwsE :: RWST r o s m ~> m

Instances

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

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

Instances

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

newtype ListT m a

Constructors

ListT

Fields

runListT :: m [a]

Instances

FunctorJoin2 ListT

FunctorUnit2 ListT

FunctorFunctor2 * ListT

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

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

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

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

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

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

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

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

Functorial * Monoid m => MonadConcat (ListT m)

Functorial * Monoid m => MonadZero (ListT m)

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

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

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

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

Functor m => Functor (ListT m)

Unit m => Unit (ListT m)

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

(Functorial * Pretty m, Pretty a) => Pretty (ListT m a)

class Monad m => MonadListI m where

Methods

listI :: m ~> ListT m

Instances

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

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

class Monad m => MonadListE m where

Methods

listE :: ListT m ~> m

Instances

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

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

class (MonadListI m, MonadListE m) => MonadList m

Instances

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

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

liftList :: (Monad m, MonadListE m) => [a] -> m a

listAbort :: MonadListE m => m a

newtype ListSetT m a

Constructors

ListSetT

Fields

runListSetT :: m (ListSet a)

Instances

FunctorJoin2 ListSetT

FunctorUnit2 ListSetT

FunctorFunctor2 * ListSetT

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

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

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

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

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

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

Functorial * JoinLattice m => MonadPlus (ListSetT m)

Functorial * JoinLattice m => MonadZero (ListSetT m)

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

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

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

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

Functor m => Functor (ListSetT m)

Unit m => Unit (ListSetT m)

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

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

class Monad m => MonadListSetI m where

Methods

listSetI :: m ~> ListSetT m

Instances

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

(MonadListSetI m, Functorial * JoinLattice m, JoinLattice s) => MonadListSetI (StateT s m)

class Monad m => MonadListSetE m where

Methods

listSetE :: ListSetT m ~> m

Instances

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

(MonadListSetE m, Functorial * JoinLattice m) => MonadListSetE (StateT s m)

class (MonadListSetI m, MonadListSetE m) => MonadListSet m

Instances

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

(MonadListSet m, Functorial * JoinLattice m, JoinLattice s) => MonadListSet (StateT s m)

class MonadIO m where

Methods

liftIO :: IO ~> m

Instances

MonadIO IO

class MonadQ m where

Methods

liftQ :: Q ~> m

Instances

MonadQ Q

newtype SetT m a

Constructors

SetT

Fields

runSetT :: m (Set a)

Instances

Functorial * JoinLattice m => MonadPlus (SetT m)

Functorial * JoinLattice m => MonadZero (SetT m)

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

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

mapSetT :: (m (Set a) -> m (Set b)) -> SetT m a -> SetT m b

class Bind m => MonadSetI m where

Methods

setI :: m ~> SetT m

class Bind m => MonadSetE m where

Methods

setE :: SetT m ~> m

newtype KonT r m a

Constructors

KonT

Fields

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

Instances

MonadIsoFunctor2 * (KonT * r)

Monad m => MonadKon r (KonT * r m)

Monad m => MonadKonE r (KonT * r m)

Monad m => MonadKonI r (KonT * r m)

(Monad m, MonadState s m) => MonadStateE s (KonT * r m)

(Monad m, MonadState s m) => MonadStateI s (KonT * r m)

Unit m => Monad (KonT * r m)

Unit m => Bind (KonT * r m)

Unit m => Applicative (KonT * r m)

Unit m => Product (KonT * r m)

Unit m => Functor (KonT * r m)

Unit m => Unit (KonT * r m)

class Monad m => MonadKonI r m | m -> r where

Methods

konI :: m ~> KonT r m

Instances

Monad m => MonadKonI r (KonT * r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKonI r (OpaqueKonT * * k r m)

class Monad m => MonadKonE r m | m -> r where

Methods

konE :: KonT r m ~> m

Instances

Monad m => MonadKonE r (KonT * r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKonE r (OpaqueKonT * * k r m)

class (MonadKonI r m, MonadKonE r m) => MonadKon r m | m -> r

Instances

Monad m => MonadKon r (KonT * r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKon r (OpaqueKonT * * k r m)

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

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

reset :: MonadKon r m => m r -> m r

modifyC :: MonadKon r m => (r -> m r) -> m a -> m a

newtype KFun r m a

Constructors

KFun

Fields

runKFun :: a -> m r

Instances

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

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

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

newtype OpaqueKonT k r m a

Constructors

OpaqueKonT

Fields

runOpaqueKonT :: k r m a -> m r

Instances

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKon k r (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKonE k r (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKonI k r (OpaqueKonT * * k r m)

Isomorphism3 (* -> *) * (k r) (KFun * r) => MonadIsoFunctor2 * (OpaqueKonT * * k r)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKon r (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKonE r (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadKonI r (OpaqueKonT * * k r m)

(Monad m, MonadState s m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadState s (OpaqueKonT * * k r m)

(Monad m, MonadState s m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadStateE s (OpaqueKonT * * k r m)

(Monad m, MonadState s m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => MonadStateI s (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Monad (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Bind (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Applicative (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Product (OpaqueKonT * * k r m)

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r)) => Functor (OpaqueKonT * * k r m)

(Monad m, Morphism3 (* -> *) * (k r) (KFun * r)) => Unit (OpaqueKonT * * k r m)

class (MonadKonI r m, Monad m) => MonadOpaqueKonI k r m | m -> k, m -> r where

Methods

withOpaqueC :: k r m a -> m a -> m r

Instances

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKonI k r (OpaqueKonT * * k r m)

class (MonadKonE r m, Monad m) => MonadOpaqueKonE k r m | m -> k, m -> r where

Methods

callOpaqueCC :: (k r m a -> m r) -> m a

Instances

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKonE k r (OpaqueKonT * * k r m)

class (MonadKon r m, MonadOpaqueKonI k r m, MonadOpaqueKonE k r m) => MonadOpaqueKon k r m | m -> k, m -> r

Instances

(Monad m, Isomorphism3 (* -> *) * (KFun * r) (k r), Balloon k r) => MonadOpaqueKon k r (OpaqueKonT * * k r m)

class Iterable a t | t -> a where

Minimal complete definition

Nothing

Methods

foldlk :: forall b. (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 ψ (Kτ k ψ)

Iterable (k, v) (Map k v)

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

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

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

mlist :: (Iterable a t, MonadZero m, Unit m, MonadConcat m) => t -> m a

mtry :: MonadMaybe m => [m a] -> m a

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

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

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

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

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

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

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

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

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

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

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 ()

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

class Buildable a t | t -> a where

Methods

nil :: t

cons :: a -> t -> t

Instances

Ord a => Buildable a (Set a)

Buildable a [a]

Buildable a (ListSet a)

Buildable ψ (Cτ ψ)

Buildable ψ (Kτ k ψ)

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

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

class Container e t | t -> e where

Methods

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

Instances

Container a (Set a)

Eq a => Container a [a]

Eq a => Container a (ListSet a)

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

Container (val lτ dτ ψ) (Power k 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, Buildable a t) => ListLike a t | t -> a where

Minimal complete definition

uncons

Methods

isNil :: t -> Bool

uncons :: t -> Maybe (a, t)

Instances

ListLike a [a]

ListLike ψ (Cτ ψ)

ListLike ψ (Kτ k ψ)

toListLike :: ListLike a t => [a] -> t

fromListLike :: ListLike a t => t -> [a]

single :: a -> [a]

filter :: (a -> Bool) -> [a] -> [a]

reverse :: [a] -> [a]

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

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

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

replicate :: (Eq n, Peano n) => n -> a -> [a]

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

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

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

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

head :: [a] -> Maybe a

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

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

class (Iterable e t, Container e t) => SetLike e t | t -> e where

Minimal complete definition

learnSet, empty, insert, remove

Methods

learnSet :: t -> b -> (Ord e => b) -> b

empty :: t

isEmpty :: t -> Bool

insert :: Ord e => e -> t -> t

remove :: t -> Maybe (e, t)

union :: t -> t -> t

intersection :: t -> t -> t

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

Instances

SetLike a (Set a)

SetLike (val lτ dτ ψ) (Power k k k val lτ dτ ψ)

singleton :: Ord e => e -> Set e

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

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

toSet :: Ord a => [a] -> Set a

fromSet :: Set a -> [a]

class (Iterable (k, v) t, Indexed k v t) => MapLike k v t | t -> k, t -> v where

Minimal complete definition

learnMap, mapEmpty, mapIsEmpty, mapInsertWith, mapRemove

Methods

learnMap :: t -> b -> (Ord k => b) -> b

mapEmpty :: t

mapIsEmpty :: t -> Bool

mapInsertWith :: Ord k => (v -> v -> v) -> k -> v -> t -> t

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

mapUnionWith :: (v -> v -> v) -> t -> t -> t

mapIntersectionWith :: (v -> v -> v) -> t -> t -> t

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

mapKeys :: t -> Set k

Instances

Ord k => MapLike k v [(k, v)]

MapLike k v (Map k v)

mapInsert :: (MapLike k v t, Ord k) => k -> v -> t -> t

onlyKeys :: (SetLike k t, MapLike k v u) => t -> u -> u

toMap :: Ord k => [(k, v)] -> Map k v

fromMap :: Map k v -> [(k, v)]

data P a

Constructors

P

data Cursor a b

Constructors

Cursor

Fields

focus :: a

construct :: a -> b

data Lens a b

Constructors

Lens

Fields

runLens :: a -> Cursor b a

Instances

Category * Lens

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

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

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

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

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

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

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

coerce :: a -> Maybe b

inject :: b -> a

Instances

Category * Prism

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

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

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

isL :: Prism a b -> a -> Bool

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

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

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

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

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

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

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

type String = Text

type Chars = [Char]

error :: String -> a

show :: Show a => a -> String

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

MonadErrorI a ((:+:) a)

MonadErrorE a ((:+:) a)

Monad ((:+:) a)

Bind ((:+:) a)

Applicative ((:+:) a)

Product ((:+:) 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'

newtype (t :.: u) a infixr 9

Constructors

Compose

Fields

runCompose :: t (u a)

Instances

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

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

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

Isomorphism2 * (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τ ψ)

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τ ψ)

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

(Unit t, Unit u) => Unit ((:.:) * * 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) => MonadStep ((:.:) * * ς ListSet) (ListSetT m)

(MonadStep ς m, Commute ς ListSet, Functorial * JoinLattice ς) => 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)

JoinLattice (t (u a)) => JoinLattice ((:.:) 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

newtype (t :..: u) m a infixr 9

Constructors

Compose2

Fields

runCompose2 :: t (u m) a

nothingL :: Prism (Maybe a) ()

justL :: Prism (Maybe a) a

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

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

whenNothing :: a -> Maybe a -> a

nilL :: Prism [a] ()

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

singleL :: Prism [a] a

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

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

data Set a where

Constructors

EmptySet :: Set a

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

Instances

MonadPlus Set

MonadConcat Set

MonadZero Set

Bind Set

SetLike a (Set a)

Container a (Set a)

Ord a => Buildable a (Set a)

Iterable a (Set a)

Eq (Set a)

Ord (Set a)

JoinLattice (Set a)

Monoid (Set a)

PartialOrder (Set a)

Pretty a => Pretty (Set a)

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

newtype ListSet a

Constructors

ListSet

Fields

runListSet :: [a]

Instances

MonadPlus ListSet

Monad ListSet

Bind ListSet

Applicative ListSet

Product ListSet

Functor ListSet

Unit ListSet

Inject ListSet

Commute ID ListSet

Eq a => Container a (ListSet a)

Buildable a (ListSet a)

Iterable a (ListSet a)

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

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

Isomorphism2 * (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τ ψ)

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τ ψ)

JoinLattice (ListSet a)

Monoid (ListSet a)

Ord a => PartialOrder (ListSet a)

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

Commute ((,) 𝓈) ListSet

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

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

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

data Map k v where

Constructors

EmptyMap :: Map k v

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

Instances

MapLike k v (Map k v)

Indexed k v (Map k v)

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

Isomorphism2 * (FSΣ val lτ dτ ψ) (FSΣ' 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τ ψ)

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

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

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

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

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

Initial (Map k v)

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

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

Iterable (k, v) (Map k v)

Morphism (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ) (𝒮 val lτ dτ ψ)

Isomorphism (𝒮 val lτ dτ ψ) (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ)

Morphism (𝒮 val lτ dτ ψ) (PI𝒮 lτ dτ ψ, Store val lτ dτ ψ)

data Annotated ann a

Constructors

Annotated

Fields

annotation :: ann

annValue :: a

data Stamped a f

Constructors

Stamped

Fields

stampedID :: a

stamped :: f

Instances

Balloon CPSKon SGCall

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

runFix :: f (Fix f)

Instances

Functorial * Pretty f => Pretty (Fix f)

data StampedFix a f

Constructors

StampedFix

Fields

stampedFixID :: a

stampedFix :: f (StampedFix a f)

Instances

Balloon CPSKon SGCall

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

print :: String -> IO ()

module GHC.Exts

module Data.Char

module Language.Haskell.TH