{-# LANGUAGE RoleAnnotations #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DerivingStrategies #-}

module Language.Hasmtlib.Type.Expr where

import Prelude hiding (Integral(..), not, and, or, any, all, (&&), (||))
import Language.Hasmtlib.Internal.Render
import Language.Hasmtlib.Internal.Uniplate1
import Language.Hasmtlib.Type.ArrayMap
import Language.Hasmtlib.Type.SMTSort
import Language.Hasmtlib.Integraled
import Language.Hasmtlib.Boolean
import Data.GADT.Compare
import Data.GADT.DeepSeq
import Data.Map hiding (toList)
import Data.Proxy
import Data.Coerce
import Data.Int
import Data.Word
import Data.Void
import Data.Sequence (Seq)
import Data.Tree (Tree)
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 Data.ByteString.Builder
import Data.ByteString.Lazy.UTF8 (toString)
import qualified Data.Vector.Sized as V
import Control.Lens hiding (from, to)
import GHC.TypeLits hiding (someNatVal)
import GHC.TypeNats (someNatVal)
import GHC.Generics

-- | An internal SMT variable with a phantom-type which holds an 'Int' as it's identifier.
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)

-- | A wrapper for values of 'SMTSort's.
data Value (t :: SMTSort) where
  IntValue    :: HaskellType IntSort    -> Value IntSort
  RealValue   :: HaskellType RealSort   -> Value RealSort
  BoolValue   :: HaskellType BoolSort   -> Value BoolSort
  BvValue     :: KnownNat n => HaskellType (BvSort n) -> Value (BvSort n)
  ArrayValue  :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Eq (HaskellType v)) => HaskellType (ArraySort k v) -> Value (ArraySort k v)
  StringValue :: HaskellType StringSort -> Value StringSort

deriving instance Eq (HaskellType t) => Eq (Value t)
deriving instance Ord (HaskellType t) => Ord (Value t)

instance GEq Value where
  geq :: forall (a :: SMTSort) (b :: SMTSort).
Value a -> Value b -> Maybe (a :~: b)
geq (BoolValue HaskellType 'BoolSort
x) (BoolValue HaskellType 'BoolSort
y)   = if Bool
HaskellType 'BoolSort
x Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
HaskellType 'BoolSort
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq (IntValue HaskellType 'IntSort
x) (IntValue HaskellType 'IntSort
y)     = if Integer
HaskellType 'IntSort
x Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
HaskellType 'IntSort
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq (RealValue HaskellType 'RealSort
x) (RealValue HaskellType 'RealSort
y)   = if Double
HaskellType 'RealSort
x Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
HaskellType 'RealSort
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq (BvValue HaskellType ('BvSort n)
x) (BvValue HaskellType ('BvSort n)
y)       = case Bitvec n -> Bitvec n -> OrderingI n n
forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *)
       (proxy2 :: Nat -> *).
(KnownNat a, KnownNat b) =>
proxy1 a -> proxy2 b -> OrderingI a b
cmpNat Bitvec n
HaskellType ('BvSort n)
x Bitvec n
HaskellType ('BvSort n)
y of
    OrderingI n n
EQI -> if Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bool
forall a. Eq a => a -> a -> Bool
== Bitvec n
HaskellType ('BvSort n)
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
    OrderingI n n
_   -> Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq ax :: Value a
ax@(ArrayValue HaskellType ('ArraySort k v)
x) ay :: Value b
ay@(ArrayValue HaskellType ('ArraySort k v)
y) = case SSMTSort a -> SSMTSort b -> Maybe (a :~: b)
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 (Value a -> SSMTSort a
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Value a
ax) (Value b -> SSMTSort b
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Value b
ay) of
    Maybe (a :~: b)
Nothing -> Maybe (a :~: b)
forall a. Maybe a
Nothing
    Just a :~: b
Refl -> if ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
x ConstArray (HaskellType k) (HaskellType v)
-> ConstArray (HaskellType k) (HaskellType v) -> Bool
forall a. Eq a => a -> a -> Bool
== ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq (StringValue HaskellType 'StringSort
x) (StringValue HaskellType 'StringSort
y) = if Text
HaskellType 'StringSort
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
HaskellType 'StringSort
y then (a :~: b) -> Maybe (a :~: b)
forall a. a -> Maybe a
Just a :~: a
a :~: b
forall {k} (a :: k). a :~: a
Refl else Maybe (a :~: b)
forall a. Maybe a
Nothing
  geq Value a
_ Value b
_ = Maybe (a :~: b)
forall a. Maybe a
Nothing

-- | Unwrap a value from 'Value'.
unwrapValue :: Value t -> HaskellType t
unwrapValue :: forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue (IntValue  HaskellType 'IntSort
v)   = HaskellType t
HaskellType 'IntSort
v
unwrapValue (RealValue HaskellType 'RealSort
v)   = HaskellType t
HaskellType 'RealSort
v
unwrapValue (BoolValue HaskellType 'BoolSort
v)   = HaskellType t
HaskellType 'BoolSort
v
unwrapValue (BvValue   HaskellType ('BvSort n)
v)   = HaskellType t
HaskellType ('BvSort n)
v
unwrapValue (ArrayValue HaskellType ('ArraySort k v)
v)  = HaskellType t
HaskellType ('ArraySort k v)
v
unwrapValue (StringValue HaskellType 'StringSort
v) = HaskellType t
HaskellType 'StringSort
v
{-# INLINEABLE unwrapValue #-}

-- | Wrap a value into 'Value'.
wrapValue :: forall t. KnownSMTSort t => HaskellType t -> Value t
wrapValue :: forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue = case forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t of
  SSMTSort t
SIntSort       -> HaskellType t -> Value t
HaskellType 'IntSort -> Value 'IntSort
IntValue
  SSMTSort t
SRealSort      -> HaskellType t -> Value t
HaskellType 'RealSort -> Value 'RealSort
RealValue
  SSMTSort t
SBoolSort      -> HaskellType t -> Value t
HaskellType 'BoolSort -> Value 'BoolSort
BoolValue
  SBvSort Proxy n
_      -> HaskellType t -> Value t
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue
  SArraySort Proxy k
_ Proxy v
_ -> HaskellType t -> Value t
HaskellType ('ArraySort k v) -> Value ('ArraySort k v)
forall (t :: SMTSort) (n :: SMTSort).
(KnownSMTSort t, KnownSMTSort n, Ord (HaskellType t),
 Eq (HaskellType n)) =>
HaskellType ('ArraySort t n) -> Value ('ArraySort t n)
ArrayValue
  SSMTSort t
SStringSort    -> HaskellType t -> Value t
HaskellType 'StringSort -> Value 'StringSort
StringValue
{-# INLINEABLE wrapValue #-}

-- | An existential wrapper that hides some known 'SMTSort'.
type SomeKnownSMTSort f = SomeSMTSort '[KnownSMTSort] f

-- | Am SMT expression.
--   For internal use only.
--   For building expressions use the corresponding instances (Num, Boolean, ...).
data Expr (t :: SMTSort) where
  Var       :: SMTVar t -> Expr t
  Constant  :: Value  t -> Expr t

  Plus      :: 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       :: Expr IntSort  -> Expr IntSort  -> Expr IntSort
  IDiv      :: Expr IntSort  -> Expr IntSort  -> Expr IntSort
  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

  BvNot     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n)
  BvAnd     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvOr      :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvXor     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvNand    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvNor     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvNeg     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n)
  BvAdd     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvSub     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvMul     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvuDiv    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvuRem    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvShL     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvLShR    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvConcat  :: (KnownNat n, KnownNat m) => Expr (BvSort n) -> Expr (BvSort m) -> Expr (BvSort (n + m))
  BvRotL    :: (KnownNat n, KnownNat i, KnownNat (Mod i n)) => Proxy i -> Expr (BvSort n) -> Expr (BvSort n)
  BvRotR    :: (KnownNat n, KnownNat i, KnownNat (Mod i n)) => Proxy i -> Expr (BvSort n) -> Expr (BvSort n)
  BvuLT     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr BoolSort
  BvuLTHE   :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr BoolSort
  BvuGTHE   :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr BoolSort
  BvuGT     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr BoolSort

  ArrSelect :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Eq (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
  StrLT         :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrLTHE       :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  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

  -- | Just v if quantified var has been created already, Nothing otherwise
  ForAll    :: KnownSMTSort t => Maybe (SMTVar t) -> (Expr t -> Expr BoolSort) -> Expr BoolSort
  -- | Just v if quantified var has been created already, Nothing otherwise
  Exists    :: KnownSMTSort t => Maybe (SMTVar t) -> (Expr t -> Expr BoolSort) -> Expr BoolSort

  -- | Indicates whether an expression is a leaf.
  --   All non-recursive contructors form leafs.
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 #-}

-- | If condition (p :: b) then (t :: a) else (f :: a)
--
--    >>> ite true "1" "2"
--        "1"
--    >>> ite false 100 42
--        42
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 = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite
  {-# INLINE 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')

-- | Test two as on equality as SMT-Expression.
--
--   You can derive an instance of this class if your type is 'Generic'.
--
-- @
--     x <- var @RealType
--     y <- var
--     assert $ y === x && not (y /== x)
-- @
--
class Equatable a where
  -- | Test whether two values are equal in the SMT-Problem.
  (===) :: 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

  -- | Test whether two values are not equal in the SMT-Problem.
  (/==) :: 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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)

-- | Compare two as as SMT-Expression.
--
--   You can derive an instance of this class if your type is 'Generic'.
--
-- @
-- x <- var @RealSort
-- y <- var
-- assert $ x >? y
-- assert $ x === min' 42 100
-- @
--
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 <?, <=?, >=?, >?

-- | Minimum of two as SMT-Expression.
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

-- | Maximum of two as SMT-Expression.
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 Orderable (Expr IntSort) where
  <? :: Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
(<?)     = Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
LTH
  {-# INLINE (<?) #-}
  <=? :: Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
(<=?)    = Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
LTHE
  {-# INLINE (<=?) #-}
  >=? :: Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
(>=?)    = Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
GTHE
  {-# INLINE (>=?) #-}
  >? :: Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
(>?)     = Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
GTH
  {-# INLINE (>?) #-}

instance Orderable (Expr RealSort) where
  <? :: Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
(<?)     = Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
LTH
  {-# INLINE (<?) #-}
  <=? :: Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
(<=?)    = Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
LTHE
  {-# INLINE (<=?) #-}
  >=? :: Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
(>=?)    = Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
GTHE
  {-# INLINE (>=?) #-}
  >? :: Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
(>?)     = Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> Expr 'BoolSort
GTH
  {-# INLINE (>?) #-}

instance KnownNat n => Orderable (Expr (BvSort n)) where
  <? :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
(<?)     = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLT
  {-# INLINE (<?) #-}
  <=? :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
(<=?)    = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLTHE
  {-# INLINE (<=?) #-}
  >=? :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
(>=?)    = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGTHE
  {-# INLINE (>=?) #-}
  >? :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
(>?)     = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGT
  {-# INLINE (>?) #-}

-- | Lexicographic ordering for '(<?)' and reflexive closure of lexicographic ordering for '(<=?)'
instance Orderable (Expr StringSort) where
  <? :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
(<?)     = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLT
  {-# INLINE (<?) #-}
  <=? :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
(<=?)    = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLTHE
  {-# 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

-- Boring instances that end up being useful when deriving Orderable with Generics

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)

-- | Test multiple expressions on equality within in the 'SMT'-Problem.
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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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

-- | Test multiple expressions on distinctness within in the 'SMT'-Problem.
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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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

-- | A universal quantification for any specific 'SMTSort'.
--   If the type cannot be inferred, apply a type-annotation.
--   Nested quantifiers are also supported.
--
--   Usage:
--
--   @
--   assert $
--      for_all @IntSort $ \x ->
--         x + 0 === x && 0 + x === x
--   @
--
--   The lambdas 'x' is all-quantified here.
--   It will only be scoped for the lambdas body.
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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE for_all #-}

-- | An existential quantification for any specific 'SMTSort'
--   If the type cannot be inferred, apply a type-annotation.
--   Nested quantifiers are also supported.
--
--   Usage:
--
--   @
--   assert $
--      for_all @(BvSort 8) $ \x ->
--          exists $ \y ->
--            x - y === 0
--   @
--
--   The lambdas 'y' is existentially quantified here.
--   It will only be scoped for the lambdas body.
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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE exists #-}

-- | Select a value from an array.
select :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Eq (HaskellType v)) => Expr (ArraySort k v) -> Expr k -> Expr v
select :: forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Eq (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),
 Eq (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect
{-# INLINE select #-}

-- | Store a value in an array.
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 #-}

-- | Bitvector shift left
bvShL    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
bvShL :: forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
bvShL    = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL
{-# INLINE bvShL #-}

-- | Bitvector logical shift right
bvLShR   :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
bvLShR :: forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
bvLShR   = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR
{-# INLINE bvLShR #-}

-- | Concat two bitvectors
bvConcat :: (KnownNat n, KnownNat m) => Expr (BvSort n) -> Expr (BvSort m) -> Expr (BvSort (n + m))
bvConcat :: forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
bvConcat = Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
BvConcat
{-# INLINE bvConcat #-}

-- | Rotate bitvector left
bvRotL   :: (KnownNat n, KnownNat i, KnownNat (Mod i n)) => Proxy i -> Expr (BvSort n) -> Expr (BvSort n)
bvRotL :: forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
bvRotL   = Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL
{-# INLINE bvRotL #-}

-- | Rotate bitvector right
bvRotR   :: (KnownNat n, KnownNat i, KnownNat (Mod i n)) => Proxy i -> Expr (BvSort n) -> Expr (BvSort n)
bvRotR :: forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
bvRotR   = Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR
{-# INLINE bvRotR #-}

-- | Converts an expression of type 'IntSort' to type 'RealSort'.
toRealSort :: Expr IntSort  -> Expr RealSort
toRealSort :: Expr 'IntSort -> Expr 'RealSort
toRealSort = Expr 'IntSort -> Expr 'RealSort
ToReal
{-# INLINE toRealSort #-}

-- | Converts an expression of type 'RealSort' to type 'IntSort'.
toIntSort :: Expr RealSort -> Expr IntSort
toIntSort :: Expr 'RealSort -> Expr 'IntSort
toIntSort = Expr 'RealSort -> Expr 'IntSort
ToInt
{-# INLINE toIntSort #-}

-- | Checks whether an expression of type 'RealSort' may be safely converted to type 'IntSort'.
isIntSort :: Expr RealSort -> Expr BoolSort
isIntSort :: Expr 'RealSort -> Expr 'BoolSort
isIntSort = Expr 'RealSort -> Expr 'BoolSort
IsInt
{-# INLINE isIntSort #-}

-- | Length of a string.
strLength :: Expr StringSort -> Expr IntSort
strLength :: Expr 'StringSort -> Expr 'IntSort
strLength = Expr 'StringSort -> Expr 'IntSort
StrLength
{-# INLINE strLength #-}

-- | Singleton string containing a character at given position
--   or empty string when position is out of range.
--   The leftmost position is 0.
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 s i n)@ evaluates to the longest (unscattered) substring
--   of @s@ of length at most @n@ starting at position @i@.
--   It evaluates to the empty string if @n@ is negative or @i@ is not in
--   the interval @[0,l-1]@ where @l@ is the length of @s@.
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 #-}

-- | First string is a prefix of second one.
--   @(str.prefixof s t)@ is @true@ iff @s@ is a prefix of @t@.
strPrefixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strPrefixOf :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strPrefixOf = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf
{-# INLINE strPrefixOf #-}

-- | First string is a suffix of second one.
--   @(str.suffixof s t)@ is @true@ iff @s@ is a suffix of @t@.
strSuffixOf :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strSuffixOf :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strSuffixOf = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf
{-# INLINE strSuffixOf #-}

-- | First string contains second one
--   @(str.contains s t)@ iff @s@ contains @t@.
strContains :: Expr StringSort -> Expr StringSort -> Expr BoolSort
strContains :: Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
strContains = Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains
{-# INLINE strContains #-}

-- | Index of first occurrence of second string in first one starting at the position specified by the third argument.
--   @(str.indexof s t i)@, with @0 <= i <= |s|@ is the position of the first
--   occurrence of @t@ in @s@ at or after position @i@, if any.
--   Otherwise, it is @-1@. Note that the result is @i@ whenever @i@ is within
--   the range @[0, |s|]@ and @t@ is empty.
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 #-}

-- | @(str.replace s t t')@ is the string obtained by replacing the first
--   occurrence of @t@ in @s@, if any, by @t'@. Note that if @t@ is empty, the
--   result is to prepend @t'@ to @s@; also, if @t@ does not occur in @s@ then
--   the result is @s@.
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 #-}

-- | @(str.replace_all s t t’)@ is @s@ if @t@ is the empty string. Otherwise, it
--   is the string obtained from @s@ by replacing all occurrences of @t@ in @s@
--   by @t’@, starting with the first occurrence and proceeding in left-to-right order.
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 Num (Expr IntSort) where
   fromInteger :: Integer -> Expr 'IntSort
fromInteger = Value 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'IntSort -> Expr 'IntSort)
-> (Integer -> Value 'IntSort) -> Integer -> Expr 'IntSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Value 'IntSort
HaskellType 'IntSort -> Value 'IntSort
IntValue
   {-# INLINE fromInteger #-}
   (Constant (IntValue HaskellType 'IntSort
0)) + :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
+ Expr 'IntSort
y = Expr 'IntSort
y
   Expr 'IntSort
x + (Constant (IntValue HaskellType 'IntSort
0)) = Expr 'IntSort
x
   (Constant (IntValue HaskellType 'IntSort
x)) + (Constant (IntValue HaskellType 'IntSort
y)) = Value 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'IntSort -> Value 'IntSort
IntValue (Integer
HaskellType 'IntSort
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
HaskellType 'IntSort
y))
   Expr 'IntSort
x + Expr 'IntSort
y = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr 'IntSort
x Expr 'IntSort
y
   {-# INLINE (+) #-}
   Expr 'IntSort
x - :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
- (Constant (IntValue HaskellType 'IntSort
0)) = Expr 'IntSort
x
   (Constant (IntValue HaskellType 'IntSort
x)) - (Constant (IntValue HaskellType 'IntSort
y)) = Value 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'IntSort -> Value 'IntSort
IntValue (Integer
HaskellType 'IntSort
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
HaskellType 'IntSort
y))
   Expr 'IntSort
x - Expr 'IntSort
y = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr 'IntSort
x (Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg Expr 'IntSort
y)
   {-# INLINE (-) #-}
   (Constant (IntValue HaskellType 'IntSort
0)) * :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
* Expr 'IntSort
_ = Expr 'IntSort
0
   Expr 'IntSort
_ * (Constant (IntValue HaskellType 'IntSort
0)) = Expr 'IntSort
0
   (Constant (IntValue HaskellType 'IntSort
1)) * Expr 'IntSort
y = Expr 'IntSort
y
   Expr 'IntSort
x * (Constant (IntValue HaskellType 'IntSort
1)) = Expr 'IntSort
x
   (Constant (IntValue HaskellType 'IntSort
x)) * (Constant (IntValue HaskellType 'IntSort
y)) = Value 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'IntSort -> Value 'IntSort
IntValue (Integer
HaskellType 'IntSort
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
HaskellType 'IntSort
y))
   Expr 'IntSort
x * Expr 'IntSort
y = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul Expr 'IntSort
x Expr 'IntSort
y
   {-# INLINE (*) #-}
   negate :: Expr 'IntSort -> Expr 'IntSort
negate      = Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg
   {-# INLINE negate #-}
   abs :: Expr 'IntSort -> Expr 'IntSort
abs         = Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs
   {-# INLINE abs #-}
   signum :: Expr 'IntSort -> Expr 'IntSort
signum Expr 'IntSort
x    = Expr 'BoolSort -> Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'IntSort
x Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr 'IntSort
0) Expr 'IntSort
0 (Expr 'IntSort -> Expr 'IntSort) -> Expr 'IntSort -> Expr 'IntSort
forall a b. (a -> b) -> a -> b
$ Expr 'BoolSort -> Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'IntSort
x Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<? Expr 'IntSort
0) (-Expr 'IntSort
1) Expr 'IntSort
1
   {-# INLINE signum #-}

instance Num (Expr RealSort) where
   fromInteger :: Integer -> Expr 'RealSort
fromInteger = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'RealSort -> Expr 'RealSort)
-> (Integer -> Value 'RealSort) -> Integer -> Expr 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Value 'RealSort
HaskellType 'RealSort -> Value 'RealSort
RealValue (Double -> Value 'RealSort)
-> (Integer -> Double) -> Integer -> Value 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral
   {-# INLINE fromInteger #-}
   (Constant (RealValue HaskellType 'RealSort
0)) + :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
+ Expr 'RealSort
y = Expr 'RealSort
y
   Expr 'RealSort
x + (Constant (RealValue HaskellType 'RealSort
0)) = Expr 'RealSort
x
   (Constant (RealValue HaskellType 'RealSort
x)) + (Constant (RealValue HaskellType 'RealSort
y)) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'RealSort -> Value 'RealSort
RealValue (Double
HaskellType 'RealSort
x Double -> Double -> Double
forall a. Num a => a -> a -> a
+ Double
HaskellType 'RealSort
y))
   Expr 'RealSort
x + Expr 'RealSort
y = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr 'RealSort
x Expr 'RealSort
y
   {-# INLINE (+) #-}
   Expr 'RealSort
x - :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
- (Constant (RealValue HaskellType 'RealSort
0)) = Expr 'RealSort
x
   (Constant (RealValue HaskellType 'RealSort
x)) - (Constant (RealValue HaskellType 'RealSort
y)) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'RealSort -> Value 'RealSort
RealValue (Double
HaskellType 'RealSort
x Double -> Double -> Double
forall a. Num a => a -> a -> a
- Double
HaskellType 'RealSort
y))
   Expr 'RealSort
x - Expr 'RealSort
y = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr 'RealSort
x (Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg Expr 'RealSort
y)
   {-# INLINE (-) #-}
   (Constant (RealValue HaskellType 'RealSort
0)) * :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
* Expr 'RealSort
_ = Expr 'RealSort
0
   Expr 'RealSort
_ * (Constant (RealValue HaskellType 'RealSort
0)) = Expr 'RealSort
0
   (Constant (RealValue HaskellType 'RealSort
1)) * Expr 'RealSort
y = Expr 'RealSort
y
   Expr 'RealSort
x * (Constant (RealValue HaskellType 'RealSort
1)) = Expr 'RealSort
x
   (Constant (RealValue HaskellType 'RealSort
x)) * (Constant (RealValue HaskellType 'RealSort
y)) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'RealSort -> Value 'RealSort
RealValue (Double
HaskellType 'RealSort
x Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
HaskellType 'RealSort
y))
   Expr 'RealSort
x * Expr 'RealSort
y = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul Expr 'RealSort
x Expr 'RealSort
y
   {-# INLINE (*) #-}
   negate :: Expr 'RealSort -> Expr 'RealSort
negate      = Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg
   {-# INLINE negate #-}
   abs :: Expr 'RealSort -> Expr 'RealSort
abs         = Expr 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs
   {-# INLINE abs #-}
   signum :: Expr 'RealSort -> Expr 'RealSort
signum Expr 'RealSort
x    = Expr 'BoolSort
-> Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'RealSort
x Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr 'RealSort
0) Expr 'RealSort
0 (Expr 'RealSort -> Expr 'RealSort)
-> Expr 'RealSort -> Expr 'RealSort
forall a b. (a -> b) -> a -> b
$ Expr 'BoolSort
-> Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'RealSort
x Expr 'RealSort -> Expr 'RealSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<? Expr 'RealSort
0) (-Expr 'RealSort
1) Expr 'RealSort
1
   {-# INLINE signum #-}

instance KnownNat n => Num (Expr (BvSort n)) where
   fromInteger :: Integer -> Expr ('BvSort n)
fromInteger = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> (Integer -> Value ('BvSort n)) -> Integer -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec n -> Value ('BvSort n)
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue (Bitvec n -> Value ('BvSort n))
-> (Integer -> Bitvec n) -> Integer -> Value ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Bitvec n
forall a. Num a => Integer -> a
fromInteger
   {-# INLINE fromInteger #-}
   (Constant (BvValue HaskellType ('BvSort n)
0)) + :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
+ Expr ('BvSort n)
y = Expr ('BvSort n)
y
   Expr ('BvSort n)
x + (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) + (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
+ Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x + Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAdd Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (+) #-}
   Expr ('BvSort n)
x - :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
- (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) - (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
- Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x - Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvSub Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (-) #-}
   (Constant (BvValue HaskellType ('BvSort n)
0)) * :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
* Expr ('BvSort n)
_ = Expr ('BvSort n)
0
   Expr ('BvSort n)
_ * (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
0
   (Constant (BvValue HaskellType ('BvSort n)
1)) * Expr ('BvSort n)
y = Expr ('BvSort n)
y
   Expr ('BvSort n)
x * (Constant (BvValue HaskellType ('BvSort n)
1)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) * (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
* Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x * Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvMul Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (*) #-}
   abs :: Expr ('BvSort n) -> Expr ('BvSort n)
abs         = Expr ('BvSort n) -> Expr ('BvSort n)
forall a. a -> a
id
   {-# INLINE abs #-}
   signum :: Expr ('BvSort n) -> Expr ('BvSort n)
signum Expr ('BvSort n)
_    = Expr ('BvSort n)
0
   {-# 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
. Double -> Value 'RealSort
HaskellType 'RealSort -> Value 'RealSort
RealValue (Double -> Value 'RealSort)
-> (Rational -> Double) -> Rational -> Value 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Double
forall a. Fractional a => Rational -> a
fromRational
  {-# INLINE fromRational #-}
  Expr 'RealSort
x / :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
/ (Constant (RealValue HaskellType 'RealSort
1)) = Expr 'RealSort
x
  (Constant (RealValue HaskellType 'RealSort
0)) / Expr 'RealSort
_ = Expr 'RealSort
0
  (Constant (RealValue HaskellType 'RealSort
x)) / (Constant (RealValue HaskellType 'RealSort
y)) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType 'RealSort -> Value 'RealSort
RealValue (Double
HaskellType 'RealSort
x Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
HaskellType 'RealSort
y))
  Expr 'RealSort
x / Expr 'RealSort
y          = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div Expr 'RealSort
x Expr 'RealSort
y
  {-# INLINE (/) #-}

-- | Not in the SMTLib2.6-standard. Solvers like CVC5 and MathSAT support it though.
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 Integraled (Expr IntSort) where
  quot :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
quot = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
IDiv
  {-# INLINE quot #-}
  rem :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
rem  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
Mod
  {-# INLINE rem #-}
  div :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
div  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
IDiv
  {-# INLINE div #-}
  mod :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
mod  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
Mod
  {-# INLINE mod #-}
  quotRem :: Expr 'IntSort -> Expr 'IntSort -> (Expr 'IntSort, Expr 'IntSort)
quotRem Expr 'IntSort
x Expr 'IntSort
y = (Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integraled a => a -> a -> a
quot Expr 'IntSort
x Expr 'IntSort
y, Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integraled a => a -> a -> a
rem Expr 'IntSort
x Expr 'IntSort
y)
  {-# INLINE quotRem #-}
  divMod :: Expr 'IntSort -> Expr 'IntSort -> (Expr 'IntSort, Expr 'IntSort)
divMod Expr 'IntSort
x Expr 'IntSort
y  = (Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integraled a => a -> a -> a
div Expr 'IntSort
x Expr 'IntSort
y, Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integraled a => a -> a -> a
mod Expr 'IntSort
x Expr 'IntSort
y)
  {-# INLINE divMod #-}

instance KnownNat n => Integraled (Expr (BvSort n)) where
  quot :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
quot        = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuDiv
  {-# INLINE quot #-}
  rem :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
rem         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuRem
  {-# INLINE rem #-}
  div :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
div         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuDiv
  {-# INLINE div #-}
  mod :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
mod         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuRem
  {-# INLINE mod #-}
  quotRem :: Expr ('BvSort n)
-> Expr ('BvSort n) -> (Expr ('BvSort n), Expr ('BvSort n))
quotRem Expr ('BvSort n)
x Expr ('BvSort n)
y = (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integraled a => a -> a -> a
quot Expr ('BvSort n)
x Expr ('BvSort n)
y, Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integraled a => a -> a -> a
rem Expr ('BvSort n)
x Expr ('BvSort n)
y)
  {-# INLINE quotRem #-}
  divMod :: Expr ('BvSort n)
-> Expr ('BvSort n) -> (Expr ('BvSort n), Expr ('BvSort n))
divMod Expr ('BvSort n)
x Expr ('BvSort n)
y  = (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integraled a => a -> a -> a
div Expr ('BvSort n)
x Expr ('BvSort n)
y, Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integraled a => a -> a -> a
mod Expr ('BvSort n)
x Expr ('BvSort n)
y)
  {-# INLINE divMod #-}

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 #-}
  && :: 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 (||) #-}
  not :: Expr 'BoolSort -> Expr 'BoolSort
not  = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE not #-}
  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 #-}
  <==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(<==>) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
(===)
  {-# INLINE (<==>) #-}

instance KnownNat n => Boolean (Expr (BvSort n)) where
  bool :: Bool -> Expr ('BvSort n)
bool = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> (Bool -> Value ('BvSort n)) -> Bool -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec n -> Value ('BvSort n)
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue (Bitvec n -> Value ('BvSort n))
-> (Bool -> Bitvec n) -> Bool -> Value ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bitvec n
forall b. Boolean b => Bool -> b
bool
  {-# INLINE bool #-}
  && :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(&&) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAnd
  {-# INLINE (&&) #-}
  || :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(||) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvOr
  {-# INLINE (||) #-}
  not :: Expr ('BvSort n) -> Expr ('BvSort n)
not  = Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n)
BvNot
  {-# INLINE not #-}
  xor :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
xor  = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvXor
  {-# INLINE xor #-}

instance Bounded (Expr BoolSort) where
  minBound :: Expr 'BoolSort
minBound = Expr 'BoolSort
forall b. Boolean b => b
false
  maxBound :: Expr 'BoolSort
maxBound = Expr 'BoolSort
forall b. Boolean b => b
true

instance KnownNat n => Bounded (Expr (BvSort n)) where
  minBound :: Expr ('BvSort n)
minBound = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> Value ('BvSort n) -> Expr ('BvSort n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue Bitvec n
HaskellType ('BvSort n)
forall a. Bounded a => a
minBound
  maxBound :: Expr ('BvSort n)
maxBound = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> Value ('BvSort n) -> Expr ('BvSort n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort n) -> Value ('BvSort n)
forall (t :: Nat).
KnownNat t =>
HaskellType ('BvSort t) -> Value ('BvSort t)
BvValue Bitvec n
HaskellType ('BvSort n)
forall a. Bounded a => a
maxBound

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

instance Render (SMTVar t) where
  render :: SMTVar t -> Builder
render SMTVar t
v = Builder
"var_" Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
intDec (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @(SMTVar t) @Int SMTVar t
v)
  {-# INLINE render #-}

instance Render (Value t) where
  render :: Value t -> Builder
render (IntValue HaskellType 'IntSort
x)   = Integer -> Builder
forall a. Render a => a -> Builder
render Integer
HaskellType 'IntSort
x
  render (RealValue HaskellType 'RealSort
x)  = Double -> Builder
forall a. Render a => a -> Builder
render Double
HaskellType 'RealSort
x
  render (BoolValue HaskellType 'BoolSort
x)  = Bool -> Builder
forall a. Render a => a -> Builder
render Bool
HaskellType 'BoolSort
x
  render (BvValue   HaskellType ('BvSort n)
v)  = Builder
"#b" Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Bitvec n -> Builder
forall a. Render a => a -> Builder
render Bitvec n
HaskellType ('BvSort n)
v
  render (ArrayValue HaskellType ('ArraySort k v)
arr) = case Map (HaskellType k) (HaskellType v)
-> Maybe
     ((HaskellType k, HaskellType v),
      Map (HaskellType k) (HaskellType v))
forall k a. Map k a -> Maybe ((k, a), Map k a)
minViewWithKey (ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
arrConstArray (HaskellType k) (HaskellType v)
-> Getting
     (Map (HaskellType k) (HaskellType v))
     (ConstArray (HaskellType k) (HaskellType v))
     (Map (HaskellType k) (HaskellType v))
-> Map (HaskellType k) (HaskellType v)
forall s a. s -> Getting a s a -> a
^.Getting
  (Map (HaskellType k) (HaskellType v))
  (ConstArray (HaskellType k) (HaskellType v))
  (Map (HaskellType k) (HaskellType v))
forall k1 v k2 (f :: * -> *).
Functor f =>
(Map k1 v -> f (Map k2 v))
-> ConstArray k1 v -> f (ConstArray k2 v)
stored) of
    Maybe
  ((HaskellType k, HaskellType v),
   Map (HaskellType k) (HaskellType v))
Nothing -> HaskellType v -> Builder
constRender (HaskellType v -> Builder) -> HaskellType v -> Builder
forall a b. (a -> b) -> a -> b
$ ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
arrConstArray (HaskellType k) (HaskellType v)
-> Getting
     (HaskellType v)
     (ConstArray (HaskellType k) (HaskellType v))
     (HaskellType v)
-> HaskellType v
forall s a. s -> Getting a s a -> a
^.Getting
  (HaskellType v)
  (ConstArray (HaskellType k) (HaskellType v))
  (HaskellType v)
forall k v (f :: * -> *).
Functor f =>
(v -> f v) -> ConstArray k v -> f (ConstArray k v)
arrConst
    Just ((HaskellType k
k,HaskellType v
v), Map (HaskellType k) (HaskellType v)
stored')
      | Map (HaskellType k) (HaskellType v) -> Int
forall k a. Map k a -> Int
size (ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
arrConstArray (HaskellType k) (HaskellType v)
-> Getting
     (Map (HaskellType k) (HaskellType v))
     (ConstArray (HaskellType k) (HaskellType v))
     (Map (HaskellType k) (HaskellType v))
-> Map (HaskellType k) (HaskellType v)
forall s a. s -> Getting a s a -> a
^.Getting
  (Map (HaskellType k) (HaskellType v))
  (ConstArray (HaskellType k) (HaskellType v))
  (Map (HaskellType k) (HaskellType v))
forall k1 v k2 (f :: * -> *).
Functor f =>
(Map k1 v -> f (Map k2 v))
-> ConstArray k1 v -> f (ConstArray k2 v)
stored) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 -> Expr ('ArraySort k v) -> Builder
forall a. Render a => a -> Builder
render (Expr ('ArraySort k v) -> Builder)
-> Expr ('ArraySort k v) -> Builder
forall a b. (a -> b) -> a -> 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)
ArrStore (Value ('ArraySort k v) -> Expr ('ArraySort k v)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('ArraySort k v) -> Value ('ArraySort k v)
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue (ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
arr ConstArray (HaskellType k) (HaskellType v)
-> (ConstArray (HaskellType k) (HaskellType v)
    -> ConstArray (HaskellType k) (HaskellType v))
-> ConstArray (HaskellType k) (HaskellType v)
forall a b. a -> (a -> b) -> b
& (Map (HaskellType k) (HaskellType v)
 -> Identity (Map (HaskellType k) (HaskellType v)))
-> ConstArray (HaskellType k) (HaskellType v)
-> Identity (ConstArray (HaskellType k) (HaskellType v))
forall k1 v k2 (f :: * -> *).
Functor f =>
(Map k1 v -> f (Map k2 v))
-> ConstArray k1 v -> f (ConstArray k2 v)
stored ((Map (HaskellType k) (HaskellType v)
  -> Identity (Map (HaskellType k) (HaskellType v)))
 -> ConstArray (HaskellType k) (HaskellType v)
 -> Identity (ConstArray (HaskellType k) (HaskellType v)))
-> Map (HaskellType k) (HaskellType v)
-> ConstArray (HaskellType k) (HaskellType v)
-> ConstArray (HaskellType k) (HaskellType v)
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Map (HaskellType k) (HaskellType v)
stored'))) (Value k -> Expr k
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType k -> Value k
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue HaskellType k
k)) (Value v -> Expr v
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType v -> Value v
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue HaskellType v
v))
      | Bool
otherwise  -> HaskellType v -> Builder
constRender HaskellType v
v
    where
      constRender :: HaskellType v -> Builder
constRender HaskellType v
v = Builder
"((as const " Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> SSMTSort ('ArraySort k v) -> Builder
forall a. Render a => a -> Builder
render (ConstArray (HaskellType k) (HaskellType v)
-> SSMTSort ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Eq (HaskellType v)) =>
ConstArray (HaskellType k) (HaskellType v)
-> SSMTSort ('ArraySort k v)
goSing ConstArray (HaskellType k) (HaskellType v)
HaskellType ('ArraySort k v)
arr) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
") " Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Value v -> Builder
forall a. Render a => a -> Builder
render (HaskellType v -> Value v
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue HaskellType v
v) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
")"
      goSing :: forall k v. (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Eq (HaskellType v)) => ConstArray (HaskellType k) (HaskellType v) -> SSMTSort (ArraySort k v)
      goSing :: forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Eq (HaskellType v)) =>
ConstArray (HaskellType k) (HaskellType v)
-> SSMTSort ('ArraySort k v)
goSing ConstArray (HaskellType k) (HaskellType v)
_ = forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @(ArraySort k v)
  render (StringValue HaskellType 'StringSort
x) = Builder
"\"" Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Text -> Builder
forall a. Render a => a -> Builder
render Text
HaskellType 'StringSort
x Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
"\""

instance KnownSMTSort t => Render (Expr t) where
  render :: Expr t -> Builder
render (Var SMTVar t
v)      = SMTVar t -> Builder
forall a. Render a => a -> Builder
render SMTVar t
v
  render (Constant Value t
c) = Value t -> Builder
forall a. Render a => a -> Builder
render Value t
c

  render (Plus Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"+" Expr t
x Expr t
y
  render (Neg Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"-" Expr t
x
  render (Mul Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"*" Expr t
x Expr t
y
  render (Abs Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"abs" Expr t
x
  render (Mod Expr 'IntSort
x Expr 'IntSort
y)    = Builder -> Expr 'IntSort -> Expr 'IntSort -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"mod" Expr 'IntSort
x Expr 'IntSort
y
  render (IDiv Expr 'IntSort
x Expr 'IntSort
y)   = Builder -> Expr 'IntSort -> Expr 'IntSort -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"div" Expr 'IntSort
x Expr 'IntSort
y
  render (Div Expr 'RealSort
x Expr 'RealSort
y)    = Builder -> Expr 'RealSort -> Expr 'RealSort -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"/" Expr 'RealSort
x Expr 'RealSort
y

  render (LTH Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"<" Expr t
x Expr t
y
  render (LTHE Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"<=" Expr t
x Expr t
y
  render (EQU Vector (n + 2) (Expr t)
xs)     = Builder -> [Expr t] -> Builder
forall a. Render a => Builder -> [a] -> Builder
renderNary Builder
"=" ([Expr t] -> Builder) -> [Expr t] -> Builder
forall a b. (a -> b) -> a -> b
$ Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList Vector (n + 2) (Expr t)
xs
  render (Distinct Vector (n + 2) (Expr t)
xs)= Builder -> [Expr t] -> Builder
forall a. Render a => Builder -> [a] -> Builder
renderNary Builder
"distinct" ([Expr t] -> Builder) -> [Expr t] -> Builder
forall a b. (a -> b) -> a -> b
$ Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList Vector (n + 2) (Expr t)
xs
  render (GTHE Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
">=" Expr t
x Expr t
y
  render (GTH Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
">" Expr t
x Expr t
y

  render (Not Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"not" Expr t
x
  render (And Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"and" Expr t
x Expr t
y
  render (Or Expr t
x Expr t
y)     = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"or" Expr t
x Expr t
y
  render (Impl Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"=>" Expr t
x Expr t
y
  render (Xor Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"xor" Expr t
x Expr t
y

  render Expr t
Pi           = Builder
"real.pi"
  render (Sqrt Expr 'RealSort
x)     = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"sqrt" Expr 'RealSort
x
  render (Exp Expr 'RealSort
x)      = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"exp" Expr 'RealSort
x
  render (Sin Expr 'RealSort
x)      = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"sin" Expr 'RealSort
x
  render (Cos Expr 'RealSort
x)      = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"cos" Expr 'RealSort
x
  render (Tan Expr 'RealSort
x)      = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"tan" Expr 'RealSort
x
  render (Asin Expr 'RealSort
x)     = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"arcsin" Expr 'RealSort
x
  render (Acos Expr 'RealSort
x)     = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"arccos" Expr 'RealSort
x
  render (Atan Expr 'RealSort
x)     = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"arctan" Expr 'RealSort
x

  render (ToReal Expr 'IntSort
x)   = Builder -> Expr 'IntSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"to_real" Expr 'IntSort
x
  render (ToInt Expr 'RealSort
x)    = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"to_int" Expr 'RealSort
x
  render (IsInt Expr 'RealSort
x)    = Builder -> Expr 'RealSort -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary Builder
"is_int" Expr 'RealSort
x

  render (Ite Expr 'BoolSort
p Expr t
t Expr t
f)  = Builder -> Expr 'BoolSort -> Expr t -> Expr t -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"ite" Expr 'BoolSort
p Expr t
t Expr t
f

  render (BvNot Expr ('BvSort n)
x)          = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"bvnot"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)
  render (BvAnd Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvand"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvOr Expr ('BvSort n)
x Expr ('BvSort n)
y)         = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvor"   (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvXor Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvxor"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvNand Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvnand" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvnor"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvNeg Expr ('BvSort n)
x)          = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"bvneg"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)
  render (BvAdd Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvadd"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvSub Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvsub"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvMul Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvmul"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvuDiv Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvudiv" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvuRem Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvurem" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvshl"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvlshr" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y)     = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"concat" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort m) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort m)
y)
  render (BvRotL Proxy i
i Expr ('BvSort n)
x)       = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary (Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"_" (Builder
"rotate_left"  :: Builder) (Integer -> Builder
forall a. Render a => a -> Builder
render (Proxy i -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal Proxy i
i))) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)
  render (BvRotR Proxy i
i Expr ('BvSort n)
x)       = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary (Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"_" (Builder
"rotate_right" :: Builder) (Integer -> Builder
forall a. Render a => a -> Builder
render (Proxy i -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal Proxy i
i))) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)
  render (BvuLT Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvult"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvuLTHE Expr ('BvSort n)
x Expr ('BvSort n)
y)      = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvule"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvuGTHE Expr ('BvSort n)
x Expr ('BvSort n)
y)      = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvuge"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvuGT Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvugt"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)

  render (ArrSelect Expr ('ArraySort k t)
a Expr k
i)    = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary  Builder
"select" (Expr ('ArraySort k t) -> Builder
forall a. Render a => a -> Builder
render Expr ('ArraySort k t)
a) (Expr k -> Builder
forall a. Render a => a -> Builder
render Expr k
i)
  render (ArrStore Expr ('ArraySort k v)
a Expr k
i Expr v
v)   = Builder -> Builder -> Builder -> Builder -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"store"  (Expr ('ArraySort k v) -> Builder
forall a. Render a => a -> Builder
render Expr ('ArraySort k v)
a) (Expr k -> Builder
forall a. Render a => a -> Builder
render Expr k
i) (Expr v -> Builder
forall a. Render a => a -> Builder
render Expr v
v)

  render (StrConcat Expr 'StringSort
x Expr 'StringSort
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.++"  (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrLength Expr 'StringSort
x)          = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"str.len" (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x)
  render (StrLT Expr 'StringSort
x Expr 'StringSort
y)            = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.<"   (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrLTHE Expr 'StringSort
x Expr 'StringSort
y)          = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.<="  (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrAt Expr 'StringSort
x Expr 'IntSort
i)            = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.at"  (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'IntSort -> Builder
forall a. Render a => a -> Builder
render Expr 'IntSort
i)
  render (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j)   = Builder -> Builder -> Builder -> Builder -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"str.substr"  (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'IntSort -> Builder
forall a. Render a => a -> Builder
render Expr 'IntSort
i) (Expr 'IntSort -> Builder
forall a. Render a => a -> Builder
render Expr 'IntSort
j)
  render (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y)      = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.prefixof" (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y)      = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.suffixof" (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrContains Expr 'StringSort
x Expr 'StringSort
y)      = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"str.contains" (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y)
  render (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i)     = Builder -> Builder -> Builder -> Builder -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"str.indexof"     (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y) (Expr 'IntSort -> Builder
forall a. Render a => a -> Builder
render Expr 'IntSort
i)
  render (StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y')    = Builder -> Builder -> Builder -> Builder -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"str.replace"     (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y')
  render (StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y') = Builder -> Builder -> Builder -> Builder -> Builder
forall a b c.
(Render a, Render b, Render c) =>
Builder -> a -> b -> c -> Builder
renderTernary Builder
"str.replace_all" (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
x) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y) (Expr 'StringSort -> Builder
forall a. Render a => a -> Builder
render Expr 'StringSort
y')

  render (ForAll Maybe (SMTVar t)
mQvar Expr t -> Expr 'BoolSort
f) = Builder
-> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Builder
forall (t :: SMTSort).
KnownSMTSort t =>
Builder
-> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Builder
renderQuantifier Builder
"forall" Maybe (SMTVar t)
mQvar Expr t -> Expr 'BoolSort
f
  render (Exists Maybe (SMTVar t)
mQvar Expr t -> Expr 'BoolSort
f) = Builder
-> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Builder
forall (t :: SMTSort).
KnownSMTSort t =>
Builder
-> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Builder
renderQuantifier Builder
"exists" Maybe (SMTVar t)
mQvar Expr t -> Expr 'BoolSort
f

renderQuantifier :: forall t. KnownSMTSort t => Builder -> Maybe (SMTVar t) -> (Expr t -> Expr BoolSort) -> Builder
renderQuantifier :: forall (t :: SMTSort).
KnownSMTSort t =>
Builder
-> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Builder
renderQuantifier Builder
qname (Just SMTVar t
qvar) Expr t -> Expr 'BoolSort
f =
  Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary
    Builder
qname
    (Builder
"(" Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder -> SSMTSort t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary (SMTVar t -> Builder
forall a. Render a => a -> Builder
render SMTVar t
qvar) (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
")")
    Builder
expr
  where
    expr :: Builder
expr = Expr 'BoolSort -> Builder
forall a. Render a => a -> Builder
render (Expr 'BoolSort -> Builder) -> Expr 'BoolSort -> Builder
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). SMTVar t -> Expr t
Var SMTVar t
qvar
renderQuantifier Builder
_ Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_ = Builder
forall a. Monoid a => a
mempty

instance Show (Value t) where
  show :: Value t -> String
show = ByteString -> String
toString (ByteString -> String)
-> (Value t -> ByteString) -> Value t -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
toLazyByteString (Builder -> ByteString)
-> (Value t -> Builder) -> Value t -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value t -> Builder
forall a. Render a => a -> Builder
render

instance KnownSMTSort t => Show (Expr t) where
  show :: Expr t -> String
show = ByteString -> String
toString (ByteString -> String)
-> (Expr t -> ByteString) -> Expr t -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
toLazyByteString (Builder -> ByteString)
-> (Expr t -> Builder) -> Expr t -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr t -> Builder
forall a. Render a => a -> Builder
render

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

-- | __Caution for quantified expressions:__ 'uniplate1' will only be applied if quantification has taken place already.
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 (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 'IntSort
x Expr 'IntSort
y)               = Expr 'IntSort -> Expr 'IntSort -> Expr b
Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
Mod (Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'IntSort) -> m (Expr 'IntSort -> 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 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
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (IDiv Expr 'IntSort
x Expr 'IntSort
y)              = Expr 'IntSort -> Expr 'IntSort -> Expr b
Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
IDiv (Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'IntSort) -> m (Expr 'IntSort -> 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 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
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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (BvNot Expr ('BvSort n)
x)               = Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n)
BvNot (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvAnd Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAnd (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvOr Expr ('BvSort n)
x Expr ('BvSort n)
y)              = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvOr (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvXor Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvXor (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNand Expr ('BvSort n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNand (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNor (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNeg Expr ('BvSort n)
x)               = Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n)
BvNeg (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvAdd Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAdd (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvSub Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvSub (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvMul Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvMul (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuDiv Expr ('BvSort n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuDiv (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuRem Expr ('BvSort n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuRem (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y)          = Expr ('BvSort n) -> Expr ('BvSort m) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
BvConcat (Expr ('BvSort n) -> Expr ('BvSort m) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort m) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort m) -> Expr b)
-> m (Expr ('BvSort 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 m) -> m (Expr ('BvSort m))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort m)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotL Proxy i
i Expr ('BvSort n)
x)            = Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL Proxy i
i (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotR Proxy i
i Expr ('BvSort n)
x)            = Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR Proxy i
i (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuLT Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLT (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuLTHE Expr ('BvSort n)
x Expr ('BvSort n)
y)           = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLTHE (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuGTHE Expr ('BvSort n)
x Expr ('BvSort n)
y)           = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGTHE (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvuGT Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGT (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort 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 n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  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),
 Eq (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 (StrLT Expr 'StringSort
x Expr 'StringSort
y)             = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLT (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 (StrLTHE Expr 'StringSort
x Expr 'StringSort
y)           = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLTHE (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 (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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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). 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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). 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
expr

-- | __Caution for quantified expressions:__ 'plate' will only be applied if quantification has taken place already.
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
          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 'IntSort
x Expr 'IntSort
y              -> Expr 'IntSort -> Expr 'IntSort -> Expr r
Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
Mod  (Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'IntSort) -> 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 'IntSort
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
y
          IDiv Expr 'IntSort
x Expr 'IntSort
y             -> Expr 'IntSort -> Expr 'IntSort -> Expr r
Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
IDiv (Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'IntSort) -> 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 'IntSort
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
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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort) (n :: Nat).
(Eq (HaskellType t), KnownSMTSort t, KnownNat n) =>
Vector (n + 2) (Expr t) -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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 (t :: SMTSort).
(Ord (HaskellType t), KnownSMTSort t) =>
Expr t -> Expr t -> 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
          BvNot Expr ('BvSort n)
x              -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n)
BvNot  (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort 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 n)
x
          BvAnd Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAnd  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvOr Expr ('BvSort n)
x Expr ('BvSort n)
y             -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvOr   (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvXor Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvXor  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvNand Expr ('BvSort n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNand (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNor  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvNeg Expr ('BvSort n)
x              -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n)
BvNeg  (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort 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 n)
x
          BvAdd Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvAdd  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvSub Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvSub  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvMul Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvMul  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvuDiv Expr ('BvSort n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuDiv (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvuRem Expr ('BvSort n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvuRem (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y         -> Expr ('BvSort n) -> Expr ('BvSort m) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
BvConcat (Expr ('BvSort n) -> Expr ('BvSort m) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort m) -> Expr r)
-> f (Expr ('BvSort 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 m)
y
          BvRotL Proxy i
i Expr ('BvSort n)
x           -> Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL Proxy i
i (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort 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 n)
x
          BvRotR Proxy i
i Expr ('BvSort n)
x           -> Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) (i :: Nat).
(KnownNat n, KnownNat i, KnownNat (Mod i n)) =>
Proxy i -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR Proxy i
i (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort 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 n)
x
          BvuLT Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLT    (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvuLTHE Expr ('BvSort n)
x Expr ('BvSort n)
y          -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuLTHE  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvuGTHE Expr ('BvSort n)
x Expr ('BvSort n)
y          -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGTHE  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          BvuGT Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr 'BoolSort
BvuGT    (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort 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 n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort 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 n)
y
          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),
 Eq (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
          StrLT Expr 'StringSort
x Expr 'StringSort
y            -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLT         (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
          StrLTHE Expr 'StringSort
x Expr 'StringSort
y          -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLTHE       (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
          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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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). 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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). 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 (t :: SMTSort).
KnownSMTSort t =>
Maybe (SMTVar t) -> (Expr t -> 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
    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 'IntSort
e1 Expr 'IntSort
e2            -> Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
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
    IDiv Expr 'IntSort
e1 Expr 'IntSort
e2           -> Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
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
    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
    BvNot Expr ('BvSort n)
e              -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    BvAnd Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvOr Expr ('BvSort n)
e1 Expr ('BvSort n)
e2           -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvXor Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvNand Expr ('BvSort n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvNor Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvNeg Expr ('BvSort n)
e              -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    BvAdd Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvSub Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvMul Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvuDiv Expr ('BvSort n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvuRem Expr ('BvSort n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvShL Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvLShR Expr ('BvSort n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvConcat Expr ('BvSort n)
e1 Expr ('BvSort m)
e2       -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort m) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort m)
e2
    BvRotL Proxy i
_ Expr ('BvSort n)
e           -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    BvRotR Proxy i
_ Expr ('BvSort n)
e           -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    BvuLT Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvuLTHE Expr ('BvSort n)
e1 Expr ('BvSort n)
e2        -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvuGTHE Expr ('BvSort n)
e1 Expr ('BvSort n)
e2        -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvuGT Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    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
    StrLT 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
    StrLTHE 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
    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). 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). SMTVar t -> Expr t
Var SMTVar t
qv