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

module Language.Hasmtlib.Type.Expr
  ( SMTVar(..), varId
  , Value(..) , unwrapValue, wrapValue
  , Expr(..), isLeaf
  , Iteable(..), Equatable(..), Orderable(..), min', max'
  , equal, distinct
  , for_all, exists
  , select, store
  , bvShL, bvLShR, bvConcat
  , toRealSort, toIntSort, isIntSort
  , strLength, strAt, strSubstring, strPrefixOf, strSuffixOf, strContains, strIndexOf, strReplace, strReplaceAll
  )
where

import Prelude hiding (not, and, or, any, all, (&&), (||))
import Language.Hasmtlib.Internal.Uniplate1
import Language.Hasmtlib.Internal.Render
import Language.Hasmtlib.Type.ArrayMap
import Language.Hasmtlib.Type.SMTSort
import Language.Hasmtlib.Type.Value
import Language.Hasmtlib.Boolean
import Data.GADT.Compare
import Data.GADT.DeepSeq
import Data.Map hiding (toList)
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.Monoid (Sum, Product, First, Last, Dual)
import Data.String (IsString(..))
import Data.Text (pack)
import Data.List(genericLength)
import Data.Foldable (toList)
import Data.ByteString.Builder
import Data.ByteString.Lazy.UTF8 (toString)
import qualified Data.Vector.Sized as V
import Control.Lens hiding (from, to)
import GHC.TypeLits hiding (someNatVal)
import GHC.TypeNats (someNatVal)
import GHC.Generics

-- | An internal SMT variable with a phantom-type which holds an 'Int' as it's identifier.
type role SMTVar phantom
newtype SMTVar (t :: SMTSort) = SMTVar { forall (t :: SMTSort). SMTVar t -> Int
_varId :: Int }
  deriving stock (Int -> SMTVar t -> ShowS
[SMTVar t] -> ShowS
SMTVar t -> String
(Int -> SMTVar t -> ShowS)
-> (SMTVar t -> String) -> ([SMTVar t] -> ShowS) -> Show (SMTVar t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (t :: SMTSort). Int -> SMTVar t -> ShowS
forall (t :: SMTSort). [SMTVar t] -> ShowS
forall (t :: SMTSort). SMTVar t -> String
$cshowsPrec :: forall (t :: SMTSort). Int -> SMTVar t -> ShowS
showsPrec :: Int -> SMTVar t -> ShowS
$cshow :: forall (t :: SMTSort). SMTVar t -> String
show :: SMTVar t -> String
$cshowList :: forall (t :: SMTSort). [SMTVar t] -> ShowS
showList :: [SMTVar t] -> ShowS
Show, (forall x. SMTVar t -> Rep (SMTVar t) x)
-> (forall x. Rep (SMTVar t) x -> SMTVar t) -> Generic (SMTVar t)
forall x. Rep (SMTVar t) x -> SMTVar t
forall x. SMTVar t -> Rep (SMTVar t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (t :: SMTSort) x. Rep (SMTVar t) x -> SMTVar t
forall (t :: SMTSort) x. SMTVar t -> Rep (SMTVar t) x
$cfrom :: forall (t :: SMTSort) x. SMTVar t -> Rep (SMTVar t) x
from :: forall x. SMTVar t -> Rep (SMTVar t) x
$cto :: forall (t :: SMTSort) x. Rep (SMTVar t) x -> SMTVar t
to :: forall x. Rep (SMTVar t) x -> SMTVar t
Generic)
  deriving newtype (SMTVar t -> SMTVar t -> Bool
(SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool) -> Eq (SMTVar t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
$c== :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
== :: SMTVar t -> SMTVar t -> Bool
$c/= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
/= :: SMTVar t -> SMTVar t -> Bool
Eq, Eq (SMTVar t)
Eq (SMTVar t) =>
(SMTVar t -> SMTVar t -> Ordering)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> Bool)
-> (SMTVar t -> SMTVar t -> SMTVar t)
-> (SMTVar t -> SMTVar t -> SMTVar t)
-> Ord (SMTVar t)
SMTVar t -> SMTVar t -> Bool
SMTVar t -> SMTVar t -> Ordering
SMTVar t -> SMTVar t -> SMTVar t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (t :: SMTSort). Eq (SMTVar t)
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
forall (t :: SMTSort). SMTVar t -> SMTVar t -> Ordering
forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
$ccompare :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Ordering
compare :: SMTVar t -> SMTVar t -> Ordering
$c< :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
< :: SMTVar t -> SMTVar t -> Bool
$c<= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
<= :: SMTVar t -> SMTVar t -> Bool
$c> :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
> :: SMTVar t -> SMTVar t -> Bool
$c>= :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> Bool
>= :: SMTVar t -> SMTVar t -> Bool
$cmax :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
max :: SMTVar t -> SMTVar t -> SMTVar t
$cmin :: forall (t :: SMTSort). SMTVar t -> SMTVar t -> SMTVar t
min :: SMTVar t -> SMTVar t -> SMTVar t
Ord)
$(makeLenses ''SMTVar)

-- | An SMT-Expression.
--   For building expressions use the corresponding instances: 'Boolean', 'Num', 'Equatable', ...
--
--   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
  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    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvNor     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvShL     :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvLShR    :: KnownNat n => Expr (BvSort n) -> Expr (BvSort n) -> Expr (BvSort n)
  BvConcat  :: (KnownNat n, KnownNat m) => Expr (BvSort n) -> Expr (BvSort m) -> Expr (BvSort (n + m))
  BvRotL    :: (KnownNat n, Integral a) => a -> Expr (BvSort n) -> Expr (BvSort n)
  BvRotR    :: (KnownNat n, Integral a) => a -> Expr (BvSort n) -> Expr (BvSort 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
  StrLT         :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrLTHE       :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrAt         :: Expr StringSort -> Expr IntSort -> Expr StringSort
  StrSubstring  :: Expr StringSort -> Expr IntSort -> Expr IntSort -> Expr StringSort
  StrPrefixOf   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrSuffixOf   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrContains   :: Expr StringSort -> Expr StringSort -> Expr BoolSort
  StrIndexOf    :: Expr StringSort -> Expr StringSort -> Expr IntSort -> Expr IntSort
  StrReplace    :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
  StrReplaceAll :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort

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

  -- | Indicates whether an expression is a leaf.
  --   All non-recursive contructors form leafs.
isLeaf :: Expr t -> Bool
isLeaf :: forall (t :: SMTSort). Expr t -> Bool
isLeaf (Var SMTVar t
_) = Bool
True
isLeaf (Constant Value t
_) = Bool
True
isLeaf Expr t
Pi = Bool
True
isLeaf Expr t
_ = Bool
False
{-# INLINE isLeaf #-}

-- | If condition (p :: b) then (t :: a) else (f :: a)
--
--    >>> ite true "1" "2"
--        "1"
--    >>> ite false 100 42
--        42
class Iteable b a where
  ite :: b -> a -> a -> a
  default ite :: (Iteable b c, Applicative f, f c ~ a) => b -> a -> a -> a
  ite b
p a
t a
f = b -> c -> c -> c
forall b a. Iteable b a => b -> a -> a -> a
ite b
p (c -> c -> c) -> f c -> f (c -> c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a
f c
t f (c -> c) -> f c -> f c
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
f c
f

instance Iteable (Expr BoolSort) (Expr t) where
  ite :: Expr 'BoolSort -> Expr t -> Expr t -> Expr t
ite = Expr 'BoolSort -> Expr t -> Expr t -> Expr t
forall (t :: SMTSort). Expr 'BoolSort -> Expr t -> Expr t -> Expr t
Ite
  {-# INLINE ite #-}

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

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

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

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

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

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

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

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

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

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

-- | Test two as on equality as SMT-Expression.
--
--   You can derive an instance of this class if your type is 'Generic'.
--
-- @
--     x <- var @RealType
--     y <- var
--     assert $ y === x && not (y /== x)
-- @
--
class Equatable a where
  -- | Test whether two values are equal in the SMT-Problem.
  (===) :: a -> a -> Expr BoolSort
  default (===) :: (Generic a, GEquatable (Rep a)) => a -> a -> Expr BoolSort
  a
a === a
b = a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
a Rep a Any -> Rep a Any -> Expr 'BoolSort
forall a. Rep a a -> Rep a a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GEquatable f =>
f a -> f a -> Expr 'BoolSort
===# a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
b

  -- | Test whether two values are not equal in the SMT-Problem.
  (/==) :: a -> a -> Expr BoolSort
  a
x /== a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
=== a
y

infix 4 ===, /==

instance (KnownSMTSort t, Eq (HaskellType t)) => Equatable (Expr t) where
  Expr t
x === :: Expr t -> Expr t -> Expr 'BoolSort
=== Expr t
y = Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> Expr 'BoolSort
Distinct (Vector (0 + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ (Expr t, Expr t) -> Vector (0 + 2) (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
x,Expr t
y)
  {-# INLINE (/==) #-}

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

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

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

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

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

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

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

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

-- | Compare two as as SMT-Expression.
--
--   You can derive an instance of this class if your type is 'Generic'.
--
-- @
-- x <- var @RealSort
-- y <- var
-- assert $ x >? y
-- assert $ x === min' 42 100
-- @
--
class Equatable a => Orderable a where
  (<=?) :: a -> a -> Expr BoolSort
  default (<=?) :: (Generic a, GOrderable (Rep a)) => a -> a -> Expr BoolSort
  a
x <=? a
y = a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
x Rep a Any -> Rep a Any -> Expr 'BoolSort
forall a. Rep a a -> Rep a a -> Expr 'BoolSort
forall {k} (f :: k -> *) (a :: k).
GOrderable f =>
f a -> f a -> Expr 'BoolSort
<=?# a -> Rep a Any
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
from a
y

  (>=?) :: a -> a -> Expr BoolSort
  a
x >=? a
y = a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x

  (<?)  :: a -> a -> Expr BoolSort
  a
x <? a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x

  (>?)  :: a -> a -> Expr BoolSort
  a
x >? a
y = Expr 'BoolSort -> Expr 'BoolSort
forall b. Boolean b => b -> b
not (Expr 'BoolSort -> Expr 'BoolSort)
-> Expr 'BoolSort -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
y

infix 4 <?, <=?, >=?, >?

-- | Minimum of two as SMT-Expression.
min' :: (Orderable a, Iteable (Expr BoolSort) a) => a -> a -> a
min' :: forall a. (Orderable a, Iteable (Expr 'BoolSort) a) => a -> a -> a
min' a
x a
y = Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite (a
x a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
y) a
x a
y

-- | Maximum of two as SMT-Expression.
max' :: (Orderable a, Iteable (Expr BoolSort) a) => a -> a -> a
max' :: forall a. (Orderable a, Iteable (Expr 'BoolSort) a) => a -> a -> a
max' a
x a
y = Expr 'BoolSort -> a -> a -> a
forall b a. Iteable b a => b -> a -> a -> a
ite (a
y a -> a -> Expr 'BoolSort
forall a. Orderable a => a -> a -> Expr 'BoolSort
<=? a
x) a
x a
y

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

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

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

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

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

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

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

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

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

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

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

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

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

instance Orderable ()       where ()
_ <? :: () -> () -> Expr 'BoolSort
<?  ()
_ = Expr 'BoolSort
forall b. Boolean b => b
false
                                  ()
_ <=? :: () -> () -> Expr 'BoolSort
<=? ()
_ = Expr 'BoolSort
forall b. Boolean b => b
true
instance Orderable Void     where Void
x <? :: Void -> Void -> Expr 'BoolSort
<?  Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Orderable[Void].<?"
                                  Void
x <=? :: Void -> Void -> Expr 'BoolSort
<=? Void
y = Void
x Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` Void
y Void -> Expr 'BoolSort -> Expr 'BoolSort
forall a b. a -> b -> b
`seq` String -> Expr 'BoolSort
forall a. HasCallStack => String -> a
error String
"Orderable[Void].<=?"
instance Orderable Int      where Int
x <? :: Int -> Int -> Expr 'BoolSort
<?  Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<  Int
y)
                                  Int
x <=? :: Int -> Int -> Expr 'BoolSort
<=? Int
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
y)
instance Orderable Integer  where Integer
x <? :: Integer -> Integer -> Expr 'BoolSort
<?  Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<  Integer
y)
                                  Integer
x <=? :: Integer -> Integer -> Expr 'BoolSort
<=? Integer
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
y)
instance Orderable Natural  where Nat
x <? :: Nat -> Nat -> Expr 'BoolSort
<?  Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Ord a => a -> a -> Bool
<  Nat
y)
                                  Nat
x <=? :: Nat -> Nat -> Expr 'BoolSort
<=? Nat
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Nat
x Nat -> Nat -> Bool
forall a. Ord a => a -> a -> Bool
<= Nat
y)
instance Orderable Word     where Word
x <? :: Word -> Word -> Expr 'BoolSort
<?  Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
<  Word
y)
                                  Word
x <=? :: Word -> Word -> Expr 'BoolSort
<=? Word
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word
x Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
<= Word
y)
instance Orderable Word8    where Word8
x <? :: Word8 -> Word8 -> Expr 'BoolSort
<?  Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<  Word8
y)
                                  Word8
x <=? :: Word8 -> Word8 -> Expr 'BoolSort
<=? Word8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
y)
instance Orderable Word16   where Word16
x <? :: Word16 -> Word16 -> Expr 'BoolSort
<?  Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
<  Word16
y)
                                  Word16
x <=? :: Word16 -> Word16 -> Expr 'BoolSort
<=? Word16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word16
x Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word16
y)
instance Orderable Word32   where Word32
x <? :: Word32 -> Word32 -> Expr 'BoolSort
<?  Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<  Word32
y)
                                  Word32
x <=? :: Word32 -> Word32 -> Expr 'BoolSort
<=? Word32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word32
x Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
y)
instance Orderable Word64   where Word64
x <? :: Word64 -> Word64 -> Expr 'BoolSort
<?  Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<  Word64
y)
                                  Word64
x <=? :: Word64 -> Word64 -> Expr 'BoolSort
<=? Word64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Word64
x Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word64
y)
instance Orderable Int8     where Int8
x <? :: Int8 -> Int8 -> Expr 'BoolSort
<?  Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
<  Int8
y)
                                  Int8
x <=? :: Int8 -> Int8 -> Expr 'BoolSort
<=? Int8
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int8
y)
instance Orderable Int16    where Int16
x <? :: Int16 -> Int16 -> Expr 'BoolSort
<?  Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Ord a => a -> a -> Bool
<  Int16
y)
                                  Int16
x <=? :: Int16 -> Int16 -> Expr 'BoolSort
<=? Int16
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int16
x Int16 -> Int16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int16
y)
instance Orderable Int32    where Int32
x <? :: Int32 -> Int32 -> Expr 'BoolSort
<?  Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
<  Int32
y)
                                  Int32
x <=? :: Int32 -> Int32 -> Expr 'BoolSort
<=? Int32
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int32
x Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int32
y)
instance Orderable Int64    where Int64
x <? :: Int64 -> Int64 -> Expr 'BoolSort
<?  Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
<  Int64
y)
                                  Int64
x <=? :: Int64 -> Int64 -> Expr 'BoolSort
<=? Int64
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Int64
x Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int64
y)
instance Orderable Char     where Char
x <? :: Char -> Char -> Expr 'BoolSort
<?  Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<  Char
y)
                                  Char
x <=? :: Char -> Char -> Expr 'BoolSort
<=? Char
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Char
x Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
y)
instance Orderable Float    where Float
x <? :: Float -> Float -> Expr 'BoolSort
<?  Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<  Float
y)
                                  Float
x <=? :: Float -> Float -> Expr 'BoolSort
<=? Float
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Float
x Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
<= Float
y)
instance Orderable Double   where Double
x <? :: Double -> Double -> Expr 'BoolSort
<?  Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<  Double
y)
                                  Double
x <=? :: Double -> Double -> Expr 'BoolSort
<=? Double
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
y)
instance Orderable Ordering where Ordering
x <? :: Ordering -> Ordering -> Expr 'BoolSort
<?  Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
<  Ordering
y)
                                  Ordering
x <=? :: Ordering -> Ordering -> Expr 'BoolSort
<=? Ordering
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Ordering
x Ordering -> Ordering -> Bool
forall a. Ord a => a -> a -> Bool
<= Ordering
y)
instance Orderable Bool     where Bool
x <? :: Bool -> Bool -> Expr 'BoolSort
<?  Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
<  Bool
y)
                                  Bool
x <=? :: Bool -> Bool -> Expr 'BoolSort
<=? Bool
y = Bool -> Expr 'BoolSort
forall b. Boolean b => Bool -> b
bool (Bool
x Bool -> Bool -> Bool
forall a. Ord a => a -> a -> Bool
<= Bool
y)

instance (Orderable a, Orderable b) => Orderable (a,b)
instance (Orderable a, Orderable b, Orderable c) => Orderable (a,b,c)
instance (Orderable a, Orderable b, Orderable c, Orderable d) => Orderable (a,b,c,d)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e) => Orderable (a,b,c,d,e)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f) => Orderable (a,b,c,d,e,f)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f, Orderable g) => Orderable (a,b,c,d,e,f,g)
instance (Orderable a, Orderable b, Orderable c, Orderable d, Orderable e, Orderable f, Orderable g, Orderable h) => Orderable (a,b,c,d,e,f,g,h)
instance Orderable a => Orderable [a]
instance Orderable a => Orderable (Tree a)
instance Orderable a => Orderable (Maybe a)
instance (Orderable a, Orderable b) => Orderable (Either a b)
instance Orderable a => Orderable (Sum a)
instance Orderable a => Orderable (Product a)
instance Orderable a => Orderable (First a)
instance Orderable a => Orderable (Last a)
instance Orderable a => Orderable (Dual a)
instance Orderable a => Orderable (Identity a)

-- | Test multiple expressions on equality within in the 'SMT'-Problem.
equal :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
equal :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
  SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
    Maybe (Vector n (Expr t))
Nothing  -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> Expr 'BoolSort
EQU (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
equal (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_)        = Expr 'BoolSort
forall b. Boolean b => b
true

-- | Test multiple expressions on distinctness within in the 'SMT'-Problem.
distinct :: (Eq (HaskellType t), KnownSMTSort t, Foldable f) => f (Expr t) -> Expr BoolSort
distinct :: forall (t :: SMTSort) (f :: * -> *).
(Eq (HaskellType t), KnownSMTSort t, Foldable f) =>
f (Expr t) -> Expr 'BoolSort
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> (Expr t
a:Expr t
b:[Expr t]
xs)) = case Nat -> SomeNat
someNatVal ([Expr t] -> Nat
forall i a. Num i => [a] -> i
genericLength [Expr t]
xs) of
  SomeNat Proxy n
n -> case Proxy n -> [Expr t] -> Maybe (Vector n (Expr t))
forall (n :: Nat) a (p :: Nat -> *).
KnownNat n =>
p n -> [a] -> Maybe (Vector n a)
V.fromListN' Proxy n
n [Expr t]
xs of
    Maybe (Vector n (Expr t))
Nothing  -> Vector (0 + 2) (Expr t) -> Expr 'BoolSort
forall (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> Expr 'BoolSort
Distinct (Vector (n + 2) (Expr t) -> Expr 'BoolSort)
-> Vector (n + 2) (Expr t) -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ Vector n (Expr t)
xs' Vector n (Expr t) -> Vector 2 (Expr t) -> Vector (n + 2) (Expr t)
forall (n :: Nat) (m :: Nat) a.
Vector n a -> Vector m a -> Vector (n + m) a
V.++ (Expr t, Expr t) -> Vector 2 (Expr t)
forall input (length :: Nat) ty.
(IndexedListLiterals input length ty, KnownNat length) =>
input -> Vector length ty
V.fromTuple (Expr t
a,Expr t
b)
distinct (f (Expr t) -> [Expr t]
forall a. f a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList -> [Expr t]
_)        = Expr 'BoolSort
forall b. Boolean b => b
true

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

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

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

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

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

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

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

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

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

-- | Singleton string containing a character at given position
--   or empty string when position is out of range.
--   The leftmost position is 0.
strAt :: Expr StringSort -> Expr IntSort -> Expr StringSort
strAt :: Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
strAt = Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt
{-# INLINE strAt #-}

-- | @(strSubstring s i n)@ evaluates to the longest (unscattered) substring
--   of @s@ of length at most @n@ starting at position @i@.
--   It evaluates to the empty string if @n@ is negative or @i@ is not in
--   the interval @[0,l-1]@ where @l@ is the length of @s@.
strSubstring :: Expr StringSort -> Expr IntSort -> Expr IntSort -> Expr StringSort
strSubstring :: Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
strSubstring = Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring
{-# INLINE strSubstring #-}

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

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

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

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

-- | @(str.replace s t t')@ is the string obtained by replacing the first
--   occurrence of @t@ in @s@, if any, by @t'@. Note that if @t@ is empty, the
--   result is to prepend @t'@ to @s@; also, if @t@ does not occur in @s@ then
--   the result is @s@.
strReplace :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
strReplace :: Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplace = Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace
{-# INLINE strReplace #-}

-- | @(str.replace_all s t t’)@ is @s@ if @t@ is the empty string. Otherwise, it
--   is the string obtained from @s@ by replacing all occurrences of @t@ in @s@
--   by @t’@, starting with the first occurrence and proceeding in left-to-right order.
strReplaceAll :: Expr StringSort -> Expr StringSort -> Expr StringSort -> Expr StringSort
strReplaceAll :: Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
strReplaceAll = Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll
{-# INLINE strReplaceAll #-}

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

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

instance KnownNat n => Num (Expr (BvSort n)) where
   fromInteger :: Integer -> Expr ('BvSort n)
fromInteger = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> (Integer -> Value ('BvSort n)) -> Integer -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec n -> Value ('BvSort n)
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n -> Value ('BvSort n))
-> (Integer -> Bitvec n) -> Integer -> Value ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Bitvec n
forall a. Num a => Integer -> a
fromInteger
   {-# INLINE fromInteger #-}
   (Constant (BvValue HaskellType ('BvSort n)
0)) + :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
+ Expr ('BvSort n)
y = Expr ('BvSort n)
y
   Expr ('BvSort n)
x + (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) + (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
+ Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x + Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Plus Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (+) #-}
   Expr ('BvSort n)
x - :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
- (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) - (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
- Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x - Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Minus Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (-) #-}
   (Constant (BvValue HaskellType ('BvSort n)
0)) * :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
* Expr ('BvSort n)
_ = Expr ('BvSort n)
0
   Expr ('BvSort n)
_ * (Constant (BvValue HaskellType ('BvSort n)
0)) = Expr ('BvSort n)
0
   (Constant (BvValue HaskellType ('BvSort n)
1)) * Expr ('BvSort n)
y = Expr ('BvSort n)
y
   Expr ('BvSort n)
x * (Constant (BvValue HaskellType ('BvSort n)
1)) = Expr ('BvSort n)
x
   (Constant (BvValue HaskellType ('BvSort n)
x)) * (Constant (BvValue HaskellType ('BvSort n)
y)) = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n
HaskellType ('BvSort n)
x Bitvec n -> Bitvec n -> Bitvec n
forall a. Num a => a -> a -> a
* Bitvec n
HaskellType ('BvSort n)
y))
   Expr ('BvSort n)
x * Expr ('BvSort n)
y = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Num (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mul Expr ('BvSort n)
x Expr ('BvSort n)
y
   {-# INLINE (*) #-}
   abs :: Expr ('BvSort n) -> Expr ('BvSort n)
abs         = Expr ('BvSort n) -> Expr ('BvSort n)
forall a. a -> a
id
   {-# INLINE abs #-}
   signum :: Expr ('BvSort n) -> Expr ('BvSort n)
signum Expr ('BvSort n)
_    = Expr ('BvSort n)
0
   {-# INLINE signum #-}

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

-- | Not in the SMTLib2.6-standard. Solvers like CVC5 and MathSAT support it though.
instance Floating (Expr RealSort) where
    pi :: Expr 'RealSort
pi    = Expr 'RealSort
Pi
    {-# INLINE pi #-}
    exp :: Expr 'RealSort -> Expr 'RealSort
exp   = Expr 'RealSort -> Expr 'RealSort
Exp
    {-# INLINE exp #-}
    log :: Expr 'RealSort -> Expr 'RealSort
log   = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support log"
    sqrt :: Expr 'RealSort -> Expr 'RealSort
sqrt  = Expr 'RealSort -> Expr 'RealSort
Sqrt
    {-# INLINE sqrt #-}
    sin :: Expr 'RealSort -> Expr 'RealSort
sin   = Expr 'RealSort -> Expr 'RealSort
Sin
    {-# INLINE sin #-}
    cos :: Expr 'RealSort -> Expr 'RealSort
cos   = Expr 'RealSort -> Expr 'RealSort
Cos
    {-# INLINE cos #-}
    tan :: Expr 'RealSort -> Expr 'RealSort
tan   = Expr 'RealSort -> Expr 'RealSort
Tan
    {-# INLINE tan #-}
    asin :: Expr 'RealSort -> Expr 'RealSort
asin  = Expr 'RealSort -> Expr 'RealSort
Asin
    {-# INLINE asin #-}
    acos :: Expr 'RealSort -> Expr 'RealSort
acos  = Expr 'RealSort -> Expr 'RealSort
Acos
    {-# INLINE acos #-}
    atan :: Expr 'RealSort -> Expr 'RealSort
atan  = Expr 'RealSort -> Expr 'RealSort
Atan
    {-# INLINE atan #-}
    sinh :: Expr 'RealSort -> Expr 'RealSort
sinh  = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support sinh"
    cosh :: Expr 'RealSort -> Expr 'RealSort
cosh  = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support cosh"
    tanh :: Expr 'RealSort -> Expr 'RealSort
tanh  = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support tanh"
    asinh :: Expr 'RealSort -> Expr 'RealSort
asinh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support asinh"
    acosh :: Expr 'RealSort -> Expr 'RealSort
acosh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support acosh"
    atanh :: Expr 'RealSort -> Expr 'RealSort
atanh = String -> Expr 'RealSort -> Expr 'RealSort
forall a. HasCallStack => String -> a
error String
"SMT-Solvers currently do not support atanh"

-- | This instance is __partial__ for 'toRational', it's only intended for use with constants ('Constant').
instance Real (Expr IntSort) where
  toRational :: Expr 'IntSort -> Rational
toRational (Constant (IntValue HaskellType 'IntSort
x)) = Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
HaskellType 'IntSort
x
  toRational Expr 'IntSort
x = String -> Rational
forall a. HasCallStack => String -> a
error (String -> Rational) -> String -> Rational
forall a b. (a -> b) -> a -> b
$ String
"Real#toRational[Expr IntSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'IntSort -> String
forall a. Show a => a -> String
show Expr 'IntSort
x
  {-# INLINE toRational #-}

-- | This instance is __partial__ for 'toEnum', it's only intended for use with constants ('Constant').
instance Enum (Expr IntSort) where
  fromEnum :: Expr 'IntSort -> Int
fromEnum (Constant (IntValue HaskellType 'IntSort
x)) = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
HaskellType 'IntSort
x
  fromEnum Expr 'IntSort
x = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Enum#fromEnum[Expr IntSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'IntSort -> String
forall a. Show a => a -> String
show Expr 'IntSort
x
  {-# INLINE fromEnum #-}
  toEnum :: Int -> Expr 'IntSort
toEnum = Integer -> Expr 'IntSort
forall a. Num a => Integer -> a
fromInteger (Integer -> Expr 'IntSort)
-> (Int -> Integer) -> Int -> Expr 'IntSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE toEnum #-}

-- | This instance is __partial__ for 'toInteger', it's only intended for use with constants ('Constant').
instance Integral (Expr IntSort) where
  quot :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
quot = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv
  {-# INLINE quot #-}
  rem :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
rem  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod
  {-# INLINE rem #-}
  div :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
div  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv
  {-# INLINE div #-}
  mod :: Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
mod  = Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod
  {-# INLINE mod #-}
  quotRem :: Expr 'IntSort -> Expr 'IntSort -> (Expr 'IntSort, Expr 'IntSort)
quotRem Expr 'IntSort
x Expr 'IntSort
y = (Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integral a => a -> a -> a
quot Expr 'IntSort
x Expr 'IntSort
y, Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integral a => a -> a -> a
rem Expr 'IntSort
x Expr 'IntSort
y)
  {-# INLINE quotRem #-}
  divMod :: Expr 'IntSort -> Expr 'IntSort -> (Expr 'IntSort, Expr 'IntSort)
divMod Expr 'IntSort
x Expr 'IntSort
y  = (Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integral a => a -> a -> a
div Expr 'IntSort
x Expr 'IntSort
y, Expr 'IntSort -> Expr 'IntSort -> Expr 'IntSort
forall a. Integral a => a -> a -> a
mod Expr 'IntSort
x Expr 'IntSort
y)
  {-# INLINE divMod #-}
  toInteger :: Expr 'IntSort -> Integer
toInteger (Constant (IntValue HaskellType 'IntSort
x)) = Integer
HaskellType 'IntSort
x
  toInteger Expr 'IntSort
x = String -> Integer
forall a. HasCallStack => String -> a
error (String -> Integer) -> String -> Integer
forall a b. (a -> b) -> a -> b
$ String
"Integer#toInteger[Expr IntSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'IntSort -> String
forall a. Show a => a -> String
show Expr 'IntSort
x
  {-# INLINE toInteger #-}

-- | This instance is __partial__ for 'toRational', it's only intended for use with constants ('Constant').
instance Real (Expr RealSort) where
  toRational :: Expr 'RealSort -> Rational
toRational (Constant (RealValue HaskellType 'RealSort
x)) = Double -> Rational
forall a. Real a => a -> Rational
toRational Double
HaskellType 'RealSort
x
  toRational Expr 'RealSort
x = String -> Rational
forall a. HasCallStack => String -> a
error (String -> Rational) -> String -> Rational
forall a b. (a -> b) -> a -> b
$ String
"Real#toRational[Expr RealSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'RealSort -> String
forall a. Show a => a -> String
show Expr 'RealSort
x
  {-# INLINE toRational #-}

-- | This instance is __partial__ for 'toEnum', it's only intended for use with constants ('Constant').
instance Enum (Expr RealSort) where
  fromEnum :: Expr 'RealSort -> Int
fromEnum (Constant (RealValue HaskellType 'RealSort
x)) = Double -> Int
forall a. Enum a => a -> Int
fromEnum Double
HaskellType 'RealSort
x
  fromEnum Expr 'RealSort
x = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Enum#fromEnum[Expr RealSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'RealSort -> String
forall a. Show a => a -> String
show Expr 'RealSort
x
  {-# INLINE fromEnum #-}
  toEnum :: Int -> Expr 'RealSort
toEnum = Integer -> Expr 'RealSort
forall a. Num a => Integer -> a
fromInteger (Integer -> Expr 'RealSort)
-> (Int -> Integer) -> Int -> Expr 'RealSort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE toEnum #-}

-- | This instance is __partial__ for 'toRational', it's only intended for use with constants ('Constant').
instance KnownNat n => Real (Expr (BvSort n)) where
  toRational :: Expr ('BvSort n) -> Rational
toRational (Constant (BvValue HaskellType ('BvSort n)
x)) = Bitvec n -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Bitvec n
HaskellType ('BvSort n)
x
  toRational Expr ('BvSort n)
x = String -> Rational
forall a. HasCallStack => String -> a
error (String -> Rational) -> String -> Rational
forall a b. (a -> b) -> a -> b
$ String
"Real#toRational[Expr BvSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr ('BvSort n) -> String
forall a. Show a => a -> String
show Expr ('BvSort n)
x
  {-# INLINE toRational #-}

-- | This instance is __partial__ for 'toEnum', it's only intended for use with constants ('Constant').
instance KnownNat n => Enum (Expr (BvSort n)) where
  fromEnum :: Expr ('BvSort n) -> Int
fromEnum (Constant (BvValue HaskellType ('BvSort n)
x)) = Bitvec n -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Bitvec n
HaskellType ('BvSort n)
x
  fromEnum Expr ('BvSort n)
x = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Enum#fromEnum[Expr BvSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr ('BvSort n) -> String
forall a. Show a => a -> String
show Expr ('BvSort n)
x
  {-# INLINE fromEnum #-}
  toEnum :: Int -> Expr ('BvSort n)
toEnum = Integer -> Expr ('BvSort n)
forall a. Num a => Integer -> a
fromInteger (Integer -> Expr ('BvSort n))
-> (Int -> Integer) -> Int -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE toEnum #-}

-- | This instance is __partial__ for 'toInteger', it's only intended for use with constants ('Constant').
instance KnownNat n => Integral (Expr (BvSort n)) where
  quot :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
quot        = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv
  {-# INLINE quot #-}
  rem :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
rem         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod
  {-# INLINE rem #-}
  div :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
div         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
IDiv
  {-# INLINE div #-}
  mod :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
mod         = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Integral (HaskellType t) =>
Expr t -> Expr t -> Expr t
Mod
  {-# INLINE mod #-}
  quotRem :: Expr ('BvSort n)
-> Expr ('BvSort n) -> (Expr ('BvSort n), Expr ('BvSort n))
quotRem Expr ('BvSort n)
x Expr ('BvSort n)
y = (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integral a => a -> a -> a
quot Expr ('BvSort n)
x Expr ('BvSort n)
y, Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integral a => a -> a -> a
rem Expr ('BvSort n)
x Expr ('BvSort n)
y)
  {-# INLINE quotRem #-}
  divMod :: Expr ('BvSort n)
-> Expr ('BvSort n) -> (Expr ('BvSort n), Expr ('BvSort n))
divMod Expr ('BvSort n)
x Expr ('BvSort n)
y  = (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integral a => a -> a -> a
div Expr ('BvSort n)
x Expr ('BvSort n)
y, Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall a. Integral a => a -> a -> a
mod Expr ('BvSort n)
x Expr ('BvSort n)
y)
  {-# INLINE divMod #-}
  toInteger :: Expr ('BvSort n) -> Integer
toInteger (Constant (BvValue HaskellType ('BvSort n)
x)) = Bitvec n -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Bitvec n
HaskellType ('BvSort n)
x
  toInteger Expr ('BvSort n)
x = String -> Integer
forall a. HasCallStack => String -> a
error (String -> Integer) -> String -> Integer
forall a b. (a -> b) -> a -> b
$ String
"Integer#toInteger[Expr BvSort] only supported for constants. But given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr ('BvSort n) -> String
forall a. Show a => a -> String
show Expr ('BvSort n)
x
  {-# 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 #-}
  && :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(&&) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (&&) #-}
  || :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(||) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (||) #-}
  not :: Expr 'BoolSort -> Expr 'BoolSort
not  = Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE not #-}
  xor :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
xor  = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
  {-# INLINE xor #-}
  <==> :: Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
(<==>) = Expr 'BoolSort -> Expr 'BoolSort -> Expr 'BoolSort
forall a. Equatable a => a -> a -> Expr 'BoolSort
(===)
  {-# INLINE (<==>) #-}

instance KnownNat n => Boolean (Expr (BvSort n)) where
  bool :: Bool -> Expr ('BvSort n)
bool = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> (Bool -> Value ('BvSort n)) -> Bool -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec n -> Value ('BvSort n)
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n -> Value ('BvSort n))
-> (Bool -> Bitvec n) -> Bool -> Value ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bitvec n
forall b. Boolean b => Bool -> b
bool
  {-# INLINE bool #-}
  && :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(&&) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (&&) #-}
  || :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(||) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (||) #-}
  not :: Expr ('BvSort n) -> Expr ('BvSort n)
not  = Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE not #-}
  xor :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
xor  = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort 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 KnownNat n => Bounded (Expr (BvSort n)) where
  minBound :: Expr ('BvSort n)
minBound = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> Value ('BvSort n) -> Expr ('BvSort n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue Bitvec n
HaskellType ('BvSort n)
forall a. Bounded a => a
minBound
  {-# INLINE minBound #-}
  maxBound :: Expr ('BvSort n)
maxBound = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> Value ('BvSort n) -> Expr ('BvSort n)
forall a b. (a -> b) -> a -> b
$ HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue Bitvec n
HaskellType ('BvSort 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
sb Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
"Bits#testBit[Expr BoolSort] is only supported for constants. Given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'BoolSort -> String
forall a. Show a => a -> String
show Expr 'BoolSort
sb
  {-# 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
sb = String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"Bits#popCount[Expr BoolSort] is only supported for constants. Given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr 'BoolSort -> String
forall a. Show a => a -> String
show Expr 'BoolSort
sb
  {-# INLINE popCount #-}

-- | This instance is __partial__ for 'testBit' and 'popCount', it's only intended for use with constants ('Constant').
instance KnownNat n => Bits.Bits (Expr (BvSort n)) where
  .&. :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(.&.) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
And
  {-# INLINE (.&.) #-}
  .|. :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
(.|.) = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Or
  {-# INLINE (.|.) #-}
  xor :: Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
xor = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort).
Boolean (HaskellType t) =>
Expr t -> Expr t -> Expr t
Xor
  {-# INLINE xor #-}
  complement :: Expr ('BvSort n) -> Expr ('BvSort n)
complement = Expr ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Boolean (HaskellType t) => Expr t -> Expr t
Not
  {-# INLINE complement #-}
  zeroBits :: Expr ('BvSort n)
zeroBits = Expr ('BvSort n)
forall b. Boolean b => b
false
  {-# INLINE zeroBits #-}
  bit :: Int -> Expr ('BvSort n)
bit = Value ('BvSort n) -> Expr ('BvSort n)
forall (t :: SMTSort). Value t -> Expr t
Constant (Value ('BvSort n) -> Expr ('BvSort n))
-> (Int -> Value ('BvSort n)) -> Int -> Expr ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bitvec n -> Value ('BvSort n)
HaskellType ('BvSort n) -> Value ('BvSort n)
forall (n :: Nat).
KnownNat n =>
HaskellType ('BvSort n) -> Value ('BvSort n)
BvValue (Bitvec n -> Value ('BvSort n))
-> (Int -> Bitvec n) -> Int -> Value ('BvSort n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Bitvec n
forall a. Bits a => Int -> a
Bits.bit
  {-# INLINE bit #-}
  testBit :: Expr ('BvSort n) -> Int -> Bool
testBit (Constant (BvValue HaskellType ('BvSort n)
b)) Int
i = Bitvec n -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
Bits.testBit Bitvec n
HaskellType ('BvSort n)
b Int
i
  testBit Expr ('BvSort n)
sb Int
_ = String -> Bool
forall a. HasCallStack => String -> a
error (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
"Bits#testBit[Expr BvSort] is only supported for constants. Given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr ('BvSort n) -> String
forall a. Show a => a -> String
show Expr ('BvSort n)
sb
  {-# INLINE testBit #-}
  bitSizeMaybe :: Expr ('BvSort n) -> Maybe Int
bitSizeMaybe Expr ('BvSort 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 n) -> Int
bitSize Expr ('BvSort 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 n) -> Bool
isSigned Expr ('BvSort n)
_ = Bool
False
  {-# INLINE isSigned #-}
  shiftL :: Expr ('BvSort n) -> Int -> Expr ('BvSort n)
shiftL Expr ('BvSort n)
b Int
i = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL Expr ('BvSort n)
b (Int -> Expr ('BvSort n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
  {-# INLINE shiftL #-}
  shiftR :: Expr ('BvSort n) -> Int -> Expr ('BvSort n)
shiftR Expr ('BvSort n)
b Int
i = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR Expr ('BvSort n)
b (Int -> Expr ('BvSort n)
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
  {-# INLINE shiftR #-}
  rotateL :: Expr ('BvSort n) -> Int -> Expr ('BvSort n)
rotateL Expr ('BvSort n)
b Int
i = Int -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL Int
i Expr ('BvSort n)
b
  {-# INLINE rotateL #-}
  rotateR :: Expr ('BvSort n) -> Int -> Expr ('BvSort n)
rotateR Expr ('BvSort n)
b Int
i = Int -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR Int
i Expr ('BvSort n)
b
  {-# INLINE rotateR #-}
  popCount :: Expr ('BvSort n) -> Int
popCount (Constant (BvValue HaskellType ('BvSort n)
b)) = Bitvec n -> Int
forall a. Bits a => a -> Int
Bits.popCount Bitvec n
HaskellType ('BvSort n)
b
  popCount Expr ('BvSort n)
sb = 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. Given: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Expr ('BvSort n) -> String
forall a. Show a => a -> String
show Expr ('BvSort n)
sb
  {-# 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 #-}

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

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

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

  render (Plus Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvadd" ; SSMTSort t
_ -> Builder
"+") Expr t
x Expr t
y
  render (Minus Expr t
x Expr t
y)  = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvsub" ; SSMTSort t
_ -> Builder
"-") Expr t
x Expr t
y
  render (Neg Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvneg" ; SSMTSort t
_ -> Builder
"-") Expr t
x
  render (Mul Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvmul" ; SSMTSort t
_ -> Builder
"*") Expr t
x Expr t
y
  render (Abs Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  Builder
"abs" Expr t
x
  render (Mod Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvurem" ; SSMTSort t
_ -> Builder
"mod") Expr t
x Expr t
y
  render (IDiv Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvudiv" ; SSMTSort t
_ -> Builder
"div") Expr t
x Expr t
y
  render (Div Expr 'RealSort
x Expr 'RealSort
y)    = Builder -> Expr 'RealSort -> Expr 'RealSort -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"/" Expr 'RealSort
x Expr 'RealSort
y

  render (LTH Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvult" ; SSMTSort t
_ -> Builder
"<") Expr t
x Expr t
y
  render (LTHE Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvule" ; SSMTSort t
_ -> Builder
"<=") Expr t
x Expr t
y
  render (EQU Vector (n + 2) (Expr t)
xs)     = Builder -> [Expr t] -> Builder
forall a. Render a => Builder -> [a] -> Builder
renderNary Builder
"=" ([Expr t] -> Builder) -> [Expr t] -> Builder
forall a b. (a -> b) -> a -> b
$ Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList Vector (n + 2) (Expr t)
xs
  render (Distinct Vector (n + 2) (Expr t)
xs)= Builder -> [Expr t] -> Builder
forall a. Render a => Builder -> [a] -> Builder
renderNary Builder
"distinct" ([Expr t] -> Builder) -> [Expr t] -> Builder
forall a b. (a -> b) -> a -> b
$ Vector (n + 2) (Expr t) -> [Expr t]
forall (n :: Nat) a. Vector n a -> [a]
V.toList Vector (n + 2) (Expr t)
xs
  render (GTHE Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvuge" ; SSMTSort t
_ -> Builder
">=") Expr t
x Expr t
y
  render (GTH Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvugt" ; SSMTSort t
_ -> Builder
">") Expr t
x Expr t
y

  render (Not Expr t
x)      = Builder -> Expr t -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary  (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvnot" ; SSMTSort t
_ -> Builder
"not") Expr t
x
  render (And Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvand" ; SSMTSort t
_ -> Builder
"and") Expr t
x Expr t
y
  render (Or Expr t
x Expr t
y)     = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvor" ; SSMTSort t
_ -> Builder
"or") Expr t
x Expr t
y
  render (Impl Expr t
x Expr t
y)   = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"=>" Expr t
x Expr t
y
  render (Xor Expr t
x Expr t
y)    = Builder -> Expr t -> Expr t -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary (case Expr t -> SSMTSort t
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr t
x of SBvSort Proxy n
_ -> Builder
"bvxor" ; SSMTSort t
_ -> Builder
"xor") Expr t
x Expr t
y

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

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

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

  render (BvNand Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvnand" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvnor"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y)        = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvshl"  (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y)       = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"bvlshr" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
y)
  render (BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y)     = Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"concat" (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x) (Expr ('BvSort m) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort m)
y)
  render (BvRotL a
i Expr ('BvSort n)
x)       = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary (Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"_" (Builder
"rotate_left"  :: Builder) (Integer -> Builder
forall a. Render a => a -> Builder
render (Integer -> Builder) -> Integer -> Builder
forall a b. (a -> b) -> a -> b
$ a -> Integer
forall a. Integral a => a -> Integer
toInteger a
i)) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)
  render (BvRotR a
i Expr ('BvSort n)
x)       = Builder -> Builder -> Builder
forall a. Render a => Builder -> a -> Builder
renderUnary (Builder -> Builder -> Builder -> Builder
forall a b. (Render a, Render b) => Builder -> a -> b -> Builder
renderBinary Builder
"_" (Builder
"rotate_right" :: Builder) (Integer -> Builder
forall a. Render a => a -> Builder
render (Integer -> Builder) -> Integer -> Builder
forall a b. (a -> b) -> a -> b
$ a -> Integer
forall a. Integral a => a -> Integer
toInteger a
i)) (Expr ('BvSort n) -> Builder
forall a. Render a => a -> Builder
render Expr ('BvSort n)
x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

instance (KnownSMTSort k, KnownSMTSort v, Ord (HaskellType k), 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 (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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNand (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNor (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y)             = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y)            = Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort n) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort n) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y)          = Expr ('BvSort n) -> Expr ('BvSort m) -> Expr b
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
BvConcat (Expr ('BvSort n) -> Expr ('BvSort m) -> Expr b)
-> m (Expr ('BvSort n)) -> m (Expr ('BvSort m) -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x m (Expr ('BvSort m) -> Expr b)
-> m (Expr ('BvSort m)) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr ('BvSort m) -> m (Expr ('BvSort m))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort m)
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotL a
i Expr ('BvSort n)
x)            = a -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL a
i (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (BvRotR a
i Expr ('BvSort n)
x)            = a -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR a
i (Expr ('BvSort n) -> Expr b) -> m (Expr ('BvSort n)) -> m (Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr ('BvSort n) -> m (Expr ('BvSort n))
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr ('BvSort n)
x
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (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 (StrLT Expr 'StringSort
x Expr 'StringSort
y)             = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLT (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrLTHE Expr 'StringSort
x Expr 'StringSort
y)           = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLTHE (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrAt Expr 'StringSort
x Expr 'IntSort
i)             = Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j)    = Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'IntSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'IntSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
j
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrContains Expr 'StringSort
x Expr 'StringSort
y)       = Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i)      = Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'IntSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'IntSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'IntSort -> Expr b) -> m (Expr 'IntSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'IntSort -> m (Expr 'IntSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'IntSort
i
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y')     = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y')  = Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr b
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort)
-> m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
x m (Expr 'StringSort -> Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr 'StringSort -> Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y m (Expr 'StringSort -> Expr b)
-> m (Expr 'StringSort) -> m (Expr b)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr 'StringSort -> m (Expr 'StringSort)
forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f Expr 'StringSort
y'
  uniplate1 forall (a :: SMTSort).
AllC '[KnownSMTSort] a =>
Expr a -> m (Expr a)
f (ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
expr) = Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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
          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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort) (a :: Nat).
(Eq (HaskellType n), KnownSMTSort n, KnownNat a) =>
Vector (a + 2) (Expr n) -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 (n :: SMTSort).
(Ord (HaskellType n), KnownSMTSort n) =>
Expr n -> Expr n -> 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 n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNand (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
y
          BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvNor  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
y
          BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y            -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvShL  (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
y
          BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y           -> Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat).
KnownNat n =>
Expr ('BvSort n) -> Expr ('BvSort n) -> Expr ('BvSort n)
BvLShR (Expr ('BvSort n) -> Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort n) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x f (Expr ('BvSort n) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
y
          BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y         -> Expr ('BvSort n) -> Expr ('BvSort m) -> Expr r
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
forall (n :: Nat) (m :: Nat).
(KnownNat n, KnownNat m) =>
Expr ('BvSort n) -> Expr ('BvSort m) -> Expr ('BvSort (n + m))
BvConcat (Expr ('BvSort n) -> Expr ('BvSort m) -> Expr r)
-> f (Expr ('BvSort n)) -> f (Expr ('BvSort m) -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x f (Expr ('BvSort m) -> Expr r)
-> f (Expr ('BvSort m)) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort m)
y
          BvRotL a
i Expr ('BvSort n)
x           -> a -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotL a
i (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x
          BvRotR a
i Expr ('BvSort n)
x           -> a -> Expr ('BvSort n) -> Expr ('BvSort n)
forall (n :: Nat) a.
(KnownNat n, Integral a) =>
a -> Expr ('BvSort n) -> Expr ('BvSort n)
BvRotR a
i (Expr ('BvSort n) -> Expr r) -> f (Expr ('BvSort n)) -> f (Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr ('BvSort n)
x
          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
          StrLT Expr 'StringSort
x Expr 'StringSort
y            -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLT         (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrLTHE Expr 'StringSort
x Expr 'StringSort
y          -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrLTHE       (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrAt Expr 'StringSort
x Expr 'IntSort
i            -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort -> Expr 'IntSort -> Expr 'StringSort
StrAt         (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
          StrSubstring Expr 'StringSort
x Expr 'IntSort
i Expr 'IntSort
j   -> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'IntSort -> Expr 'IntSort -> Expr 'StringSort
StrSubstring  (Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'IntSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'IntSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
j
          StrPrefixOf Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrPrefixOf   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrSuffixOf Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrSuffixOf   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrContains Expr 'StringSort
x Expr 'StringSort
y      -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort -> Expr 'StringSort -> Expr 'BoolSort
StrContains   (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y
          StrIndexOf Expr 'StringSort
x Expr 'StringSort
y Expr 'IntSort
i     -> Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'IntSort -> Expr 'IntSort
StrIndexOf    (Expr 'StringSort -> Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'IntSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'IntSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'IntSort -> Expr r) -> f (Expr 'IntSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'IntSort
i
          StrReplace Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y'    -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplace    (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
          StrReplaceAll Expr 'StringSort
x Expr 'StringSort
y Expr 'StringSort
y' -> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort -> Expr r
Expr 'StringSort
-> Expr 'StringSort -> Expr 'StringSort -> Expr 'StringSort
StrReplaceAll (Expr 'StringSort
 -> Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort)
-> f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
x f (Expr 'StringSort -> Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr 'StringSort -> Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y f (Expr 'StringSort -> Expr r)
-> f (Expr 'StringSort) -> f (Expr r)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
forall (s :: SMTSort) (f :: * -> *).
(KnownSMTSort s, Applicative f) =>
(Expr s -> f (Expr s))
-> forall (r :: SMTSort). KnownSMTSort r => Expr r -> f (Expr r)
tryPlate Expr s -> f (Expr s)
f' Expr 'StringSort
y'
          ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
qexpr -> Maybe (SMTVar t) -> (Expr t -> Expr 'BoolSort) -> Expr 'BoolSort
forall (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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 (n :: SMTSort).
KnownSMTSort n =>
Maybe (SMTVar n) -> (Expr n -> 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
    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 n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvNor Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvShL Expr ('BvSort n)
e1 Expr ('BvSort n)
e2          -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvLShR Expr ('BvSort n)
e1 Expr ('BvSort n)
e2         -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e2
    BvConcat Expr ('BvSort n)
e1 Expr ('BvSort m)
e2       -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr ('BvSort m) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort m)
e2
    BvRotL a
_ Expr ('BvSort n)
e           -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    BvRotR a
_ Expr ('BvSort n)
e           -> Expr ('BvSort n) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('BvSort n)
e
    ArrSelect Expr ('ArraySort k a)
e1 Expr k
e2      -> Expr ('ArraySort k a) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k a)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2
    ArrStore Expr ('ArraySort k v)
e1 Expr k
e2 Expr v
e3    -> Expr ('ArraySort k v) -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr ('ArraySort k v)
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr k -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr k
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr v -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr v
e3
    StrConcat Expr 'StringSort
e1 Expr 'StringSort
e2      -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrLength Expr 'StringSort
e          -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e
    StrLT Expr 'StringSort
e1 Expr 'StringSort
e2          -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrLTHE Expr 'StringSort
e1 Expr 'StringSort
e2        -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrAt Expr 'StringSort
e1 Expr 'IntSort
e2          -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2
    StrSubstring Expr 'StringSort
e1 Expr 'IntSort
e2 Expr 'IntSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
    StrPrefixOf Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrSuffixOf Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrContains Expr 'StringSort
e1 Expr 'StringSort
e2    -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2
    StrIndexOf Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'IntSort
e3  -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'IntSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'IntSort
e3
    StrReplace Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3  -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
    StrReplaceAll Expr 'StringSort
e1 Expr 'StringSort
e2 Expr 'StringSort
e3 -> Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e1 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e2 () -> () -> ()
forall a b. a -> b -> b
`seq` Expr 'StringSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf Expr 'StringSort
e3
    ForAll Maybe (SMTVar t)
Nothing Expr t -> Expr 'BoolSort
_     -> ()
    ForAll (Just SMTVar t
qv) Expr t -> Expr 'BoolSort
f   -> Expr 'BoolSort -> ()
forall k (f :: k -> *) (a :: k). GNFData f => f a -> ()
forall (a :: SMTSort). Expr a -> ()
grnf (Expr 'BoolSort -> ()) -> Expr 'BoolSort -> ()
forall a b. (a -> b) -> a -> b
$ Expr t -> Expr 'BoolSort
f (Expr t -> Expr 'BoolSort) -> Expr t -> Expr 'BoolSort
forall a b. (a -> b) -> a -> b
$ SMTVar t -> Expr t
forall (t :: SMTSort). 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 (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 n)
x Expr ('BvSort n)
y)            (BvNand Expr ('BvSort n)
x' Expr ('BvSort 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 n)
x,Expr b
Expr ('BvSort n)
x'), (Expr a
Expr ('BvSort n)
y,Expr b
Expr ('BvSort n)
y')]
  gcompare (BvNand Expr ('BvSort n)
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvNand Expr ('BvSort n)
_ Expr ('BvSort n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvNor Expr ('BvSort n)
x Expr ('BvSort n)
y)             (BvNor Expr ('BvSort n)
x' Expr ('BvSort 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 n)
x,Expr b
Expr ('BvSort n)
x'), (Expr a
Expr ('BvSort n)
y,Expr b
Expr ('BvSort n)
y')]
  gcompare (BvNor Expr ('BvSort n)
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvNor Expr ('BvSort n)
_ Expr ('BvSort n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvShL Expr ('BvSort n)
x Expr ('BvSort n)
y)             (BvShL Expr ('BvSort n)
x' Expr ('BvSort 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 n)
x,Expr b
Expr ('BvSort n)
x'), (Expr a
Expr ('BvSort n)
y,Expr b
Expr ('BvSort n)
y')]
  gcompare (BvShL Expr ('BvSort n)
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvShL Expr ('BvSort n)
_ Expr ('BvSort n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvLShR Expr ('BvSort n)
x Expr ('BvSort n)
y)            (BvLShR Expr ('BvSort n)
x' Expr ('BvSort 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 n)
x,Expr b
Expr ('BvSort n)
x'), (Expr a
Expr ('BvSort n)
y,Expr b
Expr ('BvSort n)
y')]
  gcompare (BvLShR Expr ('BvSort n)
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvLShR Expr ('BvSort n)
_ Expr ('BvSort n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvConcat Expr ('BvSort n)
x Expr ('BvSort m)
y)          (BvConcat Expr ('BvSort n)
x' Expr ('BvSort m)
y')        = case SSMTSort ('BvSort n)
-> SSMTSort ('BvSort n) -> GOrdering ('BvSort n) ('BvSort 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 n) -> SSMTSort ('BvSort n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort n)
x) (Expr ('BvSort n) -> SSMTSort ('BvSort n)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort n)
x') of
    GOrdering ('BvSort n) ('BvSort n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
    GOrdering ('BvSort n) ('BvSort n)
GEQ -> case Expr ('BvSort n)
-> Expr ('BvSort n) -> GOrdering ('BvSort n) ('BvSort 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 n)
x Expr ('BvSort n)
x' of
      GOrdering ('BvSort n) ('BvSort n)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
      GOrdering ('BvSort n) ('BvSort n)
GEQ -> case SSMTSort ('BvSort m)
-> SSMTSort ('BvSort m) -> GOrdering ('BvSort m) ('BvSort 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 m) -> SSMTSort ('BvSort m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort m)
y) (Expr ('BvSort m) -> SSMTSort ('BvSort m)
forall (prxy :: SMTSort -> *) (t :: SMTSort).
KnownSMTSort t =>
prxy t -> SSMTSort t
sortSing' Expr ('BvSort m)
y') of
        GOrdering ('BvSort m) ('BvSort m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
        GOrdering ('BvSort m) ('BvSort m)
GEQ -> case Expr ('BvSort m)
-> Expr ('BvSort m) -> GOrdering ('BvSort m) ('BvSort 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 m)
y Expr ('BvSort m)
y' of
          GOrdering ('BvSort m) ('BvSort m)
GLT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
          GOrdering ('BvSort m) ('BvSort m)
GEQ -> GOrdering a a
GOrdering a b
forall {k} (a :: k). GOrdering a a
GEQ
          GOrdering ('BvSort m) ('BvSort m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
        GOrdering ('BvSort m) ('BvSort m)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
      GOrdering ('BvSort n) ('BvSort n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
    GOrdering ('BvSort n) ('BvSort n)
GGT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvConcat Expr ('BvSort n)
_ Expr ('BvSort m)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvConcat Expr ('BvSort n)
_ Expr ('BvSort m)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotL a
i Expr ('BvSort n)
x)            (BvRotL a
i' Expr ('BvSort 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 n)
x Expr b
Expr ('BvSort n)
x'
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotL a
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvRotL a
_ Expr ('BvSort n)
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotR a
i Expr ('BvSort n)
x)            (BvRotR a
i' Expr ('BvSort 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 n)
x Expr b
Expr ('BvSort n)
x'
    Ordering
GT -> GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (BvRotR a
_ Expr ('BvSort n)
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (BvRotR a
_ Expr ('BvSort 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 (StrLT Expr 'StringSort
x Expr 'StringSort
y)             (StrLT 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 (StrLT Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrLT Expr 'StringSort
_ Expr 'StringSort
_) = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GGT
  gcompare (StrLTHE Expr 'StringSort
x Expr 'StringSort
y)           (StrLTHE 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 (StrLTHE Expr 'StringSort
_ Expr 'StringSort
_) Expr b
_ = GOrdering a b
forall {k} (a :: k) (b :: k). GOrdering a b
GLT
  gcompare Expr a
_ (StrLTHE Expr 'StringSort
_ 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