Safe Haskell	None
Language	Haskell98

Language.SMTLib2.Internals.Expression

Documentation

type family AllEq (tp :: Type) (n :: Nat) :: [Type] where ... Source #

Equations

AllEq tp Z = '[]
AllEq tp (S n) = tp ': AllEq tp n

allEqToList :: Natural n -> List a (AllEq tp n) -> [a tp] Source #

allEqFromList :: [a tp] -> (forall n. Natural n -> List a (AllEq tp n) -> r) -> r Source #

allEqOf :: Repr tp -> Natural n -> List Repr (AllEq tp n) Source #

mapAllEq :: Monad m => (e1 tp -> m (e2 tp)) -> Natural n -> List e1 (AllEq tp n) -> m (List e2 (AllEq tp n)) Source #

data Function fun sig where Source #

Constructors

Fun :: fun '(arg, res) -> Function fun '(arg, res)
Eq :: Repr tp -> Natural n -> Function fun '(AllEq tp n, BoolType)
Distinct :: Repr tp -> Natural n -> Function fun '(AllEq tp n, BoolType)
Map :: List Repr idx -> Function fun '(arg, res) -> Function fun '(Lifted arg idx, ArrayType idx res)
Ord :: NumRepr tp -> OrdOp -> Function fun '('[tp, tp], BoolType)
Arith :: NumRepr tp -> ArithOp -> Natural n -> Function fun '(AllEq tp n, tp)
ArithIntBin :: ArithOpInt -> Function fun '('[IntType, IntType], IntType)
Divide :: Function fun '('[RealType, RealType], RealType)
Abs :: NumRepr tp -> Function fun '('[tp], tp)
Not :: Function fun '('[BoolType], BoolType)
Logic :: LogicOp -> Natural n -> Function fun '(AllEq BoolType n, BoolType)
ToReal :: Function fun '('[IntType], RealType)
ToInt :: Function fun '('[RealType], IntType)
ITE :: Repr a -> Function fun '('[BoolType, a, a], a)
BVComp :: BVCompOp -> BitWidth a -> Function fun '('[BitVecType a, BitVecType a], BoolType)
BVBin :: BVBinOp -> BitWidth a -> Function fun '('[BitVecType a, BitVecType a], BitVecType a)
BVUn :: BVUnOp -> BitWidth a -> Function fun '('[BitVecType a], BitVecType a)
Select :: List Repr idx -> Repr val -> Function fun '(ArrayType idx val ': idx, val)
Store :: List Repr idx -> Repr val -> Function fun '(ArrayType idx val ': (val ': idx), ArrayType idx val)
ConstArray :: List Repr idx -> Repr val -> Function fun '('[val], ArrayType idx val)
Concat :: BitWidth n1 -> BitWidth n2 -> Function fun '('[BitVecType n1, BitVecType n2], BitVecType (n1 + n2))
Extract :: BitWidth bw -> BitWidth start -> BitWidth len -> Function fun '('[BitVecType bw], BitVecType len)
Constructor :: (IsDatatype dt, Length par ~ Parameters dt) => Datatype dt -> List Repr par -> Constr dt sig -> Function fun '(Instantiated sig par, DataType dt par)
Test :: (IsDatatype dt, Length par ~ Parameters dt) => Datatype dt -> List Repr par -> Constr dt sig -> Function fun '('[DataType dt par], BoolType)
Field :: (IsDatatype dt, Length par ~ Parameters dt) => Datatype dt -> List Repr par -> Field dt t -> Function fun '('[DataType dt par], CType t par)
Divisible :: Integer -> Function fun '('[IntType], BoolType)

Instances

GetFunType fun => GetFunType (Function fun) Source #
Methods getFunType :: Function fun (([Type], Type) arg res) -> (List Type Repr arg, Repr res) Source #
GEq ([Type], Type) fun => Eq (Function fun sig) Source #
Methods (==) :: Function fun sig -> Function fun sig -> Bool # (/=) :: Function fun sig -> Function fun sig -> Bool #
GShow ([Type], Type) fun => Show (Function fun sig) Source #
Methods showsPrec :: Int -> Function fun sig -> ShowS # show :: Function fun sig -> String # showList :: [Function fun sig] -> ShowS #
GCompare ([Type], Type) fun => GCompare ([Type], Type) (Function fun) Source #
Methods gcompare :: f a -> f b -> GOrdering (Function fun) a b #
GEq ([Type], Type) fun => GEq ([Type], Type) (Function fun) Source #
Methods geq :: f a -> f b -> Maybe ((Function fun := a) b) #
GShow ([Type], Type) fun => GShow ([Type], Type) (Function fun) Source #
Methods gshowsPrec :: Int -> t a -> ShowS #

data AnyFunction fun where Source #

Constructors

AnyFunction :: Function fun '(arg, t) -> AnyFunction fun

data OrdOp Source #

Constructors

Ge
Gt
Le
Lt

Instances

Eq OrdOp Source #
Methods (==) :: OrdOp -> OrdOp -> Bool # (/=) :: OrdOp -> OrdOp -> Bool #
Ord OrdOp Source #
Methods compare :: OrdOp -> OrdOp -> Ordering # (<) :: OrdOp -> OrdOp -> Bool # (<=) :: OrdOp -> OrdOp -> Bool # (>) :: OrdOp -> OrdOp -> Bool # (>=) :: OrdOp -> OrdOp -> Bool # max :: OrdOp -> OrdOp -> OrdOp # min :: OrdOp -> OrdOp -> OrdOp #
Show OrdOp Source #
Methods showsPrec :: Int -> OrdOp -> ShowS # show :: OrdOp -> String # showList :: [OrdOp] -> ShowS #

data ArithOp Source #

Constructors

Plus
Mult
Minus

Instances

Eq ArithOp Source #
Methods (==) :: ArithOp -> ArithOp -> Bool # (/=) :: ArithOp -> ArithOp -> Bool #
Ord ArithOp Source #
Methods compare :: ArithOp -> ArithOp -> Ordering # (<) :: ArithOp -> ArithOp -> Bool # (<=) :: ArithOp -> ArithOp -> Bool # (>) :: ArithOp -> ArithOp -> Bool # (>=) :: ArithOp -> ArithOp -> Bool # max :: ArithOp -> ArithOp -> ArithOp # min :: ArithOp -> ArithOp -> ArithOp #
Show ArithOp Source #
Methods showsPrec :: Int -> ArithOp -> ShowS # show :: ArithOp -> String # showList :: [ArithOp] -> ShowS #

data ArithOpInt Source #

Constructors

Div
Mod
Rem

Instances

Eq ArithOpInt Source #
Methods (==) :: ArithOpInt -> ArithOpInt -> Bool # (/=) :: ArithOpInt -> ArithOpInt -> Bool #
Ord ArithOpInt Source #
Methods compare :: ArithOpInt -> ArithOpInt -> Ordering # (<) :: ArithOpInt -> ArithOpInt -> Bool # (<=) :: ArithOpInt -> ArithOpInt -> Bool # (>) :: ArithOpInt -> ArithOpInt -> Bool # (>=) :: ArithOpInt -> ArithOpInt -> Bool # max :: ArithOpInt -> ArithOpInt -> ArithOpInt # min :: ArithOpInt -> ArithOpInt -> ArithOpInt #
Show ArithOpInt Source #
Methods showsPrec :: Int -> ArithOpInt -> ShowS # show :: ArithOpInt -> String # showList :: [ArithOpInt] -> ShowS #

data LogicOp Source #

Constructors

And
Or
XOr
Implies

Instances

Eq LogicOp Source #
Methods (==) :: LogicOp -> LogicOp -> Bool # (/=) :: LogicOp -> LogicOp -> Bool #
Ord LogicOp Source #
Methods compare :: LogicOp -> LogicOp -> Ordering # (<) :: LogicOp -> LogicOp -> Bool # (<=) :: LogicOp -> LogicOp -> Bool # (>) :: LogicOp -> LogicOp -> Bool # (>=) :: LogicOp -> LogicOp -> Bool # max :: LogicOp -> LogicOp -> LogicOp # min :: LogicOp -> LogicOp -> LogicOp #
Show LogicOp Source #
Methods showsPrec :: Int -> LogicOp -> ShowS # show :: LogicOp -> String # showList :: [LogicOp] -> ShowS #

data BVCompOp Source #

Constructors

BVULE
BVULT
BVUGE
BVUGT
BVSLE
BVSLT
BVSGE
BVSGT

Instances

Eq BVCompOp Source #
Methods (==) :: BVCompOp -> BVCompOp -> Bool # (/=) :: BVCompOp -> BVCompOp -> Bool #
Ord BVCompOp Source #
Methods compare :: BVCompOp -> BVCompOp -> Ordering # (<) :: BVCompOp -> BVCompOp -> Bool # (<=) :: BVCompOp -> BVCompOp -> Bool # (>) :: BVCompOp -> BVCompOp -> Bool # (>=) :: BVCompOp -> BVCompOp -> Bool # max :: BVCompOp -> BVCompOp -> BVCompOp # min :: BVCompOp -> BVCompOp -> BVCompOp #
Show BVCompOp Source #
Methods showsPrec :: Int -> BVCompOp -> ShowS # show :: BVCompOp -> String # showList :: [BVCompOp] -> ShowS #

data BVBinOp Source #

Constructors

BVAdd
BVSub
BVMul
BVURem
BVSRem
BVUDiv
BVSDiv
BVSHL
BVLSHR
BVASHR
BVXor
BVAnd
BVOr

Instances

Eq BVBinOp Source #
Methods (==) :: BVBinOp -> BVBinOp -> Bool # (/=) :: BVBinOp -> BVBinOp -> Bool #
Ord BVBinOp Source #
Methods compare :: BVBinOp -> BVBinOp -> Ordering # (<) :: BVBinOp -> BVBinOp -> Bool # (<=) :: BVBinOp -> BVBinOp -> Bool # (>) :: BVBinOp -> BVBinOp -> Bool # (>=) :: BVBinOp -> BVBinOp -> Bool # max :: BVBinOp -> BVBinOp -> BVBinOp # min :: BVBinOp -> BVBinOp -> BVBinOp #
Show BVBinOp Source #
Methods showsPrec :: Int -> BVBinOp -> ShowS # show :: BVBinOp -> String # showList :: [BVBinOp] -> ShowS #

data BVUnOp Source #

Constructors

BVNot
BVNeg

Instances

Eq BVUnOp Source #
Methods (==) :: BVUnOp -> BVUnOp -> Bool # (/=) :: BVUnOp -> BVUnOp -> Bool #
Ord BVUnOp Source #
Methods compare :: BVUnOp -> BVUnOp -> Ordering # (<) :: BVUnOp -> BVUnOp -> Bool # (<=) :: BVUnOp -> BVUnOp -> Bool # (>) :: BVUnOp -> BVUnOp -> Bool # (>=) :: BVUnOp -> BVUnOp -> Bool # max :: BVUnOp -> BVUnOp -> BVUnOp # min :: BVUnOp -> BVUnOp -> BVUnOp #
Show BVUnOp Source #
Methods showsPrec :: Int -> BVUnOp -> ShowS # show :: BVUnOp -> String # showList :: [BVUnOp] -> ShowS #

data LetBinding v e t Source #

Constructors

LetBinding
Fields letVar :: v t letExpr :: e t

Instances

(GCompare Type v, GCompare Type e) => GCompare Type (LetBinding v e) Source #
Methods gcompare :: f a -> f b -> GOrdering (LetBinding v e) a b #
(GEq Type v, GEq Type e) => GEq Type (LetBinding v e) Source #
Methods geq :: f a -> f b -> Maybe ((LetBinding v e := a) b) #

data Quantifier Source #

Constructors

Forall
Exists

Instances

Eq Quantifier Source #
Methods (==) :: Quantifier -> Quantifier -> Bool # (/=) :: Quantifier -> Quantifier -> Bool #
Ord Quantifier Source #
Methods compare :: Quantifier -> Quantifier -> Ordering # (<) :: Quantifier -> Quantifier -> Bool # (<=) :: Quantifier -> Quantifier -> Bool # (>) :: Quantifier -> Quantifier -> Bool # (>=) :: Quantifier -> Quantifier -> Bool # max :: Quantifier -> Quantifier -> Quantifier # min :: Quantifier -> Quantifier -> Quantifier #
Show Quantifier Source #
Methods showsPrec :: Int -> Quantifier -> ShowS # show :: Quantifier -> String # showList :: [Quantifier] -> ShowS #

data Expression v qv fun fv lv e res where Source #

Constructors

Var :: v res -> Expression v qv fun fv lv e res	Free variable.
QVar :: qv res -> Expression v qv fun fv lv e res	Quantified variable, i.e. a variable that's bound by a forall/exists quantor.
FVar :: fv res -> Expression v qv fun fv lv e res	A function argument variable. Only used in function bodies.
LVar :: lv res -> Expression v qv fun fv lv e res	A variable bound by a let binding.
App :: Function fun '(arg, res) -> List e arg -> Expression v qv fun fv lv e res	Function application
Const :: Value a -> Expression v qv fun fv lv e a	Constant
AsArray :: Function fun '(arg, res) -> Expression v qv fun fv lv e (ArrayType arg res)	AsArray converts a function into an array by using the function arguments as array indices and the return type as array element.
Quantification :: Quantifier -> List qv arg -> e BoolType -> Expression v qv fun fv lv e BoolType	Bind variables using a forall or exists quantor.
Let :: List (LetBinding lv e) arg -> e res -> Expression v qv fun fv lv e res	Bind variables to expressions.

Instances

(GCompare Type v, GCompare Type qv, GCompare ([Type], Type) fun, GCompare Type fv, GCompare Type lv, GCompare Type e) => GCompare Type (Expression v qv fun fv lv e) Source #
Methods gcompare :: f a -> f b -> GOrdering (Expression v qv fun fv lv e) a b #
(GEq Type v, GEq Type qv, GEq ([Type], Type) fun, GEq Type fv, GEq Type lv, GEq Type e) => GEq Type (Expression v qv fun fv lv e) Source #
Methods geq :: f a -> f b -> Maybe ((Expression v qv fun fv lv e := a) b) #
(GShow Type v, GShow Type qv, GShow ([Type], Type) fun, GShow Type fv, GShow Type lv, GShow Type e) => GShow Type (Expression v qv fun fv lv e) Source #
Methods gshowsPrec :: Int -> t a -> ShowS #
(GetType v, GetType qv, GetFunType fun, GetType fv, GetType lv, GetType e) => GetType (Expression v qv fun fv lv e) Source #
Methods getType :: Expression v qv fun fv lv e tp -> Repr tp Source #
(GEq Type v, GEq Type qv, GEq ([Type], Type) fun, GEq Type fv, GEq Type lv, GEq Type e) => Eq (Expression v qv fun fv lv e t) Source #
Methods (==) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool # (/=) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool #
(GCompare Type v, GCompare Type qv, GCompare ([Type], Type) fun, GCompare Type fv, GCompare Type lv, GCompare Type e) => Ord (Expression v qv fun fv lv e t) Source #
Methods compare :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Ordering # (<) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool # (<=) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool # (>) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool # (>=) :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Bool # max :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t # min :: Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t -> Expression v qv fun fv lv e t #
(GShow Type v, GShow Type qv, GShow ([Type], Type) fun, GShow Type fv, GShow Type lv, GShow Type e) => Show (Expression v qv fun fv lv e r) Source #
Methods showsPrec :: Int -> Expression v qv fun fv lv e r -> ShowS # show :: Expression v qv fun fv lv e r -> String # showList :: [Expression v qv fun fv lv e r] -> ShowS #

class SMTOrd t where Source #

Minimal complete definition

lt, le, gt, ge

Methods

lt :: Function fun '('[t, t], BoolType) Source #

le :: Function fun '('[t, t], BoolType) Source #

gt :: Function fun '('[t, t], BoolType) Source #

ge :: Function fun '('[t, t], BoolType) Source #

Instances

SMTOrd IntType Source #
Methods lt :: Function fun (([Type], Type) ((Type ': IntType) ((Type ': IntType) [Type])) BoolType) Source # le :: Function fun (([Type], Type) ((Type ': IntType) ((Type ': IntType) [Type])) BoolType) Source # gt :: Function fun (([Type], Type) ((Type ': IntType) ((Type ': IntType) [Type])) BoolType) Source # ge :: Function fun (([Type], Type) ((Type ': IntType) ((Type ': IntType) [Type])) BoolType) Source #
SMTOrd RealType Source #
Methods lt :: Function fun (([Type], Type) ((Type ': RealType) ((Type ': RealType) [Type])) BoolType) Source # le :: Function fun (([Type], Type) ((Type ': RealType) ((Type ': RealType) [Type])) BoolType) Source # gt :: Function fun (([Type], Type) ((Type ': RealType) ((Type ': RealType) [Type])) BoolType) Source # ge :: Function fun (([Type], Type) ((Type ': RealType) ((Type ': RealType) [Type])) BoolType) Source #

class SMTArith t where Source #

Minimal complete definition

arithFromInteger, arith, plus, minus, mult, abs'

Methods

arithFromInteger :: Integer -> Value t Source #

arith :: ArithOp -> Natural n -> Function fun '(AllEq t n, t) Source #

plus :: Natural n -> Function fun '(AllEq t n, t) Source #

minus :: Natural n -> Function fun '(AllEq t n, t) Source #

mult :: Natural n -> Function fun '(AllEq t n, t) Source #

abs' :: Function fun '('[t], t) Source #

Instances

SMTArith IntType Source #
Methods arithFromInteger :: Integer -> Value IntType Source # arith :: ArithOp -> Natural n -> Function fun (([Type], Type) (AllEq IntType n) IntType) Source # plus :: Natural n -> Function fun (([Type], Type) (AllEq IntType n) IntType) Source # minus :: Natural n -> Function fun (([Type], Type) (AllEq IntType n) IntType) Source # mult :: Natural n -> Function fun (([Type], Type) (AllEq IntType n) IntType) Source # abs' :: Function fun (([Type], Type) ((Type ': IntType) [Type]) IntType) Source #
SMTArith RealType Source #
Methods arithFromInteger :: Integer -> Value RealType Source # arith :: ArithOp -> Natural n -> Function fun (([Type], Type) (AllEq RealType n) RealType) Source # plus :: Natural n -> Function fun (([Type], Type) (AllEq RealType n) RealType) Source # minus :: Natural n -> Function fun (([Type], Type) (AllEq RealType n) RealType) Source # mult :: Natural n -> Function fun (([Type], Type) (AllEq RealType n) RealType) Source # abs' :: Function fun (([Type], Type) ((Type ': RealType) [Type]) RealType) Source #

functionType :: Monad m => (forall arg t. fun '(arg, t) -> m (List Repr arg, Repr t)) -> Function fun '(arg, res) -> m (List Repr arg, Repr res) Source #

expressionType :: (Monad m, Functor m) => (forall t. v t -> m (Repr t)) -> (forall t. qv t -> m (Repr t)) -> (forall arg t. fun '(arg, t) -> m (List Repr arg, Repr t)) -> (forall t. fv t -> m (Repr t)) -> (forall t. lv t -> m (Repr t)) -> (forall t. e t -> m (Repr t)) -> Expression v qv fun fv lv e res -> m (Repr res) Source #

mapExpr Source #

Arguments

:: (Functor m, Monad m)
=> (forall t. v1 t -> m (v2 t))	How to translate variables
-> (forall t. qv1 t -> m (qv2 t))	How to translate quantified variables
-> (forall arg t. fun1 '(arg, t) -> m (fun2 '(arg, t)))	How to translate functions
-> (forall t. fv1 t -> m (fv2 t))	How to translate function variables
-> (forall t. lv1 t -> m (lv2 t))	How to translate let variables
-> (forall t. e1 t -> m (e2 t))	How to translate sub-expressions
-> Expression v1 qv1 fun1 fv1 lv1 e1 r	The expression to translate
-> m (Expression v2 qv2 fun2 fv2 lv2 e2 r)

mapFunction :: (Functor m, Monad m) => (forall arg t. fun1 '(arg, t) -> m (fun2 '(arg, t))) -> Function fun1 '(arg, res) -> m (Function fun2 '(arg, res)) Source #

data RenderMode Source #

Constructors

SMTRendering

Instances

Eq RenderMode Source #
Methods (==) :: RenderMode -> RenderMode -> Bool # (/=) :: RenderMode -> RenderMode -> Bool #
Ord RenderMode Source #
Methods compare :: RenderMode -> RenderMode -> Ordering # (<) :: RenderMode -> RenderMode -> Bool # (<=) :: RenderMode -> RenderMode -> Bool # (>) :: RenderMode -> RenderMode -> Bool # (>=) :: RenderMode -> RenderMode -> Bool # max :: RenderMode -> RenderMode -> RenderMode # min :: RenderMode -> RenderMode -> RenderMode #
Show RenderMode Source #
Methods showsPrec :: Int -> RenderMode -> ShowS # show :: RenderMode -> String # showList :: [RenderMode] -> ShowS #

renderExprDefault :: (GetType qv, GShow v, GShow qv, GShow fun, GShow fv, GShow lv, GShow e) => RenderMode -> Expression v qv fun fv lv e tp -> ShowS Source #

renderExpr :: GetType qv => RenderMode -> (forall tp. v tp -> ShowS) -> (forall tp. qv tp -> ShowS) -> (forall arg res. fun '(arg, res) -> ShowS) -> (forall tp. fv tp -> ShowS) -> (forall tp. lv tp -> ShowS) -> (forall tp. e tp -> ShowS) -> Expression v qv fun fv lv e tp -> ShowS Source #

renderValue :: RenderMode -> Value tp -> ShowS Source #

renderFunction :: RenderMode -> (forall arg res. fun '(arg, res) -> ShowS) -> Function fun '(arg, res) -> ShowS Source #

renderType :: RenderMode -> Repr tp -> ShowS Source #

renderTypes :: List Repr tps -> ShowS Source #

data NoVar t Source #

Constructors

NoVar'

Instances

GetType NoVar Source #
Methods getType :: NoVar tp -> Repr tp Source #
GCompare Type NoVar Source #
Methods gcompare :: f a -> f b -> GOrdering NoVar a b #
GEq Type NoVar Source #
Methods geq :: f a -> f b -> Maybe ((NoVar := a) b) #
GShow Type NoVar Source #
Methods gshowsPrec :: Int -> t a -> ShowS #
Eq (NoVar t) Source #
Methods (==) :: NoVar t -> NoVar t -> Bool # (/=) :: NoVar t -> NoVar t -> Bool #
Ord (NoVar t) Source #
Methods compare :: NoVar t -> NoVar t -> Ordering # (<) :: NoVar t -> NoVar t -> Bool # (<=) :: NoVar t -> NoVar t -> Bool # (>) :: NoVar t -> NoVar t -> Bool # (>=) :: NoVar t -> NoVar t -> Bool # max :: NoVar t -> NoVar t -> NoVar t # min :: NoVar t -> NoVar t -> NoVar t #
Show (NoVar t) Source #
Methods showsPrec :: Int -> NoVar t -> ShowS # show :: NoVar t -> String # showList :: [NoVar t] -> ShowS #

data NoFun sig Source #

Constructors

NoFun'

Instances

GetFunType NoFun Source #
Methods getFunType :: NoFun (([Type], Type) arg res) -> (List Type Repr arg, Repr res) Source #
Eq (NoFun t) Source #
Methods (==) :: NoFun t -> NoFun t -> Bool # (/=) :: NoFun t -> NoFun t -> Bool #
Ord (NoFun t) Source #
Methods compare :: NoFun t -> NoFun t -> Ordering # (<) :: NoFun t -> NoFun t -> Bool # (<=) :: NoFun t -> NoFun t -> Bool # (>) :: NoFun t -> NoFun t -> Bool # (>=) :: NoFun t -> NoFun t -> Bool # max :: NoFun t -> NoFun t -> NoFun t # min :: NoFun t -> NoFun t -> NoFun t #
Show (NoFun t) Source #
Methods showsPrec :: Int -> NoFun t -> ShowS # show :: NoFun t -> String # showList :: [NoFun t] -> ShowS #
GCompare ([Type], Type) NoFun Source #
Methods gcompare :: f a -> f b -> GOrdering NoFun a b #
GEq ([Type], Type) NoFun Source #
Methods geq :: f a -> f b -> Maybe ((NoFun := a) b) #
GShow ([Type], Type) NoFun Source #
Methods gshowsPrec :: Int -> t a -> ShowS #

data NoCon sig Source #

Constructors

NoCon'

Instances

Eq (NoCon t) Source #
Methods (==) :: NoCon t -> NoCon t -> Bool # (/=) :: NoCon t -> NoCon t -> Bool #
Ord (NoCon t) Source #
Methods compare :: NoCon t -> NoCon t -> Ordering # (<) :: NoCon t -> NoCon t -> Bool # (<=) :: NoCon t -> NoCon t -> Bool # (>) :: NoCon t -> NoCon t -> Bool # (>=) :: NoCon t -> NoCon t -> Bool # max :: NoCon t -> NoCon t -> NoCon t # min :: NoCon t -> NoCon t -> NoCon t #
Show (NoCon t) Source #
Methods showsPrec :: Int -> NoCon t -> ShowS # show :: NoCon t -> String # showList :: [NoCon t] -> ShowS #
GCompare ([Type], *) NoCon Source #
Methods gcompare :: f a -> f b -> GOrdering NoCon a b #
GEq ([Type], *) NoCon Source #
Methods geq :: f a -> f b -> Maybe ((NoCon := a) b) #
GShow ([Type], *) NoCon Source #
Methods gshowsPrec :: Int -> t a -> ShowS #

data NoField sig Source #

Constructors

NoField'

Instances

Eq (NoField t) Source #
Methods (==) :: NoField t -> NoField t -> Bool # (/=) :: NoField t -> NoField t -> Bool #
Ord (NoField t) Source #
Methods compare :: NoField t -> NoField t -> Ordering # (<) :: NoField t -> NoField t -> Bool # (<=) :: NoField t -> NoField t -> Bool # (>) :: NoField t -> NoField t -> Bool # (>=) :: NoField t -> NoField t -> Bool # max :: NoField t -> NoField t -> NoField t # min :: NoField t -> NoField t -> NoField t #
Show (NoField t) Source #
Methods showsPrec :: Int -> NoField t -> ShowS # show :: NoField t -> String # showList :: [NoField t] -> ShowS #
GCompare (*, Type) NoField Source #
Methods gcompare :: f a -> f b -> GOrdering NoField a b #
GEq (*, Type) NoField Source #
Methods geq :: f a -> f b -> Maybe ((NoField := a) b) #
GShow (*, Type) NoField Source #
Methods gshowsPrec :: Int -> t a -> ShowS #