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

{- |
This module provides the data-type 'Expr'.

It represents SMTLib-expressions via an abstract syntax tree (AST), implemented as GADT.

Variables are just 'Int's wrapped in a newtype 'SMTVar' with a phantom-type 'SMTSort'.

Usually the end user of this library does not need to deal with this representation.
Instead he should rely on the provided instances for building expressions.
Some of the main classes of these include:

1. 'Equatable' and 'Orderable' for symbolic comparisons,

2. 'Iteable' for symbolic branching via 'ite',

3. 'Boolean' for symbolic bool operations,

4. Prelude classics like: 'Num', 'Floating', 'Integral', 'Bounded', ... for arithmetics

5. 'Bits.Bits' for BitVec-operations

Besides that, there are also some operations defined by the SMTLib-Standard Version 2.6 that do not fit into any classes
and therefore are exported as plain functions, like 'for_all' or 'bvConcat'.
-}
module Language.Hasmtlib.Type.Expr
  (
  -- * SMTVar
    SMTVar(..), varId

  -- * Expr type
  , Expr(..), isLeaf, exprSize

  -- * Compare
  -- ** Equatable
  -- *** Class
  , Equatable(..)
  , equal, distinct

  -- *** Generic
  , GEquatable(..)

  -- ** Orderable
  -- *** Class
  , Orderable(..)
  , min', max'

  -- *** Generic
  , GOrderable(..)

  -- ** Iteable
  , Iteable(..)

  -- * Non-class functions
  -- ** Quantifier
  , for_all, exists

  -- ** BitVec
  , bvConcat

  -- ** Array
  , select, store

  -- ** String
  , strLength, strAt, strSubstring, strPrefixOf, strSuffixOf, strContains, strIndexOf, strReplace, strReplaceAll

  -- ** Conversion
  , toRealSort, toIntSort, isIntSort
  )
where

import Prelude hiding (not, and, or, any, all, (&&), (||))
import Language.Hasmtlib.Internal.Uniplate1
import Language.Hasmtlib.Type.Bitvec (BvEnc(..), KnownBvEnc(..), SBvEnc(..))
import Language.Hasmtlib.Type.SMTSort
import Language.Hasmtlib.Type.Value
import Language.Hasmtlib.Boolean
import Data.GADT.Compare
import Data.GADT.DeepSeq
import Data.Coerce
import Data.Proxy
import Data.Int
import Data.Word
import Data.Void
import qualified Data.Bits as Bits
import Data.Sequence (Seq)
import Data.Tree (Tree)
import Data.STRef
import Data.Monoid (Sum, Product, First, Last, Dual)
import Data.String (IsString(..))
import Data.Text (pack)
import Data.List(genericLength)
import Data.Foldable (toList)
import qualified Data.Vector.Sized as V
import Control.Lens hiding (from, to)
import Control.Monad.ST
import Control.Monad
import GHC.TypeLits hiding (someNatVal)
import GHC.TypeNats (someNatVal)
import GHC.Generics

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

-- | An SMT-Expression.
--   For building expressions use the corresponding instances.
--
--   With a lot of criminal energy you may build invalid expressions regarding the SMTLib Version 2.6 - specification.
--   Therefore it is highly recommended to rely on the instances.
data Expr (t :: SMTSort) where
  Var       :: KnownSMTSort t => SMTVar t -> Expr t
  Constant  :: Value t -> Expr t
  Plus      :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
  Minus     :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
  Neg       :: Num (HaskellType t) => Expr t -> Expr t
  Mul       :: Num (HaskellType t) => Expr t -> Expr t -> Expr t
  Abs       :: Num (HaskellType t) => Expr t -> Expr t
  Mod       :: Integral (HaskellType t) => Expr t -> Expr t  -> Expr t
  Rem       :: Integral (HaskellType t) => Expr t -> Expr t  -> Expr t
  IDiv      :: Integral (HaskellType t) => Expr t -> Expr t  -> Expr t
  Div       :: Expr RealSort -> Expr RealSort -> Expr RealSort
  LTH       :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
  LTHE      :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
  EQU       :: (Eq (HaskellType t), KnownSMTSort t, KnownNat n) => V.Vector (n + 2) (Expr t) -> Expr BoolSort
  Distinct  :: (Eq (HaskellType t), KnownSMTSort t, KnownNat n) => V.Vector (n + 2) (Expr t) -> Expr BoolSort
  GTHE      :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
  GTH       :: (Ord (HaskellType t), KnownSMTSort t) => Expr t -> Expr t -> Expr BoolSort
  Not       :: Boolean (HaskellType t) => Expr t -> Expr t
  And       :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
  Or        :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
  Impl      :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
  Xor       :: Boolean (HaskellType t) => Expr t -> Expr t -> Expr t
  Pi        :: Expr RealSort
  Sqrt      :: Expr RealSort -> Expr RealSort
  Exp       :: Expr RealSort -> Expr RealSort
  Sin       :: Expr RealSort -> Expr RealSort
  Cos       :: Expr RealSort -> Expr RealSort
  Tan       :: Expr RealSort -> Expr RealSort
  Asin      :: Expr RealSort -> Expr RealSort
  Acos      :: Expr RealSort -> Expr RealSort
  Atan      :: Expr RealSort -> Expr RealSort
  ToReal    :: Expr IntSort  -> Expr RealSort
  ToInt     :: Expr RealSort -> Expr IntSort
  IsInt     :: Expr RealSort -> Expr BoolSort
  Ite       :: Expr BoolSort -> Expr t -> Expr t -> Expr t
  BvNand    :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
  BvNor     :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
  BvShL     :: (KnownBvEnc enc, KnownNat n) => Expr (BvSort enc n) -> Expr (BvSort enc n) -> Expr (BvSort enc n)
  BvLShR    :: KnownNat n => Expr (BvSort Unsigned n) -> Expr (BvSort Unsigned n) -> Expr (BvSort Unsigned n)
  BvAShR    :: KnownNat n => Expr (BvSort Signed n) -> Expr (BvSort Signed n) -> Expr (BvSort Signed n)
  BvConcat  :: (KnownBvEnc enc , KnownNat n, KnownNat m) => Expr (BvSort enc n) -> Expr (BvSort enc m) -> Expr (BvSort enc (n + m))
  BvRotL    :: (KnownBvEnc enc, KnownNat n, Integral a) => a -> Expr (BvSort enc n) -> Expr (BvSort enc n)
  BvRotR    :: (KnownBvEnc enc, KnownNat n, Integral a) => a -> Expr (BvSort enc n) -> Expr (BvSort enc n)
  ArrSelect :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Ord (HaskellType v)) => Expr (ArraySort k v) -> Expr k -> Expr v
  ArrStore  :: (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) => Expr (ArraySort k v) -> Expr k -> Expr v -> Expr (ArraySort k v)
  StrConcat     :: Expr StringSort -> Expr StringSort -> Expr StringSort
  StrLength     :: Expr StringSort -> Expr IntSort
  StrAt         :: Expr StringSort -> Expr IntSort -> Expr StringSort
  StrSubstring  :: Expr StringSort -> Expr IntSort -> Expr IntSort -> Expr StringSort
  StrPrefixOf   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrSuffixOf   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrContains   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrIndexOf    :: Expr StringSort -> Expr StringSort -> Expr IntSort -> Expr IntSort
  StrReplace    :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
  StrReplaceAll :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
  -- | 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 are 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 #-}

-- | Size of the expression.
--
--   Counts the amount of operations.
--
-- ==== __Examples__
--
--    >>> nodeSize $ x + y === x + y
--        3
--    >>> nodeSize $ false
--        0
exprSize :: KnownSMTSort t => Expr t -> Integer
exprSize :: forall (t :: SMTSort). KnownSMTSort t => Expr t -> Integer
exprSize Expr t
expr = (forall s. ST s Integer) -> Integer
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s Integer) -> Integer)
-> (forall s. ST s Integer) -> Integer
forall a b. (a -> b) -> a -> b
$ do
  STRef s Integer
nodesRef <- Integer -> ST s (STRef s Integer)
forall a s. a -> ST s (STRef s a)
newSTRef Integer
0
  Expr t
_ <- (forall (a :: SMTSort).
 AllC '[KnownSMTSort] a =>
 Expr a -> ST s (Expr a))
-> Expr t -> ST s (Expr t)
forall {k} (m :: * -> *) (f :: k -> *) (cs :: [k -> Constraint])
       (b :: k).
(Monad m, Uniplate1 f cs, AllC cs b) =>
(forall (a :: k). AllC cs a => f a -> m (f a)) -> f b -> m (f b)
transformM1
    (\Expr a
expr' -> do
      Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Expr a -> Bool
forall (t :: SMTSort). Expr t -> Bool
isLeaf Expr a
expr') (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ STRef s Integer -> (Integer -> Integer) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
modifySTRef' STRef s Integer
nodesRef (Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)
      Expr a -> ST s (Expr a)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return Expr a
expr')
    Expr t
expr
  STRef s Integer -> ST s Integer
forall s a. STRef s a -> ST s a
readSTRef STRef s Integer
nodesRef

-- | Class that allows branching on predicates of type @b@ on branches of type @a@.
--
--   If predicate (p :: b) then (t :: a) else (f :: a).
--
--   There is a default implementation if your type is an 'Applicative'.
--
-- ==== __Examples__
--
--    >>> 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 (Constant (BoolValue Bool
HaskellType 'BoolSort
False)) Expr t
_ Expr t
f = Expr t
f
  ite (Constant (BoolValue Bool
HaskellType 'BoolSort
True)) Expr t
t Expr t
_  = Expr t
t
  ite Expr 'BoolSort
p t :: Expr t
t@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f') f :: Expr t
f@(Ite Expr 'BoolSort
p'' Expr t
t'' Expr t
f'')
    | Expr 'BoolSort
p' Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p'' Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Expr t
t' Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
t'' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p' Expr t
t' (Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
f' Expr t
f'')
    | Expr 'BoolSort
p' Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p'' Bool -> Bool -> Bool
forall b. Boolean b => b -> b -> b
&& Expr t
f' Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f'' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
p') Expr t
f' (Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t' Expr t
t'')
    | Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
  ite Expr 'BoolSort
p Expr t
t f :: Expr t
f@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f')
    | Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f'
    | Expr t
t Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
t' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| Expr 'BoolSort
p') Expr t
t Expr t
f'
    | Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
  ite Expr 'BoolSort
p t :: Expr t
t@(Ite Expr 'BoolSort
p' Expr t
t' Expr t
f') Expr t
f
    | Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Bool
forall a. Eq a => a -> a -> Bool
== Expr 'BoolSort
p' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t' Expr t
f
    | Expr t
f Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f' = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort
p Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& Expr 'BoolSort
p') Expr t
t' Expr t
f
    | Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
  ite Expr 'BoolSort
p Expr t
t Expr t
f
    | Expr t
t Expr t -> Expr t -> Bool
forall a. Eq a => a -> a -> Bool
== Expr t
f = Expr t
t
    | Bool
otherwise = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite Expr 'BoolSort
p Expr t
t Expr t
f
  {-# INLINEABLE ite #-}

instance Iteable Bool a where
  ite :: Bool -> a -> a -> a
ite Bool
p a
t a
f = if Bool
p then a
t else a
f
  {-# INLINE ite #-}

instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) [a]
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Maybe a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Seq a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Tree a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Sum a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Product a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (First a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Last a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Dual a)
instance Iteable (Expr BoolSort) a => Iteable (Expr BoolSort) (Identity a)

instance Iteable (Expr BoolSort) () where
  ite :: Expr 'BoolSort -> () -> () -> ()
ite Expr 'BoolSort
_ ()
_ ()
_ = ()

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b) => Iteable (Expr BoolSort) (a,b) where
  ite :: Expr 'BoolSort -> (a, b) -> (a, b) -> (a, b)
ite Expr 'BoolSort
p (a
a,b
b) (a
a',b
b') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c) => Iteable (Expr BoolSort) (a,b,c) where
  ite :: Expr 'BoolSort -> (a, b, c) -> (a, b, c) -> (a, b, c)
ite Expr 'BoolSort
p (a
a,b
b,c
c) (a
a',b
b',c
c') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d) => Iteable (Expr BoolSort) (a,b,c,d) where
  ite :: Expr 'BoolSort -> (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d) (a
a',b
b',c
c',d
d') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e) => Iteable (Expr BoolSort) (a,b,c,d,e) where
  ite :: Expr 'BoolSort
-> (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e) (a
a',b
b',c
c',d
d',e
e') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f) => Iteable (Expr BoolSort) (a,b,c,d,e,f) where
  ite :: Expr 'BoolSort
-> (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f) (a
a',b
b',c
c',d
d',e
e',f
f') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f, Iteable (Expr BoolSort) g) => Iteable (Expr BoolSort) (a,b,c,d,e,f,g) where
  ite :: Expr 'BoolSort
-> (a, b, c, d, e, f, g)
-> (a, b, c, d, e, f, g)
-> (a, b, c, d, e, f, g)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f,g
g) (a
a',b
b',c
c',d
d',e
e',f
f',g
g') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f', Expr 'BoolSort -> g -> g -> g
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p g
g g
g')

instance (Iteable (Expr BoolSort) a, Iteable (Expr BoolSort) b, Iteable (Expr BoolSort) c, Iteable (Expr BoolSort) d, Iteable (Expr BoolSort) e, Iteable (Expr BoolSort) f, Iteable (Expr BoolSort) g, Iteable (Expr BoolSort) h) => Iteable (Expr BoolSort) (a,b,c,d,e,f,g,h) where
  ite :: Expr 'BoolSort
-> (a, b, c, d, e, f, g, h)
-> (a, b, c, d, e, f, g, h)
-> (a, b, c, d, e, f, g, h)
ite Expr 'BoolSort
p (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) (a
a',b
b',c
c',d
d',e
e',f
f',g
g',h
h') = (Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p a
a a
a', Expr 'BoolSort -> b -> b -> b
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p b
b b
b', Expr 'BoolSort -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p c
c c
c', Expr 'BoolSort -> d -> d -> d
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p d
d d
d', Expr 'BoolSort -> e -> e -> e
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p e
e e
e', Expr 'BoolSort -> f -> f -> f
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p f
f f
f', Expr 'BoolSort -> g -> g -> g
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p g
g g
g', Expr 'BoolSort -> h -> h -> h
forall b a. Iteable b a => b -> a -> a -> a
ite Expr 'BoolSort
p h
h h
h')

-- | Symbolically test two values on equality.
--
-- A generic default implementation with 'GEquatable' is possible.
--
-- ==== __Example__
--
-- @
-- x <- var @RealType
-- y <- var
-- assert $ y === x && not (y /== x) && x === 42
-- @
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 (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
x,Expr t
y)
  {-# INLINE (===) #-}
  Expr t
x /== :: Expr t -> Expr t -> Expr 'BoolSort
/== Expr t
y = Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
x,Expr t
y)
  {-# INLINE (/==) #-}

class GEquatable f where
  (===#) :: f a -> f a -> Expr BoolSort

instance GEquatable U1 where
  U1 a
U1 ===# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
===# U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
true

instance GEquatable V1 where
  V1 a
x ===# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
===# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GEquatable[V1].===#"

instance (GEquatable f, GEquatable g) => GEquatable (f :*: g) where
  (f a
a :*: g a
b) ===# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
===# (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& (g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# g a
d)

instance (GEquatable f, GEquatable g) => GEquatable (f :+: g) where
  L1 f a
a ===# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
===# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
b
  R1 g a
a ===# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# g a
b
  (:+:) f g a
_ ===# (:+:) f g a
_ = Expr 'BoolSort
forall b. Boolean b => b
false

instance GEquatable f => GEquatable (M1 i c f) where
  M1 f a
x ===# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
===# M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
y

instance Equatable a => GEquatable (K1 i a) where
  K1 a
a ===# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
===# K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== a
b

instance Equatable ()       where ()
_ === :: () -> () -> Expr 'BoolSort
=== ()
_ = Expr 'BoolSort
forall b. Boolean b => b
true
instance Equatable Void     where Void
x === :: Void -> Void -> Expr 'BoolSort
=== Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Equatable[Void].==="
instance Equatable Int      where Int
x === :: Int -> Int -> Expr 'BoolSort
=== Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
y)
instance Equatable Integer  where Integer
x === :: Integer -> Integer -> Expr 'BoolSort
=== Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
y)
instance Equatable Natural  where Nat
x === :: Nat -> Nat -> Expr 'BoolSort
=== Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Eq a => a -> a -> Bool
== Nat
y)
instance Equatable Word     where Word
x === :: Word -> Word -> Expr 'BoolSort
=== Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
y)
instance Equatable Word8    where Word8
x === :: Word8 -> Word8 -> Expr 'BoolSort
=== Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
y)
instance Equatable Word16   where Word16
x === :: Word16 -> Word16 -> Expr 'BoolSort
=== Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
== Word16
y)
instance Equatable Word32   where Word32
x === :: Word32 -> Word32 -> Expr 'BoolSort
=== Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
y)
instance Equatable Word64   where Word64
x === :: Word64 -> Word64 -> Expr 'BoolSort
=== Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
y)
instance Equatable Int8     where Int8
x === :: Int8 -> Int8 -> Expr 'BoolSort
=== Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
y)
instance Equatable Int16    where Int16
x === :: Int16 -> Int16 -> Expr 'BoolSort
=== Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
y)
instance Equatable Int32    where Int32
x === :: Int32 -> Int32 -> Expr 'BoolSort
=== Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
y)
instance Equatable Int64    where Int64
x === :: Int64 -> Int64 -> Expr 'BoolSort
=== Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
y)
instance Equatable Char     where Char
x === :: Char -> Char -> Expr 'BoolSort
=== Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
y)
instance Equatable Float    where Float
x === :: Float -> Float -> Expr 'BoolSort
=== Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Eq a => a -> a -> Bool
== Float
y)
instance Equatable Double   where Double
x === :: Double -> Double -> Expr 'BoolSort
=== Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Eq a => a -> a -> Bool
== Double
y)
instance Equatable Ordering where Ordering
x === :: Ordering -> Ordering -> Expr 'BoolSort
=== Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
y)
instance Equatable Bool     where Bool
x === :: Bool -> Bool -> Expr 'BoolSort
=== Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
y)
instance (Equatable a, Equatable b) => Equatable (a,b)
instance (Equatable a, Equatable b, Equatable c) => Equatable (a,b,c)
instance (Equatable a, Equatable b, Equatable c, Equatable d) => Equatable (a,b,c,d)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e) => Equatable (a,b,c,d,e)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f) => Equatable (a,b,c,d,e,f)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f, Equatable g) => Equatable (a,b,c,d,e,f,g)
instance (Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f, Equatable g, Equatable h) => Equatable (a,b,c,d,e,f,g,h)
instance Equatable a => Equatable [a]
instance Equatable a => Equatable (Tree a)
instance Equatable a => Equatable (Maybe a)
instance (Equatable a, Equatable b) => Equatable (Either a b)
instance Equatable a => Equatable (Sum a)
instance Equatable a => Equatable (Product a)
instance Equatable a => Equatable (First a)
instance Equatable a => Equatable (Last a)
instance Equatable a => Equatable (Dual a)
instance Equatable a => Equatable (Identity a)

-- | Symbolically compare two values.
--
-- A generic default implementation with 'GOrderable' is possible.
--
-- ==== __Example__
--
-- @
-- 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 <?, <=?, >=?, >?

-- | Symbolic evaluation of the minimum of two symbolic values.
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

-- | Symbolic evaluation of the maximum of two symbolic values.
max' :: (Orderable a, Iteable (Expr BoolSort) a) => a -> a -> a
max' :: forall a. (Orderable a, Iteable (Expr 'BoolSort) a) => a -> a -> a
max' a
x a
y = Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite (a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x) a
x a
y

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

class GEquatable f => GOrderable f where
  (<?#)  :: f a -> f a -> Expr BoolSort
  (<=?#) :: f a -> f a -> Expr BoolSort

instance GOrderable U1 where
  U1 a
U1 <?# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
<?#  U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
false
  U1 a
U1 <=?# :: forall (a :: k). U1 a -> U1 a -> Expr 'BoolSort
<=?# U1 a
U1 = Expr 'BoolSort
forall b. Boolean b => b
true

instance GOrderable V1 where
  V1 a
x <?# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
<?# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GOrderable[V1].<?#"
  V1 a
x <=?# :: forall (a :: k). V1 a -> V1 a -> Expr 'BoolSort
<=?# V1 a
y = V1 a
x V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` V1 a
y V1 a -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"GOrderable[V1].<=?#"

instance (GOrderable f, GOrderable g) => GOrderable (f :*: g) where
  (f a
a :*: g a
b) <?# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
<?#  (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# g a
d)
  (f a
a :*: g a
b) <=?# :: forall (a :: k). (:*:) f g a -> (:*:) f g a -> Expr 'BoolSort
<=?# (f a
c :*: g a
d) = (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
c) Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
|| (f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# f a
c Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b -> b
&& g a
b g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# g a
d)

instance (GOrderable f, GOrderable g) => GOrderable (f :+: g) where
  L1 f a
_ <?# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
<?# R1 g a
_ = Expr 'BoolSort
forall b. Boolean b => b
true
  L1 f a
a <?# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# f a
b
  R1 g a
a <?# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?# g a
b
  R1 g a
_ <?# L1 f a
_ = Expr 'BoolSort
forall b. Boolean b => b
false

  L1 f a
_ <=?# :: forall (a :: k). (:+:) f g a -> (:+:) f g a -> Expr 'BoolSort
<=?# R1 g a
_ = Expr 'BoolSort
forall b. Boolean b => b
true
  L1 f a
a <=?# L1 f a
b = f a
a f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# f a
b
  R1 g a
a <=?# R1 g a
b = g a
a g a -> g a -> Expr 'BoolSort
forall (a :: k). g a -> g a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# g a
b
  R1 g a
_ <=?# L1 f a
_ = Expr 'BoolSort
forall b. Boolean b => b
false

instance GOrderable f => GOrderable (M1 i c f) where
  M1 f a
x <?# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
<?#  M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<?#  f a
y
  M1 f a
x <=?# :: forall (a :: k). M1 i c f a -> M1 i c f a -> Expr 'BoolSort
<=?# M1 f a
y = f a
x f a -> f a -> Expr 'BoolSort
forall (a :: k). f a -> f a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# f a
y

instance Orderable a => GOrderable (K1 i a) where
  K1 a
a <?# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
<?#  K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<?  a
b
  K1 a
a <=?# :: forall (a :: k). K1 i a a -> K1 i a a -> Expr 'BoolSort
<=?# K1 a
b = a
a a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
b

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

-- | Symbolically test multiple expressions on equality.
--
--   Returns 'true' if given less than two arguments.
equal :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
equal :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
  SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
    Maybe (Vector n (Expr t))
Nothing  -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
    Just Vector n (Expr t)
xs' -> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_)        = Expr 'BoolSort
forall b. Boolean b => b
true

-- | Symbolically test multiple expressions on distinctness.
--
--   Returns 'true' if given less than two arguments.
distinct :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
distinct :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
  SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
    Maybe (Vector n (Expr t))
Nothing  -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
    Just Vector n (Expr t)
xs' -> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_)        = Expr 'BoolSort
forall b. Boolean b => b
true

-- | Universal quantification for any specific 'SMTSort'.
--
-- ==== __Example__
--
--   @
--   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 (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE for_all #-}

-- | Existential quantification for any specific 'SMTSort'
--
-- ==== __Example__
--
--   @
--   assert $
--      for_all @(BvSort Unsigned 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 (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing
{-# INLINE exists #-}

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

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

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

-- | 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.
--   @(strPrefixof 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.
--   @(strSuffixof 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
--   @(strContains 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.
--   @(strIndexof 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 #-}

-- | @(strReplace 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 #-}

-- | @(strReplaceAll 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 (KnownSMTSort t, Num (HaskellType t), Ord (HaskellType t)) => Num (Expr t) where
   fromInteger :: Integer -> Expr t
fromInteger = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> (Integer -> Value t) -> Integer -> Expr t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HaskellType t -> Value t
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue (HaskellType t -> Value t)
-> (Integer -> HaskellType t) -> Integer -> Value t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> HaskellType t
forall a. Num a => Integer -> a
fromInteger
   {-# INLINE fromInteger #-}
   (Constant Value t
0) + :: Expr t -> Expr t -> Expr t
+ Expr t
y = Expr t
y
   Expr t
x + (Constant Value t
0) = Expr t
x
   (Constant Value t
x) + (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
+ Value t
y)
   Expr t
x + Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr t
x Expr t
y
   {-# INLINE (+) #-}
   Expr t
x - :: Expr t -> Expr t -> Expr t
- (Constant Value t
0) = Expr t
x
   (Constant Value t
x) - (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
- Value t
y)
   (Constant Value t
0) - Expr t
x = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
   Expr t
x - Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus Expr t
x Expr t
y
   {-# INLINE (-) #-}
   (Constant Value t
0) * :: Expr t -> Expr t -> Expr t
* Expr t
_ = Expr t
0
   Expr t
_ * (Constant Value t
0) = Expr t
0
   (Constant Value t
1) * Expr t
y = Expr t
y
   Expr t
x * (Constant Value t
1) = Expr t
x
   (Constant (-1)) * Expr t
x = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
   Expr t
x * (Constant (-1)) = Expr t -> Expr t
forall a. Num a => a -> a
negate Expr t
x
   (Constant Value t
x) * (Constant Value t
y) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t
x Value t -> Value t -> Value t
forall a. Num a => a -> a -> a
* Value t
y)
   Expr t
x * Expr t
y = Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul Expr t
x Expr t
y
   {-# INLINE (*) #-}
   negate :: Expr t -> Expr t
negate (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
negate Value t
x
   negate (Neg Expr t
x)      = Expr t
x
   negate Expr t
x            = Expr t -> Expr t
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg Expr t
x
   {-# INLINE negate #-}
   abs :: Expr t -> Expr t
abs (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
abs Value t
x
   abs Expr t
x            = Expr t -> Expr t
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs Expr t
x
   {-# INLINE abs #-}
   signum :: Expr t -> Expr t
signum (Constant Value t
x) = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> Value t -> Expr t
forall a b. (a -> b) -> a -> b
$ Value t -> Value t
forall a. Num a => a -> a
signum Value t
x
   signum Expr t
x            = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr t
x Expr t -> Expr t -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr t
0) Expr t
0 (Expr t -> Expr t) -> Expr t -> Expr t
forall a b. (a -> b) -> a -> b
$ Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr t
x Expr t -> Expr t -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<? Expr t
0) (-Expr t
1) Expr t
1
   {-# INLINE signum #-}

instance Fractional (Expr RealSort) where
  fromRational :: Rational -> Expr 'RealSort
fromRational = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'RealSort -> Expr 'RealSort)
-> (Rational -> Value 'RealSort) -> Rational -> Expr 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Value 'RealSort
HaskellType 'RealSort -> Value 'RealSort
RealValue (Rational -> Value 'RealSort)
-> (Rational -> Rational) -> Rational -> Value 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational
forall a. Fractional a => Rational -> a
fromRational
  {-# INLINE fromRational #-}
  Expr 'RealSort
x / :: Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
/ (Constant  Value 'RealSort
1) = Expr 'RealSort
x
  (Constant Value 'RealSort
0) / Expr 'RealSort
_ = Expr 'RealSort
0
  (Constant Value 'RealSort
x) / (Constant Value 'RealSort
y) = Value 'RealSort -> Expr 'RealSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'RealSort
x Value 'RealSort -> Value 'RealSort -> Value 'RealSort
forall a. Fractional a => a -> a -> a
/ Value 'RealSort
y)
  Expr 'RealSort
x / Expr 'RealSort
y          = Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div Expr 'RealSort
x Expr 'RealSort
y
  {-# INLINE (/) #-}

-- | Not part of the SMTLib standard Version 2.6.
--   Some solvers support it. At least valid for CVC5 and MathSAT.
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"

-- | This instance is __partial__ for 'toRational', this method is only intended for use with constants.
instance (KnownSMTSort t, Real (HaskellType t)) => Real (Expr t) where
  toRational :: Expr t -> Rational
toRational (Constant Value t
x) = HaskellType t -> Rational
forall a. Real a => a -> Rational
toRational (HaskellType t -> Rational) -> HaskellType t -> Rational
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
  toRational Expr t
_ = String -> Rational
forall a. HasCallStack => String -> a
error (String -> Rational) -> String -> Rational
forall a b. (a -> b) -> a -> b
$ String
"Real#toRational[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
  {-# INLINE toRational #-}

-- | This instance is __partial__ for 'fromEnum', this method is only intended for use with constants.
instance (KnownSMTSort t, Enum (HaskellType t)) => Enum (Expr t) where
  fromEnum :: Expr t -> Int
fromEnum (Constant Value t
x) = HaskellType t -> Int
forall a. Enum a => a -> Int
fromEnum (HaskellType t -> Int) -> HaskellType t -> Int
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
  fromEnum Expr t
_ = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Enum#fromEnum[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
  {-# INLINE fromEnum #-}
  toEnum :: Int -> Expr t
toEnum = Value t -> Expr t
forall (t :: SMTSort). Value t -> Expr t
Constant (Value t -> Expr t) -> (Int -> Value t) -> Int -> Expr t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HaskellType t -> Value t
forall (t :: SMTSort). KnownSMTSort t => HaskellType t -> Value t
wrapValue (HaskellType t -> Value t)
-> (Int -> HaskellType t) -> Int -> Value t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> HaskellType t
forall a. Enum a => Int -> a
toEnum
  {-# INLINE toEnum #-}

-- | This instance is __partial__ for 'toInteger', this method is only intended for use with constants.
instance (KnownSMTSort t, Integral (HaskellType t)) => Integral (Expr t) where
  quotRem :: Expr t -> Expr t -> (Expr t, Expr t)
quotRem Expr t
x Expr t
y = (Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv Expr t
x Expr t
y, Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Rem Expr t
x Expr t
y)
  {-# INLINE quotRem #-}
  divMod :: Expr t -> Expr t -> (Expr t, Expr t)
divMod Expr t
x Expr t
y  = (Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv Expr t
x Expr t
y, Expr t -> Expr t -> Expr t
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod Expr t
x Expr t
y)
  {-# INLINE divMod #-}
  toInteger :: Expr t -> Integer
toInteger (Constant Value t
x) = HaskellType t -> Integer
forall a. Integral a => a -> Integer
toInteger (HaskellType t -> Integer) -> HaskellType t -> Integer
forall a b. (a -> b) -> a -> b
$ Value t -> HaskellType t
forall (t :: SMTSort). Value t -> HaskellType t
unwrapValue Value t
x
  toInteger Expr t
_ = String -> Integer
forall a. HasCallStack => String -> a
error (String -> Integer) -> String -> Integer
forall a b. (a -> b) -> a -> b
$ String
"Integer#toInteger[Expr " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> SSMTSort t -> String
forall a. Show a => a -> String
show (forall (t :: SMTSort). KnownSMTSort t => SSMTSort t
sortSing @t) String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"] only supported for constants."
  {-# INLINE toInteger #-}

instance Boolean (Expr BoolSort) where
  bool :: Bool -> Expr 'BoolSort
bool = Value 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'BoolSort -> Expr 'BoolSort)
-> (Bool -> Value 'BoolSort) -> Bool -> Expr 'BoolSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value 'BoolSort
HaskellType 'BoolSort -> Value 'BoolSort
BoolValue
  {-# INLINE bool #-}
  (Constant (BoolValue HaskellType 'BoolSort
x)) && :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
&& Expr 'BoolSort
y = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort
y else Expr 'BoolSort
forall b. Boolean b => b
false
  Expr 'BoolSort
x && (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort
x else Expr 'BoolSort
forall b. Boolean b => b
false
  Expr 'BoolSort
x && Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And Expr 'BoolSort
x Expr 'BoolSort
y
  {-# INLINE (&&) #-}
  (Constant (BoolValue HaskellType 'BoolSort
x)) || :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
|| Expr 'BoolSort
y = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort
forall b. Boolean b => b
true else Expr 'BoolSort
y
  Expr 'BoolSort
x || (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort
forall b. Boolean b => b
true else Expr 'BoolSort
x
  Expr 'BoolSort
x || Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or Expr 'BoolSort
x Expr 'BoolSort
y
  {-# INLINE (||) #-}
  not :: Expr 'BoolSort -> Expr 'BoolSort
not (Constant Value 'BoolSort
x) = Value 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'BoolSort -> Expr 'BoolSort)
-> Value 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Value 'BoolSort -> Value 'BoolSort
forall b. Boolean b => b -> b
not Value 'BoolSort
x
  not (Not Expr 'BoolSort
x) = Expr 'BoolSort
x
  not Expr 'BoolSort
x = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr 'BoolSort
x
  {-# INLINE not #-}
  xor :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
xor (Constant (BoolValue HaskellType 'BoolSort
x)) Expr 'BoolSort
y  = if Bool
HaskellType 'BoolSort
x then Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
y else Expr 'BoolSort
y
  xor Expr 'BoolSort
x (Constant (BoolValue HaskellType 'BoolSort
y)) = if Bool
HaskellType 'BoolSort
y then Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not Expr 'BoolSort
x else Expr 'BoolSort
x
  xor Expr 'BoolSort
x Expr 'BoolSort
y = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor Expr 'BoolSort
x Expr 'BoolSort
y
  {-# INLINE xor #-}
  (Constant (BoolValue Bool
HaskellType 'BoolSort
False)) ==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
==> Expr 'BoolSort
_ = Expr 'BoolSort
forall b. Boolean b => b
true
  Expr 'BoolSort
x ==> Expr 'BoolSort
y  = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl Expr 'BoolSort
x Expr 'BoolSort
y
  {-# INLINE (==>) #-}
  <==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(<==>) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
(===)
  {-# INLINE (<==>) #-}

instance (KnownBvEnc enc, KnownNat n) => Boolean (Expr (BvSort enc n)) where
  bool :: Bool -> Expr ('BvSort enc n)
bool = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> (Bool -> Value ('BvSort enc n)) -> Bool -> Expr ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec enc n -> Value ('BvSort enc n)
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue (Bitvec enc n -> Value ('BvSort enc n))
-> (Bool -> Bitvec enc n) -> Bool -> Value ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bitvec enc n
forall b. Boolean b => Bool -> b
bool
  {-# INLINE bool #-}
  && :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(&&) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (&&) #-}
  || :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(||) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (||) #-}
  not :: Expr ('BvSort enc n) -> Expr ('BvSort enc n)
not (Not Expr ('BvSort enc n)
x) = Expr ('BvSort enc n)
x
  not Expr ('BvSort enc n)
x = Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr ('BvSort enc n)
x
  {-# INLINE not #-}
  xor :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
xor  = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
  {-# INLINE xor #-}

instance Bounded (Expr BoolSort) where
  minBound :: Expr 'BoolSort
minBound = Expr 'BoolSort
forall b. Boolean b => b
false
  {-# INLINE minBound #-}
  maxBound :: Expr 'BoolSort
maxBound = Expr 'BoolSort
forall b. Boolean b => b
true
  {-# INLINE maxBound #-}

instance (KnownBvEnc enc, KnownNat n) => Bounded (Expr (BvSort enc n)) where
  minBound :: Expr ('BvSort enc n)
minBound = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue Bitvec enc n
HaskellType ('BvSort enc n)
forall a. Bounded a => a
minBound
  {-# INLINE minBound #-}
  maxBound :: Expr ('BvSort enc n)
maxBound = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue Bitvec enc n
HaskellType ('BvSort enc n)
forall a. Bounded a => a
maxBound
  {-# INLINE maxBound #-}

-- | This instance is __partial__ for 'testBit' and 'popCount', it's only intended for use with constants ('Constant').
instance Bits.Bits (Expr BoolSort) where
  .&. :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(.&.) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (.&.) #-}
  .|. :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(.|.) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (.|.) #-}
  xor :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
xor = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
  {-# INLINE xor #-}
  complement :: Expr 'BoolSort -> Expr 'BoolSort
complement = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE complement #-}
  zeroBits :: Expr 'BoolSort
zeroBits = Expr 'BoolSort
forall b. Boolean b => b
false
  {-# INLINE zeroBits #-}
  bit :: Int -> Expr 'BoolSort
bit Int
_ = Expr 'BoolSort
forall b. Boolean b => b
true
  {-# INLINE bit #-}
  setBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
setBit Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
true
  {-# INLINE setBit #-}
  clearBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
clearBit Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
  {-# INLINE clearBit #-}
  complementBit :: Expr 'BoolSort -> Int -> Expr 'BoolSort
complementBit Expr 'BoolSort
b Int
_ = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not Expr 'BoolSort
b
  {-# INLINE complementBit #-}
  testBit :: Expr 'BoolSort -> Int -> Bool
testBit (Constant (BoolValue HaskellType 'BoolSort
b)) Int
_ = Bool
HaskellType 'BoolSort
b
  testBit Expr 'BoolSort
_ Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error String
"Bits#testBit[Expr BoolSort] is only supported for constants."
  {-# INLINE testBit #-}
  bitSizeMaybe :: Expr 'BoolSort -> Maybe Int
bitSizeMaybe Expr 'BoolSort
_ = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
  {-# INLINE bitSizeMaybe #-}
  bitSize :: Expr 'BoolSort -> Int
bitSize Expr 'BoolSort
_ = Int
1
  {-# INLINE bitSize #-}
  isSigned :: Expr 'BoolSort -> Bool
isSigned Expr 'BoolSort
_ = Bool
False
  {-# INLINE isSigned #-}
  shiftL :: Expr 'BoolSort -> Int -> Expr 'BoolSort
shiftL Expr 'BoolSort
b Int
0 = Expr 'BoolSort
b
  shiftL Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
  {-# INLINE shiftL #-}
  shiftR :: Expr 'BoolSort -> Int -> Expr 'BoolSort
shiftR Expr 'BoolSort
b Int
0 = Expr 'BoolSort
b
  shiftR Expr 'BoolSort
_ Int
_ = Expr 'BoolSort
forall b. Boolean b => b
false
  {-# INLINE shiftR #-}
  rotateL :: Expr 'BoolSort -> Int -> Expr 'BoolSort
rotateL Expr 'BoolSort
b Int
_ = Expr 'BoolSort
b
  {-# INLINE rotateL #-}
  rotateR :: Expr 'BoolSort -> Int -> Expr 'BoolSort
rotateR Expr 'BoolSort
b Int
_ = Expr 'BoolSort
b
  {-# INLINE rotateR #-}
  popCount :: Expr 'BoolSort -> Int
popCount (Constant (BoolValue HaskellType 'BoolSort
b)) = if Bool
HaskellType 'BoolSort
b then Int
1 else Int
0
  popCount Expr 'BoolSort
_ = String -> Int
forall a. HasCallStack => String -> a
error String
"Bits#popCount[Expr BoolSort] is only supported for constants."
  {-# INLINE popCount #-}

-- | This instance is __partial__ for 'testBit' and 'popCount', it's only intended for use with constants ('Constant').
instance (KnownBvEnc enc, KnownNat n) => Bits.Bits (Expr (BvSort enc n)) where
  .&. :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(.&.) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (.&.) #-}
  .|. :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
(.|.) = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (.|.) #-}
  xor :: Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
xor = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
  {-# INLINE xor #-}
  complement :: Expr ('BvSort enc n) -> Expr ('BvSort enc n)
complement = Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE complement #-}
  zeroBits :: Expr ('BvSort enc n)
zeroBits = Expr ('BvSort enc n)
forall b. Boolean b => b
false
  {-# INLINE zeroBits #-}
  bit :: Int -> Expr ('BvSort enc n)
bit = Value ('BvSort enc n) -> Expr ('BvSort enc n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort enc n) -> Expr ('BvSort enc n))
-> (Int -> Value ('BvSort enc n)) -> Int -> Expr ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec enc n -> Value ('BvSort enc n)
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
HaskellType ('BvSort enc n) -> Value ('BvSort enc n)
BvValue (Bitvec enc n -> Value ('BvSort enc n))
-> (Int -> Bitvec enc n) -> Int -> Value ('BvSort enc n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Bitvec enc n
forall a. Bits a => Int -> a
Bits.bit
  {-# INLINE bit #-}
  testBit :: Expr ('BvSort enc n) -> Int -> Bool
testBit (Constant (BvValue HaskellType ('BvSort enc n)
b)) Int
i = Bitvec enc n -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
Bits.testBit Bitvec enc n
HaskellType ('BvSort enc n)
b Int
i
  testBit Expr ('BvSort enc n)
_ Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error String
"Bits#testBit[Expr BvSort] is only supported for constants."
  {-# INLINE testBit #-}
  bitSizeMaybe :: Expr ('BvSort enc n) -> Maybe Int
bitSizeMaybe Expr ('BvSort enc n)
_ = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n -> Integer) -> Proxy n -> Integer
forall a b. (a -> b) -> a -> b
$ forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n
  {-# INLINE bitSizeMaybe #-}
  bitSize :: Expr ('BvSort enc n) -> Int
bitSize Expr ('BvSort enc n)
_ = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n -> Integer) -> Proxy n -> Integer
forall a b. (a -> b) -> a -> b
$ forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @n
  {-# INLINE bitSize #-}
  isSigned :: Expr ('BvSort enc n) -> Bool
isSigned Expr ('BvSort enc n)
_ = case forall (enc :: BvEnc). KnownBvEnc enc => SBvEnc enc
bvEncSing @enc of
    SBvEnc enc
SUnsigned -> Bool
False
    SBvEnc enc
SSigned   -> Bool
True
  {-# INLINE isSigned #-}
  shiftL :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
shiftL Expr ('BvSort enc n)
b Int
i = Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL Expr ('BvSort enc n)
b (Int -> Expr ('BvSort enc n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
  {-# INLINE shiftL #-}
  shiftR :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
shiftR Expr ('BvSort enc n)
b Int
i = case forall (enc :: BvEnc). KnownBvEnc enc => SBvEnc enc
bvEncSing @enc of
    SBvEnc enc
SUnsigned -> Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR Expr ('BvSort enc n)
Expr ('BvSort 'Unsigned n)
b (Int -> Expr ('BvSort 'Unsigned n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
    SBvEnc enc
SSigned   -> Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR Expr ('BvSort enc n)
Expr ('BvSort 'Signed n)
b (Int -> Expr ('BvSort 'Signed n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
  {-# INLINE shiftR #-}
  rotateL :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
rotateL Expr ('BvSort enc n)
b Int
i = Int -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL Int
i Expr ('BvSort enc n)
b
  {-# INLINE rotateL #-}
  rotateR :: Expr ('BvSort enc n) -> Int -> Expr ('BvSort enc n)
rotateR Expr ('BvSort enc n)
b Int
i = Int -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR Int
i Expr ('BvSort enc n)
b
  {-# INLINE rotateR #-}
  popCount :: Expr ('BvSort enc n) -> Int
popCount (Constant (BvValue HaskellType ('BvSort enc n)
b)) = Bitvec enc n -> Int
forall a. Bits a => a -> Int
Bits.popCount Bitvec enc n
HaskellType ('BvSort enc n)
b
  popCount Expr ('BvSort enc n)
_ = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Bits#popCount[Expr BvSort] is only supported for constants."
  {-# INLINE popCount #-}

instance Semigroup (Expr StringSort) where
  <> :: Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
(<>) = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat
  {-# INLINE (<>) #-}

instance Monoid (Expr StringSort) where
  mempty :: Expr 'StringSort
mempty = Value 'StringSort -> Expr 'StringSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'StringSort -> Expr 'StringSort)
-> Value 'StringSort -> Expr 'StringSort
forall a b. (a -> b) -> a -> b
$ HaskellType 'StringSort -> Value 'StringSort
StringValue Text
HaskellType 'StringSort
forall a. Monoid a => a
mempty
  {-# INLINE mempty #-}
  mappend :: Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
mappend = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>)
  {-# INLINE mappend #-}

instance IsString (Expr StringSort) where
  fromString :: String -> Expr 'StringSort
fromString = Value 'StringSort -> Expr 'StringSort
forall (t :: SMTSort). Value t -> Expr t
Constant (Value 'StringSort -> Expr 'StringSort)
-> (String -> Value 'StringSort) -> String -> Expr 'StringSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value 'StringSort
HaskellType 'StringSort -> Value 'StringSort
StringValue (Text -> Value 'StringSort)
-> (String -> Text) -> String -> Value 'StringSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack
  {-# INLINE fromString #-}

type instance Index   (Expr StringSort) = Expr IntSort
type instance IxValue (Expr StringSort) = Expr StringSort

instance Ixed (Expr StringSort) where
  ix :: Index (Expr 'StringSort)
-> Traversal' (Expr 'StringSort) (IxValue (Expr 'StringSort))
ix Index (Expr 'StringSort)
i IxValue (Expr 'StringSort) -> f (IxValue (Expr 'StringSort))
f Expr 'StringSort
s = IxValue (Expr 'StringSort) -> f (IxValue (Expr 'StringSort))
f (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s Index (Expr 'StringSort)
Expr 'IntSort
i) f (Expr 'StringSort)
-> (Expr 'StringSort -> Expr 'StringSort) -> f (Expr 'StringSort)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Expr 'StringSort
a ->
    let l :: Expr 'StringSort
l = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
a Expr 'IntSort
0 Index (Expr 'StringSort)
Expr 'IntSort
i
        r :: Expr 'StringSort
r = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
a Index (Expr 'StringSort)
Expr 'IntSort
i (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
a)
     in Expr 'StringSort
l Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
<> Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace Expr 'StringSort
r (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
a Index (Expr 'StringSort)
Expr 'IntSort
i) Expr 'StringSort
s

instance AsEmpty (Expr StringSort) where
  _Empty :: Prism' (Expr 'StringSort) ()
_Empty = (() -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe ()) -> Prism' (Expr 'StringSort) ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    (Expr 'StringSort -> () -> Expr 'StringSort
forall a b. a -> b -> a
const Expr 'StringSort
forall a. Monoid a => a
mempty)
    (\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort
s Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== Expr 'StringSort
forall a. Monoid a => a
mempty) (() -> Maybe ()
forall a. a -> Maybe a
Just ()) Maybe ()
forall a. Maybe a
Nothing)

instance Prefixed (Expr StringSort) where
  prefixed :: Expr 'StringSort -> Prism' (Expr 'StringSort) (Expr 'StringSort)
prefixed Expr 'StringSort
p = (Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Prism' (Expr 'StringSort) (Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    (Expr 'StringSort
p <>)
    (\Expr 'StringSort
s -> Expr 'BoolSort
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'StringSort
p Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
`strPrefixOf` Expr 'StringSort
s) (Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a b. (a -> b) -> a -> b
$ Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace Expr 'StringSort
s Expr 'StringSort
p Expr 'StringSort
forall a. Monoid a => a
mempty) Maybe (Expr 'StringSort)
forall a. Maybe a
Nothing)

instance Suffixed (Expr StringSort) where
  suffixed :: Expr 'StringSort -> Prism' (Expr 'StringSort) (Expr 'StringSort)
suffixed Expr 'StringSort
qs = (Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Prism' (Expr 'StringSort) (Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    (Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
<> Expr 'StringSort
qs)
    (\Expr 'StringSort
s -> Expr 'BoolSort
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
-> Maybe (Expr 'StringSort)
forall b a. Iteable b a => b -> a -> a -> a
ite (Expr 'StringSort
qs Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
`strSuffixOf` Expr 'StringSort
s) (Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Maybe (Expr 'StringSort))
-> Expr 'StringSort -> Maybe (Expr 'StringSort)
forall a b. (a -> b) -> a -> b
$ Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
0 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
qs)) Maybe (Expr 'StringSort)
forall a. Maybe a
Nothing)

instance Cons (Expr StringSort) (Expr StringSort) (Expr StringSort) (Expr StringSort) where
  _Cons :: Prism
  (Expr 'StringSort)
  (Expr 'StringSort)
  (Expr 'StringSort, Expr 'StringSort)
  (Expr 'StringSort, Expr 'StringSort)
_Cons = ((Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort, Expr 'StringSort))
-> Prism
     (Expr 'StringSort)
     (Expr 'StringSort)
     (Expr 'StringSort, Expr 'StringSort)
     (Expr 'StringSort, Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    ((Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>))
    (\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
>? Expr 'IntSort
0) ((Expr 'StringSort, Expr 'StringSort)
-> Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s Expr 'IntSort
0, Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
1 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s))) Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. Maybe a
Nothing)

instance Snoc (Expr StringSort) (Expr StringSort) (Expr StringSort) (Expr StringSort) where
  _Snoc :: Prism
  (Expr 'StringSort)
  (Expr 'StringSort)
  (Expr 'StringSort, Expr 'StringSort)
  (Expr 'StringSort, Expr 'StringSort)
_Snoc = ((Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort)
-> (Expr 'StringSort -> Maybe (Expr 'StringSort, Expr 'StringSort))
-> Prism
     (Expr 'StringSort)
     (Expr 'StringSort)
     (Expr 'StringSort, Expr 'StringSort)
     (Expr 'StringSort, Expr 'StringSort)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism'
    ((Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort)
-> (Expr 'StringSort, Expr 'StringSort) -> Expr 'StringSort
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
forall a. Semigroup a => a -> a -> a
(<>))
    (\Expr 'StringSort
s -> forall b a. Iteable b a => b -> a -> a -> a
ite @(Expr BoolSort) (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
>? Expr 'IntSort
0) ((Expr 'StringSort, Expr 'StringSort)
-> Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. a -> Maybe a
Just (Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring Expr 'StringSort
s Expr 'IntSort
0 (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'IntSort
1), Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt Expr 'StringSort
s (Expr 'StringSort -> Expr 'IntSort
strLength Expr 'StringSort
s Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Num a => a -> a -> a
- Expr 'IntSort
1))) Maybe (Expr 'StringSort, Expr 'StringSort)
forall a. Maybe a
Nothing)

type instance Index   (Expr (ArraySort k v)) = Expr k
type instance IxValue (Expr (ArraySort k v)) = Expr v

instance (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), Ord (HaskellType v)) => Ixed (Expr (ArraySort k v)) where
  ix :: Index (Expr ('ArraySort k v))
-> Traversal'
     (Expr ('ArraySort k v)) (IxValue (Expr ('ArraySort k v)))
ix Index (Expr ('ArraySort k v))
i IxValue (Expr ('ArraySort k v))
-> f (IxValue (Expr ('ArraySort k v)))
f Expr ('ArraySort k v)
arr = IxValue (Expr ('ArraySort k v))
-> f (IxValue (Expr ('ArraySort k v)))
f (Expr ('ArraySort k v) -> Expr k -> Expr v
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
select Expr ('ArraySort k v)
arr Index (Expr ('ArraySort k v))
Expr k
i) f (Expr v)
-> (Expr v -> Expr ('ArraySort k v)) -> f (Expr ('ArraySort k v))
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
store Expr ('ArraySort k v)
arr Index (Expr ('ArraySort k v))
Expr k
i

-- | __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 (Minus Expr b
x Expr b
y)             = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Neg Expr b
x)                 = Expr b -> Expr b
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Mul Expr b
x Expr b
y)               = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Abs Expr b
x)                 = Expr b -> Expr b
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Mod Expr b
x Expr b
y)               = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Rem Expr b
x Expr b
y)               = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Rem (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (IDiv Expr b
x Expr b
y)              = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Div Expr 'RealSort
x Expr 'RealSort
y)               = Expr 'RealSort -> Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div (Expr 'RealSort -> Expr 'RealSort -> Expr b)
-> m (Expr 'RealSort) -> m (Expr 'RealSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x m (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (LTH Expr t
x Expr t
y)               = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTH (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (LTHE Expr t
x Expr t
y)              = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTHE (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (EQU Vector (n + 2) (Expr t)
xs)                = Vector (n + 2) (Expr t) -> Expr b
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr b)
-> m (Vector (n + 2) (Expr t)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> m (Expr t))
-> Vector (n + 2) (Expr t) -> m (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Vector (n + 2) (Expr t)
xs
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Distinct Vector (n + 2) (Expr t)
xs)           = Vector (n + 2) (Expr t) -> Expr b
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr b)
-> m (Vector (n + 2) (Expr t)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> m (Expr t))
-> Vector (n + 2) (Expr t) -> m (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Vector (n + 2) (Expr t)
xs
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (GTHE Expr t
x Expr t
y)              = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTHE (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (GTH Expr t
x Expr t
y)               = Expr t -> Expr t -> Expr b
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTH (Expr t -> Expr t -> Expr b) -> m (Expr t) -> m (Expr t -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
x m (Expr t -> Expr b) -> m (Expr t) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr t -> m (Expr t)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr t
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Not Expr b
x)                 = Expr b -> Expr b
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (And Expr b
x Expr b
y)               = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Or Expr b
x Expr b
y)                = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Impl Expr b
x Expr b
y)              = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Xor Expr b
x Expr b
y)               = Expr b -> Expr b -> Expr b
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor (Expr b -> Expr b -> Expr b) -> m (Expr b) -> m (Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
x m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ Expr b
Pi                      = Expr b -> m (Expr b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr b
Expr 'RealSort
Pi
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Sqrt Expr 'RealSort
x)                = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Sqrt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Exp Expr 'RealSort
x)                 = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Exp (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Sin Expr 'RealSort
x)                 = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Sin (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Cos Expr 'RealSort
x)                 = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Cos (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Tan Expr 'RealSort
x)                 = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Tan (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Asin Expr 'RealSort
x)                = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Asin (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Acos Expr 'RealSort
x)                = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Acos (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Atan Expr 'RealSort
x)                = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'RealSort
Atan (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ToReal Expr 'IntSort
x)              = Expr 'IntSort -> Expr b
Expr 'IntSort -> Expr 'RealSort
ToReal (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ToInt Expr 'RealSort
x)               = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'IntSort
ToInt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (IsInt Expr 'RealSort
x)               = Expr 'RealSort -> Expr b
Expr 'RealSort -> Expr 'BoolSort
IsInt (Expr 'RealSort -> Expr b) -> m (Expr 'RealSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'RealSort -> m (Expr 'RealSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'RealSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Ite Expr 'BoolSort
p Expr b
t Expr b
n)             = Expr 'BoolSort -> Expr b -> Expr b -> Expr b
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite (Expr 'BoolSort -> Expr b -> Expr b -> Expr b)
-> m (Expr 'BoolSort) -> m (Expr b -> Expr b -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'BoolSort
p m (Expr b -> Expr b -> Expr b)
-> m (Expr b) -> m (Expr b -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
t m (Expr b -> Expr b) -> m (Expr b) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr b -> m (Expr b)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr b
n
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)            = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNand (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)             = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNor (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)             = Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y)            = Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n) -> Expr b
Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR (Expr ('BvSort 'Unsigned n)
 -> Expr ('BvSort 'Unsigned n) -> Expr b)
-> m (Expr ('BvSort 'Unsigned n))
-> m (Expr ('BvSort 'Unsigned n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort 'Unsigned n) -> m (Expr ('BvSort 'Unsigned n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Unsigned n)
x m (Expr ('BvSort 'Unsigned n) -> Expr b)
-> m (Expr ('BvSort 'Unsigned n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort 'Unsigned n) -> m (Expr ('BvSort 'Unsigned n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Unsigned n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y)            = Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr b
Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR (Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr b)
-> m (Expr ('BvSort 'Signed n))
-> m (Expr ('BvSort 'Signed n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort 'Signed n) -> m (Expr ('BvSort 'Signed n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Signed n)
x m (Expr ('BvSort 'Signed n) -> Expr b)
-> m (Expr ('BvSort 'Signed n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort 'Signed n) -> m (Expr ('BvSort 'Signed n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort 'Signed n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y)          = Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr b
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
BvConcat (Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr ('BvSort enc m) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x m (Expr ('BvSort enc m) -> Expr b)
-> m (Expr ('BvSort enc m)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort enc m) -> m (Expr ('BvSort enc m))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc m)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotL a
i Expr ('BvSort enc n)
x)            = a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL a
i (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotR a
i Expr ('BvSort enc n)
x)            = a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR a
i (Expr ('BvSort enc n) -> Expr b)
-> m (Expr ('BvSort enc n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort enc n) -> m (Expr ('BvSort enc n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort enc n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ArrSelect Expr ('ArraySort k b)
i Expr k
arr)       = Expr ('ArraySort k b) -> Expr k -> Expr b
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect Expr ('ArraySort k b)
i (Expr k -> Expr b) -> m (Expr k) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr k -> m (Expr k)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr k
arr
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ArrStore Expr ('ArraySort k v)
i Expr k
x Expr v
arr)      = Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
ArrStore Expr ('ArraySort k v)
i (Expr k -> Expr v -> Expr b) -> m (Expr k) -> m (Expr v -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr k -> m (Expr k)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr k
x m (Expr v -> Expr b) -> m (Expr v) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr v -> m (Expr v)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr v
arr
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrConcat Expr 'StringSort
x Expr 'StringSort
y)         = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrLength Expr 'StringSort
x)           = Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'IntSort
StrLength (Expr 'StringSort -> Expr b) -> m (Expr 'StringSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrAt Expr 'StringSort
x Expr 'IntSort
i)             = Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j)    = Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'IntSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
j
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrContains Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i)      = Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y')     = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y')  = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
expr) = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr b)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr b) -> m (Expr 'BoolSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Expr t -> Expr 'BoolSort
expr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ (ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
expr)   = Expr 'BoolSort -> m (Expr 'BoolSort)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> m (Expr 'BoolSort))
-> Expr 'BoolSort -> m (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
expr
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
expr) = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr b)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr b) -> m (Expr 'BoolSort) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'BoolSort -> m (Expr 'BoolSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (Expr t -> Expr 'BoolSort
expr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
_ (Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
expr)   = Expr 'BoolSort -> m (Expr 'BoolSort)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> m (Expr 'BoolSort))
-> Expr 'BoolSort -> m (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
expr

-- | __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
          Minus Expr r
x Expr r
y            -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Neg Expr r
x                -> Expr r -> Expr r
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Neg  (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
          Mul Expr r
x Expr r
y              -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul  (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Abs Expr r
x                -> Expr r -> Expr r
forall (t :: SMTSort). Num (HaskellType t) => Expr t -> Expr t
Abs  (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
          Mod Expr r
x Expr r
y              -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod  (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Rem Expr r
x Expr r
y              -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod  (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          IDiv Expr r
x Expr r
y             -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Div Expr 'RealSort
x Expr 'RealSort
y              -> Expr 'RealSort -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort -> Expr 'RealSort
Div  (Expr 'RealSort -> Expr 'RealSort -> Expr r)
-> f (Expr 'RealSort) -> f (Expr 'RealSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x f (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
y
          LTH Expr t
x Expr t
y              -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTH  (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
          LTHE Expr t
x Expr t
y             -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
LTHE (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
          EQU Vector (n + 2) (Expr t)
xs               -> Vector (n + 2) (Expr t) -> Expr r
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
EQU  (Vector (n + 2) (Expr t) -> Expr r)
-> f (Vector (n + 2) (Expr t)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> f (Expr t))
-> Vector (n + 2) (Expr t) -> f (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse ((Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f') Vector (n + 2) (Expr t)
xs
          Distinct Vector (n + 2) (Expr t)
xs          -> Vector (n + 2) (Expr t) -> Expr r
Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall (enc :: SMTSort) (n :: Nat).
(Eq (HaskellType enc), KnownSMTSort enc, KnownNat n) =>
Vector (n + 2) (Expr enc) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr r)
-> f (Vector (n + 2) (Expr t)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr t -> f (Expr t))
-> Vector (n + 2) (Expr t) -> f (Vector (n + 2) (Expr t))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> Vector Vector (n + 2) a -> f (Vector Vector (n + 2) b)
traverse ((Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f') Vector (n + 2) (Expr t)
xs
          GTHE Expr t
x Expr t
y             -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTHE (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
          GTH Expr t
x Expr t
y              -> Expr t -> Expr t -> Expr r
Expr t -> Expr t -> Expr 'BoolSort
forall (enc :: SMTSort).
(Ord (HaskellType enc), KnownSMTSort enc) =>
Expr enc -> Expr enc -> Expr 'BoolSort
GTH  (Expr t -> Expr t -> Expr r) -> f (Expr t) -> f (Expr t -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
x f (Expr t -> Expr r) -> f (Expr t) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr t
y
          Not Expr r
x                -> Expr r -> Expr r
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not  (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x
          And Expr r
x Expr r
y              -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And  (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Or Expr r
x Expr r
y               -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or   (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Impl Expr r
x Expr r
y             -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Impl (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Xor Expr r
x Expr r
y              -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor  (Expr r -> Expr r -> Expr r) -> f (Expr r) -> f (Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
x f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
y
          Expr r
Pi                   -> Expr r -> f (Expr r)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr r
Expr 'RealSort
Pi
          Sqrt Expr 'RealSort
x               -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Sqrt (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Exp Expr 'RealSort
x                -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Exp  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Sin Expr 'RealSort
x                -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Sin  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Cos Expr 'RealSort
x                -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Cos  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Tan Expr 'RealSort
x                -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Tan  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Asin Expr 'RealSort
x               -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Asin (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Acos Expr 'RealSort
x               -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Acos (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Atan Expr 'RealSort
x               -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'RealSort
Atan (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          ToReal Expr 'IntSort
x             -> Expr 'IntSort -> Expr r
Expr 'IntSort -> Expr 'RealSort
ToReal (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
x
          ToInt Expr 'RealSort
x              -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'IntSort
ToInt  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          IsInt Expr 'RealSort
x              -> Expr 'RealSort -> Expr r
Expr 'RealSort -> Expr 'BoolSort
IsInt  (Expr 'RealSort -> Expr r) -> f (Expr 'RealSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'RealSort
x
          Ite Expr 'BoolSort
p Expr r
t Expr r
n            -> Expr 'BoolSort -> Expr r -> Expr r -> Expr r
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite    (Expr 'BoolSort -> Expr r -> Expr r -> Expr r)
-> f (Expr 'BoolSort) -> f (Expr r -> Expr r -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'BoolSort
p f (Expr r -> Expr r -> Expr r)
-> f (Expr r) -> f (Expr r -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
t f (Expr r -> Expr r) -> f (Expr r) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr r
n
          BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y           -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNand (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
          BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y            -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvNor  (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
          BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y            -> Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat).
(KnownBvEnc enc, KnownNat n) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvShL  (Expr ('BvSort enc n) -> Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
y
          BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y           -> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n) -> Expr r
Expr ('BvSort 'Unsigned n)
-> Expr ('BvSort 'Unsigned n) -> Expr ('BvSort 'Unsigned n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Unsigned enc)
-> Expr ('BvSort 'Unsigned enc) -> Expr ('BvSort 'Unsigned enc)
BvLShR (Expr ('BvSort 'Unsigned n)
 -> Expr ('BvSort 'Unsigned n) -> Expr r)
-> f (Expr ('BvSort 'Unsigned n))
-> f (Expr ('BvSort 'Unsigned n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Unsigned n)
x f (Expr ('BvSort 'Unsigned n) -> Expr r)
-> f (Expr ('BvSort 'Unsigned n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Unsigned n)
y
          BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y           -> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr r
Expr ('BvSort 'Signed n)
-> Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n)
forall (enc :: Nat).
KnownNat enc =>
Expr ('BvSort 'Signed enc)
-> Expr ('BvSort 'Signed enc) -> Expr ('BvSort 'Signed enc)
BvAShR (Expr ('BvSort 'Signed n) -> Expr ('BvSort 'Signed n) -> Expr r)
-> f (Expr ('BvSort 'Signed n))
-> f (Expr ('BvSort 'Signed n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Signed n)
x f (Expr ('BvSort 'Signed n) -> Expr r)
-> f (Expr ('BvSort 'Signed n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort 'Signed n)
y
          BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y         -> Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr r
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
forall (enc :: BvEnc) (n :: Nat) (m :: Nat).
(KnownBvEnc enc, KnownNat n, KnownNat m) =>
Expr ('BvSort enc n)
-> Expr ('BvSort enc m) -> Expr ('BvSort enc (n + m))
BvConcat (Expr ('BvSort enc n) -> Expr ('BvSort enc m) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr ('BvSort enc m) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x f (Expr ('BvSort enc m) -> Expr r)
-> f (Expr ('BvSort enc m)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc m)
y
          BvRotL a
i Expr ('BvSort enc n)
x           -> a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotL a
i (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x
          BvRotR a
i Expr ('BvSort enc n)
x           -> a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
forall (enc :: BvEnc) (n :: Nat) a.
(KnownBvEnc enc, KnownNat n, Integral a) =>
a -> Expr ('BvSort enc n) -> Expr ('BvSort enc n)
BvRotR a
i (Expr ('BvSort enc n) -> Expr r)
-> f (Expr ('BvSort enc n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort enc n)
x
          ArrSelect Expr ('ArraySort k r)
i Expr k
arr      -> Expr ('ArraySort k r) -> Expr k -> Expr r
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k),
 Ord (HaskellType v)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v
ArrSelect Expr ('ArraySort k r)
i   (Expr k -> Expr r) -> f (Expr k) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr k
arr
          ArrStore Expr ('ArraySort k v)
i Expr k
x Expr v
arr     -> Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
forall (k :: SMTSort) (v :: SMTSort).
(KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k)) =>
Expr ('ArraySort k v) -> Expr k -> Expr v -> Expr ('ArraySort k v)
ArrStore Expr ('ArraySort k v)
i    (Expr k -> Expr v -> Expr r) -> f (Expr k) -> f (Expr v -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr k
x f (Expr v -> Expr r) -> f (Expr v) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr v
arr
          StrConcat Expr 'StringSort
x Expr 'StringSort
y        -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrConcat     (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrLength Expr 'StringSort
x          -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'IntSort
StrLength     (Expr 'StringSort -> Expr r) -> f (Expr 'StringSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x
          StrAt Expr 'StringSort
x Expr 'IntSort
i            -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt         (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
          StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j   -> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring  (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'IntSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
j
          StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrContains Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i     -> Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf    (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
          StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y'    -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace    (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
          StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y' -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
          ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
qexpr -> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr r)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr r) -> f (Expr 'BoolSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' (Expr t -> Expr 'BoolSort
qexpr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
          ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
qexpr   -> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> f (Expr 'BoolSort))
-> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
ForAll Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
qexpr
          Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
qexpr -> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists (SMTVar t -> Maybe (SMTVar t)
forall a. a -> Maybe a
Just SMTVar t
qv) ((Expr t -> Expr 'BoolSort) -> Expr r)
-> (Expr 'BoolSort -> Expr t -> Expr 'BoolSort)
-> Expr 'BoolSort
-> Expr r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr 'BoolSort -> Expr t -> Expr 'BoolSort
forall a b. a -> b -> a
const (Expr 'BoolSort -> Expr r) -> f (Expr 'BoolSort) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' (Expr t -> Expr 'BoolSort
qexpr (SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv))
          Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
qexpr   -> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Expr 'BoolSort -> f (Expr 'BoolSort))
-> Expr 'BoolSort -> f (Expr 'BoolSort)
forall a b. (a -> b) -> a -> b
$ Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (enc :: SMTSort).
KnownSMTSort enc =>
Maybe (SMTVar enc)
-> (Expr enc -> Expr 'BoolSort) -> Expr 'BoolSort
Exists Maybe (SMTVar t)
forall a. Maybe a
Nothing Expr t -> Expr 'BoolSort
qexpr

instance GNFData Expr where
  grnf :: forall (a :: SMTSort). Expr a -> ()
grnf Expr a
expr = case Expr a
expr of
    Var (SMTVar Int
vId)     -> Int
vId Int -> () -> ()
forall a b. a -> b -> b
`seq` ()
    Constant Value a
c           -> Value a
c Value a -> () -> ()
forall a b. a -> b -> b
`seq` ()
    Plus Expr a
e1 Expr a
e2           -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Minus Expr a
e1 Expr a
e2          -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Neg Expr a
e                -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
    Mul Expr a
e1 Expr a
e2            -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Abs Expr a
e                -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
    Mod Expr a
e1 Expr a
e2            -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Rem Expr a
e1 Expr a
e2            -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    IDiv Expr a
e1 Expr a
e2           -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Div Expr 'RealSort
e1 Expr 'RealSort
e2            -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e2
    LTH Expr t
e1 Expr t
e2            -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
    LTHE Expr t
e1 Expr t
e2           -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
    EQU Vector (n + 2) (Expr t)
vec              -> Vector (n + 2) (Expr t)
vec Vector (n + 2) (Expr t) -> () -> ()
forall a b. a -> b -> b
`seq` (() -> Expr t -> ()) -> () -> Vector (n + 2) (Expr t) -> ()
forall a b (n :: Nat). (a -> b -> a) -> a -> Vector n b -> a
V.foldl' ((Expr t -> ()) -> () -> Expr t -> ()
forall a b. a -> b -> a
const Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf) () Vector (n + 2) (Expr t)
vec
    Distinct Vector (n + 2) (Expr t)
vec         -> Vector (n + 2) (Expr t)
vec Vector (n + 2) (Expr t) -> () -> ()
forall a b. a -> b -> b
`seq` (() -> Expr t -> ()) -> () -> Vector (n + 2) (Expr t) -> ()
forall a b (n :: Nat). (a -> b -> a) -> a -> Vector n b -> a
V.foldl' ((Expr t -> ()) -> () -> Expr t -> ()
forall a b. a -> b -> a
const Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf) () Vector (n + 2) (Expr t)
vec
    GTHE Expr t
e1 Expr t
e2           -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
    GTH Expr t
e1 Expr t
e2            -> Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr t -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr t
e2
    Not Expr a
e                -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e
    And Expr a
e1 Expr a
e2            -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Or Expr a
e1 Expr a
e2             -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Impl Expr a
e1 Expr a
e2           -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Xor Expr a
e1 Expr a
e2            -> Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    Expr a
Pi                   -> ()
    Sqrt Expr 'RealSort
e               -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Exp Expr 'RealSort
e                -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Sin Expr 'RealSort
e                -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Cos Expr 'RealSort
e                -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Tan Expr 'RealSort
e                -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Asin Expr 'RealSort
e               -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Acos Expr 'RealSort
e               -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Atan Expr 'RealSort
e               -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    ToReal Expr 'IntSort
e             -> Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e
    ToInt Expr 'RealSort
e              -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    IsInt Expr 'RealSort
e              -> Expr 'RealSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'RealSort
e
    Ite Expr 'BoolSort
c Expr a
e1 Expr a
e2          -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'BoolSort
c () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr a -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr a
e2
    BvNand Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2         -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
    BvNor Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2          -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
    BvShL Expr ('BvSort enc n)
e1 Expr ('BvSort enc n)
e2          -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e2
    BvLShR Expr ('BvSort 'Unsigned n)
e1 Expr ('BvSort 'Unsigned n)
e2         -> Expr ('BvSort 'Unsigned n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Unsigned n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort 'Unsigned n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Unsigned n)
e2
    BvAShR Expr ('BvSort 'Signed n)
e1 Expr ('BvSort 'Signed n)
e2         -> Expr ('BvSort 'Signed n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Signed n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort 'Signed n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort 'Signed n)
e2
    BvConcat Expr ('BvSort enc n)
e1 Expr ('BvSort enc m)
e2       -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort enc m) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc m)
e2
    BvRotL a
_ Expr ('BvSort enc n)
e           -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e
    BvRotR a
_ Expr ('BvSort enc n)
e           -> Expr ('BvSort enc n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort enc n)
e
    ArrSelect Expr ('ArraySort k a)
e1 Expr k
e2      -> Expr ('ArraySort k a) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k a)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2
    ArrStore Expr ('ArraySort k v)
e1 Expr k
e2 Expr v
e3    -> Expr ('ArraySort k v) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k v)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr v -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr v
e3
    StrConcat Expr 'StringSort
e1 Expr 'StringSort
e2      -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrLength Expr 'StringSort
e          -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e
    StrAt Expr 'StringSort
e1 Expr 'IntSort
e2          -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2
    StrSubstring Expr 'StringSort
e1 Expr 'IntSort
e2 Expr 'IntSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
    StrPrefixOf Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrSuffixOf Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrContains Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrIndexOf Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'IntSort
e3  -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
    StrReplace Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3  -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
    StrReplaceAll Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
    ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_     -> ()
    ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
f   -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf (Expr 'BoolSort -> ()) -> Expr 'BoolSort -> ()
forall a b. (a -> b) -> a -> b
$ Expr t -> Expr 'BoolSort
f (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv
    Exists Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_     -> ()
    Exists (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
f   -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf (Expr 'BoolSort -> ()) -> Expr 'BoolSort -> ()
forall a b. (a -> b) -> a -> b
$ Expr t -> Expr 'BoolSort
f (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var SMTVar t
qv

instance Eq (Expr t) where
  == :: Expr t -> Expr t -> Bool
(==) = Expr t -> Expr t -> Bool
forall {k} (f :: k -> *) (a :: k) (b :: k).
GEq f =>
f a -> f b -> Bool
defaultEq

instance Ord (Expr t) where
  compare :: Expr t -> Expr t -> Ordering
compare = Expr t -> Expr t -> Ordering
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> Ordering
defaultCompare

instance GEq Expr where
  geq :: forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> Maybe (a :~: b)
geq = Expr a -> Expr b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> Maybe (a :~: b)
defaultGeq

gcomparing :: GCompare f => [(f a, f b)] -> GOrdering a b
gcomparing :: forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [] = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
gcomparing ((f a
x,f b
y):[(f a, f b)]
xys) = case f a -> f b -> GOrdering a b
forall (a :: k) (b :: k). f a -> f b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
gcompare f a
x f b
y of
  GOrdering a b
GEQ -> [(f a, f b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(f a, f b)]
xys
  GOrdering a b
o -> GOrdering a b
o

instance GCompare Expr where
  gcompare :: forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Var SMTVar a
v) (Var SMTVar b
v') = case SSMTSort a -> SSMTSort b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (SMTVar a -> SSMTSort a
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' SMTVar a
v) (SMTVar b -> SSMTSort b
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' SMTVar b
v') of
    GOrdering a b
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering a b
GEQ -> case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @_ @Int SMTVar a
v) (SMTVar b -> Int
forall a b. Coercible a b => a -> b
coerce SMTVar b
v') of
      Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      Ordering
EQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering a b
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Var SMTVar a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Var SMTVar b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Constant Value a
c) (Constant Value b
c') = Value a -> Value b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Value a -> Value b -> GOrdering a b
gcompare Value a
c Value b
c'
  gcompare (Constant Value a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Constant Value b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Plus Expr a
x Expr a
y) (Plus Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Plus Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Plus Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Minus Expr a
x Expr a
y) (Minus Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Minus Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Minus Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Neg Expr a
x) (Neg Expr b
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
  gcompare (Neg Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Neg Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Mul Expr a
x Expr a
y) (Mul Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Mul Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Mul Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Abs Expr a
x) (Abs Expr b
x') = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
  gcompare (Abs Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Abs Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Mod Expr a
x Expr a
y) (Mod Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Mod Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Mod Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Rem Expr a
x Expr a
y) (Rem Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Rem Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Rem Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (IDiv Expr a
x Expr a
y) (IDiv Expr b
x' Expr b
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (IDiv Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (IDiv Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Div Expr 'RealSort
x Expr 'RealSort
y) (Div Expr 'RealSort
x' Expr 'RealSort
y') = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'RealSort
x,Expr b
Expr 'RealSort
x'), (Expr a
Expr 'RealSort
y,Expr b
Expr 'RealSort
y')]
  gcompare (Div Expr 'RealSort
_ Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Div Expr 'RealSort
_ Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (LTH Expr t
x Expr t
y)               (LTH Expr t
x' Expr t
y')             = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
    GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (LTH Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (LTH Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (LTHE Expr t
x Expr t
y)              (LTHE Expr t
x' Expr t
y')            = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
    GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (LTHE Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (LTHE Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (EQU (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs))  (EQU (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs')) = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs ) ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs') of
    Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
EQ -> case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing ([(Expr t, Expr t)] -> GOrdering t t)
-> [(Expr t, Expr t)] -> GOrdering t t
forall a b. (a -> b) -> a -> b
$ [Expr t] -> [Expr t] -> [(Expr t, Expr t)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Expr t]
xs [Expr t]
xs' of
      GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
      GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (EQU Vector (n + 2) (Expr t)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (EQU Vector (n + 2) (Expr t)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Distinct (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs)) (Distinct (Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList -> [Expr t]
xs')) = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs ) ([Expr t] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr t]
xs') of
    Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
EQ -> case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing ([(Expr t, Expr t)] -> GOrdering t t)
-> [(Expr t, Expr t)] -> GOrdering t t
forall a b. (a -> b) -> a -> b
$ [Expr t] -> [Expr t] -> [(Expr t, Expr t)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Expr t]
xs [Expr t]
xs' of
      GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
      GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Distinct Vector (n + 2) (Expr t)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Distinct Vector (n + 2) (Expr t)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (GTHE Expr t
x Expr t
y)              (GTHE Expr t
x' Expr t
y')            = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
    GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (GTHE Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (GTHE Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (GTH Expr t
x Expr t
y)               (GTH Expr t
x' Expr t
y')             = case [(Expr t, Expr t)] -> GOrdering t t
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr t
x,Expr t
x'), (Expr t
y,Expr t
y')] of
    GOrdering t t
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering t t
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering t t
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (GTH Expr t
_ Expr t
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (GTH Expr t
_ Expr t
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Not Expr a
x)                 (Not Expr b
x')                = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
x Expr b
x'
  gcompare (Not Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Not Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (And Expr a
x Expr a
y)               (And Expr b
x' Expr b
y')             = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (And Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (And Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Or Expr a
x Expr a
y)                (Or Expr b
x' Expr b
y')              = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Or Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Or Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Impl Expr a
x Expr a
y)              (Impl Expr b
x' Expr b
y')            = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Impl Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Impl Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Xor Expr a
x Expr a
y)               (Xor Expr b
x' Expr b
y')             = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
x,Expr b
x'), (Expr a
y,Expr b
y')]
  gcompare (Xor Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Xor Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare Expr a
Pi                      Expr b
Pi                      = GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
  gcompare Expr a
Pi Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ Expr b
Pi = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Sqrt Expr 'RealSort
x)                (Sqrt Expr 'RealSort
x')               = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Sqrt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Sqrt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Exp Expr 'RealSort
x)                 (Exp Expr 'RealSort
x')                = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Exp Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Exp Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Sin Expr 'RealSort
x)                 (Sin Expr 'RealSort
x')                = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Sin Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Sin Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Cos Expr 'RealSort
x)                 (Cos Expr 'RealSort
x')                = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Cos Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Cos Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Tan Expr 'RealSort
x)                 (Tan Expr 'RealSort
x')                = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Tan Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Tan Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Asin Expr 'RealSort
x)                (Asin Expr 'RealSort
x')               = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Asin Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Asin Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Acos Expr 'RealSort
x)                (Acos Expr 'RealSort
x')               = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Acos Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Acos Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Atan Expr 'RealSort
x)                (Atan Expr 'RealSort
x')               = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'RealSort
x Expr b
Expr 'RealSort
x'
  gcompare (Atan Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Atan Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ToReal Expr 'IntSort
x)              (ToReal Expr 'IntSort
x')             = case Expr 'IntSort -> Expr 'IntSort -> GOrdering 'IntSort 'IntSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'IntSort
x Expr 'IntSort
x' of
    GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ToReal Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (ToReal Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ToInt Expr 'RealSort
x)               (ToInt Expr 'RealSort
x')              = case Expr 'RealSort -> Expr 'RealSort -> GOrdering 'RealSort 'RealSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'RealSort
x Expr 'RealSort
x' of
    GOrdering 'RealSort 'RealSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'RealSort 'RealSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'RealSort 'RealSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ToInt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (ToInt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (IsInt Expr 'RealSort
x)               (IsInt Expr 'RealSort
x')              = case Expr 'RealSort -> Expr 'RealSort -> GOrdering 'RealSort 'RealSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'RealSort
x Expr 'RealSort
x' of
    GOrdering 'RealSort 'RealSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'RealSort 'RealSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'RealSort 'RealSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (IsInt Expr 'RealSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (IsInt Expr 'RealSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Ite Expr 'BoolSort
p Expr a
t Expr a
n)             (Ite Expr 'BoolSort
p' Expr b
t' Expr b
n')          = case Expr 'BoolSort -> Expr 'BoolSort -> GOrdering 'BoolSort 'BoolSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'BoolSort
p Expr 'BoolSort
p' of
    GOrdering 'BoolSort 'BoolSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'BoolSort 'BoolSort
GEQ -> [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
t,Expr b
t'), (Expr a
n,Expr b
n')]
    GOrdering 'BoolSort 'BoolSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Ite Expr 'BoolSort
_ Expr a
_ Expr a
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (Ite Expr 'BoolSort
_ Expr b
_ Expr b
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvNand Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)            (BvNand Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y')          = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
  gcompare (BvNand Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvNand Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvNor Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)             (BvNor Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y')           = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
  gcompare (BvNor Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvNor Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvShL Expr ('BvSort enc n)
x Expr ('BvSort enc n)
y)             (BvShL Expr ('BvSort enc n)
x' Expr ('BvSort enc n)
y')           = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort enc n)
x,Expr b
Expr ('BvSort enc n)
x'), (Expr a
Expr ('BvSort enc n)
y,Expr b
Expr ('BvSort enc n)
y')]
  gcompare (BvShL Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvShL Expr ('BvSort enc n)
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvLShR Expr ('BvSort 'Unsigned n)
x Expr ('BvSort 'Unsigned n)
y)            (BvLShR Expr ('BvSort 'Unsigned n)
x' Expr ('BvSort 'Unsigned n)
y')          = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort 'Unsigned n)
x,Expr b
Expr ('BvSort 'Unsigned n)
x'), (Expr a
Expr ('BvSort 'Unsigned n)
y,Expr b
Expr ('BvSort 'Unsigned n)
y')]
  gcompare (BvLShR Expr ('BvSort 'Unsigned n)
_ Expr ('BvSort 'Unsigned n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvLShR Expr ('BvSort 'Unsigned n)
_ Expr ('BvSort 'Unsigned n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvAShR Expr ('BvSort 'Signed n)
x Expr ('BvSort 'Signed n)
y)            (BvAShR Expr ('BvSort 'Signed n)
x' Expr ('BvSort 'Signed n)
y')          = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr ('BvSort 'Signed n)
x,Expr b
Expr ('BvSort 'Signed n)
x'), (Expr a
Expr ('BvSort 'Signed n)
y,Expr b
Expr ('BvSort 'Signed n)
y')]
  gcompare (BvAShR Expr ('BvSort 'Signed n)
_ Expr ('BvSort 'Signed n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvAShR Expr ('BvSort 'Signed n)
_ Expr ('BvSort 'Signed n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvConcat Expr ('BvSort enc n)
x Expr ('BvSort enc m)
y)          (BvConcat Expr ('BvSort enc n)
x' Expr ('BvSort enc m)
y')        = case SSMTSort ('BvSort enc n)
-> SSMTSort ('BvSort enc n)
-> GOrdering ('BvSort enc n) ('BvSort enc n)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (Expr ('BvSort enc n) -> SSMTSort ('BvSort enc n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc n)
x) (Expr ('BvSort enc n) -> SSMTSort ('BvSort enc n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc n)
x') of
    GOrdering ('BvSort enc n) ('BvSort enc n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering ('BvSort enc n) ('BvSort enc n)
GEQ -> case Expr ('BvSort enc n)
-> Expr ('BvSort enc n)
-> GOrdering ('BvSort enc n) ('BvSort enc n)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('BvSort enc n)
x Expr ('BvSort enc n)
x' of
      GOrdering ('BvSort enc n) ('BvSort enc n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering ('BvSort enc n) ('BvSort enc n)
GEQ -> case SSMTSort ('BvSort enc m)
-> SSMTSort ('BvSort enc m)
-> GOrdering ('BvSort enc m) ('BvSort enc m)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
SSMTSort a -> SSMTSort b -> GOrdering a b
gcompare (Expr ('BvSort enc m) -> SSMTSort ('BvSort enc m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc m)
y) (Expr ('BvSort enc m) -> SSMTSort ('BvSort enc m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort enc m)
y') of
        GOrdering ('BvSort enc m) ('BvSort enc m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
        GOrdering ('BvSort enc m) ('BvSort enc m)
GEQ -> case Expr ('BvSort enc m)
-> Expr ('BvSort enc m)
-> GOrdering ('BvSort enc m) ('BvSort enc m)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('BvSort enc m)
y Expr ('BvSort enc m)
y' of
          GOrdering ('BvSort enc m) ('BvSort enc m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
          GOrdering ('BvSort enc m) ('BvSort enc m)
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
          GOrdering ('BvSort enc m) ('BvSort enc m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
        GOrdering ('BvSort enc m) ('BvSort enc m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
      GOrdering ('BvSort enc n) ('BvSort enc n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering ('BvSort enc n) ('BvSort enc n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvConcat Expr ('BvSort enc n)
_ Expr ('BvSort enc m)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvConcat Expr ('BvSort enc n)
_ Expr ('BvSort enc m)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotL a
i Expr ('BvSort enc n)
x)            (BvRotL a
i' Expr ('BvSort enc n)
x')          = case Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i :: Integer) (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i') of
    Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
EQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr ('BvSort enc n)
x Expr b
Expr ('BvSort enc n)
x'
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotL a
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvRotL a
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotR a
i Expr ('BvSort enc n)
x)            (BvRotR a
i' Expr ('BvSort enc n)
x')          = case Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i :: Integer) (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i') of
    Ordering
LT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    Ordering
EQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr ('BvSort enc n)
x Expr b
Expr ('BvSort enc n)
x'
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotR a
_ Expr ('BvSort enc n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvRotR a
_ Expr ('BvSort enc n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ArrSelect Expr ('ArraySort k a)
arr Expr k
i)       (ArrSelect Expr ('ArraySort k b)
arr' Expr k
i')     = case Expr ('ArraySort k a)
-> Expr ('ArraySort k b)
-> GOrdering ('ArraySort k a) ('ArraySort k b)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('ArraySort k a)
arr Expr ('ArraySort k b)
arr' of
    GOrdering ('ArraySort k a) ('ArraySort k b)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering ('ArraySort k a) ('ArraySort k b)
GEQ -> case Expr k -> Expr k -> GOrdering k k
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr k
i Expr k
i' of
      GOrdering k k
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering k k
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      GOrdering k k
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering ('ArraySort k a) ('ArraySort k b)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ArrSelect Expr ('ArraySort k a)
_ Expr k
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (ArrSelect Expr ('ArraySort k b)
_ Expr k
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ArrStore Expr ('ArraySort k v)
arr Expr k
k Expr v
v)      (ArrStore Expr ('ArraySort k v)
arr' Expr k
k' Expr v
v')   = case Expr ('ArraySort k v)
-> Expr ('ArraySort k v)
-> GOrdering ('ArraySort k v) ('ArraySort k v)
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr ('ArraySort k v)
arr Expr ('ArraySort k v)
arr' of
    GOrdering ('ArraySort k v) ('ArraySort k v)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering ('ArraySort k v) ('ArraySort k v)
GEQ -> case Expr k -> Expr k -> GOrdering k k
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr k
k Expr k
k' of
      GOrdering k k
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering k k
GEQ -> case Expr v -> Expr v -> GOrdering v v
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr v
v Expr v
v' of
        GOrdering v v
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
        GOrdering v v
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
        GOrdering v v
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
      GOrdering k k
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering ('ArraySort k v) ('ArraySort k v)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ArrStore Expr ('ArraySort k v)
_ Expr k
_ Expr v
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (ArrStore Expr ('ArraySort k v)
_ Expr k
_ Expr v
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrConcat Expr 'StringSort
x Expr 'StringSort
y)         (StrConcat Expr 'StringSort
x' Expr 'StringSort
y')       = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
x,Expr b
Expr 'StringSort
x'), (Expr a
Expr 'StringSort
y,Expr b
Expr 'StringSort
y')]
  gcompare (StrConcat Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrConcat Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrLength Expr 'StringSort
x)           (StrLength Expr 'StringSort
x')          = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrLength Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrLength Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrAt Expr 'StringSort
x Expr 'IntSort
i)             (StrAt Expr 'StringSort
x' Expr 'IntSort
i')           = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> case Expr 'IntSort -> Expr 'IntSort -> GOrdering 'IntSort 'IntSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'IntSort
i Expr 'IntSort
i' of
      GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrAt Expr 'StringSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrAt Expr 'StringSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j)    (StrSubstring Expr 'StringSort
x' Expr 'IntSort
i' Expr 'IntSort
j') = case Expr 'StringSort
-> Expr 'StringSort -> GOrdering 'StringSort 'StringSort
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr 'StringSort
x Expr 'StringSort
x' of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> case [(Expr 'IntSort, Expr 'IntSort)] -> GOrdering 'IntSort 'IntSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'IntSort
i,Expr 'IntSort
i'), (Expr 'IntSort
j,Expr 'IntSort
j')] of
      GOrdering 'IntSort 'IntSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering 'IntSort 'IntSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
      GOrdering 'IntSort 'IntSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrSubstring Expr 'StringSort
_ Expr 'IntSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrSubstring Expr 'StringSort
_ Expr 'IntSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y)       (StrPrefixOf Expr 'StringSort
x' Expr 'StringSort
y')     = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrPrefixOf Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrPrefixOf Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y)       (StrSuffixOf Expr 'StringSort
x' Expr 'StringSort
y')     = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrSuffixOf Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrSuffixOf Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrContains Expr 'StringSort
x Expr 'StringSort
y)       (StrContains Expr 'StringSort
x' Expr 'StringSort
y')     = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrContains Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrContains Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i)      (StrIndexOf Expr 'StringSort
x' Expr 'StringSort
y' Expr 'IntSort
i')   = case [(Expr 'StringSort, Expr 'StringSort)]
-> GOrdering 'StringSort 'StringSort
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr 'StringSort
x,Expr 'StringSort
x'), (Expr 'StringSort
y,Expr 'StringSort
y')] of
    GOrdering 'StringSort 'StringSort
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering 'StringSort 'StringSort
GEQ -> Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare Expr a
Expr 'IntSort
i Expr b
Expr 'IntSort
i'
    GOrdering 'StringSort 'StringSort
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrIndexOf Expr 'StringSort
_ Expr 'StringSort
_ Expr 'IntSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrIndexOf Expr 'StringSort
_ Expr 'StringSort
_ Expr 'IntSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrReplace Expr 'StringSort
source Expr 'StringSort
target Expr 'StringSort
replacement)     (StrReplace Expr 'StringSort
source' Expr 'StringSort
target' Expr 'StringSort
replacement')     = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
source, Expr b
Expr 'StringSort
source'), (Expr a
Expr 'StringSort
target, Expr b
Expr 'StringSort
target'), (Expr a
Expr 'StringSort
replacement, Expr b
Expr 'StringSort
replacement')]
  gcompare (StrReplace Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrReplace Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrReplaceAll Expr 'StringSort
source Expr 'StringSort
target Expr 'StringSort
replacement)  (StrReplaceAll Expr 'StringSort
source' Expr 'StringSort
target' Expr 'StringSort
replacement')  = [(Expr a, Expr b)] -> GOrdering a b
forall {k} (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
[(f a, f b)] -> GOrdering a b
gcomparing [(Expr a
Expr 'StringSort
source, Expr b
Expr 'StringSort
source'), (Expr a
Expr 'StringSort
target, Expr b
Expr 'StringSort
target'), (Expr a
Expr 'StringSort
replacement, Expr b
Expr 'StringSort
replacement')]
  gcompare (StrReplaceAll Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrReplaceAll Expr 'StringSort
_ Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr)         (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr')        = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Expr t -> Expr 'BoolSort
expr (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1))) (Expr t -> Expr 'BoolSort
expr' (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1)))
  gcompare (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (ForAll Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (Exists Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr)         (Exists Maybe (SMTVar t)
_ Expr t -> Expr 'BoolSort
expr')        = Expr a -> Expr b -> GOrdering a b
forall k (f :: k -> *) (a :: k) (b :: k).
GCompare f =>
f a -> f b -> GOrdering a b
forall (a :: SMTSort) (b :: SMTSort).
Expr a -> Expr b -> GOrdering a b
gcompare (Expr t -> Expr 'BoolSort
expr (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1))) (Expr t -> Expr 'BoolSort
expr' (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). KnownSMTSort t => SMTVar t -> Expr t
Var (Int -> SMTVar t
forall (t :: SMTSort). Int -> SMTVar t
SMTVar (-Int
1)))
  -- gcompare (Exists _ _) _ = GLT
  -- gcompare _ (Exists _ _) = GGT