{-# LANGUAGE RoleAnnotations #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DerivingStrategies #-}
module Language.Hasmtlib.Type.Expr
(
SMTVar(..), varId
, Expr(..), isLeaf, exprSize
, Equatable(..)
, equal, distinct
, GEquatable(..)
, Orderable(..)
, min', max'
, GOrderable(..)
, Iteable(..)
, for_all, exists
, bvConcat
, select, store
, strLength, strAt, strSubstring, strPrefixOf, strSuffixOf, strContains, strIndexOf, strReplace, strReplaceAll
, toRealSort, toIntSort, isIntSort
)
where
import Prelude hiding (not, and, or, any, all, (&&), (||))
import Language.Hasmtlib.Internal.Uniplate1
import Language.Hasmtlib.Type.Bitvec (BvEnc(..), KnownBvEnc(..), SBvEnc(..))
import Language.Hasmtlib.Type.SMTSort
import Language.Hasmtlib.Type.Value
import Language.Hasmtlib.Boolean
import Data.GADT.Compare
import Data.GADT.DeepSeq
import Data.Coerce
import Data.Proxy
import Data.Int
import Data.Word
import Data.Void
import qualified Data.Bits as Bits
import Data.Sequence (Seq)
import Data.Tree (Tree)
import Data.STRef
import Data.Monoid (Sum, Product, First, Last, Dual)
import Data.String (IsString(..))
import Data.Text (pack)
import Data.List(genericLength)
import Data.Foldable (toList)
import qualified Data.Vector.Sized as V
import Control.Lens hiding (from, to)
import Control.Monad.ST
import Control.Monad
import GHC.TypeLits hiding (someNatVal)
import GHC.TypeNats (someNatVal)
import GHC.Generics
type role SMTVar phantom
newtype SMTVar (t :: SMTSort) = SMTVar { forall (t :: SMTSort). SMTVar t -> Int
_varId :: Int }
deriving stock (Int -> SMTVar t -> ShowS
[SMTVar t] -> ShowS
SMTVar t -> String
(Int -> SMTVar t -> ShowS)
-> (SMTVar t -> String) -> ([SMTVar t] -> ShowS) -> Show (SMTVar t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (t :: SMTSort). Int -> SMTVar t -> ShowS
forall (t :: SMTSort). [SMTVar t] -> ShowS
forall (t :: SMTSort). SMTVar t -> String
$cshowsPrec :: forall (t :: SMTSort). Int -> SMTVar t -> ShowS
showsPrec :: Int -> SMTVar t -> ShowS
$cshow :: forall (t :: SMTSort). SMTVar t -> String
show :: SMTVar t -> String
$cshowList :: forall (t :: SMTSort). [SMTVar t] -> ShowS
showList :: [SMTVar t] -> ShowS
Show, (forall x. SMTVar t -> Rep (SMTVar t) x)
-> (forall x. Rep (SMTVar t) x -> SMTVar t) -> Generic (SMTVar t)
forall x. Rep (SMTVar t) x -> SMTVar t
forall x. SMTVar t -> Rep (SMTVar t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (t :: SMTSort) x. Rep (SMTVar t) x -> SMTVar t
forall (t :: SMTSort) x. SMTVar t -> Rep (SMTVar t) x
$cfrom :: forall (t :: SMTSort) x. SMTVar t -> Rep (SMTVar t) x
from :: forall x. SMTVar t -> Rep (SMTVar t) x
$cto :: forall (t :: SMTSort) x. Rep (SMTVar t) x -> SMTVar t
to :: forall x. Rep (SMTVar t) x -> SMTVar t
Generic)
deriving newtype (SMTVar t -> SMTVar t -> Bool
(SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool) -> Eq (SMTVar t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
$c== :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
== :: SMTVar t -> SMTVar t -> Bool
$c/= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
/= :: SMTVar t -> SMTVar t -> Bool
Eq, Eq (SMTVar t)
Eq (SMTVar t) =>
(SMTVar t -> SMTVar t -> Ordering)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> SMTVar t)
-> (SMTVar t -> SMTVar t -> SMTVar t)
-> Ord (SMTVar t)
SMTVar t -> SMTVar t -> Bool
SMTVar t -> SMTVar t -> Ordering
SMTVar t -> SMTVar t -> SMTVar t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (t :: SMTSort). Eq (SMTVar t)
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Ordering
forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
$ccompare :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Ordering
compare :: SMTVar t -> SMTVar t -> Ordering
$c< :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
< :: SMTVar t -> SMTVar t -> Bool
$c<= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
<= :: SMTVar t -> SMTVar t -> Bool
$c> :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
> :: SMTVar t -> SMTVar t -> Bool
$c>= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
>= :: SMTVar t -> SMTVar t -> Bool
$cmax :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
max :: SMTVar t -> SMTVar t -> SMTVar t
$cmin :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
min :: SMTVar t -> SMTVar t -> SMTVar t
Ord)
$(makeLenses ''SMTVar)
data Expr (t :: SMTSort) where
Var :: KnownSMTSort t => SMTVar t -> Expr t
Constant :: Value t -> Expr t
Plus :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
Minus :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
Neg :: Num (HaskellType t) => Expr t -> Expr t
Mul :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
Abs :: Num (HaskellType t) => Expr t -> Expr t
Mod :: Integral (HaskellType t) => Expr t -> Expr t -> Expr t
Rem :: Integral (HaskellType t) => Expr t -> Expr t -> Expr t
IDiv :: Integral (HaskellType t) => Expr t -> Expr t -> Expr t
Div :: Expr RealSort -> Expr RealSort -> Expr RealSort
LTH :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
LTHE :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
EQU :: (Eq (HaskellType t), KnownSMTSort t, KnownNat n) => V.Vector (n + 2) (Expr t) -> Expr BoolSort
Distinct :: (Eq (HaskellType t), KnownSMTSort t, KnownNat n) => V.Vector (n + 2) (Expr t) -> Expr BoolSort
GTHE :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
GTH :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
Not :: Boolean (HaskellType t) => Expr t -> Expr t
And :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
Or :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
Impl :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
Xor :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
Pi :: Expr RealSort
Sqrt :: Expr RealSort -> Expr RealSort
Exp :: Expr RealSort -> Expr RealSort
Sin :: Expr RealSort -> Expr RealSort
Cos :: Expr RealSort -> Expr RealSort
Tan :: Expr RealSort -> Expr RealSort
Asin :: Expr RealSort -> Expr RealSort
Acos :: Expr RealSort -> Expr RealSort
Atan :: Expr RealSort -> Expr RealSort
ToReal :: Expr IntSort -> Expr RealSort
ToInt :: Expr RealSort -> Expr IntSort
IsInt :: Expr RealSort -> Expr BoolSort
Ite :: Expr BoolSort -> Expr t -> Expr t -> Expr t
BvNand :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
BvNor :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
BvShL :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
BvLShR :: KnownNat n => Expr (BvSort Unsigned n) -> Expr (BvSort Unsigned n) -> Expr (BvSort Unsigned n)
BvAShR :: KnownNat n => Expr (BvSort Signed n) -> Expr (BvSort Signed n) -> Expr (BvSort Signed n)
BvConcat :: (KnownBvEnc enc , KnownNat n, KnownNat m) => Expr (BvSort enc n) -> Expr (BvSort enc m) -> Expr (BvSort enc (n + m))
BvRotL :: (KnownBvEnc enc, KnownNat n, Integral a) => a -> Expr (BvSort enc n) -> Expr (BvSort enc n)
BvRotR :: (KnownBvEnc enc, KnownNat n, Integral a) => a -> Expr (BvSort enc n) -> Expr (BvSort enc n)
ArrSelect :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Ord (HaskellType v)) => Expr (ArraySort k v) -> Expr k -> Expr v
ArrStore :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) => Expr (ArraySort k v) -> Expr k -> Expr v -> Expr (ArraySort k v)
StrConcat :: Expr StringSort -> Expr StringSort -> Expr StringSort
StrLength :: Expr StringSort -> Expr IntSort
StrAt :: Expr StringSort -> Expr IntSort -> Expr StringSort
StrSubstring :: Expr StringSort -> Expr IntSort -> Expr IntSort -> Expr StringSort
StrPrefixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
StrSuffixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
StrContains :: Expr StringSort -> Expr StringSort -> Expr BoolSort
StrIndexOf :: Expr StringSort -> Expr StringSort -> Expr IntSort -> Expr IntSort
StrReplace :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
StrReplaceAll :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
ForAll :: KnownSMTSort t => Maybe (SMTVar t) -> (Expr t -> Expr BoolSort) -> Expr BoolSort
Exists :: KnownSMTSort t => Maybe (SMTVar t) -> (Expr t -> Expr BoolSort) -> Expr BoolSort
isLeaf :: Expr t -> Bool
isLeaf :: forall (t :: SMTSort). Expr t -> Bool
isLeaf (Var SMTVar t
_) = Bool
True
isLeaf (Constant Value t
_) = Bool
True
isLeaf Expr t
Pi = Bool
True
isLeaf Expr t
_ = Bool
False
{-# INLINE isLeaf #-}
exprSize :: KnownSMTSort t => Expr t -> Integer
exprSize :: forall (t :: SMTSort). KnownSMTSort t => Expr t -> Integer
exprSize Expr t
expr = (forall s. ST s Integer) -> Integer
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s Integer) -> Integer)
-> (forall s. ST s Integer) -> Integer
forall a b. (a -> b) -> a -> b
$ do
STRef s Integer
nodesRef <- Integer -> ST s (STRef s Integer)
forall a s. a -> ST s (STRef s a)
newSTRef Integer
0
Expr t
_ <- (forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> ST s (Expr a))
-> Expr t -> ST s (Expr t)
forall {k} (m :: * -> *) (f :: k -> *) (cs :: [k -> Constraint])
(b :: k).
(Monad m, Uniplate1 f cs, AllC cs b) =>
(forall (a :: k). AllC cs a => f a -> m (f a)) -> f b -> m (f b)
transformM1
(\Expr a
expr' -> do
Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Expr a -> Bool
forall (t :: SMTSort). Expr t -> Bool
isLeaf Expr a
expr') (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ STRef s Integer -> (Integer -> Integer) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
modifySTRef' STRef s Integer
nodesRef (Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)
Expr a -> ST s (Expr a)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return Expr a
expr')
Expr t
expr
STRef s Integer -> ST s Integer
forall s a. STRef s a -> ST s a
readSTRef STRef s Integer
nodesRef
class Iteable b a where
ite :: b -> a -> a -> a
default ite :: (Iteable b c, Applicative f, f c ~ a) => b -> a -> a -> a
ite b
p a
t a
f = b -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite b
p (c -> c -> c) -> f c -> f (c -> c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a
f c
t f (c -> c) -> f c -> f c
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
f c
f
instance Iteable (Expr BoolSort) (Expr t) where
ite :: Expr 'BoolSort -> Expr t -> Expr t -> Expr t
ite (Constant (BoolValue Bool
HaskellType 'BoolSort
False)) Expr t
_ Expr t
f = Expr t
f
ite (Constant (BoolValue Bool
HaskellType 'BoolSort
True)) Expr t
t Expr t
_ = Expr t
t
ite Expr 'BoolSort
p t :: Expr t
t@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f') f :: Expr t
f@(Ite Expr 'BoolSort
p'' Expr t
t'' Expr t
f'')
| Expr 'BoolSort
p' Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p'' Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Expr t
t' Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
t'' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p' Expr t
t' (Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
f' Expr t
f'')
| Expr 'BoolSort
p' Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p'' Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Expr t
f' Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f'' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
p') Expr t
f' (Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t' Expr t
t'')
| Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
ite Expr 'BoolSort
p Expr t
t f :: Expr t
f@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f')
| Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f'
| Expr t
t Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
t' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| Expr 'BoolSort
p') Expr t
t Expr t
f'
| Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
ite Expr 'BoolSort
p t :: Expr t
t@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f') Expr t
f
| Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t' Expr t
f
| Expr t
f Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& Expr 'BoolSort
p') Expr t
t' Expr t
f
| Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
ite Expr 'BoolSort
p Expr t
t Expr t
f
| Expr t
t Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f = Expr t
t
| Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
{-# INLINEABLE ite #-}
instance Iteable Bool a where
ite :: Bool -> a -> a -> a
ite Bool
p a
t a
f = if Bool
p then a
t else a
f
{-# INLINE ite #-}
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) [a]
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Maybe a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Seq a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Tree a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Sum a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Product a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (First a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Last a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Dual a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Identity a)
instance Iteable (Expr BoolSort) () where
ite :: Expr 'BoolSort -> () -> () -> ()
ite Expr 'BoolSort
_ ()
_ ()
_ = ()
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b) => Iteable (Expr BoolSort) (a,b) where
ite :: Expr 'BoolSort -> (a, b) -> (a, b) -> (a, b)
ite Expr 'BoolSort
p (a
a,b
b) (a
a',b
b') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c) => Iteable (Expr BoolSort) (a,b,c) where
ite :: Expr 'BoolSort -> (a, b, c) -> (a, b, c) -> (a, b, c)
ite Expr 'BoolSort
p (a
a,b
b,c
c) (a
a',b
b',c
c') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d) => Iteable (Expr BoolSort) (a,b,c,d) where
ite :: Expr 'BoolSort -> (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d) (a
a',b
b',c
c',d
d') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e) => Iteable (Expr BoolSort) (a,b,c,d,e) where
ite :: Expr 'BoolSort
-> (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e) (a
a',b
b',c
c',d
d',e
e') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f) => Iteable (Expr BoolSort) (a,b,c,d,e,f) where
ite :: Expr 'BoolSort
-> (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f) (a
a',b
b',c
c',d
d',e
e',f
f') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f, Iteable (Expr BoolSort) g) => Iteable (Expr BoolSort) (a,b,c,d,e,f,g) where
ite :: Expr 'BoolSort
-> (a, b, c, d, e, f, g)
-> (a, b, c, d, e, f, g)
-> (a, b, c, d, e, f, g)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f,g
g) (a
a',b
b',c
c',d
d',e
e',f
f',g
g') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f', Expr 'BoolSort -> g -> g -> g
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p g
g g
g')
instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f, Iteable (Expr BoolSort) g, Iteable (Expr BoolSort) h) => Iteable (Expr BoolSort) (a,b,c,d,e,f,g,h) where
ite :: Expr 'BoolSort
-> (a, b, c, d, e, f, g, h)
-> (a, b, c, d, e, f, g, h)
-> (a, b, c, d, e, f, g, h)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) (a
a',b
b',c
c',d
d',e
e',f
f',g
g',h
h') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f', Expr 'BoolSort -> g -> g -> g
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p g
g g
g', Expr 'BoolSort -> h -> h -> h
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p h
h h
h')
class Equatable a where
(===) :: a -> a -> Expr BoolSort
default (===) :: (Generic a, GEquatable (Rep a)) => a -> a -> Expr BoolSort
a
a === a
b = a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
a Rep a Any -> Rep a Any -> Expr 'BoolSort
forall a. Rep a a -> Rep a a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
b
(/==) :: a -> a -> Expr BoolSort
a
x /== a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== a
y
infix 4 ===, /==
instance (KnownSMTSort t, Eq (HaskellType t)) => Equatable (Expr t) where
Expr t
x === :: Expr t -> Expr t -> Expr 'BoolSort
=== Expr t
y = Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
x,Expr t
y)
{-# INLINE (===) #-}
Expr t
x /== :: Expr t -> Expr t -> Expr 'BoolSort
/== Expr t
y = Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
x,Expr t
y)
{-# INLINE (/==) #-}
class GEquatable f where
(===#) :: f a -> f a -> Expr BoolSort
instance GEquatable U1 where
U1 a
U1 ===# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
===# U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
true
instance GEquatable V1 where
V1 a
x ===# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
===# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GEquatable[V1].===#"
instance (GEquatable f, GEquatable g) => GEquatable (f :*: g) where
(f a
a :*: g a
b) ===# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
===# (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& (g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# g a
d)
instance (GEquatable f, GEquatable g) => GEquatable (f :+: g) where
L1 f a
a ===# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
===# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
b
R1 g a
a ===# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# g a
b
(:+:) f g a
_ ===# (:+:) f g a
_ = Expr 'BoolSort
forall b. Boolean b => b
false
instance GEquatable f => GEquatable (M1 i c f) where
M1 f a
x ===# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
===# M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
y
instance Equatable a => GEquatable (K1 i a) where
K1 a
a ===# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
===# K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== a
b
instance Equatable () where ()
_ === :: () -> () -> Expr 'BoolSort
=== ()
_ = Expr 'BoolSort
forall b. Boolean b => b
true
instance Equatable Void where Void
x === :: Void -> Void -> Expr 'BoolSort
=== Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Equatable[Void].==="
instance Equatable Int where Int
x === :: Int -> Int -> Expr 'BoolSort
=== Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
y)
instance Equatable Integer where Integer
x === :: Integer -> Integer -> Expr 'BoolSort
=== Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
y)
instance Equatable Natural where Nat
x === :: Nat -> Nat -> Expr 'BoolSort
=== Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Eq a => a -> a -> Bool
== Nat
y)
instance Equatable Word where Word
x === :: Word -> Word -> Expr 'BoolSort
=== Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
y)
instance Equatable Word8 where Word8
x === :: Word8 -> Word8 -> Expr 'BoolSort
=== Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
y)
instance Equatable Word16 where Word16
x === :: Word16 -> Word16 -> Expr 'BoolSort
=== Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
== Word16
y)
instance Equatable Word32 where Word32
x === :: Word32 -> Word32 -> Expr 'BoolSort
=== Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
y)
instance Equatable Word64 where Word64
x === :: Word64 -> Word64 -> Expr 'BoolSort
=== Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
y)
instance Equatable Int8 where Int8
x === :: Int8 -> Int8 -> Expr 'BoolSort
=== Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
y)
instance Equatable Int16 where Int16
x === :: Int16 -> Int16 -> Expr 'BoolSort
=== Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
y)
instance Equatable Int32 where Int32
x === :: Int32 -> Int32 -> Expr 'BoolSort
=== Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
y)
instance Equatable Int64 where Int64
x === :: Int64 -> Int64 -> Expr 'BoolSort
=== Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
y)
instance Equatable Char where Char
x === :: Char -> Char -> Expr 'BoolSort
=== Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
y)
instance Equatable Float where Float
x === :: Float -> Float -> Expr 'BoolSort
=== Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
== Float
y)
instance Equatable Double where Double
x === :: Double -> Double -> Expr 'BoolSort
=== Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
y)
instance Equatable Ordering where Ordering
x === :: Ordering -> Ordering -> Expr 'BoolSort
=== Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
y)
instance Equatable Bool where Bool
x === :: Bool -> Bool -> Expr 'BoolSort
=== Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
y)
instance (Equatable a, Equatable b) => Equatable (a,b)
instance (Equatable a, Equatable b, Equatable c) => Equatable (a,b,c)
instance (Equatable a, Equatable b, Equatable c, Equatable d) => Equatable (a,b,c,d)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e) => Equatable (a,b,c,d,e)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f) => Equatable (a,b,c,d,e,f)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f, Equatable g) => Equatable (a,b,c,d,e,f,g)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f, Equatable g, Equatable h) => Equatable (a,b,c,d,e,f,g,h)
instance Equatable a => Equatable [a]
instance Equatable a => Equatable (Tree a)
instance Equatable a => Equatable (Maybe a)
instance (Equatable a, Equatable b) => Equatable (Either a b)
instance Equatable a => Equatable (Sum a)
instance Equatable a => Equatable (Product a)
instance Equatable a => Equatable (First a)
instance Equatable a => Equatable (Last a)
instance Equatable a => Equatable (Dual a)
instance Equatable a => Equatable (Identity a)
class Equatable a => Orderable a where
(<=?) :: a -> a -> Expr BoolSort
default (<=?) :: (Generic a, GOrderable (Rep a)) => a -> a -> Expr BoolSort
a
x <=? a
y = a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
x Rep a Any -> Rep a Any -> Expr 'BoolSort
forall a. Rep a a -> Rep a a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
y
(>=?) :: a -> a -> Expr BoolSort
a
x >=? a
y = a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x
(<?) :: a -> a -> Expr BoolSort
a
x <? a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x
(>?) :: a -> a -> Expr BoolSort
a
x >? a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
y
infix 4 <?, <=?, >=?, >?
min' :: (Orderable a, Iteable (Expr BoolSort) a) => a -> a -> a
min' :: forall a. (Orderable a, Iteable (Expr 'BoolSort) a) => a -> a -> a
min' a
x a
y = Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite (a
x a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
y) a
x a
y
max' :: (Orderable a, Iteable (Expr BoolSort) a) => a -> a -> a
max' :: forall a. (Orderable a, Iteable (Expr 'BoolSort) a) => a -> a -> a
max' a
x a
y = Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite (a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x) a
x a
y
instance (KnownSMTSort t, Ord (HaskellType t)) => Orderable (Expr t) where
<? :: Expr t -> Expr t -> Expr 'BoolSort
(<?) = Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTH
{-# INLINE (<?) #-}
<=? :: Expr t -> Expr t -> Expr 'BoolSort
(<=?) = Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTHE
{-# INLINE (<=?) #-}
>=? :: Expr t -> Expr t -> Expr 'BoolSort
(>=?) = Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTHE
{-# INLINE (>=?) #-}
>? :: Expr t -> Expr t -> Expr 'BoolSort
(>?) = Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTH
{-# INLINE (>?) #-}
class GEquatable f => GOrderable f where
(<?#) :: f a -> f a -> Expr BoolSort
(<=?#) :: f a -> f a -> Expr BoolSort
instance GOrderable U1 where
U1 a
U1 <?# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
<?# U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
false
U1 a
U1 <=?# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
<=?# U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
true
instance GOrderable V1 where
V1 a
x <?# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
<?# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GOrderable[V1].<?#"
V1 a
x <=?# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
<=?# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GOrderable[V1].<=?#"
instance (GOrderable f, GOrderable g) => GOrderable (f :*: g) where
(f a
a :*: g a
b) <?# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
<?# (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# g a
d)
(f a
a :*: g a
b) <=?# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
<=?# (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# g a
d)
instance (GOrderable f, GOrderable g) => GOrderable (f :+: g) where
L1 f a
_ <?# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
<?# R1 g a
_ = Expr 'BoolSort
forall b. Boolean b => b
true
L1 f a
a <?# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
b
R1 g a
a <?# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# g a
b
R1 g a
_ <?# L1 f a
_ = Expr 'BoolSort
forall b. Boolean b => b
false
L1 f a
_ <=?# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
<=?# R1 g a
_ = Expr 'BoolSort
forall b. Boolean b => b
true
L1 f a
a <=?# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# f a
b
R1 g a
a <=?# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# g a
b
R1 g a
_ <=?# L1 f a
_ = Expr 'BoolSort
forall b. Boolean b => b
false
instance GOrderable f => GOrderable (M1 i c f) where
M1 f a
x <?# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
<?# M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
y
M1 f a
x <=?# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
<=?# M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# f a
y
instance Orderable a => GOrderable (K1 i a) where
K1 a
a <?# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
<?# K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<? a
b
K1 a
a <=?# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
<=?# K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
b
instance Orderable () where ()
_ <? :: () -> () -> Expr 'BoolSort
<? ()
_ = Expr 'BoolSort
forall b. Boolean b => b
false
()
_ <=? :: () -> () -> Expr 'BoolSort
<=? ()
_ = Expr 'BoolSort
forall b. Boolean b => b
true
instance Orderable Void where Void
x <? :: Void -> Void -> Expr 'BoolSort
<? Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Orderable[Void].<?"
Void
x <=? :: Void -> Void -> Expr 'BoolSort
<=? Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Orderable[Void].<=?"
instance Orderable Int where Int
x <? :: Int -> Int -> Expr 'BoolSort
<? Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
y)
Int
x <=? :: Int -> Int -> Expr 'BoolSort
<=? Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
y)
instance Orderable Integer where Integer
x <? :: Integer -> Integer -> Expr 'BoolSort
<? Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
y)
Integer
x <=? :: Integer -> Integer -> Expr 'BoolSort
<=? Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
y)
instance Orderable Natural where Nat
x <? :: Nat -> Nat -> Expr 'BoolSort
<? Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Ord a => a -> a -> Bool
< Nat
y)
Nat
x <=? :: Nat -> Nat -> Expr 'BoolSort
<=? Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Ord a => a -> a -> Bool
<= Nat
y)
instance Orderable Word where Word
x <? :: Word -> Word -> Expr 'BoolSort
<? Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
y)
Word
x <=? :: Word -> Word -> Expr 'BoolSort
<=? Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
<= Word
y)
instance Orderable Word8 where Word8
x <? :: Word8 -> Word8 -> Expr 'BoolSort
<? Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
y)
Word8
x <=? :: Word8 -> Word8 -> Expr 'BoolSort
<=? Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
y)
instance Orderable Word16 where Word16
x <? :: Word16 -> Word16 -> Expr 'BoolSort
<? Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
< Word16
y)
Word16
x <=? :: Word16 -> Word16 -> Expr 'BoolSort
<=? Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word16
y)
instance Orderable Word32 where Word32
x <? :: Word32 -> Word32 -> Expr 'BoolSort
<? Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
< Word32
y)
Word32
x <=? :: Word32 -> Word32 -> Expr 'BoolSort
<=? Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
y)
instance Orderable Word64 where Word64
x <? :: Word64 -> Word64 -> Expr 'BoolSort
<? Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
y)
Word64
x <=? :: Word64 -> Word64 -> Expr 'BoolSort
<=? Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word64
y)
instance Orderable Int8 where Int8
x <? :: Int8 -> Int8 -> Expr 'BoolSort
<? Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
y)
Int8
x <=? :: Int8 -> Int8 -> Expr 'BoolSort
<=? Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int8
y)
instance Orderable Int16 where Int16
x <? :: Int16 -> Int16 -> Expr 'BoolSort
<? Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Ord a => a -> a -> Bool
< Int16
y)
Int16
x <=? :: Int16 -> Int16 -> Expr 'BoolSort
<=? Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int16
y)
instance Orderable Int32 where Int32
x <? :: Int32 -> Int32 -> Expr 'BoolSort
<? Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
y)
Int32
x <=? :: Int32 -> Int32 -> Expr 'BoolSort
<=? Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int32
y)
instance Orderable Int64 where Int64
x <? :: Int64 -> Int64 -> Expr 'BoolSort
<? Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
< Int64
y)
Int64
x <=? :: Int64 -> Int64 -> Expr 'BoolSort
<=? Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int64
y)
instance Orderable Char where Char
x <? :: Char -> Char -> Expr 'BoolSort
<? Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
< Char
y)
Char
x <=? :: Char -> Char -> Expr 'BoolSort
<=? Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
y)
instance Orderable Float where Float
x <? :: Float -> Float -> Expr 'BoolSort
<? Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
< Float
y)
Float
x <=? :: Float -> Float -> Expr 'BoolSort
<=? Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Float
y)
instance Orderable Double where Double
x <? :: Double -> Double -> Expr 'BoolSort
<? Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
y)
Double
x <=? :: Double -> Double -> Expr 'BoolSort
<=? Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
y)
instance Orderable Ordering where Ordering
x <? :: Ordering -> Ordering -> Expr 'BoolSort
<? Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
< Ordering
y)
Ordering
x <=? :: Ordering -> Ordering -> Expr 'BoolSort
<=? Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
<= Ordering
y)
instance Orderable Bool where Bool
x <? :: Bool -> Bool -> Expr 'BoolSort
<? Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
< Bool
y)
Bool
x <=? :: Bool -> Bool -> Expr 'BoolSort
<=? Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
<= Bool
y)
instance (Orderable a, Orderable b) => Orderable (a,b)
instance (Orderable a, Orderable b, Orderable c) => Orderable (a,b,c)
instance (Orderable a, Orderable b, Orderable c, Orderable d) => Orderable (a,b,c,d)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e) => Orderable (a,b,c,d,e)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f) => Orderable (a,b,c,d,e,f)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f, Orderable g) => Orderable (a,b,c,d,e,f,g)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f, Orderable g, Orderable h) => Orderable (a,b,c,d,e,f,g,h)
instance Orderable a => Orderable [a]
instance Orderable a => Orderable (Tree a)
instance Orderable a => Orderable (Maybe a)
instance (Orderable a, Orderable b) => Orderable (Either a b)
instance Orderable a => Orderable (Sum a)
instance Orderable a => Orderable (Product a)
instance Orderable a => Orderable (First a)
instance Orderable a => Orderable (Last a)
instance Orderable a => Orderable (Dual a)
instance Orderable a => Orderable (Identity a)
equal :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
equal :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
Maybe (Vector n (Expr t))
Nothing -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
Just Vector n (Expr t)
xs' -> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_) = Expr 'BoolSort
forall b. Boolean b => b
true
distinct :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
distinct :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
Maybe (Vector n (Expr t))
Nothing -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
Just Vector n (Expr t)
xs' -> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_) = Expr 'BoolSort
forall b. Boolean b => b
true
for_all :: forall t. KnownSMTSort t => (Expr t -> Expr BoolSort) -> Expr BoolSort
for_all :: forall (t :: SMTSort).
KnownSMTSort t =>
(Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
for_all = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE for_all #-}
exists :: forall t. KnownSMTSort t => (Expr t -> Expr BoolSort) -> Expr BoolSort
exists :: forall (t :: SMTSort).
KnownSMTSort t =>
(Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
exists = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE exists #-}
select :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Ord (HaskellType v)) => Expr (ArraySort k v) -> Expr k -> Expr v
select :: forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
select = Expr ('ArraySort k v) -> Expr k -> Expr v
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect
{-# INLINE select #-}
store :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) => Expr (ArraySort k v) -> Expr k -> Expr v -> Expr (ArraySort k v)
store :: forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
store = Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
ArrStore
{-# INLINE store #-}
bvConcat :: (KnownBvEnc enc, KnownNat n, KnownNat m) => Expr (BvSort enc n) -> Expr (BvSort enc m) -> Expr (BvSort enc (n + m))
bvConcat :: forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
bvConcat = Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
BvConcat
{-# INLINE bvConcat #-}
toRealSort :: Expr IntSort -> Expr RealSort
toRealSort :: Expr 'IntSort -> Expr 'RealSort
toRealSort = Expr 'IntSort -> Expr 'RealSort
ToReal
{-# INLINE toRealSort #-}
toIntSort :: Expr RealSort -> Expr IntSort
toIntSort :: Expr 'RealSort -> Expr 'IntSort
toIntSort = Expr 'RealSort -> Expr 'IntSort
ToInt
{-# INLINE toIntSort #-}
isIntSort :: Expr RealSort -> Expr BoolSort
isIntSort :: Expr 'RealSort -> Expr 'BoolSort
isIntSort = Expr 'RealSort -> Expr 'BoolSort
IsInt
{-# INLINE isIntSort #-}
strLength :: Expr StringSort -> Expr IntSort
strLength :: Expr 'StringSort -> Expr 'IntSort
strLength = Expr 'StringSort -> Expr 'IntSort
StrLength
{-# INLINE strLength #-}
strAt :: Expr StringSort -> Expr IntSort -> Expr StringSort
strAt :: Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt = Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt
{-# INLINE strAt #-}
strSubstring :: Expr StringSort -> Expr IntSort -> Expr IntSort -> Expr StringSort
strSubstring :: Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring
{-# INLINE strSubstring #-}
strPrefixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strPrefixOf :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strPrefixOf = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf
{-# INLINE strPrefixOf #-}
strSuffixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strSuffixOf :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strSuffixOf = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf
{-# INLINE strSuffixOf #-}
strContains :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strContains :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strContains = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains
{-# INLINE strContains #-}
strIndexOf :: Expr StringSort -> Expr StringSort -> Expr IntSort -> Expr IntSort
strIndexOf :: Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
strIndexOf = Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf
{-# INLINE strIndexOf #-}
strReplace :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
strReplace :: Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace = Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace
{-# INLINE strReplace #-}
strReplaceAll :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
strReplaceAll :: Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplaceAll = Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll
{-# INLINE strReplaceAll #-}
instance (KnownSMTSort t, Num (HaskellType t), Ord (HaskellType t)) => Num (Expr t) where
fromInteger :: Integer -> Expr t
fromInteger = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> (Integer -> Value t) -> Integer -> Expr t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HaskellType t -> Value t
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue (HaskellType t -> Value t)
-> (Integer -> HaskellType t) -> Integer -> Value t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> HaskellType t
forall a. Num a => Integer -> a
fromInteger
{-# INLINE fromInteger #-}
(Constant Value t
0) + :: Expr t -> Expr t -> Expr t
+ Expr t
y = Expr t
y
Expr t
x + (Constant Value t
0) = Expr t
x
(Constant Value t
x) + (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
+ Value t
y)
Expr t
x + Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr t
x Expr t
y
{-# INLINE (+) #-}
Expr t
x - :: Expr t -> Expr t -> Expr t
- (Constant Value t
0) = Expr t
x
(Constant Value t
x) - (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
- Value t
y)
(Constant Value t
0) - Expr t
x = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
Expr t
x - Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus Expr t
x Expr t
y
{-# INLINE (-) #-}
(Constant Value t
0) * :: Expr t -> Expr t -> Expr t
* Expr t
_ = Expr t
0
Expr t
_ * (Constant Value t
0) = Expr t
0
(Constant Value t
1) * Expr t
y = Expr t
y
Expr t
x * (Constant Value t
1) = Expr t
x
(Constant (-1)) * Expr t
x = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
Expr t
x * (Constant (-1)) = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
(Constant Value t
x) * (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
* Value t
y)
Expr t
x * Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul Expr t
x Expr t
y
{-# INLINE (*) #-}
negate :: Expr t -> Expr t
negate (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
negate Value t
x
negate (Neg Expr t
x) = Expr t
x
negate Expr t
x = Expr t -> Expr t
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg Expr t
x
{-# INLINE negate #-}
abs :: Expr t -> Expr t
abs (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
abs Value t
x
abs Expr t
x = Expr t -> Expr t
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs Expr t
x
{-# INLINE abs #-}
signum :: Expr t -> Expr t
signum (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
signum Value t
x
signum Expr t
x = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr t
x Expr t -> Expr t -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr t
0) Expr t
0 (Expr t -> Expr t) -> Expr t -> Expr t
forall a b. (a -> b) -> a -> b
$ Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr t
x Expr t -> Expr t -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<? Expr t
0) (-Expr t
1) Expr t
1
{-# INLINE signum #-}
instance Fractional (Expr RealSort) where
fromRational :: Rational -> Expr 'RealSort
fromRational = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'RealSort -> Expr 'RealSort)
-> (Rational -> Value 'RealSort) -> Rational -> Expr 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value 'RealSort
HaskellType 'RealSort -> Value 'RealSort
RealValue (Rational -> Value 'RealSort)
-> (Rational -> Rational) -> Rational -> Value 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. Fractional a => Rational -> a
fromRational
{-# INLINE fromRational #-}
Expr 'RealSort
x / :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
/ (Constant Value 'RealSort
1) = Expr 'RealSort
x
(Constant Value 'RealSort
0) / Expr 'RealSort
_ = Expr 'RealSort
0
(Constant Value 'RealSort
x) / (Constant Value 'RealSort
y) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'RealSort
x Value 'RealSort -> Value 'RealSort -> Value 'RealSort
forall a. Fractional a => a -> a -> a
/ Value 'RealSort
y)
Expr 'RealSort
x / Expr 'RealSort
y = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div Expr 'RealSort
x Expr 'RealSort
y
{-# INLINE (/) #-}
instance Floating (Expr RealSort) where
pi :: Expr 'RealSort
pi = Expr 'RealSort
Pi
{-# INLINE pi #-}
exp :: Expr 'RealSort -> Expr 'RealSort
exp = Expr 'RealSort -> Expr 'RealSort
Exp
{-# INLINE exp #-}
log :: Expr 'RealSort -> Expr 'RealSort
log = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support log"
sqrt :: Expr 'RealSort -> Expr 'RealSort
sqrt = Expr 'RealSort -> Expr 'RealSort
Sqrt
{-# INLINE sqrt #-}
sin :: Expr 'RealSort -> Expr 'RealSort
sin = Expr 'RealSort -> Expr 'RealSort
Sin
{-# INLINE sin #-}
cos :: Expr 'RealSort -> Expr 'RealSort
cos = Expr 'RealSort -> Expr 'RealSort
Cos
{-# INLINE cos #-}
tan :: Expr 'RealSort -> Expr 'RealSort
tan = Expr 'RealSort -> Expr 'RealSort
Tan
{-# INLINE tan #-}
asin :: Expr 'RealSort -> Expr 'RealSort
asin = Expr 'RealSort -> Expr 'RealSort
Asin
{-# INLINE asin #-}
acos :: Expr 'RealSort -> Expr 'RealSort
acos = Expr 'RealSort -> Expr 'RealSort
Acos
{-# INLINE acos #-}
atan :: Expr 'RealSort -> Expr 'RealSort
atan = Expr 'RealSort -> Expr 'RealSort
Atan
{-# INLINE atan #-}
sinh :: Expr 'RealSort -> Expr 'RealSort
sinh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support sinh"
cosh :: Expr 'RealSort -> Expr 'RealSort
cosh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support cosh"
tanh :: Expr 'RealSort -> Expr 'RealSort
tanh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support tanh"
asinh :: Expr 'RealSort -> Expr 'RealSort
asinh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support asinh"
acosh :: Expr 'RealSort -> Expr 'RealSort
acosh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support acosh"
atanh :: Expr 'RealSort -> Expr 'RealSort
atanh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support atanh"
instance (KnownSMTSort t, Real (HaskellType t)) => Real (Expr t) where
toRational :: Expr t -> Rational
toRational (Constant Value t
x) = HaskellType t -> Rational
forall a. Real a => a -> Rational
toRational (HaskellType t -> Rational) -> HaskellType t -> Rational
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
toRational Expr t
_ = String -> Rational
forall a. HasCallStack => String -> a
error (String -> Rational) -> String -> Rational
forall a b. (a -> b) -> a -> b
$ String
"Real#toRational[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
{-# INLINE toRational #-}
instance (KnownSMTSort t, Enum (HaskellType t)) => Enum (Expr t) where
fromEnum :: Expr t -> Int
fromEnum (Constant Value t
x) = HaskellType t -> Int
forall a. Enum a => a -> Int
fromEnum (HaskellType t -> Int) -> HaskellType t -> Int
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
fromEnum Expr t
_ = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Enum#fromEnum[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
{-# INLINE fromEnum #-}
toEnum :: Int -> Expr t
toEnum = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> (Int -> Value t) -> Int -> Expr t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HaskellType t -> Value t
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue (HaskellType t -> Value t)
-> (Int -> HaskellType t) -> Int -> Value t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> HaskellType t
forall a. Enum a => Int -> a
toEnum
{-# INLINE toEnum #-}
instance (KnownSMTSort t, Integral (HaskellType t)) => Integral (Expr t) where
quotRem :: Expr t -> Expr t -> (Expr t, Expr t)
quotRem Expr t
x Expr t
y = (Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv Expr t
x Expr t
y, Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Rem Expr t
x Expr t
y)
{-# INLINE quotRem #-}
divMod :: Expr t -> Expr t -> (Expr t, Expr t)
divMod Expr t
x Expr t
y = (Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv Expr t
x Expr t
y, Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod Expr t
x Expr t
y)
{-# INLINE divMod #-}
toInteger :: Expr t -> Integer
toInteger (Constant Value t
x) = HaskellType t -> Integer
forall a. Integral a => a -> Integer
toInteger (HaskellType t -> Integer) -> HaskellType t -> Integer
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
toInteger Expr t
_ = String -> Integer
forall a. HasCallStack => String -> a
error (String -> Integer) -> String -> Integer
forall a b. (a -> b) -> a -> b
$ String
"Integer#toInteger[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
{-# INLINE toInteger #-}
instance Boolean (Expr BoolSort) where
bool :: Bool -> Expr 'BoolSort
bool = Value 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'BoolSort -> Expr 'BoolSort)
-> (Bool -> Value 'BoolSort) -> Bool -> Expr 'BoolSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value 'BoolSort
HaskellType 'BoolSort -> Value 'BoolSort
BoolValue
{-# INLINE bool #-}
(Constant (BoolValue HaskellType 'BoolSort
x)) && :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
&& Expr 'BoolSort
y = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort
y else Expr 'BoolSort
forall b. Boolean b => b
false
Expr 'BoolSort
x && (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort
x else Expr 'BoolSort
forall b. Boolean b => b
false
Expr 'BoolSort
x && Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And Expr 'BoolSort
x Expr 'BoolSort
y
{-# INLINE (&&) #-}
(Constant (BoolValue HaskellType 'BoolSort
x)) || :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
|| Expr 'BoolSort
y = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort
forall b. Boolean b => b
true else Expr 'BoolSort
y
Expr 'BoolSort
x || (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort
forall b. Boolean b => b
true else Expr 'BoolSort
x
Expr 'BoolSort
x || Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or Expr 'BoolSort
x Expr 'BoolSort
y
{-# INLINE (||) #-}
not :: Expr 'BoolSort -> Expr 'BoolSort
not (Constant Value 'BoolSort
x) = Value 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'BoolSort -> Expr 'BoolSort)
-> Value 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Value 'BoolSort -> Value 'BoolSort
forall b. Boolean b => b -> b
not Value 'BoolSort
x
not (Not Expr 'BoolSort
x) = Expr 'BoolSort
x
not Expr 'BoolSort
x = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr 'BoolSort
x
{-# INLINE not #-}
xor :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
xor (Constant (BoolValue HaskellType 'BoolSort
x)) Expr 'BoolSort
y = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
y else Expr 'BoolSort
y
xor Expr 'BoolSort
x (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
x else Expr 'BoolSort
x
xor Expr 'BoolSort
x Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor Expr 'BoolSort
x Expr 'BoolSort
y
{-# INLINE xor #-}
(Constant (BoolValue Bool
HaskellType 'BoolSort
False)) ==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
==> Expr 'BoolSort
_ = Expr 'BoolSort
forall b. Boolean b => b
true
Expr 'BoolSort
x ==> Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl Expr 'BoolSort
x Expr 'BoolSort
y
{-# INLINE (==>) #-}
<==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(<==>) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
(===)
{-# INLINE (<==>) #-}
instance (KnownBvEnc enc, KnownNat n) => Boolean (Expr (BvSort enc n)) where
bool :: Bool -> Expr ('BvSort enc n)
bool = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> (Bool -> Value ('BvSort enc n)) -> Bool -> Expr ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec enc n -> Value ('BvSort enc n)
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue (Bitvec enc n -> Value ('BvSort enc n))
-> (Bool -> Bitvec enc n) -> Bool -> Value ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bitvec enc n
forall b. Boolean b => Bool -> b
bool
{-# INLINE bool #-}
&& :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(&&) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
{-# INLINE (&&) #-}
|| :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(||) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
{-# INLINE (||) #-}
not :: Expr ('BvSort enc n) -> Expr ('BvSort enc n)
not (Not Expr ('BvSort enc n)
x) = Expr ('BvSort enc n)
x
not Expr ('BvSort enc n)
x = Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr ('BvSort enc n)
x
{-# INLINE not #-}
xor :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
xor = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
{-# INLINE xor #-}
instance Bounded (Expr BoolSort) where
minBound :: Expr 'BoolSort
minBound = Expr 'BoolSort
forall b. Boolean b => b
false
{-# INLINE minBound #-}
maxBound :: Expr 'BoolSort
maxBound = Expr 'BoolSort
forall b. Boolean b => b
true
{-# INLINE maxBound #-}
instance (KnownBvEnc enc, KnownNat n) => Bounded (Expr (BvSort enc n)) where
minBound :: Expr ('BvSort enc n)
minBound = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue Bitvec enc n
HaskellType ('BvSort enc n)
forall a. Bounded a => a
minBound
{-# INLINE minBound #-}
maxBound :: Expr ('BvSort enc n)
maxBound = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue Bitvec enc n
HaskellType ('BvSort enc n)
forall a. Bounded a => a
maxBound
{-# INLINE maxBound #-}
instance Bits.Bits (Expr BoolSort) where
.&. :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(.&.) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
{-# INLINE (.&.) #-}
.|. :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(.|.) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
{-# INLINE (.|.) #-}
xor :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
xor = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
{-# INLINE xor #-}
complement :: Expr 'BoolSort -> Expr 'BoolSort
complement = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
{-# INLINE complement #-}
zeroBits :: Expr 'BoolSort
zeroBits = Expr 'BoolSort
forall b. Boolean b => b
false
{-# INLINE zeroBits #-}
bit :: Int -> Expr 'BoolSort
bit Int
_ = Expr 'BoolSort
forall b. Boolean b => b
true
{-# INLINE bit #-}
setBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
setBit Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
true
{-# INLINE setBit #-}
clearBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
clearBit Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
{-# INLINE clearBit #-}
complementBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
complementBit Expr 'BoolSort
b Int
_ = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr 'BoolSort
b
{-# INLINE complementBit #-}
testBit :: Expr 'BoolSort -> Int -> Bool
testBit (Constant (BoolValue HaskellType 'BoolSort
b)) Int
_ = Bool
HaskellType 'BoolSort
b
testBit Expr 'BoolSort
_ Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error String
"Bits#testBit[Expr BoolSort] is only supported for constants."
{-# INLINE testBit #-}
bitSizeMaybe :: Expr 'BoolSort -> Maybe Int
bitSizeMaybe Expr 'BoolSort
_ = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
{-# INLINE bitSizeMaybe #-}
bitSize :: Expr 'BoolSort -> Int
bitSize Expr 'BoolSort
_ = Int
1
{-# INLINE bitSize #-}
isSigned :: Expr 'BoolSort -> Bool
isSigned Expr 'BoolSort
_ = Bool
False
{-# INLINE isSigned #-}
shiftL :: Expr 'BoolSort -> Int -> Expr 'BoolSort
shiftL Expr 'BoolSort
b Int
0 = Expr 'BoolSort
b
shiftL Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
{-# INLINE shiftL #-}
shiftR :: Expr 'BoolSort -> Int -> Expr 'BoolSort
shiftR Expr 'BoolSort
b Int
0 = Expr 'BoolSort
b
shiftR Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
{-# INLINE shiftR #-}
rotateL :: Expr 'BoolSort -> Int -> Expr 'BoolSort
rotateL Expr 'BoolSort
b Int
_ = Expr 'BoolSort
b
{-# INLINE rotateL #-}
rotateR :: Expr 'BoolSort -> Int -> Expr 'BoolSort
rotateR Expr 'BoolSort
b Int
_ = Expr 'BoolSort
b
{-# INLINE rotateR #-}
popCount :: Expr 'BoolSort -> Int
popCount (Constant (BoolValue HaskellType 'BoolSort
b)) = if Bool
HaskellType 'BoolSort
b then Int
1 else Int
0
popCount Expr 'BoolSort
_ = String -> Int
forall a. HasCallStack => String -> a
error String
"Bits#popCount[Expr BoolSort] is only supported for constants."
{-# INLINE popCount #-}
instance (KnownBvEnc enc, KnownNat n) => Bits.Bits (Expr (BvSort enc n)) where
.&. :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(.&.) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
{-# INLINE (.&.) #-}
.|. :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(.|.) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
{-# INLINE (.|.) #-}
xor :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
xor = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
{-# INLINE xor #-}
complement :: Expr ('BvSort enc n) -> Expr ('BvSort enc n)
complement = Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
{-# INLINE complement #-}
zeroBits :: Expr ('BvSort enc n)
zeroBits = Expr ('BvSort enc n)
forall b. Boolean b => b
false
{-# INLINE zeroBits #-}
bit :: Int -> Expr ('BvSort enc n)
bit = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> (Int -> Value ('BvSort enc n)) -> Int -> Expr ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec enc n -> Value ('BvSort enc n)
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue (Bitvec enc n -> Value ('BvSort enc n))
-> (Int -> Bitvec enc n) -> Int -> Value ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Bitvec enc n
forall a. Bits a => Int -> a
Bits.bit
{-# INLINE bit #-}
testBit :: Expr ('BvSort enc n) -> Int -> Bool
testBit (Constant (BvValue HaskellType ('BvSort enc n)
b)) Int
i = Bitvec enc n -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
Bits.testBit Bitvec enc n
HaskellType ('BvSort enc n)
b Int
i
testBit Expr ('BvSort enc n)
_ Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error String
"Bits#testBit[Expr BvSort] is only supported for constants."
{-# INLINE testBit #-}
bitSizeMaybe :: Expr ('BvSort enc n) -> Maybe Int
bitSizeMaybe Expr ('BvSort enc n)
_ = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n -> Integer) -> Proxy n -> Integer
forall a b. (a -> b) -> a -> b
$ forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n
{-# INLINE bitSizeMaybe #-}
bitSize :: Expr ('BvSort enc n) -> Int
bitSize Expr ('BvSort enc n)
_ = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n -> Integer) -> Proxy n -> Integer
forall a b. (a -> b) -> a -> b
$ forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n
{-# INLINE bitSize #-}
isSigned :: Expr ('BvSort enc n) -> Bool
isSigned Expr ('BvSort enc n)
_ = case forall (enc :: BvEnc). KnownBvEnc enc => SBvEnc enc
bvEncSing @enc of
SBvEnc enc
SUnsigned -> Bool
False
SBvEnc enc
SSigned -> Bool
True
{-# INLINE isSigned #-}
shiftL :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
shiftL Expr ('BvSort enc n)
b Int
i = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL Expr ('BvSort enc n)
b (Int -> Expr ('BvSort enc n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
{-# INLINE shiftL #-}
shiftR :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
shiftR Expr ('BvSort enc n)
b Int
i = case forall (enc :: BvEnc). KnownBvEnc enc => SBvEnc enc
bvEncSing @enc of
SBvEnc enc
SUnsigned -> Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR Expr ('BvSort enc n)
Expr ('BvSort 'Unsigned n)
b (Int -> Expr ('BvSort 'Unsigned n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
SBvEnc enc
SSigned -> Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR Expr ('BvSort enc n)
Expr ('BvSort 'Signed n)
b (Int -> Expr ('BvSort 'Signed n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
{-# INLINE shiftR #-}
rotateL :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
rotateL Expr ('BvSort enc n)
b Int
i = Int -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL Int
i Expr ('BvSort enc n)
b
{-# INLINE rotateL #-}
rotateR :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
rotateR Expr ('BvSort enc n)
b Int
i = Int -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR Int
i Expr ('BvSort enc n)
b
{-# INLINE rotateR #-}
popCount :: Expr ('BvSort enc n) -> Int
popCount (Constant (BvValue HaskellType ('BvSort enc n)
b)) = Bitvec enc n -> Int
forall a. Bits a => a -> Int
Bits.popCount Bitvec enc n
HaskellType ('BvSort enc n)
b
popCount Expr ('BvSort enc n)
_ = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Bits#popCount[Expr BvSort] is only supported for constants."
{-# INLINE popCount #-}
instance Semigroup (Expr StringSort) where
<> :: Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
(<>) = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat
{-# INLINE (<>) #-}
instance Monoid (Expr StringSort) where
mempty :: Expr 'StringSort
mempty = Value 'StringSort -> Expr 'StringSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'StringSort -> Expr 'StringSort)
-> Value 'StringSort -> Expr 'StringSort
forall a b. (a -> b) -> a -> b
$ HaskellType 'StringSort -> Value 'StringSort
StringValue Text
HaskellType 'StringSort
forall a. Monoid a => a
mempty
{-# INLINE mempty #-}
mappend :: Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
mappend = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE mappend #-}
instance IsString (Expr StringSort) where
fromString :: String -> Expr 'StringSort
fromString = Value 'StringSort -> Expr 'StringSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'StringSort -> Expr 'StringSort)
-> (String -> Value 'StringSort) -> String -> Expr 'StringSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value 'StringSort
HaskellType 'StringSort -> Value 'StringSort
StringValue (Text -> Value 'StringSort)
-> (String -> Text) -> String -> Value 'StringSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack
{-# INLINE fromString #-}
type instance Index (Expr StringSort) = Expr IntSort
type instance IxValue (Expr StringSort) = Expr StringSort
instance Ixed (Expr StringSort) where
ix :: Index (Expr 'StringSort)
-> Traversal' (Expr 'StringSort) (IxValue (Expr 'StringSort))
ix Index (Expr 'StringSort)
i IxValue (Expr 'StringSort) -> f (IxValue (Expr 'StringSort))
f Expr 'StringSort
s = IxValue (Expr 'StringSort) -> f (IxValue (Expr 'StringSort))
f (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s Index (Expr 'StringSort)
Expr 'IntSort
i) f (Expr 'StringSort)
-> (Expr 'StringSort -> Expr 'StringSort) -> f (Expr 'StringSort)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Expr 'StringSort
a ->
let l :: Expr 'StringSort
l = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
a Expr 'IntSort
0 Index (Expr 'StringSort)
Expr 'IntSort
i
r :: Expr 'StringSort
r = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
a Index (Expr 'StringSort)
Expr 'IntSort
i (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
a)
in Expr 'StringSort
l Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
<> Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace Expr 'StringSort
r (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
a Index (Expr 'StringSort)
Expr 'IntSort
i) Expr 'StringSort
s
instance AsEmpty (Expr StringSort) where
_Empty :: Prism' (Expr 'StringSort) ()
_Empty = (() -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe ()) -> Prism' (Expr 'StringSort) ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
(Expr 'StringSort -> () -> Expr 'StringSort
forall a b. a -> b -> a
const Expr 'StringSort
forall a. Monoid a => a
mempty)
(\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort
s Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr 'StringSort
forall a. Monoid a => a
mempty) (() -> Maybe ()
forall a. a -> Maybe a
Just ()) Maybe ()
forall a. Maybe a
Nothing)
instance Prefixed (Expr StringSort) where
prefixed :: Expr 'StringSort -> Prism' (Expr 'StringSort) (Expr 'StringSort)
prefixed Expr 'StringSort
p = (Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Prism' (Expr 'StringSort) (Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
(Expr 'StringSort
p <>)
(\Expr 'StringSort
s -> Expr 'BoolSort
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'StringSort
p Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
`strPrefixOf` Expr 'StringSort
s) (Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a b. (a -> b) -> a -> b
$ Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace Expr 'StringSort
s Expr 'StringSort
p Expr 'StringSort
forall a. Monoid a => a
mempty) Maybe (Expr 'StringSort)
forall a. Maybe a
Nothing)
instance Suffixed (Expr StringSort) where
suffixed :: Expr 'StringSort -> Prism' (Expr 'StringSort) (Expr 'StringSort)
suffixed Expr 'StringSort
qs = (Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Prism' (Expr 'StringSort) (Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
(Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
<> Expr 'StringSort
qs)
(\Expr 'StringSort
s -> Expr 'BoolSort
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'StringSort
qs Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
`strSuffixOf` Expr 'StringSort
s) (Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a b. (a -> b) -> a -> b
$ Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
0 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
qs)) Maybe (Expr 'StringSort)
forall a. Maybe a
Nothing)
instance Cons (Expr StringSort) (Expr StringSort) (Expr StringSort) (Expr StringSort) where
_Cons :: Prism
(Expr 'StringSort)
(Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
_Cons = ((Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort, Expr 'StringSort))
-> Prism
(Expr 'StringSort)
(Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
((Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>))
(\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
>? Expr 'IntSort
0) ((Expr 'StringSort, Expr 'StringSort)
-> Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s Expr 'IntSort
0, Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
1 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s))) Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. Maybe a
Nothing)
instance Snoc (Expr StringSort) (Expr StringSort) (Expr StringSort) (Expr StringSort) where
_Snoc :: Prism
(Expr 'StringSort)
(Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
_Snoc = ((Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort, Expr 'StringSort))
-> Prism
(Expr 'StringSort)
(Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
(Expr 'StringSort, Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
((Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>))
(\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
>? Expr 'IntSort
0) ((Expr 'StringSort, Expr 'StringSort)
-> Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
0 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'IntSort
1), Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'IntSort
1))) Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. Maybe a
Nothing)
type instance Index (Expr (ArraySort k v)) = Expr k
type instance IxValue (Expr (ArraySort k v)) = Expr v
instance (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Ord (HaskellType v)) => Ixed (Expr (ArraySort k v)) where
ix :: Index (Expr ('ArraySort k v))
-> Traversal'
(Expr ('ArraySort k v)) (IxValue (Expr ('ArraySort k v)))
ix Index (Expr ('ArraySort k v))
i IxValue (Expr ('ArraySort k v))
-> f (IxValue (Expr ('ArraySort k v)))
f Expr ('ArraySort k v)
arr = IxValue (Expr ('ArraySort k v))
-> f (IxValue (Expr ('ArraySort k v)))
f (Expr ('ArraySort k v) -> Expr k -> Expr v
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
select Expr ('ArraySort k v)
arr Index (Expr ('ArraySort k v))
Expr k
i) f (Expr v)
-> (Expr v -> Expr ('ArraySort k v)) -> f (Expr ('ArraySort k v))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
store Expr ('ArraySort k v)
arr Index (Expr ('ArraySort k v))
Expr k
i
instance Uniplate1 Expr '[KnownSMTSort] where
uniplate1 :: forall (m :: * -> *) (b :: SMTSort).
(Applicative m, AllC '[KnownSMTSort] b) =>
(forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a))
-> Expr b -> m (Expr b)
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ expr :: Expr b
expr@(Var SMTVar b
_) = Expr b -> m (Expr b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr b
expr
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ expr :: Expr b
expr@(Constant Value b
_) = Expr b -> m (Expr b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr b
expr
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Plus Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Minus Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Neg Expr b
x) = Expr b -> Expr b
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Mul Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Abs Expr b
x) = Expr b -> Expr b
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Mod Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Rem Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Rem (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (IDiv Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Div Expr 'RealSort
x Expr 'RealSort
y) = Expr 'RealSort -> Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div (Expr 'RealSort -> Expr 'RealSort -> Expr b)
-> m (Expr 'RealSort) -> m (Expr 'RealSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x m (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (LTH Expr t
x Expr t
y) = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTH (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (LTHE Expr t
x Expr t
y) = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTHE (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (EQU Vector (n + 2) (Expr t)
xs) = Vector (n + 2) (Expr t) -> Expr b
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr b)
-> m (Vector (n + 2) (Expr t)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> m (Expr t))
-> Vector (n + 2) (Expr t) -> m (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Vector (n + 2) (Expr t)
xs
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Distinct Vector (n + 2) (Expr t)
xs) = Vector (n + 2) (Expr t) -> Expr b
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr b)
-> m (Vector (n + 2) (Expr t)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> m (Expr t))
-> Vector (n + 2) (Expr t) -> m (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Vector (n + 2) (Expr t)
xs
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (GTHE Expr t
x Expr t
y) = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTHE (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (GTH Expr t
x Expr t
y) = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTH (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Not Expr b
x) = Expr b -> Expr b
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (And Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Or Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Impl Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Xor Expr b
x Expr b
y) = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ Expr b
Pi = Expr b -> m (Expr b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr b
Expr 'RealSort
Pi
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Sqrt Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Sqrt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Exp Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Exp (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Sin Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Sin (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Cos Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Cos (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Tan Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Tan (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Asin Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Asin (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Acos Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Acos (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Atan Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Atan (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ToReal Expr 'IntSort
x) = Expr 'IntSort -> Expr b
Expr 'IntSort -> Expr 'RealSort
ToReal (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ToInt Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'IntSort
ToInt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (IsInt Expr 'RealSort
x) = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'BoolSort
IsInt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Ite Expr 'BoolSort
p Expr b
t Expr b
n) = Expr 'BoolSort -> Expr b -> Expr b -> Expr b
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort -> Expr b -> Expr b -> Expr b)
-> m (Expr 'BoolSort) -> m (Expr b -> Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'BoolSort
p m (Expr b -> Expr b -> Expr b)
-> m (Expr b) -> m (Expr b -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
t m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
n
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNand (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNor (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y) = Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n) -> Expr b
Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR (Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr b)
-> m (Expr ('BvSort 'Unsigned n))
-> m (Expr ('BvSort 'Unsigned n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort 'Unsigned n) -> m (Expr ('BvSort 'Unsigned n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Unsigned n)
x m (Expr ('BvSort 'Unsigned n) -> Expr b)
-> m (Expr ('BvSort 'Unsigned n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort 'Unsigned n) -> m (Expr ('BvSort 'Unsigned n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Unsigned n)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y) = Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr b
Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR (Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr b)
-> m (Expr ('BvSort 'Signed n))
-> m (Expr ('BvSort 'Signed n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort 'Signed n) -> m (Expr ('BvSort 'Signed n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Signed n)
x m (Expr ('BvSort 'Signed n) -> Expr b)
-> m (Expr ('BvSort 'Signed n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort 'Signed n) -> m (Expr ('BvSort 'Signed n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Signed n)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y) = Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
BvConcat (Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc m) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc m) -> Expr b)
-> m (Expr ('BvSort enc m)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc m) -> m (Expr ('BvSort enc m))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc m)
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotL a
i Expr ('BvSort enc n)
x) = a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL a
i (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotR a
i Expr ('BvSort enc n)
x) = a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR a
i (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ArrSelect Expr ('ArraySort k b)
i Expr k
arr) = Expr ('ArraySort k b) -> Expr k -> Expr b
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect Expr ('ArraySort k b)
i (Expr k -> Expr b) -> m (Expr k) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr k -> m (Expr k)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr k
arr
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ArrStore Expr ('ArraySort k v)
i Expr k
x Expr v
arr) = Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
ArrStore Expr ('ArraySort k v)
i (Expr k -> Expr v -> Expr b) -> m (Expr k) -> m (Expr v -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr k -> m (Expr k)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr k
x m (Expr v -> Expr b) -> m (Expr v) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr v -> m (Expr v)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr v
arr
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrConcat Expr 'StringSort
x Expr 'StringSort
y) = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrLength Expr 'StringSort
x) = Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'IntSort
StrLength (Expr 'StringSort -> Expr b) -> m (Expr 'StringSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrAt Expr 'StringSort
x Expr 'IntSort
i) = Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j) = Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'IntSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
j
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y) = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y) = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrContains Expr 'StringSort
x Expr 'StringSort
y) = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i) = Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y') = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace (Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y') = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
expr) = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr b)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr b) -> m (Expr 'BoolSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Expr t -> Expr 'BoolSort
expr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ (ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
expr) = Expr 'BoolSort -> m (Expr 'BoolSort)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> m (Expr 'BoolSort))
-> Expr 'BoolSort -> m (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
expr
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
expr) = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr b)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr b) -> m (Expr 'BoolSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Expr t -> Expr 'BoolSort
expr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ (Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
expr) = Expr 'BoolSort -> m (Expr 'BoolSort)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> m (Expr 'BoolSort))
-> Expr 'BoolSort -> m (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
expr
instance KnownSMTSort t => Plated (Expr t) where
plate :: Traversal' (Expr t) (Expr t)
plate Expr t -> f (Expr t)
f = (forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> f (Expr a))
-> Expr t -> f (Expr t)
forall k (f :: k -> *) (cs :: [k -> Constraint]) (m :: * -> *)
(b :: k).
(Uniplate1 f cs, Applicative m, AllC cs b) =>
(forall (a :: k). AllC cs a => f a -> m (f a)) -> f b -> m (f b)
forall (m :: * -> *) (b :: SMTSort).
(Applicative m, AllC '[KnownSMTSort] b) =>
(forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a))
-> Expr b -> m (Expr b)
uniplate1 ((Expr t -> f (Expr t))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr t -> f (Expr t)
f)
where
tryPlate :: forall s f. (KnownSMTSort s, Applicative f) => (Expr s -> f (Expr s)) -> (forall r. KnownSMTSort r => Expr r -> f (Expr r))
tryPlate :: forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
expr = case SSMTSort s -> SSMTSort r -> Maybe (s :~: r)
forall k (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> Maybe (a :~: b)
geq (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @s) (Expr r -> SSMTSort r
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr r
expr) of
Just s :~: r
Refl -> Expr s -> f (Expr s)
f' Expr s
Expr r
expr
Maybe (s :~: r)
Nothing -> case Expr r
expr of
Var SMTVar r
_ -> Expr r -> f (Expr r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr r
expr
Constant Value r
_ -> Expr r -> f (Expr r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr r
expr
Plus Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Minus Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Neg Expr r
x -> Expr r -> Expr r
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
Mul Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Abs Expr r
x -> Expr r -> Expr r
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
Mod Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Rem Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
IDiv Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Div Expr 'RealSort
x Expr 'RealSort
y -> Expr 'RealSort -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div (Expr 'RealSort -> Expr 'RealSort -> Expr r)
-> f (Expr 'RealSort) -> f (Expr 'RealSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x f (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
y
LTH Expr t
x Expr t
y -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTH (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
LTHE Expr t
x Expr t
y -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTHE (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
EQU Vector (n + 2) (Expr t)
xs -> Vector (n + 2) (Expr t) -> Expr r
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr r)
-> f (Vector (n + 2) (Expr t)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> f (Expr t))
-> Vector (n + 2) (Expr t) -> f (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse ((Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f') Vector (n + 2) (Expr t)
xs
Distinct Vector (n + 2) (Expr t)
xs -> Vector (n + 2) (Expr t) -> Expr r
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr r)
-> f (Vector (n + 2) (Expr t)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> f (Expr t))
-> Vector (n + 2) (Expr t) -> f (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse ((Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f') Vector (n + 2) (Expr t)
xs
GTHE Expr t
x Expr t
y -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTHE (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
GTH Expr t
x Expr t
y -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTH (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
Not Expr r
x -> Expr r -> Expr r
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
And Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Or Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Impl Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Xor Expr r
x Expr r
y -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
Expr r
Pi -> Expr r -> f (Expr r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr r
Expr 'RealSort
Pi
Sqrt Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Sqrt (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Exp Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Exp (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Sin Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Sin (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Cos Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Cos (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Tan Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Tan (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Asin Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Asin (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Acos Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Acos (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Atan Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Atan (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
ToReal Expr 'IntSort
x -> Expr 'IntSort -> Expr r
Expr 'IntSort -> Expr 'RealSort
ToReal (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
x
ToInt Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'IntSort
ToInt (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
IsInt Expr 'RealSort
x -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'BoolSort
IsInt (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
Ite Expr 'BoolSort
p Expr r
t Expr r
n -> Expr 'BoolSort -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort -> Expr r -> Expr r -> Expr r)
-> f (Expr 'BoolSort) -> f (Expr r -> Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'BoolSort
p f (Expr r -> Expr r -> Expr r)
-> f (Expr r) -> f (Expr r -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
t f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
n
BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNand (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNor (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y -> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n) -> Expr r
Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR (Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr r)
-> f (Expr ('BvSort 'Unsigned n))
-> f (Expr ('BvSort 'Unsigned n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Unsigned n)
x f (Expr ('BvSort 'Unsigned n) -> Expr r)
-> f (Expr ('BvSort 'Unsigned n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Unsigned n)
y
BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y -> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr r
Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR (Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr r)
-> f (Expr ('BvSort 'Signed n))
-> f (Expr ('BvSort 'Signed n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Signed n)
x f (Expr ('BvSort 'Signed n) -> Expr r)
-> f (Expr ('BvSort 'Signed n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Signed n)
y
BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y -> Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
BvConcat (Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc m) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc m) -> Expr r)
-> f (Expr ('BvSort enc m)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc m)
y
BvRotL a
i Expr ('BvSort enc n)
x -> a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL a
i (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x
BvRotR a
i Expr ('BvSort enc n)
x -> a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR a
i (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x
ArrSelect Expr ('ArraySort k r)
i Expr k
arr -> Expr ('ArraySort k r) -> Expr k -> Expr r
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect Expr ('ArraySort k r)
i (Expr k -> Expr r) -> f (Expr k) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr k
arr
ArrStore Expr ('ArraySort k v)
i Expr k
x Expr v
arr -> Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
ArrStore Expr ('ArraySort k v)
i (Expr k -> Expr v -> Expr r) -> f (Expr k) -> f (Expr v -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr k
x f (Expr v -> Expr r) -> f (Expr v) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr v
arr
StrConcat Expr 'StringSort
x Expr 'StringSort
y -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
StrLength Expr 'StringSort
x -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'IntSort
StrLength (Expr 'StringSort -> Expr r) -> f (Expr 'StringSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x
StrAt Expr 'StringSort
x Expr 'IntSort
i -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j -> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'IntSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
j
StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
StrContains Expr 'StringSort
x Expr 'StringSort
y -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i -> Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y' -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace (Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y' -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
qexpr -> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr r)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr r) -> f (Expr 'BoolSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' (Expr t -> Expr 'BoolSort
qexpr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
qexpr -> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> f (Expr 'BoolSort))
-> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
qexpr
Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
qexpr -> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr r)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr r) -> f (Expr 'BoolSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' (Expr t -> Expr 'BoolSort
qexpr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
qexpr -> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> f (Expr 'BoolSort))
-> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
qexpr
instance GNFData Expr where
grnf :: forall (a :: SMTSort). Expr a -> ()
grnf Expr a
expr = case Expr a
expr of
Var (SMTVar Int
vId) -> Int
vId Int -> () -> ()
forall a b. a -> b -> b
`seq` ()
Constant Value a
c -> Value a
c Value a -> () -> ()
forall a b. a -> b -> b
`seq` ()
Plus Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Minus Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Neg Expr a
e -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
Mul Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Abs Expr a
e -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
Mod Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Rem Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
IDiv Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Div Expr 'RealSort
e1 Expr 'RealSort
e2 -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e2
LTH Expr t
e1 Expr t
e2 -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
LTHE Expr t
e1 Expr t
e2 -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
EQU Vector (n + 2) (Expr t)
vec -> Vector (n + 2) (Expr t)
vec Vector (n + 2) (Expr t) -> () -> ()
forall a b. a -> b -> b
`seq` (() -> Expr t -> ()) -> () -> Vector (n + 2) (Expr t) -> ()
forall a b (n :: Nat). (a -> b -> a) -> a -> Vector n b -> a
V.foldl' ((Expr t -> ()) -> () -> Expr t -> ()
forall a b. a -> b -> a
const Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf) () Vector (n + 2) (Expr t)
vec
Distinct Vector (n + 2) (Expr t)
vec -> Vector (n + 2) (Expr t)
vec Vector (n + 2) (Expr t) -> () -> ()
forall a b. a -> b -> b
`seq` (() -> Expr t -> ()) -> () -> Vector (n + 2) (Expr t) -> ()
forall a b (n :: Nat). (a -> b -> a) -> a -> Vector n b -> a
V.foldl' ((Expr t -> ()) -> () -> Expr t -> ()
forall a b. a -> b -> a
const Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf) () Vector (n + 2) (Expr t)
vec
GTHE Expr t
e1 Expr t
e2 -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
GTH Expr t
e1 Expr t
e2 -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
Not Expr a
e -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
And Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Or Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Impl Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Xor Expr a
e1 Expr a
e2 -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
Expr a
Pi -> ()
Sqrt Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Exp Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Sin Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Cos Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Tan Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Asin Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Acos Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Atan Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
ToReal Expr 'IntSort
e -> Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e
ToInt Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
IsInt Expr 'RealSort
e -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
Ite Expr 'BoolSort
c Expr a
e1 Expr a
e2 -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'BoolSort
c () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
BvNand Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2 -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
BvNor Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2 -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
BvShL Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2 -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
BvLShR Expr ('BvSort 'Unsigned n)
e1 Expr ('BvSort 'Unsigned n)
e2 -> Expr ('BvSort 'Unsigned n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Unsigned n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort 'Unsigned n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Unsigned n)
e2
BvAShR Expr ('BvSort 'Signed n)
e1 Expr ('BvSort 'Signed n)
e2 -> Expr ('BvSort 'Signed n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Signed n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort 'Signed n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Signed n)
e2
BvConcat Expr ('BvSort enc n)
e1 Expr ('BvSort enc m)
e2 -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc m) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc m)
e2
BvRotL a
_ Expr ('BvSort enc n)
e -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e
BvRotR a
_ Expr ('BvSort enc n)
e -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e
ArrSelect Expr ('ArraySort k a)
e1 Expr k
e2 -> Expr ('ArraySort k a) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k a)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2
ArrStore Expr ('ArraySort k v)
e1 Expr k
e2 Expr v
e3 -> Expr ('ArraySort k v) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k v)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr v -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr v
e3
StrConcat Expr 'StringSort
e1 Expr 'StringSort
e2 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
StrLength Expr 'StringSort
e -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e
StrAt Expr 'StringSort
e1 Expr 'IntSort
e2 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2
StrSubstring Expr 'StringSort
e1 Expr 'IntSort
e2 Expr 'IntSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
StrPrefixOf Expr 'StringSort
e1 Expr 'StringSort
e2 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
StrSuffixOf Expr 'StringSort
e1 Expr 'StringSort
e2 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
StrContains Expr 'StringSort
e1 Expr 'StringSort
e2 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
StrIndexOf Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'IntSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
StrReplace Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
StrReplaceAll Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_ -> ()
ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
f -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf (Expr 'BoolSort -> ()) -> Expr 'BoolSort -> ()
forall a b. (a -> b) -> a -> b
$ Expr t -> Expr 'BoolSort
f (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv
Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_ -> ()
Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
f -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf (Expr 'BoolSort -> ()) -> Expr 'BoolSort -> ()
forall a b. (a -> b) -> a -> b
$ Expr t -> Expr 'BoolSort
f (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv
instance Eq (Expr t) where
== :: Expr t -> Expr t -> Bool
(==) = Expr t -> Expr t -> Bool
forall {k} (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Bool
defaultEq
instance Ord (Expr t) where
compare :: Expr t -> Expr t -> Ordering
compare = Expr t -> Expr t -> Ordering
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> Ordering
defaultCompare
instance GEq Expr where
geq :: forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> Maybe (a :~: b)
geq = Expr a -> Expr b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> Maybe (a :~: b)
defaultGeq
gcomparing :: GCompare f => [(f a, f b)] -> GOrdering a b
gcomparing :: forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [] = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcomparing ((f a
x,f b
y):[(f a, f b)]
xys) = case f a -> f b -> GOrdering a b
forall (a :: k) (b :: k). f a -> f b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
gcompare f a
x f b
y of
GOrdering a b
GEQ -> [(f a, f b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(f a, f b)]
xys
GOrdering a b
o -> GOrdering a b
o
instance GCompare Expr where
gcompare :: forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Var SMTVar a
v) (Var SMTVar b
v') = case SSMTSort a -> SSMTSort b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (SMTVar a -> SSMTSort a
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' SMTVar a
v) (SMTVar b -> SSMTSort b
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' SMTVar b
v') of
GOrdering a b
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering a b
GEQ -> case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @_ @Int SMTVar a
v) (SMTVar b -> Int
forall a b. Coercible a b => a -> b
coerce SMTVar b
v') of
Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
EQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering a b
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Var SMTVar a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Var SMTVar b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Constant Value a
c) (Constant Value b
c') = Value a -> Value b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Value a -> Value b -> GOrdering a b
gcompare Value a
c Value b
c'
gcompare (Constant Value a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Constant Value b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Plus Expr a
x Expr a
y) (Plus Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Plus Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Plus Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Minus Expr a
x Expr a
y) (Minus Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Minus Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Minus Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Neg Expr a
x) (Neg Expr b
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
gcompare (Neg Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Neg Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Mul Expr a
x Expr a
y) (Mul Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Mul Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Mul Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Abs Expr a
x) (Abs Expr b
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
gcompare (Abs Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Abs Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Mod Expr a
x Expr a
y) (Mod Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Mod Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Mod Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Rem Expr a
x Expr a
y) (Rem Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Rem Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Rem Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (IDiv Expr a
x Expr a
y) (IDiv Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (IDiv Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (IDiv Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Div Expr 'RealSort
x Expr 'RealSort
y) (Div Expr 'RealSort
x' Expr 'RealSort
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'RealSort
x,Expr b
Expr 'RealSort
x'), (Expr a
Expr 'RealSort
y,Expr b
Expr 'RealSort
y')]
gcompare (Div Expr 'RealSort
_ Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Div Expr 'RealSort
_ Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (LTH Expr t
x Expr t
y) (LTH Expr t
x' Expr t
y') = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (LTH Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (LTH Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (LTHE Expr t
x Expr t
y) (LTHE Expr t
x' Expr t
y') = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (LTHE Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (LTHE Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (EQU (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs)) (EQU (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs')) = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs ) ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs') of
Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
EQ -> case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing ([(Expr t, Expr t)] -> GOrdering t t)
-> [(Expr t, Expr t)] -> GOrdering t t
forall a b. (a -> b) -> a -> b
$ [Expr t] -> [Expr t] -> [(Expr t, Expr t)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Expr t]
xs [Expr t]
xs' of
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (EQU Vector (n + 2) (Expr t)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (EQU Vector (n + 2) (Expr t)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Distinct (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs)) (Distinct (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs')) = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs ) ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs') of
Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
EQ -> case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing ([(Expr t, Expr t)] -> GOrdering t t)
-> [(Expr t, Expr t)] -> GOrdering t t
forall a b. (a -> b) -> a -> b
$ [Expr t] -> [Expr t] -> [(Expr t, Expr t)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Expr t]
xs [Expr t]
xs' of
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Distinct Vector (n + 2) (Expr t)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Distinct Vector (n + 2) (Expr t)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (GTHE Expr t
x Expr t
y) (GTHE Expr t
x' Expr t
y') = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (GTHE Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (GTHE Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (GTH Expr t
x Expr t
y) (GTH Expr t
x' Expr t
y') = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (GTH Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (GTH Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Not Expr a
x) (Not Expr b
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
gcompare (Not Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Not Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (And Expr a
x Expr a
y) (And Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (And Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (And Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Or Expr a
x Expr a
y) (Or Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Or Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Or Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Impl Expr a
x Expr a
y) (Impl Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Impl Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Impl Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Xor Expr a
x Expr a
y) (Xor Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
gcompare (Xor Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Xor Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare Expr a
Pi Expr b
Pi = GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
gcompare Expr a
Pi Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ Expr b
Pi = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Sqrt Expr 'RealSort
x) (Sqrt Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Sqrt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Sqrt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Exp Expr 'RealSort
x) (Exp Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Exp Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Exp Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Sin Expr 'RealSort
x) (Sin Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Sin Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Sin Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Cos Expr 'RealSort
x) (Cos Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Cos Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Cos Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Tan Expr 'RealSort
x) (Tan Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Tan Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Tan Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Asin Expr 'RealSort
x) (Asin Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Asin Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Asin Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Acos Expr 'RealSort
x) (Acos Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Acos Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Acos Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Atan Expr 'RealSort
x) (Atan Expr 'RealSort
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
gcompare (Atan Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Atan Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ToReal Expr 'IntSort
x) (ToReal Expr 'IntSort
x') = case Expr 'IntSort -> Expr 'IntSort -> GOrdering 'IntSort 'IntSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'IntSort
x Expr 'IntSort
x' of
GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ToReal Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (ToReal Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ToInt Expr 'RealSort
x) (ToInt Expr 'RealSort
x') = case Expr 'RealSort -> Expr 'RealSort -> GOrdering 'RealSort 'RealSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'RealSort
x Expr 'RealSort
x' of
GOrdering 'RealSort 'RealSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'RealSort 'RealSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'RealSort 'RealSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ToInt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (ToInt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (IsInt Expr 'RealSort
x) (IsInt Expr 'RealSort
x') = case Expr 'RealSort -> Expr 'RealSort -> GOrdering 'RealSort 'RealSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'RealSort
x Expr 'RealSort
x' of
GOrdering 'RealSort 'RealSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'RealSort 'RealSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'RealSort 'RealSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (IsInt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (IsInt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Ite Expr 'BoolSort
p Expr a
t Expr a
n) (Ite Expr 'BoolSort
p' Expr b
t' Expr b
n') = case Expr 'BoolSort -> Expr 'BoolSort -> GOrdering 'BoolSort 'BoolSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'BoolSort
p Expr 'BoolSort
p' of
GOrdering 'BoolSort 'BoolSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'BoolSort 'BoolSort
GEQ -> [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
t,Expr b
t'), (Expr a
n,Expr b
n')]
GOrdering 'BoolSort 'BoolSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Ite Expr 'BoolSort
_ Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (Ite Expr 'BoolSort
_ Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) (BvNand Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
gcompare (BvNand Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvNand Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) (BvNor Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
gcompare (BvNor Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvNor Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y) (BvShL Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
gcompare (BvShL Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvShL Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y) (BvLShR Expr ('BvSort 'Unsigned n)
x' Expr ('BvSort 'Unsigned n)
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort 'Unsigned n)
x,Expr b
Expr ('BvSort 'Unsigned n)
x'), (Expr a
Expr ('BvSort 'Unsigned n)
y,Expr b
Expr ('BvSort 'Unsigned n)
y')]
gcompare (BvLShR Expr ('BvSort 'Unsigned n)
_ Expr ('BvSort 'Unsigned n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvLShR Expr ('BvSort 'Unsigned n)
_ Expr ('BvSort 'Unsigned n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y) (BvAShR Expr ('BvSort 'Signed n)
x' Expr ('BvSort 'Signed n)
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort 'Signed n)
x,Expr b
Expr ('BvSort 'Signed n)
x'), (Expr a
Expr ('BvSort 'Signed n)
y,Expr b
Expr ('BvSort 'Signed n)
y')]
gcompare (BvAShR Expr ('BvSort 'Signed n)
_ Expr ('BvSort 'Signed n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvAShR Expr ('BvSort 'Signed n)
_ Expr ('BvSort 'Signed n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y) (BvConcat Expr ('BvSort enc n)
x' Expr ('BvSort enc m)
y') = case SSMTSort ('BvSort enc n)
-> SSMTSort ('BvSort enc n)
-> GOrdering ('BvSort enc n) ('BvSort enc n)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (Expr ('BvSort enc n) -> SSMTSort ('BvSort enc n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc n)
x) (Expr ('BvSort enc n) -> SSMTSort ('BvSort enc n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc n)
x') of
GOrdering ('BvSort enc n) ('BvSort enc n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('BvSort enc n) ('BvSort enc n)
GEQ -> case Expr ('BvSort enc n)
-> Expr ('BvSort enc n)
-> GOrdering ('BvSort enc n) ('BvSort enc n)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('BvSort enc n)
x Expr ('BvSort enc n)
x' of
GOrdering ('BvSort enc n) ('BvSort enc n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('BvSort enc n) ('BvSort enc n)
GEQ -> case SSMTSort ('BvSort enc m)
-> SSMTSort ('BvSort enc m)
-> GOrdering ('BvSort enc m) ('BvSort enc m)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (Expr ('BvSort enc m) -> SSMTSort ('BvSort enc m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc m)
y) (Expr ('BvSort enc m) -> SSMTSort ('BvSort enc m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc m)
y') of
GOrdering ('BvSort enc m) ('BvSort enc m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('BvSort enc m) ('BvSort enc m)
GEQ -> case Expr ('BvSort enc m)
-> Expr ('BvSort enc m)
-> GOrdering ('BvSort enc m) ('BvSort enc m)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('BvSort enc m)
y Expr ('BvSort enc m)
y' of
GOrdering ('BvSort enc m) ('BvSort enc m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('BvSort enc m) ('BvSort enc m)
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering ('BvSort enc m) ('BvSort enc m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering ('BvSort enc m) ('BvSort enc m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering ('BvSort enc n) ('BvSort enc n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering ('BvSort enc n) ('BvSort enc n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvConcat Expr ('BvSort enc n)
_ Expr ('BvSort enc m)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvConcat Expr ('BvSort enc n)
_ Expr ('BvSort enc m)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvRotL a
i Expr ('BvSort enc n)
x) (BvRotL a
i' Expr ('BvSort enc n)
x') = case Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i :: Integer) (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i') of
Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
EQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr ('BvSort enc n)
x Expr b
Expr ('BvSort enc n)
x'
Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvRotL a
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvRotL a
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvRotR a
i Expr ('BvSort enc n)
x) (BvRotR a
i' Expr ('BvSort enc n)
x') = case Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i :: Integer) (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i') of
Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
Ordering
EQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr ('BvSort enc n)
x Expr b
Expr ('BvSort enc n)
x'
Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (BvRotR a
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (BvRotR a
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ArrSelect Expr ('ArraySort k a)
arr Expr k
i) (ArrSelect Expr ('ArraySort k b)
arr' Expr k
i') = case Expr ('ArraySort k a)
-> Expr ('ArraySort k b)
-> GOrdering ('ArraySort k a) ('ArraySort k b)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('ArraySort k a)
arr Expr ('ArraySort k b)
arr' of
GOrdering ('ArraySort k a) ('ArraySort k b)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('ArraySort k a) ('ArraySort k b)
GEQ -> case Expr k -> Expr k -> GOrdering k k
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr k
i Expr k
i' of
GOrdering k k
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering k k
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering k k
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering ('ArraySort k a) ('ArraySort k b)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ArrSelect Expr ('ArraySort k a)
_ Expr k
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (ArrSelect Expr ('ArraySort k b)
_ Expr k
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ArrStore Expr ('ArraySort k v)
arr Expr k
k Expr v
v) (ArrStore Expr ('ArraySort k v)
arr' Expr k
k' Expr v
v') = case Expr ('ArraySort k v)
-> Expr ('ArraySort k v)
-> GOrdering ('ArraySort k v) ('ArraySort k v)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('ArraySort k v)
arr Expr ('ArraySort k v)
arr' of
GOrdering ('ArraySort k v) ('ArraySort k v)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering ('ArraySort k v) ('ArraySort k v)
GEQ -> case Expr k -> Expr k -> GOrdering k k
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr k
k Expr k
k' of
GOrdering k k
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering k k
GEQ -> case Expr v -> Expr v -> GOrdering v v
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr v
v Expr v
v' of
GOrdering v v
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering v v
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering v v
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering k k
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering ('ArraySort k v) ('ArraySort k v)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ArrStore Expr ('ArraySort k v)
_ Expr k
_ Expr v
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (ArrStore Expr ('ArraySort k v)
_ Expr k
_ Expr v
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrConcat Expr 'StringSort
x Expr 'StringSort
y) (StrConcat Expr 'StringSort
x' Expr 'StringSort
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
x,Expr b
Expr 'StringSort
x'), (Expr a
Expr 'StringSort
y,Expr b
Expr 'StringSort
y')]
gcompare (StrConcat Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrConcat Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrLength Expr 'StringSort
x) (StrLength Expr 'StringSort
x') = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrLength Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrLength Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrAt Expr 'StringSort
x Expr 'IntSort
i) (StrAt Expr 'StringSort
x' Expr 'IntSort
i') = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> case Expr 'IntSort -> Expr 'IntSort -> GOrdering 'IntSort 'IntSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'IntSort
i Expr 'IntSort
i' of
GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrAt Expr 'StringSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrAt Expr 'StringSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j) (StrSubstring Expr 'StringSort
x' Expr 'IntSort
i' Expr 'IntSort
j') = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> case [(Expr 'IntSort, Expr 'IntSort)] -> GOrdering 'IntSort 'IntSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'IntSort
i,Expr 'IntSort
i'), (Expr 'IntSort
j,Expr 'IntSort
j')] of
GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrSubstring Expr 'StringSort
_ Expr 'IntSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrSubstring Expr 'StringSort
_ Expr 'IntSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y) (StrPrefixOf Expr 'StringSort
x' Expr 'StringSort
y') = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrPrefixOf Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrPrefixOf Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y) (StrSuffixOf Expr 'StringSort
x' Expr 'StringSort
y') = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrSuffixOf Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrSuffixOf Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrContains Expr 'StringSort
x Expr 'StringSort
y) (StrContains Expr 'StringSort
x' Expr 'StringSort
y') = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrContains Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrContains Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i) (StrIndexOf Expr 'StringSort
x' Expr 'StringSort
y' Expr 'IntSort
i') = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
GOrdering 'StringSort 'StringSort
GEQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'IntSort
i Expr b
Expr 'IntSort
i'
GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrIndexOf Expr 'StringSort
_ Expr 'StringSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrIndexOf Expr 'StringSort
_ Expr 'StringSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrReplace Expr 'StringSort
source Expr 'StringSort
target Expr 'StringSort
replacement) (StrReplace Expr 'StringSort
source' Expr 'StringSort
target' Expr 'StringSort
replacement') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
source, Expr b
Expr 'StringSort
source'), (Expr a
Expr 'StringSort
target, Expr b
Expr 'StringSort
target'), (Expr a
Expr 'StringSort
replacement, Expr b
Expr 'StringSort
replacement')]
gcompare (StrReplace Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrReplace Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (StrReplaceAll Expr 'StringSort
source Expr 'StringSort
target Expr 'StringSort
replacement) (StrReplaceAll Expr 'StringSort
source' Expr 'StringSort
target' Expr 'StringSort
replacement') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
source, Expr b
Expr 'StringSort
source'), (Expr a
Expr 'StringSort
target, Expr b
Expr 'StringSort
target'), (Expr a
Expr 'StringSort
replacement, Expr b
Expr 'StringSort
replacement')]
gcompare (StrReplaceAll Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (StrReplaceAll Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr) (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Expr t -> Expr 'BoolSort
expr (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1))) (Expr t -> Expr 'BoolSort
expr' (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1)))
gcompare (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcompare Expr a
_ (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
gcompare (Exists Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr) (Exists Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Expr t -> Expr 'BoolSort
expr (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1))) (Expr t -> Expr 'BoolSort
expr' (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1)))