Clingo.Internal.AST

Documentation

newArray' :: Storable a => [a] -> IO (Ptr a)

freeArray :: Storable a => Ptr a -> CSize -> (a -> IO ()) -> IO ()

freeIndirection :: Storable a => Ptr a -> (a -> IO ()) -> IO ()

peekMaybe :: Storable a => Ptr a -> IO (Maybe a)

fromIndirect :: Storable a => Ptr a -> (a -> IO b) -> IO b

data Sign

Constructors

NoSign

NegationSign

DoubleNegationSign

Instances

Eq Sign

Methods

(==) :: Sign -> Sign -> Bool

(/=) :: Sign -> Sign -> Bool

Ord Sign

Methods

compare :: Sign -> Sign -> Ordering

(<) :: Sign -> Sign -> Bool

(<=) :: Sign -> Sign -> Bool

(>) :: Sign -> Sign -> Bool

(>=) :: Sign -> Sign -> Bool

max :: Sign -> Sign -> Sign

min :: Sign -> Sign -> Sign

Show Sign

Methods

showsPrec :: Int -> Sign -> ShowS

show :: Sign -> String

showList :: [Sign] -> ShowS

Pretty Sign

Methods

pretty :: Sign -> Doc

prettyList :: [Sign] -> Doc

rawSign :: Sign -> AstSign

fromRawSign :: AstSign -> Sign

data UnaryOperation a

Constructors

UnaryOperation UnaryOperator (Term a)

Instances

Functor UnaryOperation

Methods

fmap :: (a -> b) -> UnaryOperation a -> UnaryOperation b

(<$) :: a -> UnaryOperation b -> UnaryOperation a

Foldable UnaryOperation

Methods

fold :: Monoid m => UnaryOperation m -> m

foldMap :: Monoid m => (a -> m) -> UnaryOperation a -> m

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

foldr' :: (a -> b -> b) -> b -> UnaryOperation a -> b

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

foldl' :: (b -> a -> b) -> b -> UnaryOperation a -> b

foldr1 :: (a -> a -> a) -> UnaryOperation a -> a

foldl1 :: (a -> a -> a) -> UnaryOperation a -> a

toList :: UnaryOperation a -> [a]

null :: UnaryOperation a -> Bool

length :: UnaryOperation a -> Int

elem :: Eq a => a -> UnaryOperation a -> Bool

maximum :: Ord a => UnaryOperation a -> a

minimum :: Ord a => UnaryOperation a -> a

sum :: Num a => UnaryOperation a -> a

product :: Num a => UnaryOperation a -> a

Traversable UnaryOperation

Methods

traverse :: Applicative f => (a -> f b) -> UnaryOperation a -> f (UnaryOperation b)

sequenceA :: Applicative f => UnaryOperation (f a) -> f (UnaryOperation a)

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

sequence :: Monad m => UnaryOperation (m a) -> m (UnaryOperation a)

Eq a => Eq (UnaryOperation a)

Methods

(==) :: UnaryOperation a -> UnaryOperation a -> Bool

(/=) :: UnaryOperation a -> UnaryOperation a -> Bool

Ord a => Ord (UnaryOperation a)

Methods

compare :: UnaryOperation a -> UnaryOperation a -> Ordering

(<) :: UnaryOperation a -> UnaryOperation a -> Bool

(<=) :: UnaryOperation a -> UnaryOperation a -> Bool

(>) :: UnaryOperation a -> UnaryOperation a -> Bool

(>=) :: UnaryOperation a -> UnaryOperation a -> Bool

max :: UnaryOperation a -> UnaryOperation a -> UnaryOperation a

min :: UnaryOperation a -> UnaryOperation a -> UnaryOperation a

Show a => Show (UnaryOperation a)

Methods

showsPrec :: Int -> UnaryOperation a -> ShowS

show :: UnaryOperation a -> String

showList :: [UnaryOperation a] -> ShowS

Pretty a => Pretty (UnaryOperation a)

Methods

pretty :: UnaryOperation a -> Doc

prettyList :: [UnaryOperation a] -> Doc

rawUnaryOperation :: UnaryOperation (Symbol s) -> IO AstUnaryOperation

freeUnaryOperation :: AstUnaryOperation -> IO ()

fromRawUnaryOperation :: AstUnaryOperation -> IO (UnaryOperation (Symbol s))

data UnaryOperator

Constructors

UnaryMinus

Negation

Absolute

Instances

Eq UnaryOperator

Methods

(==) :: UnaryOperator -> UnaryOperator -> Bool

(/=) :: UnaryOperator -> UnaryOperator -> Bool

Ord UnaryOperator

Methods

compare :: UnaryOperator -> UnaryOperator -> Ordering

(<) :: UnaryOperator -> UnaryOperator -> Bool

(<=) :: UnaryOperator -> UnaryOperator -> Bool

(>) :: UnaryOperator -> UnaryOperator -> Bool

(>=) :: UnaryOperator -> UnaryOperator -> Bool

max :: UnaryOperator -> UnaryOperator -> UnaryOperator

min :: UnaryOperator -> UnaryOperator -> UnaryOperator

Show UnaryOperator

Methods

showsPrec :: Int -> UnaryOperator -> ShowS

show :: UnaryOperator -> String

showList :: [UnaryOperator] -> ShowS

Pretty UnaryOperator

Methods

pretty :: UnaryOperator -> Doc

prettyList :: [UnaryOperator] -> Doc

rawUnaryOperator :: UnaryOperator -> AstUnaryOperator

fromRawUnaryOperator :: AstUnaryOperator -> UnaryOperator

data BinaryOperation a

Constructors

BinaryOperation BinaryOperator (Term a) (Term a)

Instances

Functor BinaryOperation

Methods

fmap :: (a -> b) -> BinaryOperation a -> BinaryOperation b

(<$) :: a -> BinaryOperation b -> BinaryOperation a

Foldable BinaryOperation

Methods

fold :: Monoid m => BinaryOperation m -> m

foldMap :: Monoid m => (a -> m) -> BinaryOperation a -> m

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

foldr' :: (a -> b -> b) -> b -> BinaryOperation a -> b

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

foldl' :: (b -> a -> b) -> b -> BinaryOperation a -> b

foldr1 :: (a -> a -> a) -> BinaryOperation a -> a

foldl1 :: (a -> a -> a) -> BinaryOperation a -> a

toList :: BinaryOperation a -> [a]

null :: BinaryOperation a -> Bool

length :: BinaryOperation a -> Int

elem :: Eq a => a -> BinaryOperation a -> Bool

maximum :: Ord a => BinaryOperation a -> a

minimum :: Ord a => BinaryOperation a -> a

sum :: Num a => BinaryOperation a -> a

product :: Num a => BinaryOperation a -> a

Traversable BinaryOperation

Methods

traverse :: Applicative f => (a -> f b) -> BinaryOperation a -> f (BinaryOperation b)

sequenceA :: Applicative f => BinaryOperation (f a) -> f (BinaryOperation a)

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

sequence :: Monad m => BinaryOperation (m a) -> m (BinaryOperation a)

Eq a => Eq (BinaryOperation a)

Methods

(==) :: BinaryOperation a -> BinaryOperation a -> Bool

(/=) :: BinaryOperation a -> BinaryOperation a -> Bool

Ord a => Ord (BinaryOperation a)

Methods

compare :: BinaryOperation a -> BinaryOperation a -> Ordering

(<) :: BinaryOperation a -> BinaryOperation a -> Bool

(<=) :: BinaryOperation a -> BinaryOperation a -> Bool

(>) :: BinaryOperation a -> BinaryOperation a -> Bool

(>=) :: BinaryOperation a -> BinaryOperation a -> Bool

max :: BinaryOperation a -> BinaryOperation a -> BinaryOperation a

min :: BinaryOperation a -> BinaryOperation a -> BinaryOperation a

Show a => Show (BinaryOperation a)

Methods

showsPrec :: Int -> BinaryOperation a -> ShowS

show :: BinaryOperation a -> String

showList :: [BinaryOperation a] -> ShowS

Pretty a => Pretty (BinaryOperation a)

Methods

pretty :: BinaryOperation a -> Doc

prettyList :: [BinaryOperation a] -> Doc

rawBinaryOperation :: BinaryOperation (Symbol s) -> IO AstBinaryOperation

freeBinaryOperation :: AstBinaryOperation -> IO ()

fromRawBinaryOperation :: AstBinaryOperation -> IO (BinaryOperation (Symbol s))

data BinaryOperator

Constructors

Xor

Or

And

Plus

Minus

Mult

Div

Mod

Instances

Eq BinaryOperator

Methods

(==) :: BinaryOperator -> BinaryOperator -> Bool

(/=) :: BinaryOperator -> BinaryOperator -> Bool

Ord BinaryOperator

Methods

compare :: BinaryOperator -> BinaryOperator -> Ordering

(<) :: BinaryOperator -> BinaryOperator -> Bool

(<=) :: BinaryOperator -> BinaryOperator -> Bool

(>) :: BinaryOperator -> BinaryOperator -> Bool

(>=) :: BinaryOperator -> BinaryOperator -> Bool

max :: BinaryOperator -> BinaryOperator -> BinaryOperator

min :: BinaryOperator -> BinaryOperator -> BinaryOperator

Show BinaryOperator

Methods

showsPrec :: Int -> BinaryOperator -> ShowS

show :: BinaryOperator -> String

showList :: [BinaryOperator] -> ShowS

Pretty BinaryOperator

Methods

pretty :: BinaryOperator -> Doc

prettyList :: [BinaryOperator] -> Doc

rawBinaryOperator :: BinaryOperator -> AstBinaryOperator

fromRawBinaryOperator :: AstBinaryOperator -> BinaryOperator

data Interval a

Constructors

Interval (Term a) (Term a)

Instances

Functor Interval

Methods

fmap :: (a -> b) -> Interval a -> Interval b

(<$) :: a -> Interval b -> Interval a

Foldable Interval

Methods

fold :: Monoid m => Interval m -> m

foldMap :: Monoid m => (a -> m) -> Interval a -> m

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

foldr' :: (a -> b -> b) -> b -> Interval a -> b

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

foldl' :: (b -> a -> b) -> b -> Interval a -> b

foldr1 :: (a -> a -> a) -> Interval a -> a

foldl1 :: (a -> a -> a) -> Interval a -> a

toList :: Interval a -> [a]

null :: Interval a -> Bool

length :: Interval a -> Int

elem :: Eq a => a -> Interval a -> Bool

maximum :: Ord a => Interval a -> a

minimum :: Ord a => Interval a -> a

sum :: Num a => Interval a -> a

product :: Num a => Interval a -> a

Traversable Interval

Methods

traverse :: Applicative f => (a -> f b) -> Interval a -> f (Interval b)

sequenceA :: Applicative f => Interval (f a) -> f (Interval a)

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

sequence :: Monad m => Interval (m a) -> m (Interval a)

Eq a => Eq (Interval a)

Methods

(==) :: Interval a -> Interval a -> Bool

(/=) :: Interval a -> Interval a -> Bool

Ord a => Ord (Interval a)

Methods

compare :: Interval a -> Interval a -> Ordering

(<) :: Interval a -> Interval a -> Bool

(<=) :: Interval a -> Interval a -> Bool

(>) :: Interval a -> Interval a -> Bool

(>=) :: Interval a -> Interval a -> Bool

max :: Interval a -> Interval a -> Interval a

min :: Interval a -> Interval a -> Interval a

Show a => Show (Interval a)

Methods

showsPrec :: Int -> Interval a -> ShowS

show :: Interval a -> String

showList :: [Interval a] -> ShowS

Pretty a => Pretty (Interval a)

Methods

pretty :: Interval a -> Doc

prettyList :: [Interval a] -> Doc

rawInterval :: Interval (Symbol s) -> IO AstInterval

freeInterval :: AstInterval -> IO ()

fromRawInterval :: AstInterval -> IO (Interval (Symbol s))

data Function a

Constructors

Function Text [Term a]

Instances

Functor Function

Methods

fmap :: (a -> b) -> Function a -> Function b

(<$) :: a -> Function b -> Function a

Foldable Function

Methods

fold :: Monoid m => Function m -> m

foldMap :: Monoid m => (a -> m) -> Function a -> m

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

foldr' :: (a -> b -> b) -> b -> Function a -> b

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

foldl' :: (b -> a -> b) -> b -> Function a -> b

foldr1 :: (a -> a -> a) -> Function a -> a

foldl1 :: (a -> a -> a) -> Function a -> a

toList :: Function a -> [a]

null :: Function a -> Bool

length :: Function a -> Int

elem :: Eq a => a -> Function a -> Bool

maximum :: Ord a => Function a -> a

minimum :: Ord a => Function a -> a

sum :: Num a => Function a -> a

product :: Num a => Function a -> a

Traversable Function

Methods

traverse :: Applicative f => (a -> f b) -> Function a -> f (Function b)

sequenceA :: Applicative f => Function (f a) -> f (Function a)

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

sequence :: Monad m => Function (m a) -> m (Function a)

Eq a => Eq (Function a)

Methods

(==) :: Function a -> Function a -> Bool

(/=) :: Function a -> Function a -> Bool

Ord a => Ord (Function a)

Methods

compare :: Function a -> Function a -> Ordering

(<) :: Function a -> Function a -> Bool

(<=) :: Function a -> Function a -> Bool

(>) :: Function a -> Function a -> Bool

(>=) :: Function a -> Function a -> Bool

max :: Function a -> Function a -> Function a

min :: Function a -> Function a -> Function a

Show a => Show (Function a)

Methods

showsPrec :: Int -> Function a -> ShowS

show :: Function a -> String

showList :: [Function a] -> ShowS

Pretty a => Pretty (Function a)

Methods

pretty :: Function a -> Doc

prettyList :: [Function a] -> Doc

rawFunction :: Function (Symbol s) -> IO AstFunction

freeFunction :: AstFunction -> IO ()

fromRawFunction :: AstFunction -> IO (Function (Symbol s))

data Pool a

Constructors

Pool [Term a]

Instances

Functor Pool

Methods

fmap :: (a -> b) -> Pool a -> Pool b

(<$) :: a -> Pool b -> Pool a

Foldable Pool

Methods

fold :: Monoid m => Pool m -> m

foldMap :: Monoid m => (a -> m) -> Pool a -> m

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

foldr' :: (a -> b -> b) -> b -> Pool a -> b

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

foldl' :: (b -> a -> b) -> b -> Pool a -> b

foldr1 :: (a -> a -> a) -> Pool a -> a

foldl1 :: (a -> a -> a) -> Pool a -> a

toList :: Pool a -> [a]

null :: Pool a -> Bool

length :: Pool a -> Int

elem :: Eq a => a -> Pool a -> Bool

maximum :: Ord a => Pool a -> a

minimum :: Ord a => Pool a -> a

sum :: Num a => Pool a -> a

product :: Num a => Pool a -> a

Traversable Pool

Methods

traverse :: Applicative f => (a -> f b) -> Pool a -> f (Pool b)

sequenceA :: Applicative f => Pool (f a) -> f (Pool a)

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

sequence :: Monad m => Pool (m a) -> m (Pool a)

Eq a => Eq (Pool a)

Methods

(==) :: Pool a -> Pool a -> Bool

(/=) :: Pool a -> Pool a -> Bool

Ord a => Ord (Pool a)

Methods

compare :: Pool a -> Pool a -> Ordering

(<) :: Pool a -> Pool a -> Bool

(<=) :: Pool a -> Pool a -> Bool

(>) :: Pool a -> Pool a -> Bool

(>=) :: Pool a -> Pool a -> Bool

max :: Pool a -> Pool a -> Pool a

min :: Pool a -> Pool a -> Pool a

Show a => Show (Pool a)

Methods

showsPrec :: Int -> Pool a -> ShowS

show :: Pool a -> String

showList :: [Pool a] -> ShowS

Pretty a => Pretty (Pool a)

Methods

pretty :: Pool a -> Doc

prettyList :: [Pool a] -> Doc

rawPool :: Pool (Symbol s) -> IO AstPool

freePool :: AstPool -> IO ()

fromRawPool :: AstPool -> IO (Pool (Symbol s))

data Term a

Constructors

TermSymbol Location a

TermVariable Location Text

TermUOp Location (UnaryOperation a)

TermBOp Location (BinaryOperation a)

TermInterval Location (Interval a)

TermFunction Location (Function a)

TermExtFunction Location (Function a)

TermPool Location (Pool a)

Instances

Functor Term

Methods

fmap :: (a -> b) -> Term a -> Term b

(<$) :: a -> Term b -> Term a

Foldable Term

Methods

fold :: Monoid m => Term m -> m

foldMap :: Monoid m => (a -> m) -> Term a -> m

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

foldr' :: (a -> b -> b) -> b -> Term a -> b

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

foldl' :: (b -> a -> b) -> b -> Term a -> b

foldr1 :: (a -> a -> a) -> Term a -> a

foldl1 :: (a -> a -> a) -> Term a -> a

toList :: Term a -> [a]

null :: Term a -> Bool

length :: Term a -> Int

elem :: Eq a => a -> Term a -> Bool

maximum :: Ord a => Term a -> a

minimum :: Ord a => Term a -> a

sum :: Num a => Term a -> a

product :: Num a => Term a -> a

Traversable Term

Methods

traverse :: Applicative f => (a -> f b) -> Term a -> f (Term b)

sequenceA :: Applicative f => Term (f a) -> f (Term a)

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

sequence :: Monad m => Term (m a) -> m (Term a)

Eq a => Eq (Term a)

Methods

(==) :: Term a -> Term a -> Bool

(/=) :: Term a -> Term a -> Bool

Ord a => Ord (Term a)

Methods

compare :: Term a -> Term a -> Ordering

(<) :: Term a -> Term a -> Bool

(<=) :: Term a -> Term a -> Bool

(>) :: Term a -> Term a -> Bool

(>=) :: Term a -> Term a -> Bool

max :: Term a -> Term a -> Term a

min :: Term a -> Term a -> Term a

Show a => Show (Term a)

Methods

showsPrec :: Int -> Term a -> ShowS

show :: Term a -> String

showList :: [Term a] -> ShowS

Pretty a => Pretty (Term a)

Methods

pretty :: Term a -> Doc

prettyList :: [Term a] -> Doc

rawTerm :: Term (Symbol s) -> IO AstTerm

freeTerm :: AstTerm -> IO ()

fromRawTerm :: AstTerm -> IO (Term (Symbol s))

data CspProductTerm a

Constructors

CspProductTerm Location (Term a) (Maybe (Term a))

Instances

Functor CspProductTerm

Methods

fmap :: (a -> b) -> CspProductTerm a -> CspProductTerm b

(<$) :: a -> CspProductTerm b -> CspProductTerm a

Foldable CspProductTerm

Methods

fold :: Monoid m => CspProductTerm m -> m

foldMap :: Monoid m => (a -> m) -> CspProductTerm a -> m

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

foldr' :: (a -> b -> b) -> b -> CspProductTerm a -> b

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

foldl' :: (b -> a -> b) -> b -> CspProductTerm a -> b

foldr1 :: (a -> a -> a) -> CspProductTerm a -> a

foldl1 :: (a -> a -> a) -> CspProductTerm a -> a

toList :: CspProductTerm a -> [a]

null :: CspProductTerm a -> Bool

length :: CspProductTerm a -> Int

elem :: Eq a => a -> CspProductTerm a -> Bool

maximum :: Ord a => CspProductTerm a -> a

minimum :: Ord a => CspProductTerm a -> a

sum :: Num a => CspProductTerm a -> a

product :: Num a => CspProductTerm a -> a

Traversable CspProductTerm

Methods

traverse :: Applicative f => (a -> f b) -> CspProductTerm a -> f (CspProductTerm b)

sequenceA :: Applicative f => CspProductTerm (f a) -> f (CspProductTerm a)

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

sequence :: Monad m => CspProductTerm (m a) -> m (CspProductTerm a)

Eq a => Eq (CspProductTerm a)

Methods

(==) :: CspProductTerm a -> CspProductTerm a -> Bool

(/=) :: CspProductTerm a -> CspProductTerm a -> Bool

Ord a => Ord (CspProductTerm a)

Methods

compare :: CspProductTerm a -> CspProductTerm a -> Ordering

(<) :: CspProductTerm a -> CspProductTerm a -> Bool

(<=) :: CspProductTerm a -> CspProductTerm a -> Bool

(>) :: CspProductTerm a -> CspProductTerm a -> Bool

(>=) :: CspProductTerm a -> CspProductTerm a -> Bool

max :: CspProductTerm a -> CspProductTerm a -> CspProductTerm a

min :: CspProductTerm a -> CspProductTerm a -> CspProductTerm a

Show a => Show (CspProductTerm a)

Methods

showsPrec :: Int -> CspProductTerm a -> ShowS

show :: CspProductTerm a -> String

showList :: [CspProductTerm a] -> ShowS

rawCspProductTerm :: CspProductTerm (Symbol s) -> IO AstCspProductTerm

freeCspProductTerm :: AstCspProductTerm -> IO ()

fromRawCspProductTerm :: AstCspProductTerm -> IO (CspProductTerm (Symbol s))

data CspSumTerm a

Constructors

CspSumTerm Location [CspProductTerm a]

Instances

Functor CspSumTerm

Methods

fmap :: (a -> b) -> CspSumTerm a -> CspSumTerm b

(<$) :: a -> CspSumTerm b -> CspSumTerm a

Foldable CspSumTerm

Methods

fold :: Monoid m => CspSumTerm m -> m

foldMap :: Monoid m => (a -> m) -> CspSumTerm a -> m

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

foldr' :: (a -> b -> b) -> b -> CspSumTerm a -> b

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

foldl' :: (b -> a -> b) -> b -> CspSumTerm a -> b

foldr1 :: (a -> a -> a) -> CspSumTerm a -> a

foldl1 :: (a -> a -> a) -> CspSumTerm a -> a

toList :: CspSumTerm a -> [a]

null :: CspSumTerm a -> Bool

length :: CspSumTerm a -> Int

elem :: Eq a => a -> CspSumTerm a -> Bool

maximum :: Ord a => CspSumTerm a -> a

minimum :: Ord a => CspSumTerm a -> a

sum :: Num a => CspSumTerm a -> a

product :: Num a => CspSumTerm a -> a

Traversable CspSumTerm

Methods

traverse :: Applicative f => (a -> f b) -> CspSumTerm a -> f (CspSumTerm b)

sequenceA :: Applicative f => CspSumTerm (f a) -> f (CspSumTerm a)

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

sequence :: Monad m => CspSumTerm (m a) -> m (CspSumTerm a)

Eq a => Eq (CspSumTerm a)

Methods

(==) :: CspSumTerm a -> CspSumTerm a -> Bool

(/=) :: CspSumTerm a -> CspSumTerm a -> Bool

Ord a => Ord (CspSumTerm a)

Methods

compare :: CspSumTerm a -> CspSumTerm a -> Ordering

(<) :: CspSumTerm a -> CspSumTerm a -> Bool

(<=) :: CspSumTerm a -> CspSumTerm a -> Bool

(>) :: CspSumTerm a -> CspSumTerm a -> Bool

(>=) :: CspSumTerm a -> CspSumTerm a -> Bool

max :: CspSumTerm a -> CspSumTerm a -> CspSumTerm a

min :: CspSumTerm a -> CspSumTerm a -> CspSumTerm a

Show a => Show (CspSumTerm a)

Methods

showsPrec :: Int -> CspSumTerm a -> ShowS

show :: CspSumTerm a -> String

showList :: [CspSumTerm a] -> ShowS

rawCspSumTerm :: CspSumTerm (Symbol s) -> IO AstCspSumTerm

freeCspSumTerm :: AstCspSumTerm -> IO ()

fromRawCspSumTerm :: AstCspSumTerm -> IO (CspSumTerm (Symbol s))

data CspGuard a

Constructors

CspGuard ComparisonOperator (CspSumTerm a)

Instances

Functor CspGuard

Methods

fmap :: (a -> b) -> CspGuard a -> CspGuard b

(<$) :: a -> CspGuard b -> CspGuard a

Foldable CspGuard

Methods

fold :: Monoid m => CspGuard m -> m

foldMap :: Monoid m => (a -> m) -> CspGuard a -> m

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

foldr' :: (a -> b -> b) -> b -> CspGuard a -> b

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

foldl' :: (b -> a -> b) -> b -> CspGuard a -> b

foldr1 :: (a -> a -> a) -> CspGuard a -> a

foldl1 :: (a -> a -> a) -> CspGuard a -> a

toList :: CspGuard a -> [a]

null :: CspGuard a -> Bool

length :: CspGuard a -> Int

elem :: Eq a => a -> CspGuard a -> Bool

maximum :: Ord a => CspGuard a -> a

minimum :: Ord a => CspGuard a -> a

sum :: Num a => CspGuard a -> a

product :: Num a => CspGuard a -> a

Traversable CspGuard

Methods

traverse :: Applicative f => (a -> f b) -> CspGuard a -> f (CspGuard b)

sequenceA :: Applicative f => CspGuard (f a) -> f (CspGuard a)

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

sequence :: Monad m => CspGuard (m a) -> m (CspGuard a)

Eq a => Eq (CspGuard a)

Methods

(==) :: CspGuard a -> CspGuard a -> Bool

(/=) :: CspGuard a -> CspGuard a -> Bool

Ord a => Ord (CspGuard a)

Methods

compare :: CspGuard a -> CspGuard a -> Ordering

(<) :: CspGuard a -> CspGuard a -> Bool

(<=) :: CspGuard a -> CspGuard a -> Bool

(>) :: CspGuard a -> CspGuard a -> Bool

(>=) :: CspGuard a -> CspGuard a -> Bool

max :: CspGuard a -> CspGuard a -> CspGuard a

min :: CspGuard a -> CspGuard a -> CspGuard a

Show a => Show (CspGuard a)

Methods

showsPrec :: Int -> CspGuard a -> ShowS

show :: CspGuard a -> String

showList :: [CspGuard a] -> ShowS

rawCspGuard :: CspGuard (Symbol s) -> IO AstCspGuard

freeCspGuard :: AstCspGuard -> IO ()

fromRawCspGuard :: AstCspGuard -> IO (CspGuard (Symbol s))

data ComparisonOperator

Constructors

GreaterThan

LessThan

LessEqual

GreaterEqual

NotEqual

Equal

Instances

Eq ComparisonOperator

Methods

(==) :: ComparisonOperator -> ComparisonOperator -> Bool

(/=) :: ComparisonOperator -> ComparisonOperator -> Bool

Ord ComparisonOperator

Methods

compare :: ComparisonOperator -> ComparisonOperator -> Ordering

(<) :: ComparisonOperator -> ComparisonOperator -> Bool

(<=) :: ComparisonOperator -> ComparisonOperator -> Bool

(>) :: ComparisonOperator -> ComparisonOperator -> Bool

(>=) :: ComparisonOperator -> ComparisonOperator -> Bool

max :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator

min :: ComparisonOperator -> ComparisonOperator -> ComparisonOperator

Show ComparisonOperator

Methods

showsPrec :: Int -> ComparisonOperator -> ShowS

show :: ComparisonOperator -> String

showList :: [ComparisonOperator] -> ShowS

Pretty ComparisonOperator

Methods

pretty :: ComparisonOperator -> Doc

prettyList :: [ComparisonOperator] -> Doc

rawComparisonOperator :: ComparisonOperator -> AstComparisonOperator

fromRawComparisonOperator :: AstComparisonOperator -> ComparisonOperator

data CspLiteral a

Constructors

CspLiteral (CspSumTerm a) [CspGuard a]

Instances

Functor CspLiteral

Methods

fmap :: (a -> b) -> CspLiteral a -> CspLiteral b

(<$) :: a -> CspLiteral b -> CspLiteral a

Foldable CspLiteral

Methods

fold :: Monoid m => CspLiteral m -> m

foldMap :: Monoid m => (a -> m) -> CspLiteral a -> m

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

foldr' :: (a -> b -> b) -> b -> CspLiteral a -> b

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

foldl' :: (b -> a -> b) -> b -> CspLiteral a -> b

foldr1 :: (a -> a -> a) -> CspLiteral a -> a

foldl1 :: (a -> a -> a) -> CspLiteral a -> a

toList :: CspLiteral a -> [a]

null :: CspLiteral a -> Bool

length :: CspLiteral a -> Int

elem :: Eq a => a -> CspLiteral a -> Bool

maximum :: Ord a => CspLiteral a -> a

minimum :: Ord a => CspLiteral a -> a

sum :: Num a => CspLiteral a -> a

product :: Num a => CspLiteral a -> a

Traversable CspLiteral

Methods

traverse :: Applicative f => (a -> f b) -> CspLiteral a -> f (CspLiteral b)

sequenceA :: Applicative f => CspLiteral (f a) -> f (CspLiteral a)

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

sequence :: Monad m => CspLiteral (m a) -> m (CspLiteral a)

Eq a => Eq (CspLiteral a)

Methods

(==) :: CspLiteral a -> CspLiteral a -> Bool

(/=) :: CspLiteral a -> CspLiteral a -> Bool

Ord a => Ord (CspLiteral a)

Methods

compare :: CspLiteral a -> CspLiteral a -> Ordering

(<) :: CspLiteral a -> CspLiteral a -> Bool

(<=) :: CspLiteral a -> CspLiteral a -> Bool

(>) :: CspLiteral a -> CspLiteral a -> Bool

(>=) :: CspLiteral a -> CspLiteral a -> Bool

max :: CspLiteral a -> CspLiteral a -> CspLiteral a

min :: CspLiteral a -> CspLiteral a -> CspLiteral a

Show a => Show (CspLiteral a)

Methods

showsPrec :: Int -> CspLiteral a -> ShowS

show :: CspLiteral a -> String

showList :: [CspLiteral a] -> ShowS

rawCspLiteral :: CspLiteral (Symbol s) -> IO AstCspLiteral

freeCspLiteral :: AstCspLiteral -> IO ()

fromRawCspLiteral :: AstCspLiteral -> IO (CspLiteral (Symbol s))

data Identifier

Constructors

Identifier Location Text

Instances

Eq Identifier

Methods

(==) :: Identifier -> Identifier -> Bool

(/=) :: Identifier -> Identifier -> Bool

Ord Identifier

Methods

compare :: Identifier -> Identifier -> Ordering

(<) :: Identifier -> Identifier -> Bool

(<=) :: Identifier -> Identifier -> Bool

(>) :: Identifier -> Identifier -> Bool

(>=) :: Identifier -> Identifier -> Bool

max :: Identifier -> Identifier -> Identifier

min :: Identifier -> Identifier -> Identifier

Show Identifier

Methods

showsPrec :: Int -> Identifier -> ShowS

show :: Identifier -> String

showList :: [Identifier] -> ShowS

Pretty Identifier

Methods

pretty :: Identifier -> Doc

prettyList :: [Identifier] -> Doc

rawIdentifier :: Identifier -> IO AstId

freeIdentifier :: AstId -> IO ()

fromRawIdentifier :: AstId -> IO Identifier

data Comparison a

Constructors

Comparison ComparisonOperator (Term a) (Term a)

Instances

Functor Comparison

Methods

fmap :: (a -> b) -> Comparison a -> Comparison b

(<$) :: a -> Comparison b -> Comparison a

Foldable Comparison

Methods

fold :: Monoid m => Comparison m -> m

foldMap :: Monoid m => (a -> m) -> Comparison a -> m

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

foldr' :: (a -> b -> b) -> b -> Comparison a -> b

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

foldl' :: (b -> a -> b) -> b -> Comparison a -> b

foldr1 :: (a -> a -> a) -> Comparison a -> a

foldl1 :: (a -> a -> a) -> Comparison a -> a

toList :: Comparison a -> [a]

null :: Comparison a -> Bool

length :: Comparison a -> Int

elem :: Eq a => a -> Comparison a -> Bool

maximum :: Ord a => Comparison a -> a

minimum :: Ord a => Comparison a -> a

sum :: Num a => Comparison a -> a

product :: Num a => Comparison a -> a

Traversable Comparison

Methods

traverse :: Applicative f => (a -> f b) -> Comparison a -> f (Comparison b)

sequenceA :: Applicative f => Comparison (f a) -> f (Comparison a)

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

sequence :: Monad m => Comparison (m a) -> m (Comparison a)

Eq a => Eq (Comparison a)

Methods

(==) :: Comparison a -> Comparison a -> Bool

(/=) :: Comparison a -> Comparison a -> Bool

Ord a => Ord (Comparison a)

Methods

compare :: Comparison a -> Comparison a -> Ordering

(<) :: Comparison a -> Comparison a -> Bool

(<=) :: Comparison a -> Comparison a -> Bool

(>) :: Comparison a -> Comparison a -> Bool

(>=) :: Comparison a -> Comparison a -> Bool

max :: Comparison a -> Comparison a -> Comparison a

min :: Comparison a -> Comparison a -> Comparison a

Show a => Show (Comparison a)

Methods

showsPrec :: Int -> Comparison a -> ShowS

show :: Comparison a -> String

showList :: [Comparison a] -> ShowS

Pretty a => Pretty (Comparison a)

Methods

pretty :: Comparison a -> Doc

prettyList :: [Comparison a] -> Doc

rawComparison :: Comparison (Symbol s) -> IO AstComparison

freeComparison :: AstComparison -> IO ()

fromRawComparison :: AstComparison -> IO (Comparison (Symbol s))

data Literal a

Constructors

LiteralBool Location Sign Bool

LiteralTerm Location Sign (Term a)

LiteralComp Location Sign (Comparison a)

LiteralCSPL Location Sign (CspLiteral a)

Instances

Functor Literal

Methods

fmap :: (a -> b) -> Literal a -> Literal b

(<$) :: a -> Literal b -> Literal a

Foldable Literal

Methods

fold :: Monoid m => Literal m -> m

foldMap :: Monoid m => (a -> m) -> Literal a -> m

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

foldr' :: (a -> b -> b) -> b -> Literal a -> b

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

foldl' :: (b -> a -> b) -> b -> Literal a -> b

foldr1 :: (a -> a -> a) -> Literal a -> a

foldl1 :: (a -> a -> a) -> Literal a -> a

toList :: Literal a -> [a]

null :: Literal a -> Bool

length :: Literal a -> Int

elem :: Eq a => a -> Literal a -> Bool

maximum :: Ord a => Literal a -> a

minimum :: Ord a => Literal a -> a

sum :: Num a => Literal a -> a

product :: Num a => Literal a -> a

Traversable Literal

Methods

traverse :: Applicative f => (a -> f b) -> Literal a -> f (Literal b)

sequenceA :: Applicative f => Literal (f a) -> f (Literal a)

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

sequence :: Monad m => Literal (m a) -> m (Literal a)

Eq a => Eq (Literal a)

Methods

(==) :: Literal a -> Literal a -> Bool

(/=) :: Literal a -> Literal a -> Bool

Ord a => Ord (Literal a)

Methods

compare :: Literal a -> Literal a -> Ordering

(<) :: Literal a -> Literal a -> Bool

(<=) :: Literal a -> Literal a -> Bool

(>) :: Literal a -> Literal a -> Bool

(>=) :: Literal a -> Literal a -> Bool

max :: Literal a -> Literal a -> Literal a

min :: Literal a -> Literal a -> Literal a

Show a => Show (Literal a)

Methods

showsPrec :: Int -> Literal a -> ShowS

show :: Literal a -> String

showList :: [Literal a] -> ShowS

Pretty a => Pretty (Literal a)

Methods

pretty :: Literal a -> Doc

prettyList :: [Literal a] -> Doc

rawLiteral :: Literal (Symbol s) -> IO AstLiteral

freeLiteral :: AstLiteral -> IO ()

fromRawLiteral :: AstLiteral -> IO (Literal (Symbol s))

data AggregateGuard a

Constructors

AggregateGuard ComparisonOperator (Term a)

Instances

Functor AggregateGuard

Methods

fmap :: (a -> b) -> AggregateGuard a -> AggregateGuard b

(<$) :: a -> AggregateGuard b -> AggregateGuard a

Foldable AggregateGuard

Methods

fold :: Monoid m => AggregateGuard m -> m

foldMap :: Monoid m => (a -> m) -> AggregateGuard a -> m

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

foldr' :: (a -> b -> b) -> b -> AggregateGuard a -> b

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

foldl' :: (b -> a -> b) -> b -> AggregateGuard a -> b

foldr1 :: (a -> a -> a) -> AggregateGuard a -> a

foldl1 :: (a -> a -> a) -> AggregateGuard a -> a

toList :: AggregateGuard a -> [a]

null :: AggregateGuard a -> Bool

length :: AggregateGuard a -> Int

elem :: Eq a => a -> AggregateGuard a -> Bool

maximum :: Ord a => AggregateGuard a -> a

minimum :: Ord a => AggregateGuard a -> a

sum :: Num a => AggregateGuard a -> a

product :: Num a => AggregateGuard a -> a

Traversable AggregateGuard

Methods

traverse :: Applicative f => (a -> f b) -> AggregateGuard a -> f (AggregateGuard b)

sequenceA :: Applicative f => AggregateGuard (f a) -> f (AggregateGuard a)

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

sequence :: Monad m => AggregateGuard (m a) -> m (AggregateGuard a)

Eq a => Eq (AggregateGuard a)

Methods

(==) :: AggregateGuard a -> AggregateGuard a -> Bool

(/=) :: AggregateGuard a -> AggregateGuard a -> Bool

Ord a => Ord (AggregateGuard a)

Methods

compare :: AggregateGuard a -> AggregateGuard a -> Ordering

(<) :: AggregateGuard a -> AggregateGuard a -> Bool

(<=) :: AggregateGuard a -> AggregateGuard a -> Bool

(>) :: AggregateGuard a -> AggregateGuard a -> Bool

(>=) :: AggregateGuard a -> AggregateGuard a -> Bool

max :: AggregateGuard a -> AggregateGuard a -> AggregateGuard a

min :: AggregateGuard a -> AggregateGuard a -> AggregateGuard a

Show a => Show (AggregateGuard a)

Methods

showsPrec :: Int -> AggregateGuard a -> ShowS

show :: AggregateGuard a -> String

showList :: [AggregateGuard a] -> ShowS

Pretty a => Pretty (AggregateGuard a)

Instance describing left-guards.

Methods

pretty :: AggregateGuard a -> Doc

prettyList :: [AggregateGuard a] -> Doc

aguardPRight :: Pretty a => AggregateGuard a -> Doc

aguardPLeft :: Pretty a => AggregateGuard a -> Doc

rawAggregateGuard :: AggregateGuard (Symbol s) -> IO AstAggregateGuard

rawAggregateGuardM :: Maybe (AggregateGuard (Symbol s)) -> IO (Ptr AstAggregateGuard)

freeAggregateGuard :: AstAggregateGuard -> IO ()

fromRawAggregateGuard :: AstAggregateGuard -> IO (AggregateGuard (Symbol s))

data ConditionalLiteral a

Constructors

ConditionalLiteral (Literal a) [Literal a]

Instances

Functor ConditionalLiteral

Methods

fmap :: (a -> b) -> ConditionalLiteral a -> ConditionalLiteral b

(<$) :: a -> ConditionalLiteral b -> ConditionalLiteral a

Foldable ConditionalLiteral

Methods

fold :: Monoid m => ConditionalLiteral m -> m

foldMap :: Monoid m => (a -> m) -> ConditionalLiteral a -> m

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

foldr' :: (a -> b -> b) -> b -> ConditionalLiteral a -> b

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

foldl' :: (b -> a -> b) -> b -> ConditionalLiteral a -> b

foldr1 :: (a -> a -> a) -> ConditionalLiteral a -> a

foldl1 :: (a -> a -> a) -> ConditionalLiteral a -> a

toList :: ConditionalLiteral a -> [a]

null :: ConditionalLiteral a -> Bool

length :: ConditionalLiteral a -> Int

elem :: Eq a => a -> ConditionalLiteral a -> Bool

maximum :: Ord a => ConditionalLiteral a -> a

minimum :: Ord a => ConditionalLiteral a -> a

sum :: Num a => ConditionalLiteral a -> a

product :: Num a => ConditionalLiteral a -> a

Traversable ConditionalLiteral

Methods

traverse :: Applicative f => (a -> f b) -> ConditionalLiteral a -> f (ConditionalLiteral b)

sequenceA :: Applicative f => ConditionalLiteral (f a) -> f (ConditionalLiteral a)

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

sequence :: Monad m => ConditionalLiteral (m a) -> m (ConditionalLiteral a)

Eq a => Eq (ConditionalLiteral a)

Methods

(==) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

(/=) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

Ord a => Ord (ConditionalLiteral a)

Methods

compare :: ConditionalLiteral a -> ConditionalLiteral a -> Ordering

(<) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

(<=) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

(>) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

(>=) :: ConditionalLiteral a -> ConditionalLiteral a -> Bool

max :: ConditionalLiteral a -> ConditionalLiteral a -> ConditionalLiteral a

min :: ConditionalLiteral a -> ConditionalLiteral a -> ConditionalLiteral a

Show a => Show (ConditionalLiteral a)

Methods

showsPrec :: Int -> ConditionalLiteral a -> ShowS

show :: ConditionalLiteral a -> String

showList :: [ConditionalLiteral a] -> ShowS

Pretty a => Pretty (ConditionalLiteral a)

Methods

pretty :: ConditionalLiteral a -> Doc

prettyList :: [ConditionalLiteral a] -> Doc

rawConditionalLiteral :: ConditionalLiteral (Symbol s) -> IO AstConditionalLiteral

freeConditionalLiteral :: AstConditionalLiteral -> IO ()

fromRawConditionalLiteral :: AstConditionalLiteral -> IO (ConditionalLiteral (Symbol s))

data Aggregate a

Constructors

Aggregate [ConditionalLiteral a] (Maybe (AggregateGuard a)) (Maybe (AggregateGuard a))

Instances

Functor Aggregate

Methods

fmap :: (a -> b) -> Aggregate a -> Aggregate b

(<$) :: a -> Aggregate b -> Aggregate a

Foldable Aggregate

Methods

fold :: Monoid m => Aggregate m -> m

foldMap :: Monoid m => (a -> m) -> Aggregate a -> m

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

foldr' :: (a -> b -> b) -> b -> Aggregate a -> b

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

foldl' :: (b -> a -> b) -> b -> Aggregate a -> b

foldr1 :: (a -> a -> a) -> Aggregate a -> a

foldl1 :: (a -> a -> a) -> Aggregate a -> a

toList :: Aggregate a -> [a]

null :: Aggregate a -> Bool

length :: Aggregate a -> Int

elem :: Eq a => a -> Aggregate a -> Bool

maximum :: Ord a => Aggregate a -> a

minimum :: Ord a => Aggregate a -> a

sum :: Num a => Aggregate a -> a

product :: Num a => Aggregate a -> a

Traversable Aggregate

Methods

traverse :: Applicative f => (a -> f b) -> Aggregate a -> f (Aggregate b)

sequenceA :: Applicative f => Aggregate (f a) -> f (Aggregate a)

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

sequence :: Monad m => Aggregate (m a) -> m (Aggregate a)

Eq a => Eq (Aggregate a)

Methods

(==) :: Aggregate a -> Aggregate a -> Bool

(/=) :: Aggregate a -> Aggregate a -> Bool

Ord a => Ord (Aggregate a)

Methods

compare :: Aggregate a -> Aggregate a -> Ordering

(<) :: Aggregate a -> Aggregate a -> Bool

(<=) :: Aggregate a -> Aggregate a -> Bool

(>) :: Aggregate a -> Aggregate a -> Bool

(>=) :: Aggregate a -> Aggregate a -> Bool

max :: Aggregate a -> Aggregate a -> Aggregate a

min :: Aggregate a -> Aggregate a -> Aggregate a

Show a => Show (Aggregate a)

Methods

showsPrec :: Int -> Aggregate a -> ShowS

show :: Aggregate a -> String

showList :: [Aggregate a] -> ShowS

Pretty a => Pretty (Aggregate a)

Methods

pretty :: Aggregate a -> Doc

prettyList :: [Aggregate a] -> Doc

rawAggregate :: Aggregate (Symbol s) -> IO AstAggregate

freeAggregate :: AstAggregate -> IO ()

fromRawAggregate :: AstAggregate -> IO (Aggregate (Symbol s))

data BodyAggregateElement a

Constructors

BodyAggregateElement [Term a] [Literal a]

Instances

Functor BodyAggregateElement

Methods

fmap :: (a -> b) -> BodyAggregateElement a -> BodyAggregateElement b

(<$) :: a -> BodyAggregateElement b -> BodyAggregateElement a

Foldable BodyAggregateElement

Methods

fold :: Monoid m => BodyAggregateElement m -> m

foldMap :: Monoid m => (a -> m) -> BodyAggregateElement a -> m

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

foldr' :: (a -> b -> b) -> b -> BodyAggregateElement a -> b

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

foldl' :: (b -> a -> b) -> b -> BodyAggregateElement a -> b

foldr1 :: (a -> a -> a) -> BodyAggregateElement a -> a

foldl1 :: (a -> a -> a) -> BodyAggregateElement a -> a

toList :: BodyAggregateElement a -> [a]

null :: BodyAggregateElement a -> Bool

length :: BodyAggregateElement a -> Int

elem :: Eq a => a -> BodyAggregateElement a -> Bool

maximum :: Ord a => BodyAggregateElement a -> a

minimum :: Ord a => BodyAggregateElement a -> a

sum :: Num a => BodyAggregateElement a -> a

product :: Num a => BodyAggregateElement a -> a

Traversable BodyAggregateElement

Methods

traverse :: Applicative f => (a -> f b) -> BodyAggregateElement a -> f (BodyAggregateElement b)

sequenceA :: Applicative f => BodyAggregateElement (f a) -> f (BodyAggregateElement a)

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

sequence :: Monad m => BodyAggregateElement (m a) -> m (BodyAggregateElement a)

Eq a => Eq (BodyAggregateElement a)

Methods

(==) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

(/=) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

Ord a => Ord (BodyAggregateElement a)

Methods

compare :: BodyAggregateElement a -> BodyAggregateElement a -> Ordering

(<) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

(<=) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

(>) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

(>=) :: BodyAggregateElement a -> BodyAggregateElement a -> Bool

max :: BodyAggregateElement a -> BodyAggregateElement a -> BodyAggregateElement a

min :: BodyAggregateElement a -> BodyAggregateElement a -> BodyAggregateElement a

Show a => Show (BodyAggregateElement a)

Methods

showsPrec :: Int -> BodyAggregateElement a -> ShowS

show :: BodyAggregateElement a -> String

showList :: [BodyAggregateElement a] -> ShowS

Pretty a => Pretty (BodyAggregateElement a)

Methods

pretty :: BodyAggregateElement a -> Doc

prettyList :: [BodyAggregateElement a] -> Doc

rawBodyAggregateElement :: BodyAggregateElement (Symbol s) -> IO AstBodyAggregateElement

freeBodyAggregateElement :: AstBodyAggregateElement -> IO ()

fromRawBodyAggregateElement :: AstBodyAggregateElement -> IO (BodyAggregateElement (Symbol s))

data BodyAggregate a

Constructors

BodyAggregate AggregateFunction [BodyAggregateElement a] (Maybe (AggregateGuard a)) (Maybe (AggregateGuard a))

Instances

Functor BodyAggregate

Methods

fmap :: (a -> b) -> BodyAggregate a -> BodyAggregate b

(<$) :: a -> BodyAggregate b -> BodyAggregate a

Foldable BodyAggregate

Methods

fold :: Monoid m => BodyAggregate m -> m

foldMap :: Monoid m => (a -> m) -> BodyAggregate a -> m

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

foldr' :: (a -> b -> b) -> b -> BodyAggregate a -> b

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

foldl' :: (b -> a -> b) -> b -> BodyAggregate a -> b

foldr1 :: (a -> a -> a) -> BodyAggregate a -> a

foldl1 :: (a -> a -> a) -> BodyAggregate a -> a

toList :: BodyAggregate a -> [a]

null :: BodyAggregate a -> Bool

length :: BodyAggregate a -> Int

elem :: Eq a => a -> BodyAggregate a -> Bool

maximum :: Ord a => BodyAggregate a -> a

minimum :: Ord a => BodyAggregate a -> a

sum :: Num a => BodyAggregate a -> a

product :: Num a => BodyAggregate a -> a

Traversable BodyAggregate

Methods

traverse :: Applicative f => (a -> f b) -> BodyAggregate a -> f (BodyAggregate b)

sequenceA :: Applicative f => BodyAggregate (f a) -> f (BodyAggregate a)

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

sequence :: Monad m => BodyAggregate (m a) -> m (BodyAggregate a)

Eq a => Eq (BodyAggregate a)

Methods

(==) :: BodyAggregate a -> BodyAggregate a -> Bool

(/=) :: BodyAggregate a -> BodyAggregate a -> Bool

Ord a => Ord (BodyAggregate a)

Methods

compare :: BodyAggregate a -> BodyAggregate a -> Ordering

(<) :: BodyAggregate a -> BodyAggregate a -> Bool

(<=) :: BodyAggregate a -> BodyAggregate a -> Bool

(>) :: BodyAggregate a -> BodyAggregate a -> Bool

(>=) :: BodyAggregate a -> BodyAggregate a -> Bool

max :: BodyAggregate a -> BodyAggregate a -> BodyAggregate a

min :: BodyAggregate a -> BodyAggregate a -> BodyAggregate a

Show a => Show (BodyAggregate a)

Methods

showsPrec :: Int -> BodyAggregate a -> ShowS

show :: BodyAggregate a -> String

showList :: [BodyAggregate a] -> ShowS

Pretty a => Pretty (BodyAggregate a)

Methods

pretty :: BodyAggregate a -> Doc

prettyList :: [BodyAggregate a] -> Doc

rawBodyAggregate :: BodyAggregate (Symbol s) -> IO AstBodyAggregate

freeBodyAggregate :: AstBodyAggregate -> IO ()

fromRawBodyAggregate :: AstBodyAggregate -> IO (BodyAggregate (Symbol s))

data AggregateFunction

Constructors

Count

Sum

Sump

Min

Max

Instances

Eq AggregateFunction

Methods

(==) :: AggregateFunction -> AggregateFunction -> Bool

(/=) :: AggregateFunction -> AggregateFunction -> Bool

Ord AggregateFunction

Methods

compare :: AggregateFunction -> AggregateFunction -> Ordering

(<) :: AggregateFunction -> AggregateFunction -> Bool

(<=) :: AggregateFunction -> AggregateFunction -> Bool

(>) :: AggregateFunction -> AggregateFunction -> Bool

(>=) :: AggregateFunction -> AggregateFunction -> Bool

max :: AggregateFunction -> AggregateFunction -> AggregateFunction

min :: AggregateFunction -> AggregateFunction -> AggregateFunction

Show AggregateFunction

Methods

showsPrec :: Int -> AggregateFunction -> ShowS

show :: AggregateFunction -> String

showList :: [AggregateFunction] -> ShowS

Pretty AggregateFunction

Methods

pretty :: AggregateFunction -> Doc

prettyList :: [AggregateFunction] -> Doc

rawAggregateFunction :: AggregateFunction -> AstAggregateFunction

fromRawAggregateFunction :: AstAggregateFunction -> AggregateFunction

data HeadAggregateElement a

Constructors

HeadAggregateElement [Term a] (ConditionalLiteral a)

Instances

Functor HeadAggregateElement

Methods

fmap :: (a -> b) -> HeadAggregateElement a -> HeadAggregateElement b

(<$) :: a -> HeadAggregateElement b -> HeadAggregateElement a

Foldable HeadAggregateElement

Methods

fold :: Monoid m => HeadAggregateElement m -> m

foldMap :: Monoid m => (a -> m) -> HeadAggregateElement a -> m

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

foldr' :: (a -> b -> b) -> b -> HeadAggregateElement a -> b

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

foldl' :: (b -> a -> b) -> b -> HeadAggregateElement a -> b

foldr1 :: (a -> a -> a) -> HeadAggregateElement a -> a

foldl1 :: (a -> a -> a) -> HeadAggregateElement a -> a

toList :: HeadAggregateElement a -> [a]

null :: HeadAggregateElement a -> Bool

length :: HeadAggregateElement a -> Int

elem :: Eq a => a -> HeadAggregateElement a -> Bool

maximum :: Ord a => HeadAggregateElement a -> a

minimum :: Ord a => HeadAggregateElement a -> a

sum :: Num a => HeadAggregateElement a -> a

product :: Num a => HeadAggregateElement a -> a

Traversable HeadAggregateElement

Methods

traverse :: Applicative f => (a -> f b) -> HeadAggregateElement a -> f (HeadAggregateElement b)

sequenceA :: Applicative f => HeadAggregateElement (f a) -> f (HeadAggregateElement a)

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

sequence :: Monad m => HeadAggregateElement (m a) -> m (HeadAggregateElement a)

Eq a => Eq (HeadAggregateElement a)

Methods

(==) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

(/=) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

Ord a => Ord (HeadAggregateElement a)

Methods

compare :: HeadAggregateElement a -> HeadAggregateElement a -> Ordering

(<) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

(<=) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

(>) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

(>=) :: HeadAggregateElement a -> HeadAggregateElement a -> Bool

max :: HeadAggregateElement a -> HeadAggregateElement a -> HeadAggregateElement a

min :: HeadAggregateElement a -> HeadAggregateElement a -> HeadAggregateElement a

Show a => Show (HeadAggregateElement a)

Methods

showsPrec :: Int -> HeadAggregateElement a -> ShowS

show :: HeadAggregateElement a -> String

showList :: [HeadAggregateElement a] -> ShowS

Pretty a => Pretty (HeadAggregateElement a)

Methods

pretty :: HeadAggregateElement a -> Doc

prettyList :: [HeadAggregateElement a] -> Doc

rawHeadAggregateElement :: HeadAggregateElement (Symbol s) -> IO AstHeadAggregateElement

freeHeadAggregateElement :: AstHeadAggregateElement -> IO ()

fromRawHeadAggregateElement :: AstHeadAggregateElement -> IO (HeadAggregateElement (Symbol s))

data HeadAggregate a

Constructors

HeadAggregate AggregateFunction [HeadAggregateElement a] (Maybe (AggregateGuard a)) (Maybe (AggregateGuard a))

Instances

Functor HeadAggregate

Methods

fmap :: (a -> b) -> HeadAggregate a -> HeadAggregate b

(<$) :: a -> HeadAggregate b -> HeadAggregate a

Foldable HeadAggregate

Methods

fold :: Monoid m => HeadAggregate m -> m

foldMap :: Monoid m => (a -> m) -> HeadAggregate a -> m

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

foldr' :: (a -> b -> b) -> b -> HeadAggregate a -> b

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

foldl' :: (b -> a -> b) -> b -> HeadAggregate a -> b

foldr1 :: (a -> a -> a) -> HeadAggregate a -> a

foldl1 :: (a -> a -> a) -> HeadAggregate a -> a

toList :: HeadAggregate a -> [a]

null :: HeadAggregate a -> Bool

length :: HeadAggregate a -> Int

elem :: Eq a => a -> HeadAggregate a -> Bool

maximum :: Ord a => HeadAggregate a -> a

minimum :: Ord a => HeadAggregate a -> a

sum :: Num a => HeadAggregate a -> a

product :: Num a => HeadAggregate a -> a

Traversable HeadAggregate

Methods

traverse :: Applicative f => (a -> f b) -> HeadAggregate a -> f (HeadAggregate b)

sequenceA :: Applicative f => HeadAggregate (f a) -> f (HeadAggregate a)

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

sequence :: Monad m => HeadAggregate (m a) -> m (HeadAggregate a)

Eq a => Eq (HeadAggregate a)

Methods

(==) :: HeadAggregate a -> HeadAggregate a -> Bool

(/=) :: HeadAggregate a -> HeadAggregate a -> Bool

Ord a => Ord (HeadAggregate a)

Methods

compare :: HeadAggregate a -> HeadAggregate a -> Ordering

(<) :: HeadAggregate a -> HeadAggregate a -> Bool

(<=) :: HeadAggregate a -> HeadAggregate a -> Bool

(>) :: HeadAggregate a -> HeadAggregate a -> Bool

(>=) :: HeadAggregate a -> HeadAggregate a -> Bool

max :: HeadAggregate a -> HeadAggregate a -> HeadAggregate a

min :: HeadAggregate a -> HeadAggregate a -> HeadAggregate a

Show a => Show (HeadAggregate a)

Methods

showsPrec :: Int -> HeadAggregate a -> ShowS

show :: HeadAggregate a -> String

showList :: [HeadAggregate a] -> ShowS

Pretty a => Pretty (HeadAggregate a)

Methods

pretty :: HeadAggregate a -> Doc

prettyList :: [HeadAggregate a] -> Doc

rawHeadAggregate :: HeadAggregate (Symbol s) -> IO AstHeadAggregate

freeHeadAggregate :: AstHeadAggregate -> IO ()

fromRawHeadAggregate :: AstHeadAggregate -> IO (HeadAggregate (Symbol s))

data Disjunction a

Constructors

Disjunction [ConditionalLiteral a]

Instances

Functor Disjunction

Methods

fmap :: (a -> b) -> Disjunction a -> Disjunction b

(<$) :: a -> Disjunction b -> Disjunction a

Foldable Disjunction

Methods

fold :: Monoid m => Disjunction m -> m

foldMap :: Monoid m => (a -> m) -> Disjunction a -> m

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

foldr' :: (a -> b -> b) -> b -> Disjunction a -> b

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

foldl' :: (b -> a -> b) -> b -> Disjunction a -> b

foldr1 :: (a -> a -> a) -> Disjunction a -> a

foldl1 :: (a -> a -> a) -> Disjunction a -> a

toList :: Disjunction a -> [a]

null :: Disjunction a -> Bool

length :: Disjunction a -> Int

elem :: Eq a => a -> Disjunction a -> Bool

maximum :: Ord a => Disjunction a -> a

minimum :: Ord a => Disjunction a -> a

sum :: Num a => Disjunction a -> a

product :: Num a => Disjunction a -> a

Traversable Disjunction

Methods

traverse :: Applicative f => (a -> f b) -> Disjunction a -> f (Disjunction b)

sequenceA :: Applicative f => Disjunction (f a) -> f (Disjunction a)

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

sequence :: Monad m => Disjunction (m a) -> m (Disjunction a)

Eq a => Eq (Disjunction a)

Methods

(==) :: Disjunction a -> Disjunction a -> Bool

(/=) :: Disjunction a -> Disjunction a -> Bool

Ord a => Ord (Disjunction a)

Methods

compare :: Disjunction a -> Disjunction a -> Ordering

(<) :: Disjunction a -> Disjunction a -> Bool

(<=) :: Disjunction a -> Disjunction a -> Bool

(>) :: Disjunction a -> Disjunction a -> Bool

(>=) :: Disjunction a -> Disjunction a -> Bool

max :: Disjunction a -> Disjunction a -> Disjunction a

min :: Disjunction a -> Disjunction a -> Disjunction a

Show a => Show (Disjunction a)

Methods

showsPrec :: Int -> Disjunction a -> ShowS

show :: Disjunction a -> String

showList :: [Disjunction a] -> ShowS

Pretty a => Pretty (Disjunction a)

Methods

pretty :: Disjunction a -> Doc

prettyList :: [Disjunction a] -> Doc

rawDisjunction :: Disjunction (Symbol s) -> IO AstDisjunction

freeDisjunction :: AstDisjunction -> IO ()

fromRawDisjunction :: AstDisjunction -> IO (Disjunction (Symbol s))

data DisjointElement a

Constructors

DisjointElement Location [Term a] (CspSumTerm a) [Literal a]

Instances

Functor DisjointElement

Methods

fmap :: (a -> b) -> DisjointElement a -> DisjointElement b

(<$) :: a -> DisjointElement b -> DisjointElement a

Foldable DisjointElement

Methods

fold :: Monoid m => DisjointElement m -> m

foldMap :: Monoid m => (a -> m) -> DisjointElement a -> m

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

foldr' :: (a -> b -> b) -> b -> DisjointElement a -> b

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

foldl' :: (b -> a -> b) -> b -> DisjointElement a -> b

foldr1 :: (a -> a -> a) -> DisjointElement a -> a

foldl1 :: (a -> a -> a) -> DisjointElement a -> a

toList :: DisjointElement a -> [a]

null :: DisjointElement a -> Bool

length :: DisjointElement a -> Int

elem :: Eq a => a -> DisjointElement a -> Bool

maximum :: Ord a => DisjointElement a -> a

minimum :: Ord a => DisjointElement a -> a

sum :: Num a => DisjointElement a -> a

product :: Num a => DisjointElement a -> a

Traversable DisjointElement

Methods

traverse :: Applicative f => (a -> f b) -> DisjointElement a -> f (DisjointElement b)

sequenceA :: Applicative f => DisjointElement (f a) -> f (DisjointElement a)

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

sequence :: Monad m => DisjointElement (m a) -> m (DisjointElement a)

Eq a => Eq (DisjointElement a)

Methods

(==) :: DisjointElement a -> DisjointElement a -> Bool

(/=) :: DisjointElement a -> DisjointElement a -> Bool

Ord a => Ord (DisjointElement a)

Methods

compare :: DisjointElement a -> DisjointElement a -> Ordering

(<) :: DisjointElement a -> DisjointElement a -> Bool

(<=) :: DisjointElement a -> DisjointElement a -> Bool

(>) :: DisjointElement a -> DisjointElement a -> Bool

(>=) :: DisjointElement a -> DisjointElement a -> Bool

max :: DisjointElement a -> DisjointElement a -> DisjointElement a

min :: DisjointElement a -> DisjointElement a -> DisjointElement a

Show a => Show (DisjointElement a)

Methods

showsPrec :: Int -> DisjointElement a -> ShowS

show :: DisjointElement a -> String

showList :: [DisjointElement a] -> ShowS

rawDisjointElement :: DisjointElement (Symbol s) -> IO AstDisjointElement

freeDisjointElement :: AstDisjointElement -> IO ()

fromRawDisjointElement :: AstDisjointElement -> IO (DisjointElement (Symbol s))

data Disjoint a

Constructors

Disjoint [DisjointElement a]

Instances

Functor Disjoint

Methods

fmap :: (a -> b) -> Disjoint a -> Disjoint b

(<$) :: a -> Disjoint b -> Disjoint a

Foldable Disjoint

Methods

fold :: Monoid m => Disjoint m -> m

foldMap :: Monoid m => (a -> m) -> Disjoint a -> m

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

foldr' :: (a -> b -> b) -> b -> Disjoint a -> b

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

foldl' :: (b -> a -> b) -> b -> Disjoint a -> b

foldr1 :: (a -> a -> a) -> Disjoint a -> a

foldl1 :: (a -> a -> a) -> Disjoint a -> a

toList :: Disjoint a -> [a]

null :: Disjoint a -> Bool

length :: Disjoint a -> Int

elem :: Eq a => a -> Disjoint a -> Bool

maximum :: Ord a => Disjoint a -> a

minimum :: Ord a => Disjoint a -> a

sum :: Num a => Disjoint a -> a

product :: Num a => Disjoint a -> a

Traversable Disjoint

Methods

traverse :: Applicative f => (a -> f b) -> Disjoint a -> f (Disjoint b)

sequenceA :: Applicative f => Disjoint (f a) -> f (Disjoint a)

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

sequence :: Monad m => Disjoint (m a) -> m (Disjoint a)

Eq a => Eq (Disjoint a)

Methods

(==) :: Disjoint a -> Disjoint a -> Bool

(/=) :: Disjoint a -> Disjoint a -> Bool

Ord a => Ord (Disjoint a)

Methods

compare :: Disjoint a -> Disjoint a -> Ordering

(<) :: Disjoint a -> Disjoint a -> Bool

(<=) :: Disjoint a -> Disjoint a -> Bool

(>) :: Disjoint a -> Disjoint a -> Bool

(>=) :: Disjoint a -> Disjoint a -> Bool

max :: Disjoint a -> Disjoint a -> Disjoint a

min :: Disjoint a -> Disjoint a -> Disjoint a

Show a => Show (Disjoint a)

Methods

showsPrec :: Int -> Disjoint a -> ShowS

show :: Disjoint a -> String

showList :: [Disjoint a] -> ShowS

rawDisjoint :: Disjoint (Symbol s) -> IO AstDisjoint

freeDisjoint :: AstDisjoint -> IO ()

fromRawDisjoint :: AstDisjoint -> IO (Disjoint (Symbol s))

data TheoryTermArray a

Constructors

TheoryTermArray [TheoryTerm a]

Instances

Functor TheoryTermArray

Methods

fmap :: (a -> b) -> TheoryTermArray a -> TheoryTermArray b

(<$) :: a -> TheoryTermArray b -> TheoryTermArray a

Foldable TheoryTermArray

Methods

fold :: Monoid m => TheoryTermArray m -> m

foldMap :: Monoid m => (a -> m) -> TheoryTermArray a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryTermArray a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryTermArray a -> b

foldr1 :: (a -> a -> a) -> TheoryTermArray a -> a

foldl1 :: (a -> a -> a) -> TheoryTermArray a -> a

toList :: TheoryTermArray a -> [a]

null :: TheoryTermArray a -> Bool

length :: TheoryTermArray a -> Int

elem :: Eq a => a -> TheoryTermArray a -> Bool

maximum :: Ord a => TheoryTermArray a -> a

minimum :: Ord a => TheoryTermArray a -> a

sum :: Num a => TheoryTermArray a -> a

product :: Num a => TheoryTermArray a -> a

Traversable TheoryTermArray

Methods

traverse :: Applicative f => (a -> f b) -> TheoryTermArray a -> f (TheoryTermArray b)

sequenceA :: Applicative f => TheoryTermArray (f a) -> f (TheoryTermArray a)

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

sequence :: Monad m => TheoryTermArray (m a) -> m (TheoryTermArray a)

Eq a => Eq (TheoryTermArray a)

Methods

(==) :: TheoryTermArray a -> TheoryTermArray a -> Bool

(/=) :: TheoryTermArray a -> TheoryTermArray a -> Bool

Ord a => Ord (TheoryTermArray a)

Methods

compare :: TheoryTermArray a -> TheoryTermArray a -> Ordering

(<) :: TheoryTermArray a -> TheoryTermArray a -> Bool

(<=) :: TheoryTermArray a -> TheoryTermArray a -> Bool

(>) :: TheoryTermArray a -> TheoryTermArray a -> Bool

(>=) :: TheoryTermArray a -> TheoryTermArray a -> Bool

max :: TheoryTermArray a -> TheoryTermArray a -> TheoryTermArray a

min :: TheoryTermArray a -> TheoryTermArray a -> TheoryTermArray a

Show a => Show (TheoryTermArray a)

Methods

showsPrec :: Int -> TheoryTermArray a -> ShowS

show :: TheoryTermArray a -> String

showList :: [TheoryTermArray a] -> ShowS

rawTheoryTermArray :: TheoryTermArray (Symbol s) -> IO AstTheoryTermArray

freeTheoryTermArray :: AstTheoryTermArray -> IO ()

fromRawTheoryTermArray :: AstTheoryTermArray -> IO (TheoryTermArray (Symbol s))

data TheoryFunction a

Constructors

TheoryFunction Text [TheoryTerm a]

Instances

Functor TheoryFunction

Methods

fmap :: (a -> b) -> TheoryFunction a -> TheoryFunction b

(<$) :: a -> TheoryFunction b -> TheoryFunction a

Foldable TheoryFunction

Methods

fold :: Monoid m => TheoryFunction m -> m

foldMap :: Monoid m => (a -> m) -> TheoryFunction a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryFunction a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryFunction a -> b

foldr1 :: (a -> a -> a) -> TheoryFunction a -> a

foldl1 :: (a -> a -> a) -> TheoryFunction a -> a

toList :: TheoryFunction a -> [a]

null :: TheoryFunction a -> Bool

length :: TheoryFunction a -> Int

elem :: Eq a => a -> TheoryFunction a -> Bool

maximum :: Ord a => TheoryFunction a -> a

minimum :: Ord a => TheoryFunction a -> a

sum :: Num a => TheoryFunction a -> a

product :: Num a => TheoryFunction a -> a

Traversable TheoryFunction

Methods

traverse :: Applicative f => (a -> f b) -> TheoryFunction a -> f (TheoryFunction b)

sequenceA :: Applicative f => TheoryFunction (f a) -> f (TheoryFunction a)

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

sequence :: Monad m => TheoryFunction (m a) -> m (TheoryFunction a)

Eq a => Eq (TheoryFunction a)

Methods

(==) :: TheoryFunction a -> TheoryFunction a -> Bool

(/=) :: TheoryFunction a -> TheoryFunction a -> Bool

Ord a => Ord (TheoryFunction a)

Methods

compare :: TheoryFunction a -> TheoryFunction a -> Ordering

(<) :: TheoryFunction a -> TheoryFunction a -> Bool

(<=) :: TheoryFunction a -> TheoryFunction a -> Bool

(>) :: TheoryFunction a -> TheoryFunction a -> Bool

(>=) :: TheoryFunction a -> TheoryFunction a -> Bool

max :: TheoryFunction a -> TheoryFunction a -> TheoryFunction a

min :: TheoryFunction a -> TheoryFunction a -> TheoryFunction a

Show a => Show (TheoryFunction a)

Methods

showsPrec :: Int -> TheoryFunction a -> ShowS

show :: TheoryFunction a -> String

showList :: [TheoryFunction a] -> ShowS

rawTheoryFunction :: TheoryFunction (Symbol s) -> IO AstTheoryFunction

freeTheoryFunction :: AstTheoryFunction -> IO ()

fromRawTheoryFunction :: AstTheoryFunction -> IO (TheoryFunction (Symbol s))

data TheoryUnparsedTermElement a

Constructors

TheoryUnparsedTermElement [Text] (TheoryTerm a)

Instances

Functor TheoryUnparsedTermElement

Methods

fmap :: (a -> b) -> TheoryUnparsedTermElement a -> TheoryUnparsedTermElement b

(<$) :: a -> TheoryUnparsedTermElement b -> TheoryUnparsedTermElement a

Foldable TheoryUnparsedTermElement

Methods

fold :: Monoid m => TheoryUnparsedTermElement m -> m

foldMap :: Monoid m => (a -> m) -> TheoryUnparsedTermElement a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryUnparsedTermElement a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryUnparsedTermElement a -> b

foldr1 :: (a -> a -> a) -> TheoryUnparsedTermElement a -> a

foldl1 :: (a -> a -> a) -> TheoryUnparsedTermElement a -> a

toList :: TheoryUnparsedTermElement a -> [a]

null :: TheoryUnparsedTermElement a -> Bool

length :: TheoryUnparsedTermElement a -> Int

elem :: Eq a => a -> TheoryUnparsedTermElement a -> Bool

maximum :: Ord a => TheoryUnparsedTermElement a -> a

minimum :: Ord a => TheoryUnparsedTermElement a -> a

sum :: Num a => TheoryUnparsedTermElement a -> a

product :: Num a => TheoryUnparsedTermElement a -> a

Traversable TheoryUnparsedTermElement

Methods

traverse :: Applicative f => (a -> f b) -> TheoryUnparsedTermElement a -> f (TheoryUnparsedTermElement b)

sequenceA :: Applicative f => TheoryUnparsedTermElement (f a) -> f (TheoryUnparsedTermElement a)

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

sequence :: Monad m => TheoryUnparsedTermElement (m a) -> m (TheoryUnparsedTermElement a)

Eq a => Eq (TheoryUnparsedTermElement a)

Methods

(==) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

(/=) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

Ord a => Ord (TheoryUnparsedTermElement a)

Methods

compare :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Ordering

(<) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

(<=) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

(>) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

(>=) :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> Bool

max :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a

min :: TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a -> TheoryUnparsedTermElement a

Show a => Show (TheoryUnparsedTermElement a)

Methods

showsPrec :: Int -> TheoryUnparsedTermElement a -> ShowS

show :: TheoryUnparsedTermElement a -> String

showList :: [TheoryUnparsedTermElement a] -> ShowS

rawTheoryUnparsedTermElement :: TheoryUnparsedTermElement (Symbol s) -> IO AstTheoryUnparsedTermElement

freeTheoryUnparsedTermElement :: AstTheoryUnparsedTermElement -> IO ()

fromRawTheoryUnparsedTermElement :: AstTheoryUnparsedTermElement -> IO (TheoryUnparsedTermElement (Symbol s))

data TheoryUnparsedTerm a

Constructors

TheoryUnparsedTerm [TheoryUnparsedTermElement a]

Instances

Functor TheoryUnparsedTerm

Methods

fmap :: (a -> b) -> TheoryUnparsedTerm a -> TheoryUnparsedTerm b

(<$) :: a -> TheoryUnparsedTerm b -> TheoryUnparsedTerm a

Foldable TheoryUnparsedTerm

Methods

fold :: Monoid m => TheoryUnparsedTerm m -> m

foldMap :: Monoid m => (a -> m) -> TheoryUnparsedTerm a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryUnparsedTerm a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryUnparsedTerm a -> b

foldr1 :: (a -> a -> a) -> TheoryUnparsedTerm a -> a

foldl1 :: (a -> a -> a) -> TheoryUnparsedTerm a -> a

toList :: TheoryUnparsedTerm a -> [a]

null :: TheoryUnparsedTerm a -> Bool

length :: TheoryUnparsedTerm a -> Int

elem :: Eq a => a -> TheoryUnparsedTerm a -> Bool

maximum :: Ord a => TheoryUnparsedTerm a -> a

minimum :: Ord a => TheoryUnparsedTerm a -> a

sum :: Num a => TheoryUnparsedTerm a -> a

product :: Num a => TheoryUnparsedTerm a -> a

Traversable TheoryUnparsedTerm

Methods

traverse :: Applicative f => (a -> f b) -> TheoryUnparsedTerm a -> f (TheoryUnparsedTerm b)

sequenceA :: Applicative f => TheoryUnparsedTerm (f a) -> f (TheoryUnparsedTerm a)

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

sequence :: Monad m => TheoryUnparsedTerm (m a) -> m (TheoryUnparsedTerm a)

Eq a => Eq (TheoryUnparsedTerm a)

Methods

(==) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

(/=) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

Ord a => Ord (TheoryUnparsedTerm a)

Methods

compare :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Ordering

(<) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

(<=) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

(>) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

(>=) :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> Bool

max :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> TheoryUnparsedTerm a

min :: TheoryUnparsedTerm a -> TheoryUnparsedTerm a -> TheoryUnparsedTerm a

Show a => Show (TheoryUnparsedTerm a)

Methods

showsPrec :: Int -> TheoryUnparsedTerm a -> ShowS

show :: TheoryUnparsedTerm a -> String

showList :: [TheoryUnparsedTerm a] -> ShowS

rawTheoryUnparsedTerm :: TheoryUnparsedTerm (Symbol s) -> IO AstTheoryUnparsedTerm

freeTheoryUnparsedTerm :: AstTheoryUnparsedTerm -> IO ()

fromRawTheoryUnparsedTerm :: AstTheoryUnparsedTerm -> IO (TheoryUnparsedTerm (Symbol s))

data TheoryTerm a

Constructors

TheoryTermSymbol Location a

TheoryTermVariable Location Text

TheoryTermTuple Location (TheoryTermArray a)

TheoryTermList Location (TheoryTermArray a)

TheoryTermSet Location (TheoryTermArray a)

TheoryTermFunction Location (TheoryFunction a)

TheoryTermUnparsed Location (TheoryUnparsedTerm a)

Instances

Functor TheoryTerm

Methods

fmap :: (a -> b) -> TheoryTerm a -> TheoryTerm b

(<$) :: a -> TheoryTerm b -> TheoryTerm a

Foldable TheoryTerm

Methods

fold :: Monoid m => TheoryTerm m -> m

foldMap :: Monoid m => (a -> m) -> TheoryTerm a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryTerm a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryTerm a -> b

foldr1 :: (a -> a -> a) -> TheoryTerm a -> a

foldl1 :: (a -> a -> a) -> TheoryTerm a -> a

toList :: TheoryTerm a -> [a]

null :: TheoryTerm a -> Bool

length :: TheoryTerm a -> Int

elem :: Eq a => a -> TheoryTerm a -> Bool

maximum :: Ord a => TheoryTerm a -> a

minimum :: Ord a => TheoryTerm a -> a

sum :: Num a => TheoryTerm a -> a

product :: Num a => TheoryTerm a -> a

Traversable TheoryTerm

Methods

traverse :: Applicative f => (a -> f b) -> TheoryTerm a -> f (TheoryTerm b)

sequenceA :: Applicative f => TheoryTerm (f a) -> f (TheoryTerm a)

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

sequence :: Monad m => TheoryTerm (m a) -> m (TheoryTerm a)

Eq a => Eq (TheoryTerm a)

Methods

(==) :: TheoryTerm a -> TheoryTerm a -> Bool

(/=) :: TheoryTerm a -> TheoryTerm a -> Bool

Ord a => Ord (TheoryTerm a)

Methods

compare :: TheoryTerm a -> TheoryTerm a -> Ordering

(<) :: TheoryTerm a -> TheoryTerm a -> Bool

(<=) :: TheoryTerm a -> TheoryTerm a -> Bool

(>) :: TheoryTerm a -> TheoryTerm a -> Bool

(>=) :: TheoryTerm a -> TheoryTerm a -> Bool

max :: TheoryTerm a -> TheoryTerm a -> TheoryTerm a

min :: TheoryTerm a -> TheoryTerm a -> TheoryTerm a

Show a => Show (TheoryTerm a)

Methods

showsPrec :: Int -> TheoryTerm a -> ShowS

show :: TheoryTerm a -> String

showList :: [TheoryTerm a] -> ShowS

rawTheoryTerm :: TheoryTerm (Symbol s) -> IO AstTheoryTerm

freeTheoryTerm :: AstTheoryTerm -> IO ()

fromRawTheoryTerm :: AstTheoryTerm -> IO (TheoryTerm (Symbol s))

data TheoryAtomElement a

Constructors

TheoryAtomElement [TheoryTerm a] [Literal a]

Instances

Functor TheoryAtomElement

Methods

fmap :: (a -> b) -> TheoryAtomElement a -> TheoryAtomElement b

(<$) :: a -> TheoryAtomElement b -> TheoryAtomElement a

Foldable TheoryAtomElement

Methods

fold :: Monoid m => TheoryAtomElement m -> m

foldMap :: Monoid m => (a -> m) -> TheoryAtomElement a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryAtomElement a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryAtomElement a -> b

foldr1 :: (a -> a -> a) -> TheoryAtomElement a -> a

foldl1 :: (a -> a -> a) -> TheoryAtomElement a -> a

toList :: TheoryAtomElement a -> [a]

null :: TheoryAtomElement a -> Bool

length :: TheoryAtomElement a -> Int

elem :: Eq a => a -> TheoryAtomElement a -> Bool

maximum :: Ord a => TheoryAtomElement a -> a

minimum :: Ord a => TheoryAtomElement a -> a

sum :: Num a => TheoryAtomElement a -> a

product :: Num a => TheoryAtomElement a -> a

Traversable TheoryAtomElement

Methods

traverse :: Applicative f => (a -> f b) -> TheoryAtomElement a -> f (TheoryAtomElement b)

sequenceA :: Applicative f => TheoryAtomElement (f a) -> f (TheoryAtomElement a)

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

sequence :: Monad m => TheoryAtomElement (m a) -> m (TheoryAtomElement a)

Eq a => Eq (TheoryAtomElement a)

Methods

(==) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

(/=) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

Ord a => Ord (TheoryAtomElement a)

Methods

compare :: TheoryAtomElement a -> TheoryAtomElement a -> Ordering

(<) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

(<=) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

(>) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

(>=) :: TheoryAtomElement a -> TheoryAtomElement a -> Bool

max :: TheoryAtomElement a -> TheoryAtomElement a -> TheoryAtomElement a

min :: TheoryAtomElement a -> TheoryAtomElement a -> TheoryAtomElement a

Show a => Show (TheoryAtomElement a)

Methods

showsPrec :: Int -> TheoryAtomElement a -> ShowS

show :: TheoryAtomElement a -> String

showList :: [TheoryAtomElement a] -> ShowS

rawTheoryAtomElement :: TheoryAtomElement (Symbol s) -> IO AstTheoryAtomElement

freeTheoryAtomElement :: AstTheoryAtomElement -> IO ()

fromRawTheoryAtomElement :: AstTheoryAtomElement -> IO (TheoryAtomElement (Symbol s))

data TheoryGuard a

Constructors

TheoryGuard Text (TheoryTerm a)

Instances

Functor TheoryGuard

Methods

fmap :: (a -> b) -> TheoryGuard a -> TheoryGuard b

(<$) :: a -> TheoryGuard b -> TheoryGuard a

Foldable TheoryGuard

Methods

fold :: Monoid m => TheoryGuard m -> m

foldMap :: Monoid m => (a -> m) -> TheoryGuard a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryGuard a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryGuard a -> b

foldr1 :: (a -> a -> a) -> TheoryGuard a -> a

foldl1 :: (a -> a -> a) -> TheoryGuard a -> a

toList :: TheoryGuard a -> [a]

null :: TheoryGuard a -> Bool

length :: TheoryGuard a -> Int

elem :: Eq a => a -> TheoryGuard a -> Bool

maximum :: Ord a => TheoryGuard a -> a

minimum :: Ord a => TheoryGuard a -> a

sum :: Num a => TheoryGuard a -> a

product :: Num a => TheoryGuard a -> a

Traversable TheoryGuard

Methods

traverse :: Applicative f => (a -> f b) -> TheoryGuard a -> f (TheoryGuard b)

sequenceA :: Applicative f => TheoryGuard (f a) -> f (TheoryGuard a)

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

sequence :: Monad m => TheoryGuard (m a) -> m (TheoryGuard a)

Eq a => Eq (TheoryGuard a)

Methods

(==) :: TheoryGuard a -> TheoryGuard a -> Bool

(/=) :: TheoryGuard a -> TheoryGuard a -> Bool

Ord a => Ord (TheoryGuard a)

Methods

compare :: TheoryGuard a -> TheoryGuard a -> Ordering

(<) :: TheoryGuard a -> TheoryGuard a -> Bool

(<=) :: TheoryGuard a -> TheoryGuard a -> Bool

(>) :: TheoryGuard a -> TheoryGuard a -> Bool

(>=) :: TheoryGuard a -> TheoryGuard a -> Bool

max :: TheoryGuard a -> TheoryGuard a -> TheoryGuard a

min :: TheoryGuard a -> TheoryGuard a -> TheoryGuard a

Show a => Show (TheoryGuard a)

Methods

showsPrec :: Int -> TheoryGuard a -> ShowS

show :: TheoryGuard a -> String

showList :: [TheoryGuard a] -> ShowS

rawTheoryGuard :: TheoryGuard (Symbol s) -> IO AstTheoryGuard

freeTheoryGuard :: AstTheoryGuard -> IO ()

fromRawTheoryGuard :: AstTheoryGuard -> IO (TheoryGuard (Symbol s))

data TheoryAtom a

Constructors

TheoryAtom (Term a) [TheoryAtomElement a] (TheoryGuard a)

Instances

Functor TheoryAtom

Methods

fmap :: (a -> b) -> TheoryAtom a -> TheoryAtom b

(<$) :: a -> TheoryAtom b -> TheoryAtom a

Foldable TheoryAtom

Methods

fold :: Monoid m => TheoryAtom m -> m

foldMap :: Monoid m => (a -> m) -> TheoryAtom a -> m

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

foldr' :: (a -> b -> b) -> b -> TheoryAtom a -> b

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

foldl' :: (b -> a -> b) -> b -> TheoryAtom a -> b

foldr1 :: (a -> a -> a) -> TheoryAtom a -> a

foldl1 :: (a -> a -> a) -> TheoryAtom a -> a

toList :: TheoryAtom a -> [a]

null :: TheoryAtom a -> Bool

length :: TheoryAtom a -> Int

elem :: Eq a => a -> TheoryAtom a -> Bool

maximum :: Ord a => TheoryAtom a -> a

minimum :: Ord a => TheoryAtom a -> a

sum :: Num a => TheoryAtom a -> a

product :: Num a => TheoryAtom a -> a

Traversable TheoryAtom

Methods

traverse :: Applicative f => (a -> f b) -> TheoryAtom a -> f (TheoryAtom b)

sequenceA :: Applicative f => TheoryAtom (f a) -> f (TheoryAtom a)

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

sequence :: Monad m => TheoryAtom (m a) -> m (TheoryAtom a)

Eq a => Eq (TheoryAtom a)

Methods

(==) :: TheoryAtom a -> TheoryAtom a -> Bool

(/=) :: TheoryAtom a -> TheoryAtom a -> Bool

Ord a => Ord (TheoryAtom a)

Methods

compare :: TheoryAtom a -> TheoryAtom a -> Ordering

(<) :: TheoryAtom a -> TheoryAtom a -> Bool

(<=) :: TheoryAtom a -> TheoryAtom a -> Bool

(>) :: TheoryAtom a -> TheoryAtom a -> Bool

(>=) :: TheoryAtom a -> TheoryAtom a -> Bool

max :: TheoryAtom a -> TheoryAtom a -> TheoryAtom a

min :: TheoryAtom a -> TheoryAtom a -> TheoryAtom a

Show a => Show (TheoryAtom a)

Methods

showsPrec :: Int -> TheoryAtom a -> ShowS

show :: TheoryAtom a -> String

showList :: [TheoryAtom a] -> ShowS

rawTheoryAtom :: TheoryAtom (Symbol s) -> IO AstTheoryAtom

freeTheoryAtom :: AstTheoryAtom -> IO ()

fromRawTheoryAtom :: AstTheoryAtom -> IO (TheoryAtom (Symbol s))

data HeadLiteral a

Constructors

HeadLiteral Location (Literal a)

HeadDisjunction Location (Disjunction a)

HeadLitAggregate Location (Aggregate a)

HeadHeadAggregate Location (HeadAggregate a)

HeadTheoryAtom Location (TheoryAtom a)

Instances

Functor HeadLiteral

Methods

fmap :: (a -> b) -> HeadLiteral a -> HeadLiteral b

(<$) :: a -> HeadLiteral b -> HeadLiteral a

Foldable HeadLiteral

Methods

fold :: Monoid m => HeadLiteral m -> m

foldMap :: Monoid m => (a -> m) -> HeadLiteral a -> m

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

foldr' :: (a -> b -> b) -> b -> HeadLiteral a -> b

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

foldl' :: (b -> a -> b) -> b -> HeadLiteral a -> b

foldr1 :: (a -> a -> a) -> HeadLiteral a -> a

foldl1 :: (a -> a -> a) -> HeadLiteral a -> a

toList :: HeadLiteral a -> [a]

null :: HeadLiteral a -> Bool

length :: HeadLiteral a -> Int

elem :: Eq a => a -> HeadLiteral a -> Bool

maximum :: Ord a => HeadLiteral a -> a

minimum :: Ord a => HeadLiteral a -> a

sum :: Num a => HeadLiteral a -> a

product :: Num a => HeadLiteral a -> a

Traversable HeadLiteral

Methods

traverse :: Applicative f => (a -> f b) -> HeadLiteral a -> f (HeadLiteral b)

sequenceA :: Applicative f => HeadLiteral (f a) -> f (HeadLiteral a)

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

sequence :: Monad m => HeadLiteral (m a) -> m (HeadLiteral a)

Eq a => Eq (HeadLiteral a)

Methods

(==) :: HeadLiteral a -> HeadLiteral a -> Bool

(/=) :: HeadLiteral a -> HeadLiteral a -> Bool

Ord a => Ord (HeadLiteral a)

Methods

compare :: HeadLiteral a -> HeadLiteral a -> Ordering

(<) :: HeadLiteral a -> HeadLiteral a -> Bool

(<=) :: HeadLiteral a -> HeadLiteral a -> Bool

(>) :: HeadLiteral a -> HeadLiteral a -> Bool

(>=) :: HeadLiteral a -> HeadLiteral a -> Bool

max :: HeadLiteral a -> HeadLiteral a -> HeadLiteral a

min :: HeadLiteral a -> HeadLiteral a -> HeadLiteral a

Show a => Show (HeadLiteral a)

Methods

showsPrec :: Int -> HeadLiteral a -> ShowS

show :: HeadLiteral a -> String

showList :: [HeadLiteral a] -> ShowS

Pretty a => Pretty (HeadLiteral a)

Methods

pretty :: HeadLiteral a -> Doc

prettyList :: [HeadLiteral a] -> Doc

rawHeadLiteral :: HeadLiteral (Symbol s) -> IO AstHeadLiteral

freeHeadLiteral :: AstHeadLiteral -> IO ()

fromRawHeadLiteral :: AstHeadLiteral -> IO (HeadLiteral (Symbol s))

data BodyLiteral a

Constructors

BodyLiteral Location Sign (Literal a)

BodyConditional Location (ConditionalLiteral a)

BodyLitAggregate Location Sign (Aggregate a)

BodyBodyAggregate Location Sign (BodyAggregate a)

BodyTheoryAtom Location Sign (TheoryAtom a)

BodyDisjoint Location Sign (Disjoint a)

Instances

Functor BodyLiteral

Methods

fmap :: (a -> b) -> BodyLiteral a -> BodyLiteral b

(<$) :: a -> BodyLiteral b -> BodyLiteral a

Foldable BodyLiteral

Methods

fold :: Monoid m => BodyLiteral m -> m

foldMap :: Monoid m => (a -> m) -> BodyLiteral a -> m

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

foldr' :: (a -> b -> b) -> b -> BodyLiteral a -> b

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

foldl' :: (b -> a -> b) -> b -> BodyLiteral a -> b

foldr1 :: (a -> a -> a) -> BodyLiteral a -> a

foldl1 :: (a -> a -> a) -> BodyLiteral a -> a

toList :: BodyLiteral a -> [a]

null :: BodyLiteral a -> Bool

length :: BodyLiteral a -> Int

elem :: Eq a => a -> BodyLiteral a -> Bool

maximum :: Ord a => BodyLiteral a -> a

minimum :: Ord a => BodyLiteral a -> a

sum :: Num a => BodyLiteral a -> a

product :: Num a => BodyLiteral a -> a

Traversable BodyLiteral

Methods

traverse :: Applicative f => (a -> f b) -> BodyLiteral a -> f (BodyLiteral b)

sequenceA :: Applicative f => BodyLiteral (f a) -> f (BodyLiteral a)

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

sequence :: Monad m => BodyLiteral (m a) -> m (BodyLiteral a)

Eq a => Eq (BodyLiteral a)

Methods

(==) :: BodyLiteral a -> BodyLiteral a -> Bool

(/=) :: BodyLiteral a -> BodyLiteral a -> Bool

Ord a => Ord (BodyLiteral a)

Methods

compare :: BodyLiteral a -> BodyLiteral a -> Ordering

(<) :: BodyLiteral a -> BodyLiteral a -> Bool

(<=) :: BodyLiteral a -> BodyLiteral a -> Bool

(>) :: BodyLiteral a -> BodyLiteral a -> Bool

(>=) :: BodyLiteral a -> BodyLiteral a -> Bool

max :: BodyLiteral a -> BodyLiteral a -> BodyLiteral a

min :: BodyLiteral a -> BodyLiteral a -> BodyLiteral a

Show a => Show (BodyLiteral a)

Methods

showsPrec :: Int -> BodyLiteral a -> ShowS

show :: BodyLiteral a -> String

showList :: [BodyLiteral a] -> ShowS

Pretty a => Pretty (BodyLiteral a)

Methods

pretty :: BodyLiteral a -> Doc

prettyList :: [BodyLiteral a] -> Doc

rawBodyLiteral :: BodyLiteral (Symbol s) -> IO AstBodyLiteral

freeBodyLiteral :: AstBodyLiteral -> IO ()

fromRawBodyLiteral :: AstBodyLiteral -> IO (BodyLiteral (Symbol s))

data TheoryOperatorDefinition

Constructors

TheoryOperatorDefinition Location Text Natural TheoryOperatorType

Instances

Eq TheoryOperatorDefinition

Methods

(==) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

(/=) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

Ord TheoryOperatorDefinition

Methods

compare :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Ordering

(<) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

(<=) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

(>) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

(>=) :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> Bool

max :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> TheoryOperatorDefinition

min :: TheoryOperatorDefinition -> TheoryOperatorDefinition -> TheoryOperatorDefinition

Show TheoryOperatorDefinition

Methods

showsPrec :: Int -> TheoryOperatorDefinition -> ShowS

show :: TheoryOperatorDefinition -> String

showList :: [TheoryOperatorDefinition] -> ShowS

rawTheoryOperatorDefinition :: TheoryOperatorDefinition -> IO AstTheoryOperatorDefinition

freeTheoryOperatorDefinition :: AstTheoryOperatorDefinition -> IO ()

fromRawTheoryOperatorDefinition :: AstTheoryOperatorDefinition -> IO TheoryOperatorDefinition

data TheoryOperatorType

Constructors

Unary

BinLeft

BinRight

Instances

Eq TheoryOperatorType

Methods

(==) :: TheoryOperatorType -> TheoryOperatorType -> Bool

(/=) :: TheoryOperatorType -> TheoryOperatorType -> Bool

Ord TheoryOperatorType

Methods

compare :: TheoryOperatorType -> TheoryOperatorType -> Ordering

(<) :: TheoryOperatorType -> TheoryOperatorType -> Bool

(<=) :: TheoryOperatorType -> TheoryOperatorType -> Bool

(>) :: TheoryOperatorType -> TheoryOperatorType -> Bool

(>=) :: TheoryOperatorType -> TheoryOperatorType -> Bool

max :: TheoryOperatorType -> TheoryOperatorType -> TheoryOperatorType

min :: TheoryOperatorType -> TheoryOperatorType -> TheoryOperatorType

Show TheoryOperatorType

Methods

showsPrec :: Int -> TheoryOperatorType -> ShowS

show :: TheoryOperatorType -> String

showList :: [TheoryOperatorType] -> ShowS

rawTheoryOperatorType :: TheoryOperatorType -> AstTheoryOperatorType

fromRawTheoryOperatorType :: AstTheoryOperatorType -> TheoryOperatorType

data TheoryTermDefinition

Constructors

TheoryTermDefinition Location Text [TheoryOperatorDefinition]

Instances

Eq TheoryTermDefinition

Methods

(==) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

(/=) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

Ord TheoryTermDefinition

Methods

compare :: TheoryTermDefinition -> TheoryTermDefinition -> Ordering

(<) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

(<=) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

(>) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

(>=) :: TheoryTermDefinition -> TheoryTermDefinition -> Bool

max :: TheoryTermDefinition -> TheoryTermDefinition -> TheoryTermDefinition

min :: TheoryTermDefinition -> TheoryTermDefinition -> TheoryTermDefinition

Show TheoryTermDefinition

Methods

showsPrec :: Int -> TheoryTermDefinition -> ShowS

show :: TheoryTermDefinition -> String

showList :: [TheoryTermDefinition] -> ShowS

rawTheoryTermDefinition :: TheoryTermDefinition -> IO AstTheoryTermDefinition

freeTheoryTermDefinition :: AstTheoryTermDefinition -> IO ()

fromRawTheoryTermDefinition :: AstTheoryTermDefinition -> IO TheoryTermDefinition

data TheoryGuardDefinition

Constructors

TheoryGuardDefinition Text [Text]

Instances

Eq TheoryGuardDefinition

Methods

(==) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

(/=) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

Ord TheoryGuardDefinition

Methods

compare :: TheoryGuardDefinition -> TheoryGuardDefinition -> Ordering

(<) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

(<=) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

(>) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

(>=) :: TheoryGuardDefinition -> TheoryGuardDefinition -> Bool

max :: TheoryGuardDefinition -> TheoryGuardDefinition -> TheoryGuardDefinition

min :: TheoryGuardDefinition -> TheoryGuardDefinition -> TheoryGuardDefinition

Show TheoryGuardDefinition

Methods

showsPrec :: Int -> TheoryGuardDefinition -> ShowS

show :: TheoryGuardDefinition -> String

showList :: [TheoryGuardDefinition] -> ShowS

rawTheoryGuardDefinition :: TheoryGuardDefinition -> IO AstTheoryGuardDefinition

freeTheoryGuardDefinition :: AstTheoryGuardDefinition -> IO ()

fromRawTheoryGuardDefinition :: AstTheoryGuardDefinition -> IO TheoryGuardDefinition

data TheoryAtomDefinition

Constructors

TheoryAtomDefinition Location TheoryAtomDefinitionType Text Int Text TheoryGuardDefinition

Instances

Eq TheoryAtomDefinition

Methods

(==) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

(/=) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

Ord TheoryAtomDefinition

Methods

compare :: TheoryAtomDefinition -> TheoryAtomDefinition -> Ordering

(<) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

(<=) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

(>) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

(>=) :: TheoryAtomDefinition -> TheoryAtomDefinition -> Bool

max :: TheoryAtomDefinition -> TheoryAtomDefinition -> TheoryAtomDefinition

min :: TheoryAtomDefinition -> TheoryAtomDefinition -> TheoryAtomDefinition

Show TheoryAtomDefinition

Methods

showsPrec :: Int -> TheoryAtomDefinition -> ShowS

show :: TheoryAtomDefinition -> String

showList :: [TheoryAtomDefinition] -> ShowS

rawTheoryAtomDefinition :: TheoryAtomDefinition -> IO AstTheoryAtomDefinition

freeTheoryAtomDefinition :: AstTheoryAtomDefinition -> IO ()

fromRawTheoryAtomDefinition :: AstTheoryAtomDefinition -> IO TheoryAtomDefinition

data TheoryAtomDefinitionType

Constructors

Head

Body

Any

Directive

Instances

Eq TheoryAtomDefinitionType

Methods

(==) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

(/=) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

Ord TheoryAtomDefinitionType

Methods

compare :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Ordering

(<) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

(<=) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

(>) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

(>=) :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> Bool

max :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> TheoryAtomDefinitionType

min :: TheoryAtomDefinitionType -> TheoryAtomDefinitionType -> TheoryAtomDefinitionType

Show TheoryAtomDefinitionType

Methods

showsPrec :: Int -> TheoryAtomDefinitionType -> ShowS

show :: TheoryAtomDefinitionType -> String

showList :: [TheoryAtomDefinitionType] -> ShowS

rawTheoryAtomDefinitionType :: TheoryAtomDefinitionType -> AstTheoryAtomDefType

fromRawTheoryAtomDefinitionType :: AstTheoryAtomDefType -> TheoryAtomDefinitionType

data TheoryDefinition

Constructors

TheoryDefinition Text [TheoryTermDefinition] [TheoryAtomDefinition]

Instances

Eq TheoryDefinition

Methods

(==) :: TheoryDefinition -> TheoryDefinition -> Bool

(/=) :: TheoryDefinition -> TheoryDefinition -> Bool

Ord TheoryDefinition

Methods

compare :: TheoryDefinition -> TheoryDefinition -> Ordering

(<) :: TheoryDefinition -> TheoryDefinition -> Bool

(<=) :: TheoryDefinition -> TheoryDefinition -> Bool

(>) :: TheoryDefinition -> TheoryDefinition -> Bool

(>=) :: TheoryDefinition -> TheoryDefinition -> Bool

max :: TheoryDefinition -> TheoryDefinition -> TheoryDefinition

min :: TheoryDefinition -> TheoryDefinition -> TheoryDefinition

Show TheoryDefinition

Methods

showsPrec :: Int -> TheoryDefinition -> ShowS

show :: TheoryDefinition -> String

showList :: [TheoryDefinition] -> ShowS

rawTheoryDefinition :: TheoryDefinition -> IO AstTheoryDefinition

freeTheoryDefinition :: AstTheoryDefinition -> IO ()

fromRawTheoryDefinition :: AstTheoryDefinition -> IO TheoryDefinition

data Rule a

Constructors

Rule (HeadLiteral a) [BodyLiteral a]

Instances

Functor Rule

Methods

fmap :: (a -> b) -> Rule a -> Rule b

(<$) :: a -> Rule b -> Rule a

Foldable Rule

Methods

fold :: Monoid m => Rule m -> m

foldMap :: Monoid m => (a -> m) -> Rule a -> m

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

foldr' :: (a -> b -> b) -> b -> Rule a -> b

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

foldl' :: (b -> a -> b) -> b -> Rule a -> b

foldr1 :: (a -> a -> a) -> Rule a -> a

foldl1 :: (a -> a -> a) -> Rule a -> a

toList :: Rule a -> [a]

null :: Rule a -> Bool

length :: Rule a -> Int

elem :: Eq a => a -> Rule a -> Bool

maximum :: Ord a => Rule a -> a

minimum :: Ord a => Rule a -> a

sum :: Num a => Rule a -> a

product :: Num a => Rule a -> a

Traversable Rule

Methods

traverse :: Applicative f => (a -> f b) -> Rule a -> f (Rule b)

sequenceA :: Applicative f => Rule (f a) -> f (Rule a)

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

sequence :: Monad m => Rule (m a) -> m (Rule a)

Eq a => Eq (Rule a)

Methods

(==) :: Rule a -> Rule a -> Bool

(/=) :: Rule a -> Rule a -> Bool

Ord a => Ord (Rule a)

Methods

compare :: Rule a -> Rule a -> Ordering

(<) :: Rule a -> Rule a -> Bool

(<=) :: Rule a -> Rule a -> Bool

(>) :: Rule a -> Rule a -> Bool

(>=) :: Rule a -> Rule a -> Bool

max :: Rule a -> Rule a -> Rule a

min :: Rule a -> Rule a -> Rule a

Show a => Show (Rule a)

Methods

showsPrec :: Int -> Rule a -> ShowS

show :: Rule a -> String

showList :: [Rule a] -> ShowS

Pretty a => Pretty (Rule a)

Methods

pretty :: Rule a -> Doc

prettyList :: [Rule a] -> Doc

rawRule :: Rule (Symbol s) -> IO AstRule

freeRule :: AstRule -> IO ()

fromRawRule :: AstRule -> IO (Rule (Symbol s))

data Definition a

Constructors

Definition Text (Term a) Bool

Instances

Functor Definition

Methods

fmap :: (a -> b) -> Definition a -> Definition b

(<$) :: a -> Definition b -> Definition a

Foldable Definition

Methods

fold :: Monoid m => Definition m -> m

foldMap :: Monoid m => (a -> m) -> Definition a -> m

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

foldr' :: (a -> b -> b) -> b -> Definition a -> b

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

foldl' :: (b -> a -> b) -> b -> Definition a -> b

foldr1 :: (a -> a -> a) -> Definition a -> a

foldl1 :: (a -> a -> a) -> Definition a -> a

toList :: Definition a -> [a]

null :: Definition a -> Bool

length :: Definition a -> Int

elem :: Eq a => a -> Definition a -> Bool

maximum :: Ord a => Definition a -> a

minimum :: Ord a => Definition a -> a

sum :: Num a => Definition a -> a

product :: Num a => Definition a -> a

Traversable Definition

Methods

traverse :: Applicative f => (a -> f b) -> Definition a -> f (Definition b)

sequenceA :: Applicative f => Definition (f a) -> f (Definition a)

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

sequence :: Monad m => Definition (m a) -> m (Definition a)

Eq a => Eq (Definition a)

Methods

(==) :: Definition a -> Definition a -> Bool

(/=) :: Definition a -> Definition a -> Bool

Ord a => Ord (Definition a)

Methods

compare :: Definition a -> Definition a -> Ordering

(<) :: Definition a -> Definition a -> Bool

(<=) :: Definition a -> Definition a -> Bool

(>) :: Definition a -> Definition a -> Bool

(>=) :: Definition a -> Definition a -> Bool

max :: Definition a -> Definition a -> Definition a

min :: Definition a -> Definition a -> Definition a

Show a => Show (Definition a)

Methods

showsPrec :: Int -> Definition a -> ShowS

show :: Definition a -> String

showList :: [Definition a] -> ShowS

rawDefinition :: Definition (Symbol s) -> IO AstDefinition

freeDefinition :: AstDefinition -> IO ()

fromRawDefinition :: AstDefinition -> IO (Definition (Symbol s))

data ShowSignature b

Constructors

ShowSignature b Bool

Instances

Functor ShowSignature

Methods

fmap :: (a -> b) -> ShowSignature a -> ShowSignature b

(<$) :: a -> ShowSignature b -> ShowSignature a

Foldable ShowSignature

Methods

fold :: Monoid m => ShowSignature m -> m

foldMap :: Monoid m => (a -> m) -> ShowSignature a -> m

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

foldr' :: (a -> b -> b) -> b -> ShowSignature a -> b

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

foldl' :: (b -> a -> b) -> b -> ShowSignature a -> b

foldr1 :: (a -> a -> a) -> ShowSignature a -> a

foldl1 :: (a -> a -> a) -> ShowSignature a -> a

toList :: ShowSignature a -> [a]

null :: ShowSignature a -> Bool

length :: ShowSignature a -> Int

elem :: Eq a => a -> ShowSignature a -> Bool

maximum :: Ord a => ShowSignature a -> a

minimum :: Ord a => ShowSignature a -> a

sum :: Num a => ShowSignature a -> a

product :: Num a => ShowSignature a -> a

Traversable ShowSignature

Methods

traverse :: Applicative f => (a -> f b) -> ShowSignature a -> f (ShowSignature b)

sequenceA :: Applicative f => ShowSignature (f a) -> f (ShowSignature a)

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

sequence :: Monad m => ShowSignature (m a) -> m (ShowSignature a)

Eq b => Eq (ShowSignature b)

Methods

(==) :: ShowSignature b -> ShowSignature b -> Bool

(/=) :: ShowSignature b -> ShowSignature b -> Bool

Ord b => Ord (ShowSignature b)

Methods

compare :: ShowSignature b -> ShowSignature b -> Ordering

(<) :: ShowSignature b -> ShowSignature b -> Bool

(<=) :: ShowSignature b -> ShowSignature b -> Bool

(>) :: ShowSignature b -> ShowSignature b -> Bool

(>=) :: ShowSignature b -> ShowSignature b -> Bool

max :: ShowSignature b -> ShowSignature b -> ShowSignature b

min :: ShowSignature b -> ShowSignature b -> ShowSignature b

Show b => Show (ShowSignature b)

Methods

showsPrec :: Int -> ShowSignature b -> ShowS

show :: ShowSignature b -> String

showList :: [ShowSignature b] -> ShowS

rawShowSignature :: ShowSignature (Signature b) -> IO AstShowSignature

freeShowSignature :: AstShowSignature -> IO ()

fromRawShowSignature :: AstShowSignature -> IO (ShowSignature (Signature s))

data ShowTerm a

Constructors

ShowTerm (Term a) [BodyLiteral a] Bool

Instances

Functor ShowTerm

Methods

fmap :: (a -> b) -> ShowTerm a -> ShowTerm b

(<$) :: a -> ShowTerm b -> ShowTerm a

Foldable ShowTerm

Methods

fold :: Monoid m => ShowTerm m -> m

foldMap :: Monoid m => (a -> m) -> ShowTerm a -> m

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

foldr' :: (a -> b -> b) -> b -> ShowTerm a -> b

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

foldl' :: (b -> a -> b) -> b -> ShowTerm a -> b

foldr1 :: (a -> a -> a) -> ShowTerm a -> a

foldl1 :: (a -> a -> a) -> ShowTerm a -> a

toList :: ShowTerm a -> [a]

null :: ShowTerm a -> Bool

length :: ShowTerm a -> Int

elem :: Eq a => a -> ShowTerm a -> Bool

maximum :: Ord a => ShowTerm a -> a

minimum :: Ord a => ShowTerm a -> a

sum :: Num a => ShowTerm a -> a

product :: Num a => ShowTerm a -> a

Traversable ShowTerm

Methods

traverse :: Applicative f => (a -> f b) -> ShowTerm a -> f (ShowTerm b)

sequenceA :: Applicative f => ShowTerm (f a) -> f (ShowTerm a)

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

sequence :: Monad m => ShowTerm (m a) -> m (ShowTerm a)

Eq a => Eq (ShowTerm a)

Methods

(==) :: ShowTerm a -> ShowTerm a -> Bool

(/=) :: ShowTerm a -> ShowTerm a -> Bool

Ord a => Ord (ShowTerm a)

Methods

compare :: ShowTerm a -> ShowTerm a -> Ordering

(<) :: ShowTerm a -> ShowTerm a -> Bool

(<=) :: ShowTerm a -> ShowTerm a -> Bool

(>) :: ShowTerm a -> ShowTerm a -> Bool

(>=) :: ShowTerm a -> ShowTerm a -> Bool

max :: ShowTerm a -> ShowTerm a -> ShowTerm a

min :: ShowTerm a -> ShowTerm a -> ShowTerm a

Show a => Show (ShowTerm a)

Methods

showsPrec :: Int -> ShowTerm a -> ShowS

show :: ShowTerm a -> String

showList :: [ShowTerm a] -> ShowS

rawShowTerm :: ShowTerm (Symbol s) -> IO AstShowTerm

freeShowTerm :: AstShowTerm -> IO ()

fromRawShowTerm :: AstShowTerm -> IO (ShowTerm (Symbol s))

data Minimize a

Constructors

Minimize (Term a) (Term a) [Term a] [BodyLiteral a]

Instances

Functor Minimize

Methods

fmap :: (a -> b) -> Minimize a -> Minimize b

(<$) :: a -> Minimize b -> Minimize a

Foldable Minimize

Methods

fold :: Monoid m => Minimize m -> m

foldMap :: Monoid m => (a -> m) -> Minimize a -> m

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

foldr' :: (a -> b -> b) -> b -> Minimize a -> b

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

foldl' :: (b -> a -> b) -> b -> Minimize a -> b

foldr1 :: (a -> a -> a) -> Minimize a -> a

foldl1 :: (a -> a -> a) -> Minimize a -> a

toList :: Minimize a -> [a]

null :: Minimize a -> Bool

length :: Minimize a -> Int

elem :: Eq a => a -> Minimize a -> Bool

maximum :: Ord a => Minimize a -> a

minimum :: Ord a => Minimize a -> a

sum :: Num a => Minimize a -> a

product :: Num a => Minimize a -> a

Traversable Minimize

Methods

traverse :: Applicative f => (a -> f b) -> Minimize a -> f (Minimize b)

sequenceA :: Applicative f => Minimize (f a) -> f (Minimize a)

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

sequence :: Monad m => Minimize (m a) -> m (Minimize a)

Eq a => Eq (Minimize a)

Methods

(==) :: Minimize a -> Minimize a -> Bool

(/=) :: Minimize a -> Minimize a -> Bool

Ord a => Ord (Minimize a)

Methods

compare :: Minimize a -> Minimize a -> Ordering

(<) :: Minimize a -> Minimize a -> Bool

(<=) :: Minimize a -> Minimize a -> Bool

(>) :: Minimize a -> Minimize a -> Bool

(>=) :: Minimize a -> Minimize a -> Bool

max :: Minimize a -> Minimize a -> Minimize a

min :: Minimize a -> Minimize a -> Minimize a

Show a => Show (Minimize a)

Methods

showsPrec :: Int -> Minimize a -> ShowS

show :: Minimize a -> String

showList :: [Minimize a] -> ShowS

rawMinimize :: Minimize (Symbol s) -> IO AstMinimize

freeMinimize :: AstMinimize -> IO ()

fromRawMinimize :: AstMinimize -> IO (Minimize (Symbol s))

data Script

Constructors

Script ScriptType Text

Instances

Eq Script

Methods

(==) :: Script -> Script -> Bool

(/=) :: Script -> Script -> Bool

Ord Script

Methods

compare :: Script -> Script -> Ordering

(<) :: Script -> Script -> Bool

(<=) :: Script -> Script -> Bool

(>) :: Script -> Script -> Bool

(>=) :: Script -> Script -> Bool

max :: Script -> Script -> Script

min :: Script -> Script -> Script

Show Script

Methods

showsPrec :: Int -> Script -> ShowS

show :: Script -> String

showList :: [Script] -> ShowS

rawScript :: Script -> IO AstScript

freeScript :: AstScript -> IO ()

fromRawScript :: AstScript -> IO Script

data ScriptType

Constructors

Lua

Python

Instances

Eq ScriptType

Methods

(==) :: ScriptType -> ScriptType -> Bool

(/=) :: ScriptType -> ScriptType -> Bool

Ord ScriptType

Methods

compare :: ScriptType -> ScriptType -> Ordering

(<) :: ScriptType -> ScriptType -> Bool

(<=) :: ScriptType -> ScriptType -> Bool

(>) :: ScriptType -> ScriptType -> Bool

(>=) :: ScriptType -> ScriptType -> Bool

max :: ScriptType -> ScriptType -> ScriptType

min :: ScriptType -> ScriptType -> ScriptType

Show ScriptType

Methods

showsPrec :: Int -> ScriptType -> ShowS

show :: ScriptType -> String

showList :: [ScriptType] -> ShowS

rawScriptType :: ScriptType -> AstScriptType

fromRawScriptType :: AstScriptType -> ScriptType

data Program

Constructors

Program Text [Identifier]

Instances

Eq Program

Methods

(==) :: Program -> Program -> Bool

(/=) :: Program -> Program -> Bool

Ord Program

Methods

compare :: Program -> Program -> Ordering

(<) :: Program -> Program -> Bool

(<=) :: Program -> Program -> Bool

(>) :: Program -> Program -> Bool

(>=) :: Program -> Program -> Bool

max :: Program -> Program -> Program

min :: Program -> Program -> Program

Show Program

Methods

showsPrec :: Int -> Program -> ShowS

show :: Program -> String

showList :: [Program] -> ShowS

Pretty Program

Methods

pretty :: Program -> Doc

prettyList :: [Program] -> Doc

rawProgram :: Program -> IO AstProgram

freeProgram :: AstProgram -> IO ()

fromRawProgram :: AstProgram -> IO Program

data External a

Constructors

External (Term a) [BodyLiteral a]

Instances

Functor External

Methods

fmap :: (a -> b) -> External a -> External b

(<$) :: a -> External b -> External a

Foldable External

Methods

fold :: Monoid m => External m -> m

foldMap :: Monoid m => (a -> m) -> External a -> m

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

foldr' :: (a -> b -> b) -> b -> External a -> b

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

foldl' :: (b -> a -> b) -> b -> External a -> b

foldr1 :: (a -> a -> a) -> External a -> a

foldl1 :: (a -> a -> a) -> External a -> a

toList :: External a -> [a]

null :: External a -> Bool

length :: External a -> Int

elem :: Eq a => a -> External a -> Bool

maximum :: Ord a => External a -> a

minimum :: Ord a => External a -> a

sum :: Num a => External a -> a

product :: Num a => External a -> a

Traversable External

Methods

traverse :: Applicative f => (a -> f b) -> External a -> f (External b)

sequenceA :: Applicative f => External (f a) -> f (External a)

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

sequence :: Monad m => External (m a) -> m (External a)

Eq a => Eq (External a)

Methods

(==) :: External a -> External a -> Bool

(/=) :: External a -> External a -> Bool

Ord a => Ord (External a)

Methods

compare :: External a -> External a -> Ordering

(<) :: External a -> External a -> Bool

(<=) :: External a -> External a -> Bool

(>) :: External a -> External a -> Bool

(>=) :: External a -> External a -> Bool

max :: External a -> External a -> External a

min :: External a -> External a -> External a

Show a => Show (External a)

Methods

showsPrec :: Int -> External a -> ShowS

show :: External a -> String

showList :: [External a] -> ShowS

Pretty a => Pretty (External a)

Methods

pretty :: External a -> Doc

prettyList :: [External a] -> Doc

rawExternal :: External (Symbol s) -> IO AstExternal

freeExternal :: AstExternal -> IO ()

fromRawExternal :: AstExternal -> IO (External (Symbol s))

data Edge a

Constructors

Edge (Term a) (Term a) [BodyLiteral a]

Instances

Functor Edge

Methods

fmap :: (a -> b) -> Edge a -> Edge b

(<$) :: a -> Edge b -> Edge a

Foldable Edge

Methods

fold :: Monoid m => Edge m -> m

foldMap :: Monoid m => (a -> m) -> Edge a -> m

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

foldr' :: (a -> b -> b) -> b -> Edge a -> b

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

foldl' :: (b -> a -> b) -> b -> Edge a -> b

foldr1 :: (a -> a -> a) -> Edge a -> a

foldl1 :: (a -> a -> a) -> Edge a -> a

toList :: Edge a -> [a]

null :: Edge a -> Bool

length :: Edge a -> Int

elem :: Eq a => a -> Edge a -> Bool

maximum :: Ord a => Edge a -> a

minimum :: Ord a => Edge a -> a

sum :: Num a => Edge a -> a

product :: Num a => Edge a -> a

Traversable Edge

Methods

traverse :: Applicative f => (a -> f b) -> Edge a -> f (Edge b)

sequenceA :: Applicative f => Edge (f a) -> f (Edge a)

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

sequence :: Monad m => Edge (m a) -> m (Edge a)

Eq a => Eq (Edge a)

Methods

(==) :: Edge a -> Edge a -> Bool

(/=) :: Edge a -> Edge a -> Bool

Ord a => Ord (Edge a)

Methods

compare :: Edge a -> Edge a -> Ordering

(<) :: Edge a -> Edge a -> Bool

(<=) :: Edge a -> Edge a -> Bool

(>) :: Edge a -> Edge a -> Bool

(>=) :: Edge a -> Edge a -> Bool

max :: Edge a -> Edge a -> Edge a

min :: Edge a -> Edge a -> Edge a

Show a => Show (Edge a)

Methods

showsPrec :: Int -> Edge a -> ShowS

show :: Edge a -> String

showList :: [Edge a] -> ShowS

rawEdge :: Edge (Symbol s) -> IO AstEdge

freeEdge :: AstEdge -> IO ()

fromRawEdge :: AstEdge -> IO (Edge (Symbol s))

data Heuristic a

Constructors

Heuristic (Term a) [BodyLiteral a] (Term a) (Term a) (Term a)

Instances

Functor Heuristic

Methods

fmap :: (a -> b) -> Heuristic a -> Heuristic b

(<$) :: a -> Heuristic b -> Heuristic a

Foldable Heuristic

Methods

fold :: Monoid m => Heuristic m -> m

foldMap :: Monoid m => (a -> m) -> Heuristic a -> m

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

foldr' :: (a -> b -> b) -> b -> Heuristic a -> b

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

foldl' :: (b -> a -> b) -> b -> Heuristic a -> b

foldr1 :: (a -> a -> a) -> Heuristic a -> a

foldl1 :: (a -> a -> a) -> Heuristic a -> a

toList :: Heuristic a -> [a]

null :: Heuristic a -> Bool

length :: Heuristic a -> Int

elem :: Eq a => a -> Heuristic a -> Bool

maximum :: Ord a => Heuristic a -> a

minimum :: Ord a => Heuristic a -> a

sum :: Num a => Heuristic a -> a

product :: Num a => Heuristic a -> a

Traversable Heuristic

Methods

traverse :: Applicative f => (a -> f b) -> Heuristic a -> f (Heuristic b)

sequenceA :: Applicative f => Heuristic (f a) -> f (Heuristic a)

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

sequence :: Monad m => Heuristic (m a) -> m (Heuristic a)

Eq a => Eq (Heuristic a)

Methods

(==) :: Heuristic a -> Heuristic a -> Bool

(/=) :: Heuristic a -> Heuristic a -> Bool

Ord a => Ord (Heuristic a)

Methods

compare :: Heuristic a -> Heuristic a -> Ordering

(<) :: Heuristic a -> Heuristic a -> Bool

(<=) :: Heuristic a -> Heuristic a -> Bool

(>) :: Heuristic a -> Heuristic a -> Bool

(>=) :: Heuristic a -> Heuristic a -> Bool

max :: Heuristic a -> Heuristic a -> Heuristic a

min :: Heuristic a -> Heuristic a -> Heuristic a

Show a => Show (Heuristic a)

Methods

showsPrec :: Int -> Heuristic a -> ShowS

show :: Heuristic a -> String

showList :: [Heuristic a] -> ShowS

Pretty a => Pretty (Heuristic a)

Methods

pretty :: Heuristic a -> Doc

prettyList :: [Heuristic a] -> Doc

rawHeuristic :: Heuristic (Symbol s) -> IO AstHeuristic

freeHeuristic :: AstHeuristic -> IO ()

fromRawHeuristic :: AstHeuristic -> IO (Heuristic (Symbol s))

data Project a

Constructors

Project (Term a) [BodyLiteral a]

Instances

Functor Project

Methods

fmap :: (a -> b) -> Project a -> Project b

(<$) :: a -> Project b -> Project a

Foldable Project

Methods

fold :: Monoid m => Project m -> m

foldMap :: Monoid m => (a -> m) -> Project a -> m

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

foldr' :: (a -> b -> b) -> b -> Project a -> b

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

foldl' :: (b -> a -> b) -> b -> Project a -> b

foldr1 :: (a -> a -> a) -> Project a -> a

foldl1 :: (a -> a -> a) -> Project a -> a

toList :: Project a -> [a]

null :: Project a -> Bool

length :: Project a -> Int

elem :: Eq a => a -> Project a -> Bool

maximum :: Ord a => Project a -> a

minimum :: Ord a => Project a -> a

sum :: Num a => Project a -> a

product :: Num a => Project a -> a

Traversable Project

Methods

traverse :: Applicative f => (a -> f b) -> Project a -> f (Project b)

sequenceA :: Applicative f => Project (f a) -> f (Project a)

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

sequence :: Monad m => Project (m a) -> m (Project a)

Eq a => Eq (Project a)

Methods

(==) :: Project a -> Project a -> Bool

(/=) :: Project a -> Project a -> Bool

Ord a => Ord (Project a)

Methods

compare :: Project a -> Project a -> Ordering

(<) :: Project a -> Project a -> Bool

(<=) :: Project a -> Project a -> Bool

(>) :: Project a -> Project a -> Bool

(>=) :: Project a -> Project a -> Bool

max :: Project a -> Project a -> Project a

min :: Project a -> Project a -> Project a

Show a => Show (Project a)

Methods

showsPrec :: Int -> Project a -> ShowS

show :: Project a -> String

showList :: [Project a] -> ShowS

rawProject :: Project (Symbol s) -> IO AstProject

freeProject :: AstProject -> IO ()

fromRawProject :: AstProject -> IO (Project (Symbol s))

data Statement a b

Constructors

StmtRule Location (Rule a)

StmtDefinition Location (Definition a)

StmtShowSignature Location (ShowSignature b)

StmtShowTerm Location (ShowTerm a)

StmtMinimize Location (Minimize a)

StmtScript Location Script

StmtProgram Location Program

StmtExternal Location (External a)

StmtEdge Location (Edge a)

StmtHeuristic Location (Heuristic a)

StmtProject Location (Project a)

StmtSignature Location b

StmtTheoryDefinition Location TheoryDefinition

Instances

Bifunctor Statement

Methods

bimap :: (a -> b) -> (c -> d) -> Statement a c -> Statement b d

first :: (a -> b) -> Statement a c -> Statement b c

second :: (b -> c) -> Statement a b -> Statement a c

Bitraversable Statement

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Statement a b -> f (Statement c d)

Bifoldable Statement

Methods

bifold :: Monoid m => Statement m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Statement a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Statement a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Statement a b -> c

Functor (Statement a)

Methods

fmap :: (a -> b) -> Statement a a -> Statement a b

(<$) :: a -> Statement a b -> Statement a a

Foldable (Statement a)

Methods

fold :: Monoid m => Statement a m -> m

foldMap :: Monoid m => (a -> m) -> Statement a a -> m

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

foldr' :: (a -> b -> b) -> b -> Statement a a -> b

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

foldl' :: (b -> a -> b) -> b -> Statement a a -> b

foldr1 :: (a -> a -> a) -> Statement a a -> a

foldl1 :: (a -> a -> a) -> Statement a a -> a

toList :: Statement a a -> [a]

null :: Statement a a -> Bool

length :: Statement a a -> Int

elem :: Eq a => a -> Statement a a -> Bool

maximum :: Ord a => Statement a a -> a

minimum :: Ord a => Statement a a -> a

sum :: Num a => Statement a a -> a

product :: Num a => Statement a a -> a

Traversable (Statement a)

Methods

traverse :: Applicative f => (a -> f b) -> Statement a a -> f (Statement a b)

sequenceA :: Applicative f => Statement a (f a) -> f (Statement a a)

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

sequence :: Monad m => Statement a (m a) -> m (Statement a a)

(Eq b, Eq a) => Eq (Statement a b)

Methods

(==) :: Statement a b -> Statement a b -> Bool

(/=) :: Statement a b -> Statement a b -> Bool

(Ord b, Ord a) => Ord (Statement a b)

Methods

compare :: Statement a b -> Statement a b -> Ordering

(<) :: Statement a b -> Statement a b -> Bool

(<=) :: Statement a b -> Statement a b -> Bool

(>) :: Statement a b -> Statement a b -> Bool

(>=) :: Statement a b -> Statement a b -> Bool

max :: Statement a b -> Statement a b -> Statement a b

min :: Statement a b -> Statement a b -> Statement a b

(Show b, Show a) => Show (Statement a b)

Methods

showsPrec :: Int -> Statement a b -> ShowS

show :: Statement a b -> String

showList :: [Statement a b] -> ShowS

(Pretty a, Pretty b) => Pretty (Statement a b)

Methods

pretty :: Statement a b -> Doc

prettyList :: [Statement a b] -> Doc

rawStatement :: Statement (Symbol s) (Signature s) -> IO AstStatement

freeStatement :: AstStatement -> IO ()

fromRawStatement :: AstStatement -> IO (Statement (Symbol s) (Signature s))