{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveTraversable          #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE UndecidableInstances       #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE ConstraintKinds            #-}
{-# LANGUAGE DerivingVia                #-}
{-# LANGUAGE LambdaCase                 #-}
{-# LANGUAGE NamedFieldPuns             #-}
{-# LANGUAGE TupleSections              #-}
{-# LANGUAGE TypeFamilies               #-}
{-# LANGUAGE TypeOperators              #-}
{-# LANGUAGE ScopedTypeVariables        #-}

{-# OPTIONS_GHC -Wno-orphans #-}

-- | This module contains the types to represent refinement types.

module Language.Haskell.Liquid.Types.RType (

  -- * Bare Type Constructors and Variables
    BTyCon(..)
  , mkBTyCon
  -- , mkClassBTyCon, mkPromotedBTyCon
  , isClassBTyCon
  , BTyVar(..)

  -- * Refined Type Constructors
  , RTyCon (RTyCon, rtc_tc, rtc_info)
  , TyConInfo(..), defaultTyConInfo
  , rTyConPVs
  -- , isClassRTyCon
  , isClassType, isEqType, isRVar, isBool, isEmbeddedClass

  -- * Refinement Types
  , RType, RTypeV, RTypeBV (..), Ref, RefB(..), RTProp, RTPropV, RTPropBV, rPropP
  , RTyVar (..)
  , OkRT, OkRTBV

  -- * Classes describing operations on `RTypes`
  , TyConable (..)

  -- * Type Variables
  , RTVar (..), RTVInfo (..)
  , makeRTVar, mapTyVarValue
  , dropTyVarInfo, rTVarToBind
  , setRtvPol

  -- * Predicate Variables
  , PVar
  , PVarV
  , PVarBV (PV, pname, parg, ptype, pargs), pvType
  , Predicate
  , PredicateV
  , PredicateBV(..)
  , PredicateCompat(..)

  -- * Expression Arguments
  , notExprArg

  -- * Manipulating `Predicates`
  , emapExprVM
  , mapPredicateV
  , emapPredicateVM
  , mapPVarV
  , emapPVarVM
  , emapSubstVM
  , pvars, pApp

  -- * Refinements
  , UReft
  , UReftV
  , UReftBV(..)
  , mapUReftV
  , emapUReftVM
  , NoReft
  , NoReftB(..)

  -- * Parse-time entities describing refined data types
  , SizeFun, SizeFunV (..), szFun
  , TyConP   (..)

  -- * Pre-instantiated RType
  , RRType, RRProp
  , BRType, BRProp, BRPropV
  , BSort, BSortV, BPVar
  , RTVU, PVU

  -- * Instantiated RType
  , BareType
  , BareTypeLHName
  , BareTypeParsed
  , BareTypeV
  , SpecType, SpecProp, SpecRTVar
  , LocBareType
  , LocBareTypeLHName
  , LocBareTypeParsed
  , LocSpecType
  , RSort
  , UsedPVar
  , UsedPVarV
  , RPVar, RReft, RReftV, RReftBV

  -- * Printer Configuration
  , PPEnv (..)
  , ppEnv
  , ppEnvShort

  -- * Refined Function Info
  , RFInfo(..), defRFInfo, mkRFInfo, classRFInfo

  -- * Converting to and from refinements
  , ToReft(..)
  , Meet(..)
  , Top(..)
  , IsReft(..)
  , isTauto
  , trueReft
  )
  where

import           Liquid.GHC.API as Ghc hiding ( Expr
                                                               , isFunTy
                                                               , ($+$)
                                                               , nest
                                                               , text
                                                               , blankLine
                                                               , (<+>)
                                                               , vcat
                                                               , hsep
                                                               , comma
                                                               , colon
                                                               , parens
                                                               , empty
                                                               , char
                                                               , panic
                                                               , int
                                                               , hcat
                                                               , showPpr
                                                               , punctuate
                                                               , ($$)
                                                               , braces
                                                               , angleBrackets
                                                               , brackets
                                                               )
import           Data.String
import           GHC.Generics
import           Prelude                          hiding  (error)

import           Control.DeepSeq
import           Data.Traversable                       (forAccumM)
import           Data.Generics                          (Data)
import qualified Data.Binary                            as B
import           Data.Hashable
import qualified Data.HashMap.Strict                    as M
import qualified Data.List                              as L
import           Data.Maybe                             (mapMaybe)
import           Data.List                              as L (nub)
import           Data.Proxy                             (Proxy(..))
import           Text.PrettyPrint.HughesPJ              hiding (first, (<>))
import           Language.Fixpoint.Misc

import qualified Language.Fixpoint.Types as F
import           Language.Fixpoint.Types (Expr, ExprBV(..), KVarSubst, Symbol)

import           Language.Haskell.Liquid.GHC.Misc
import           Language.Haskell.Liquid.Types.Names
import           Language.Haskell.Liquid.Types.Variance
import           Language.Haskell.Liquid.Types.Errors
import           Language.Haskell.Liquid.Misc
import           Language.Haskell.Liquid.UX.Config


newtype RFInfo = RFInfo {RFInfo -> Maybe Bool
permitTC :: Maybe Bool }
  deriving ((forall x. RFInfo -> Rep RFInfo x)
-> (forall x. Rep RFInfo x -> RFInfo) -> Generic RFInfo
forall x. Rep RFInfo x -> RFInfo
forall x. RFInfo -> Rep RFInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RFInfo -> Rep RFInfo x
from :: forall x. RFInfo -> Rep RFInfo x
$cto :: forall x. Rep RFInfo x -> RFInfo
to :: forall x. Rep RFInfo x -> RFInfo
Generic, Typeable RFInfo
Typeable RFInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RFInfo -> c RFInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RFInfo)
-> (RFInfo -> Constr)
-> (RFInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RFInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RFInfo))
-> ((forall b. Data b => b -> b) -> RFInfo -> RFInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RFInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RFInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> RFInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RFInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RFInfo -> m RFInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RFInfo -> m RFInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RFInfo -> m RFInfo)
-> Data RFInfo
RFInfo -> Constr
RFInfo -> DataType
(forall b. Data b => b -> b) -> RFInfo -> RFInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RFInfo -> u
forall u. (forall d. Data d => d -> u) -> RFInfo -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RFInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RFInfo -> c RFInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RFInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RFInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RFInfo -> c RFInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RFInfo -> c RFInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RFInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RFInfo
$ctoConstr :: RFInfo -> Constr
toConstr :: RFInfo -> Constr
$cdataTypeOf :: RFInfo -> DataType
dataTypeOf :: RFInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RFInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RFInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RFInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RFInfo)
$cgmapT :: (forall b. Data b => b -> b) -> RFInfo -> RFInfo
gmapT :: (forall b. Data b => b -> b) -> RFInfo -> RFInfo
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RFInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RFInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RFInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RFInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RFInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RFInfo -> m RFInfo
Data, Int -> RFInfo -> ShowS
[RFInfo] -> ShowS
RFInfo -> String
(Int -> RFInfo -> ShowS)
-> (RFInfo -> String) -> ([RFInfo] -> ShowS) -> Show RFInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RFInfo -> ShowS
showsPrec :: Int -> RFInfo -> ShowS
$cshow :: RFInfo -> String
show :: RFInfo -> String
$cshowList :: [RFInfo] -> ShowS
showList :: [RFInfo] -> ShowS
Show, RFInfo -> RFInfo -> Bool
(RFInfo -> RFInfo -> Bool)
-> (RFInfo -> RFInfo -> Bool) -> Eq RFInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RFInfo -> RFInfo -> Bool
== :: RFInfo -> RFInfo -> Bool
$c/= :: RFInfo -> RFInfo -> Bool
/= :: RFInfo -> RFInfo -> Bool
Eq)

defRFInfo :: RFInfo
defRFInfo :: RFInfo
defRFInfo = Maybe Bool -> RFInfo
RFInfo Maybe Bool
forall a. Maybe a
Nothing

classRFInfo :: Bool -> RFInfo
classRFInfo :: Bool -> RFInfo
classRFInfo Bool
b = Maybe Bool -> RFInfo
RFInfo (Maybe Bool -> RFInfo) -> Maybe Bool -> RFInfo
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
b

mkRFInfo :: Config  -> RFInfo
mkRFInfo :: Config -> RFInfo
mkRFInfo Config
cfg = Maybe Bool -> RFInfo
RFInfo (Maybe Bool -> RFInfo) -> Maybe Bool -> RFInfo
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Config -> Bool
typeclass Config
cfg)

instance Hashable RFInfo
instance NFData RFInfo
instance B.Binary RFInfo

-----------------------------------------------------------------------------
-- | Printer ----------------------------------------------------------------
-----------------------------------------------------------------------------

data PPEnv = PP
  { PPEnv -> Bool
ppPs    :: Bool -- ^ print abstract-predicates
  , PPEnv -> Bool
ppTyVar :: Bool -- ^ print the unique suffix for each tyvar
  , PPEnv -> Bool
ppShort :: Bool -- ^ print the tycons without qualification
  , PPEnv -> Bool
ppDebug :: Bool -- ^ gross with full info
  }
  deriving (Int -> PPEnv -> ShowS
[PPEnv] -> ShowS
PPEnv -> String
(Int -> PPEnv -> ShowS)
-> (PPEnv -> String) -> ([PPEnv] -> ShowS) -> Show PPEnv
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PPEnv -> ShowS
showsPrec :: Int -> PPEnv -> ShowS
$cshow :: PPEnv -> String
show :: PPEnv -> String
$cshowList :: [PPEnv] -> ShowS
showList :: [PPEnv] -> ShowS
Show)

ppEnv :: PPEnv
ppEnv :: PPEnv
ppEnv = PPEnv
ppEnvDef
          { ppPs    = True }
          { ppDebug = True }   -- RJ: needed for resolution, because pp is used for serialization?

{- | [NOTE:ppEnv] For some mysterious reason, `ppDebug` must equal `True`
     or various tests fail e.g. tests/classes/pos/TypeEquality0{0,1}.hs
     Yikes. Find out why!
 -}

ppEnvDef :: PPEnv
ppEnvDef :: PPEnv
ppEnvDef = Bool -> Bool -> Bool -> Bool -> PPEnv
PP Bool
False Bool
False Bool
False Bool
False

ppEnvShort :: PPEnv -> PPEnv
ppEnvShort :: PPEnv -> PPEnv
ppEnvShort PPEnv
pp = PPEnv
pp { ppShort = True }


data TyConP = TyConP
  { TyConP -> SourcePos
tcpLoc          :: !F.SourcePos
  , TyConP -> TyCon
tcpCon          :: !TyCon
  , TyConP -> [RTyVar]
tcpFreeTyVarsTy :: ![RTyVar]
  , TyConP -> [PVar RSort]
tcpFreePredTy   :: ![PVar RSort]
  , TyConP -> VarianceInfo
tcpVarianceTs   :: !VarianceInfo
  , TyConP -> VarianceInfo
tcpVariancePs   :: !VarianceInfo
  , TyConP -> Maybe SizeFun
tcpSizeFun      :: !(Maybe SizeFun)
  } deriving ((forall x. TyConP -> Rep TyConP x)
-> (forall x. Rep TyConP x -> TyConP) -> Generic TyConP
forall x. Rep TyConP x -> TyConP
forall x. TyConP -> Rep TyConP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyConP -> Rep TyConP x
from :: forall x. TyConP -> Rep TyConP x
$cto :: forall x. Rep TyConP x -> TyConP
to :: forall x. Rep TyConP x -> TyConP
Generic, Typeable TyConP
Typeable TyConP =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyConP -> c TyConP)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyConP)
-> (TyConP -> Constr)
-> (TyConP -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyConP))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConP))
-> ((forall b. Data b => b -> b) -> TyConP -> TyConP)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConP -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConP -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyConP -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TyConP -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyConP -> m TyConP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConP -> m TyConP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConP -> m TyConP)
-> Data TyConP
TyConP -> Constr
TyConP -> DataType
(forall b. Data b => b -> b) -> TyConP -> TyConP
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TyConP -> u
forall u. (forall d. Data d => d -> u) -> TyConP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConP -> c TyConP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConP)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConP -> c TyConP
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConP -> c TyConP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConP
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConP
$ctoConstr :: TyConP -> Constr
toConstr :: TyConP -> Constr
$cdataTypeOf :: TyConP -> DataType
dataTypeOf :: TyConP -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConP)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConP)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConP)
$cgmapT :: (forall b. Data b => b -> b) -> TyConP -> TyConP
gmapT :: (forall b. Data b => b -> b) -> TyConP -> TyConP
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyConP -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyConP -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyConP -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConP -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConP -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConP -> m TyConP
Data)

instance F.Loc TyConP where
  srcSpan :: TyConP -> SrcSpan
srcSpan TyConP
tc = SourcePos -> SourcePos -> SrcSpan
F.SS (TyConP -> SourcePos
tcpLoc TyConP
tc) (TyConP -> SourcePos
tcpLoc TyConP
tc)

instance Show TyConP where
 show :: TyConP -> String
show = TyConP -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint TyConP where
  pprintTidy :: Tidy -> TyConP -> Doc
pprintTidy Tidy
k TyConP
tc = Doc
"data" Doc -> Doc -> Doc
<+> Tidy -> TyCon -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (TyConP -> TyCon
tcpCon TyConP
tc)
                           Doc -> Doc -> Doc
<+> Tidy -> [RTyVar] -> Doc
forall a. PPrint a => Tidy -> [a] -> Doc
ppComm     Tidy
k (TyConP -> [RTyVar]
tcpFreeTyVarsTy TyConP
tc)
                           Doc -> Doc -> Doc
<+> Tidy -> [PVar RSort] -> Doc
forall a. PPrint a => Tidy -> [a] -> Doc
ppComm     Tidy
k (TyConP -> [PVar RSort]
tcpFreePredTy   TyConP
tc)

ppComm :: F.PPrint a => F.Tidy -> [a] -> Doc
ppComm :: forall a. PPrint a => Tidy -> [a] -> Doc
ppComm Tidy
k = Doc -> Doc
parens (Doc -> Doc) -> ([a] -> Doc) -> [a] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
hsep ([Doc] -> Doc) -> ([a] -> [Doc]) -> [a] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> [Doc] -> [Doc]
punctuate Doc
comma ([Doc] -> [Doc]) -> ([a] -> [Doc]) -> [a] -> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Doc) -> [a] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Tidy -> a -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k)

instance F.PPrint TyCon where
  pprintTidy :: Tidy -> TyCon -> Doc
pprintTidy Tidy
F.Lossy = Doc -> Doc
shortModules (Doc -> Doc) -> (TyCon -> Doc) -> TyCon -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyCon -> Doc
forall a. Outputable a => a -> Doc
pprDoc
    where
      shortModules :: Doc -> Doc
shortModules = String -> Doc
text (String -> Doc) -> (Doc -> String) -> Doc -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> String
F.symbolString (Symbol -> String) -> (Doc -> Symbol) -> Doc -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> Symbol
dropModuleNames (Symbol -> Symbol) -> (Doc -> Symbol) -> Doc -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol (String -> Symbol) -> (Doc -> String) -> Doc -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> String
render
  pprintTidy Tidy
F.Full  =                TyCon -> Doc
forall a. Outputable a => a -> Doc
pprDoc

-- | Termination expressions
type SizeFun = SizeFunV F.Symbol
data SizeFunV v
  = IdSizeFun              -- ^ \x -> F.EVar x
  | SymSizeFun (F.Located v) -- ^ \x -> f x
  deriving (Typeable (SizeFunV v)
Typeable (SizeFunV v) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SizeFunV v -> c (SizeFunV v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SizeFunV v))
-> (SizeFunV v -> Constr)
-> (SizeFunV v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SizeFunV v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SizeFunV v)))
-> ((forall b. Data b => b -> b) -> SizeFunV v -> SizeFunV v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r)
-> (forall u. (forall d. Data d => d -> u) -> SizeFunV v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SizeFunV v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v))
-> Data (SizeFunV v)
SizeFunV v -> Constr
SizeFunV v -> DataType
(forall b. Data b => b -> b) -> SizeFunV v -> SizeFunV v
forall v. Data v => Typeable (SizeFunV v)
forall v. Data v => SizeFunV v -> Constr
forall v. Data v => SizeFunV v -> DataType
forall v.
Data v =>
(forall b. Data b => b -> b) -> SizeFunV v -> SizeFunV v
forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> SizeFunV v -> u
forall v u.
Data v =>
(forall d. Data d => d -> u) -> SizeFunV v -> [u]
forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SizeFunV v)
forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SizeFunV v -> c (SizeFunV v)
forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SizeFunV v))
forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SizeFunV v))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SizeFunV v -> u
forall u. (forall d. Data d => d -> u) -> SizeFunV v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SizeFunV v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SizeFunV v -> c (SizeFunV v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SizeFunV v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SizeFunV v))
$cgfoldl :: forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SizeFunV v -> c (SizeFunV v)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SizeFunV v -> c (SizeFunV v)
$cgunfold :: forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SizeFunV v)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SizeFunV v)
$ctoConstr :: forall v. Data v => SizeFunV v -> Constr
toConstr :: SizeFunV v -> Constr
$cdataTypeOf :: forall v. Data v => SizeFunV v -> DataType
dataTypeOf :: SizeFunV v -> DataType
$cdataCast1 :: forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SizeFunV v))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SizeFunV v))
$cdataCast2 :: forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SizeFunV v))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SizeFunV v))
$cgmapT :: forall v.
Data v =>
(forall b. Data b => b -> b) -> SizeFunV v -> SizeFunV v
gmapT :: (forall b. Data b => b -> b) -> SizeFunV v -> SizeFunV v
$cgmapQl :: forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
$cgmapQr :: forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SizeFunV v -> r
$cgmapQ :: forall v u.
Data v =>
(forall d. Data d => d -> u) -> SizeFunV v -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SizeFunV v -> [u]
$cgmapQi :: forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> SizeFunV v -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SizeFunV v -> u
$cgmapM :: forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
$cgmapMp :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
$cgmapMo :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SizeFunV v -> m (SizeFunV v)
Data, (forall x. SizeFunV v -> Rep (SizeFunV v) x)
-> (forall x. Rep (SizeFunV v) x -> SizeFunV v)
-> Generic (SizeFunV v)
forall x. Rep (SizeFunV v) x -> SizeFunV v
forall x. SizeFunV v -> Rep (SizeFunV v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (SizeFunV v) x -> SizeFunV v
forall v x. SizeFunV v -> Rep (SizeFunV v) x
$cfrom :: forall v x. SizeFunV v -> Rep (SizeFunV v) x
from :: forall x. SizeFunV v -> Rep (SizeFunV v) x
$cto :: forall v x. Rep (SizeFunV v) x -> SizeFunV v
to :: forall x. Rep (SizeFunV v) x -> SizeFunV v
Generic, SizeFunV v -> SizeFunV v -> Bool
(SizeFunV v -> SizeFunV v -> Bool)
-> (SizeFunV v -> SizeFunV v -> Bool) -> Eq (SizeFunV v)
forall v. Eq v => SizeFunV v -> SizeFunV v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall v. Eq v => SizeFunV v -> SizeFunV v -> Bool
== :: SizeFunV v -> SizeFunV v -> Bool
$c/= :: forall v. Eq v => SizeFunV v -> SizeFunV v -> Bool
/= :: SizeFunV v -> SizeFunV v -> Bool
Eq, (forall a b. (a -> b) -> SizeFunV a -> SizeFunV b)
-> (forall a b. a -> SizeFunV b -> SizeFunV a) -> Functor SizeFunV
forall a b. a -> SizeFunV b -> SizeFunV a
forall a b. (a -> b) -> SizeFunV a -> SizeFunV b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> SizeFunV a -> SizeFunV b
fmap :: forall a b. (a -> b) -> SizeFunV a -> SizeFunV b
$c<$ :: forall a b. a -> SizeFunV b -> SizeFunV a
<$ :: forall a b. a -> SizeFunV b -> SizeFunV a
Functor, (forall m. Monoid m => SizeFunV m -> m)
-> (forall m a. Monoid m => (a -> m) -> SizeFunV a -> m)
-> (forall m a. Monoid m => (a -> m) -> SizeFunV a -> m)
-> (forall a b. (a -> b -> b) -> b -> SizeFunV a -> b)
-> (forall a b. (a -> b -> b) -> b -> SizeFunV a -> b)
-> (forall b a. (b -> a -> b) -> b -> SizeFunV a -> b)
-> (forall b a. (b -> a -> b) -> b -> SizeFunV a -> b)
-> (forall a. (a -> a -> a) -> SizeFunV a -> a)
-> (forall a. (a -> a -> a) -> SizeFunV a -> a)
-> (forall a. SizeFunV a -> [a])
-> (forall a. SizeFunV a -> Bool)
-> (forall a. SizeFunV a -> Int)
-> (forall a. Eq a => a -> SizeFunV a -> Bool)
-> (forall a. Ord a => SizeFunV a -> a)
-> (forall a. Ord a => SizeFunV a -> a)
-> (forall a. Num a => SizeFunV a -> a)
-> (forall a. Num a => SizeFunV a -> a)
-> Foldable SizeFunV
forall a. Eq a => a -> SizeFunV a -> Bool
forall a. Num a => SizeFunV a -> a
forall a. Ord a => SizeFunV a -> a
forall m. Monoid m => SizeFunV m -> m
forall a. SizeFunV a -> Bool
forall a. SizeFunV a -> Int
forall a. SizeFunV a -> [a]
forall a. (a -> a -> a) -> SizeFunV a -> a
forall m a. Monoid m => (a -> m) -> SizeFunV a -> m
forall b a. (b -> a -> b) -> b -> SizeFunV a -> b
forall a b. (a -> b -> b) -> b -> SizeFunV a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => SizeFunV m -> m
fold :: forall m. Monoid m => SizeFunV m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SizeFunV a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> SizeFunV a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SizeFunV a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> SizeFunV a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> SizeFunV a -> b
foldr :: forall a b. (a -> b -> b) -> b -> SizeFunV a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SizeFunV a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> SizeFunV a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SizeFunV a -> b
foldl :: forall b a. (b -> a -> b) -> b -> SizeFunV a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SizeFunV a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> SizeFunV a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> SizeFunV a -> a
foldr1 :: forall a. (a -> a -> a) -> SizeFunV a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SizeFunV a -> a
foldl1 :: forall a. (a -> a -> a) -> SizeFunV a -> a
$ctoList :: forall a. SizeFunV a -> [a]
toList :: forall a. SizeFunV a -> [a]
$cnull :: forall a. SizeFunV a -> Bool
null :: forall a. SizeFunV a -> Bool
$clength :: forall a. SizeFunV a -> Int
length :: forall a. SizeFunV a -> Int
$celem :: forall a. Eq a => a -> SizeFunV a -> Bool
elem :: forall a. Eq a => a -> SizeFunV a -> Bool
$cmaximum :: forall a. Ord a => SizeFunV a -> a
maximum :: forall a. Ord a => SizeFunV a -> a
$cminimum :: forall a. Ord a => SizeFunV a -> a
minimum :: forall a. Ord a => SizeFunV a -> a
$csum :: forall a. Num a => SizeFunV a -> a
sum :: forall a. Num a => SizeFunV a -> a
$cproduct :: forall a. Num a => SizeFunV a -> a
product :: forall a. Num a => SizeFunV a -> a
Foldable, Functor SizeFunV
Foldable SizeFunV
(Functor SizeFunV, Foldable SizeFunV) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> SizeFunV a -> f (SizeFunV b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SizeFunV (f a) -> f (SizeFunV a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SizeFunV a -> m (SizeFunV b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SizeFunV (m a) -> m (SizeFunV a))
-> Traversable SizeFunV
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => SizeFunV (m a) -> m (SizeFunV a)
forall (f :: * -> *) a.
Applicative f =>
SizeFunV (f a) -> f (SizeFunV a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SizeFunV a -> m (SizeFunV b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SizeFunV a -> f (SizeFunV b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SizeFunV a -> f (SizeFunV b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SizeFunV a -> f (SizeFunV b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SizeFunV (f a) -> f (SizeFunV a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
SizeFunV (f a) -> f (SizeFunV a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SizeFunV a -> m (SizeFunV b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SizeFunV a -> m (SizeFunV b)
$csequence :: forall (m :: * -> *) a. Monad m => SizeFunV (m a) -> m (SizeFunV a)
sequence :: forall (m :: * -> *) a. Monad m => SizeFunV (m a) -> m (SizeFunV a)
Traversable)
  deriving (Get (SizeFunV v)
[SizeFunV v] -> Put
SizeFunV v -> Put
(SizeFunV v -> Put)
-> Get (SizeFunV v) -> ([SizeFunV v] -> Put) -> Binary (SizeFunV v)
forall v. Binary v => Get (SizeFunV v)
forall v. Binary v => [SizeFunV v] -> Put
forall v. Binary v => SizeFunV v -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall v. Binary v => SizeFunV v -> Put
put :: SizeFunV v -> Put
$cget :: forall v. Binary v => Get (SizeFunV v)
get :: Get (SizeFunV v)
$cputList :: forall v. Binary v => [SizeFunV v] -> Put
putList :: [SizeFunV v] -> Put
B.Binary, Eq (SizeFunV v)
Eq (SizeFunV v) =>
(Int -> SizeFunV v -> Int)
-> (SizeFunV v -> Int) -> Hashable (SizeFunV v)
Int -> SizeFunV v -> Int
SizeFunV v -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall v. Hashable v => Eq (SizeFunV v)
forall v. Hashable v => Int -> SizeFunV v -> Int
forall v. Hashable v => SizeFunV v -> Int
$chashWithSalt :: forall v. Hashable v => Int -> SizeFunV v -> Int
hashWithSalt :: Int -> SizeFunV v -> Int
$chash :: forall v. Hashable v => SizeFunV v -> Int
hash :: SizeFunV v -> Int
Hashable) via Generically (SizeFunV v)

instance NFData v => NFData (SizeFunV v)

instance Show v => Show (SizeFunV v) where
  show :: SizeFunV v -> String
show SizeFunV v
IdSizeFun      = String
"IdSizeFun"
  show (SymSizeFun Located v
x) = String
"SymSizeFun " String -> ShowS
forall a. [a] -> [a] -> [a]
++ v -> String
forall a. Show a => a -> String
show (Located v -> v
forall a. Located a -> a
F.val Located v
x)

szFun :: SizeFun -> Symbol -> Expr
szFun :: SizeFun -> Symbol -> Expr
szFun SizeFun
IdSizeFun      = Symbol -> Expr
forall b v. v -> ExprBV b v
F.EVar
szFun (SymSizeFun Located Symbol
f) = \Symbol
x -> Located Symbol -> [Expr] -> Expr
forall v b. Located v -> [ExprBV b v] -> ExprBV b v
F.mkEApp Located Symbol
f [Symbol -> Expr
forall b v. v -> ExprBV b v
F.EVar Symbol
x]

instance F.PPrint v => F.PPrint (SizeFunV v) where
  pprintTidy :: Tidy -> SizeFunV v -> Doc
pprintTidy Tidy
_ SizeFunV v
IdSizeFun      = Doc
"[id]"
  pprintTidy Tidy
_ (SymSizeFun Located v
x) = Doc -> Doc
brackets (v -> Doc
forall a. PPrint a => a -> Doc
F.pprint (v -> Doc) -> v -> Doc
forall a b. (a -> b) -> a -> b
$ Located v -> v
forall a. Located a -> a
F.val Located v
x)


--------------------------------------------------------------------
-- | Abstract Predicate Variables ----------------------------------
--------------------------------------------------------------------

type PVar t = PVarV Symbol t
type PVarV v t = PVarBV Symbol v t
data PVarBV b v t = PV
  { forall b v t. PVarBV b v t -> b
pname :: !b
  , forall b v t. PVarBV b v t -> t
ptype :: !t
  , forall b v t. PVarBV b v t -> b
parg  :: !b
  , forall b v t. PVarBV b v t -> [(t, b, ExprBV b v)]
pargs :: ![(t, b, F.ExprBV b v)]
  } deriving ((forall x. PVarBV b v t -> Rep (PVarBV b v t) x)
-> (forall x. Rep (PVarBV b v t) x -> PVarBV b v t)
-> Generic (PVarBV b v t)
forall x. Rep (PVarBV b v t) x -> PVarBV b v t
forall x. PVarBV b v t -> Rep (PVarBV b v t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b v t x. Rep (PVarBV b v t) x -> PVarBV b v t
forall b v t x. PVarBV b v t -> Rep (PVarBV b v t) x
$cfrom :: forall b v t x. PVarBV b v t -> Rep (PVarBV b v t) x
from :: forall x. PVarBV b v t -> Rep (PVarBV b v t) x
$cto :: forall b v t x. Rep (PVarBV b v t) x -> PVarBV b v t
to :: forall x. Rep (PVarBV b v t) x -> PVarBV b v t
Generic, Typeable (PVarBV b v t)
Typeable (PVarBV b v t) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PVarBV b v t -> c (PVarBV b v t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PVarBV b v t))
-> (PVarBV b v t -> Constr)
-> (PVarBV b v t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PVarBV b v t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PVarBV b v t)))
-> ((forall b. Data b => b -> b) -> PVarBV b v t -> PVarBV b v t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r)
-> (forall u. (forall d. Data d => d -> u) -> PVarBV b v t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PVarBV b v t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t))
-> Data (PVarBV b v t)
PVarBV b v t -> Constr
PVarBV b v t -> DataType
(forall b. Data b => b -> b) -> PVarBV b v t -> PVarBV b v t
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PVarBV b v t -> u
forall u. (forall d. Data d => d -> u) -> PVarBV b v t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
forall b v t. (Data t, Data v, Data b) => Typeable (PVarBV b v t)
forall b v t. (Data t, Data v, Data b) => PVarBV b v t -> Constr
forall b v t. (Data t, Data v, Data b) => PVarBV b v t -> DataType
forall b v t.
(Data t, Data v, Data b) =>
(forall b. Data b => b -> b) -> PVarBV b v t -> PVarBV b v t
forall b v t u.
(Data t, Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> PVarBV b v t -> u
forall b v t u.
(Data t, Data v, Data b) =>
(forall d. Data d => d -> u) -> PVarBV b v t -> [u]
forall b v t r r'.
(Data t, Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
forall b v t r r'.
(Data t, Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
forall b v t (m :: * -> *).
(Data t, Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
forall b v t (m :: * -> *).
(Data t, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
forall b v t (c :: * -> *).
(Data t, Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PVarBV b v t)
forall b v t (c :: * -> *).
(Data t, Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVarBV b v t -> c (PVarBV b v t)
forall b v t (t :: * -> *) (c :: * -> *).
(Data t, Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PVarBV b v t))
forall b v t (t :: * -> * -> *) (c :: * -> *).
(Data t, Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PVarBV b v t))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PVarBV b v t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVarBV b v t -> c (PVarBV b v t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PVarBV b v t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PVarBV b v t))
$cgfoldl :: forall b v t (c :: * -> *).
(Data t, Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVarBV b v t -> c (PVarBV b v t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PVarBV b v t -> c (PVarBV b v t)
$cgunfold :: forall b v t (c :: * -> *).
(Data t, Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PVarBV b v t)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PVarBV b v t)
$ctoConstr :: forall b v t. (Data t, Data v, Data b) => PVarBV b v t -> Constr
toConstr :: PVarBV b v t -> Constr
$cdataTypeOf :: forall b v t. (Data t, Data v, Data b) => PVarBV b v t -> DataType
dataTypeOf :: PVarBV b v t -> DataType
$cdataCast1 :: forall b v t (t :: * -> *) (c :: * -> *).
(Data t, Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PVarBV b v t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PVarBV b v t))
$cdataCast2 :: forall b v t (t :: * -> * -> *) (c :: * -> *).
(Data t, Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PVarBV b v t))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PVarBV b v t))
$cgmapT :: forall b v t.
(Data t, Data v, Data b) =>
(forall b. Data b => b -> b) -> PVarBV b v t -> PVarBV b v t
gmapT :: (forall b. Data b => b -> b) -> PVarBV b v t -> PVarBV b v t
$cgmapQl :: forall b v t r r'.
(Data t, Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
$cgmapQr :: forall b v t r r'.
(Data t, Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PVarBV b v t -> r
$cgmapQ :: forall b v t u.
(Data t, Data v, Data b) =>
(forall d. Data d => d -> u) -> PVarBV b v t -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PVarBV b v t -> [u]
$cgmapQi :: forall b v t u.
(Data t, Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> PVarBV b v t -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PVarBV b v t -> u
$cgmapM :: forall b v t (m :: * -> *).
(Data t, Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
$cgmapMp :: forall b v t (m :: * -> *).
(Data t, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
$cgmapMo :: forall b v t (m :: * -> *).
(Data t, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PVarBV b v t -> m (PVarBV b v t)
Data, Int -> PVarBV b v t -> ShowS
[PVarBV b v t] -> ShowS
PVarBV b v t -> String
(Int -> PVarBV b v t -> ShowS)
-> (PVarBV b v t -> String)
-> ([PVarBV b v t] -> ShowS)
-> Show (PVarBV b v t)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
Int -> PVarBV b v t -> ShowS
forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
[PVarBV b v t] -> ShowS
forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
PVarBV b v t -> String
$cshowsPrec :: forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
Int -> PVarBV b v t -> ShowS
showsPrec :: Int -> PVarBV b v t -> ShowS
$cshow :: forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
PVarBV b v t -> String
show :: PVarBV b v t -> String
$cshowList :: forall b v t.
(Show t, Show v, Show b, Ord v, Ord b, Fixpoint v, Fixpoint b,
 Hashable b) =>
[PVarBV b v t] -> ShowS
showList :: [PVarBV b v t] -> ShowS
Show, (forall a b. (a -> b) -> PVarBV b v a -> PVarBV b v b)
-> (forall a b. a -> PVarBV b v b -> PVarBV b v a)
-> Functor (PVarBV b v)
forall a b. a -> PVarBV b v b -> PVarBV b v a
forall a b. (a -> b) -> PVarBV b v a -> PVarBV b v b
forall b v a b. a -> PVarBV b v b -> PVarBV b v a
forall b v a b. (a -> b) -> PVarBV b v a -> PVarBV b v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall b v a b. (a -> b) -> PVarBV b v a -> PVarBV b v b
fmap :: forall a b. (a -> b) -> PVarBV b v a -> PVarBV b v b
$c<$ :: forall b v a b. a -> PVarBV b v b -> PVarBV b v a
<$ :: forall a b. a -> PVarBV b v b -> PVarBV b v a
Functor)
  deriving Get (PVarBV b v t)
[PVarBV b v t] -> Put
PVarBV b v t -> Put
(PVarBV b v t -> Put)
-> Get (PVarBV b v t)
-> ([PVarBV b v t] -> Put)
-> Binary (PVarBV b v t)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall b v t. (Binary v, Binary b, Binary t) => Get (PVarBV b v t)
forall b v t.
(Binary v, Binary b, Binary t) =>
[PVarBV b v t] -> Put
forall b v t. (Binary v, Binary b, Binary t) => PVarBV b v t -> Put
$cput :: forall b v t. (Binary v, Binary b, Binary t) => PVarBV b v t -> Put
put :: PVarBV b v t -> Put
$cget :: forall b v t. (Binary v, Binary b, Binary t) => Get (PVarBV b v t)
get :: Get (PVarBV b v t)
$cputList :: forall b v t.
(Binary v, Binary b, Binary t) =>
[PVarBV b v t] -> Put
putList :: [PVarBV b v t] -> Put
B.Binary via Generically (PVarBV b v t)

mapPVarV :: (v -> v') -> (t -> t') -> PVarBV b v t -> PVarBV b v' t'
mapPVarV :: forall v v' t t' b.
(v -> v') -> (t -> t') -> PVarBV b v t -> PVarBV b v' t'
mapPVarV v -> v'
f t -> t'
g PV {t
b
[(t, b, ExprBV b v)]
pname :: forall b v t. PVarBV b v t -> b
parg :: forall b v t. PVarBV b v t -> b
ptype :: forall b v t. PVarBV b v t -> t
pargs :: forall b v t. PVarBV b v t -> [(t, b, ExprBV b v)]
pname :: b
ptype :: t
parg :: b
pargs :: [(t, b, ExprBV b v)]
..} =
    PV
      { ptype :: t'
ptype = t -> t'
g t
ptype
      , pargs :: [(t', b, ExprBV b v')]
pargs = [ (t -> t'
g t
t, b
s, (v -> v') -> ExprBV b v -> ExprBV b v'
forall a b. (a -> b) -> ExprBV b a -> ExprBV b b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap v -> v'
f ExprBV b v
e) | (t
t, b
s, ExprBV b v
e) <- [(t, b, ExprBV b v)]
pargs ]
      , b
pname :: b
parg :: b
pname :: b
parg :: b
..
      }

-- | A map traversal that collects the local variables in scope
emapPVarVM :: (Monad m, Hashable b) => ([b] -> v -> m v') -> ([b] -> t -> m t') -> PVarBV b v t -> m (PVarBV b v' t')
emapPVarVM :: forall (m :: * -> *) b v v' t t'.
(Monad m, Hashable b) =>
([b] -> v -> m v')
-> ([b] -> t -> m t') -> PVarBV b v t -> m (PVarBV b v' t')
emapPVarVM [b] -> v -> m v'
f [b] -> t -> m t'
g PVarBV b v t
pv = do
    ptype <- [b] -> t -> m t'
g ([(t, b, ExprBV b v)] -> [b]
forall {a} {b} {c}. [(a, b, c)] -> [b]
argSyms (PVarBV b v t -> [(t, b, ExprBV b v)]
forall b v t. PVarBV b v t -> [(t, b, ExprBV b v)]
pargs PVarBV b v t
pv)) (PVarBV b v t -> t
forall b v t. PVarBV b v t -> t
ptype PVarBV b v t
pv)
    (_, pargs) <- forAccumM [] (pargs pv) $ \[b]
ss (t
t, b
s, ExprBV b v
e) -> do
      (b
sb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
ss,) ((t', b, ExprBV b v') -> ([b], (t', b, ExprBV b v')))
-> m (t', b, ExprBV b v') -> m ([b], (t', b, ExprBV b v'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((,,) (t' -> b -> ExprBV b v' -> (t', b, ExprBV b v'))
-> m t' -> m (b -> ExprBV b v' -> (t', b, ExprBV b v'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> t -> m t'
g (b
sb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
ss) t
t m (b -> ExprBV b v' -> (t', b, ExprBV b v'))
-> m b -> m (ExprBV b v' -> (t', b, ExprBV b v'))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> m b
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
s m (ExprBV b v' -> (t', b, ExprBV b v'))
-> m (ExprBV b v') -> m (t', b, ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
forall (m :: * -> *) b v v'.
(Monad m, Hashable b) =>
([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
emapExprVM ([b] -> v -> m v'
f ([b] -> v -> m v') -> ([b] -> [b]) -> [b] -> v -> m v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((b
sb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
ss) [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++)) ExprBV b v
e)
    return pv{ptype, pargs}
  where
    argSyms :: [(a, b, c)] -> [b]
argSyms = ((a, b, c) -> b) -> [(a, b, c)] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map (\(a
_, b
s, c
_) -> b
s)

instance Eq b => Eq (PVarBV b v t) where
  PVarBV b v t
pv == :: PVarBV b v t -> PVarBV b v t -> Bool
== PVarBV b v t
pv' = PVarBV b v t -> b
forall b v t. PVarBV b v t -> b
pname PVarBV b v t
pv b -> b -> Bool
forall a. Eq a => a -> a -> Bool
== PVarBV b v t -> b
forall b v t. PVarBV b v t -> b
pname PVarBV b v t
pv' {- UNIFY: What about: && eqArgs pv pv' -}

instance Ord b => Ord (PVarBV b v t) where
  compare :: PVarBV b v t -> PVarBV b v t -> Ordering
compare (PV b
n t
_ b
_ [(t, b, ExprBV b v)]
_)  (PV b
n' t
_ b
_ [(t, b, ExprBV b v)]
_) = b -> b -> Ordering
forall a. Ord a => a -> a -> Ordering
compare b
n b
n'

instance (NFData b, NFData v, NFData t) => NFData (PVarBV b v t)

instance Hashable b => Hashable (PVarBV b v a) where
  hashWithSalt :: Int -> PVarBV b v a -> Int
hashWithSalt Int
i (PV b
n a
_ b
_ [(a, b, ExprBV b v)]
_) = Int -> b -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
i b
n

pvType :: PVarBV b v t -> t
pvType :: forall b v t. PVarBV b v t -> t
pvType = PVarBV b v t -> t
forall b v t. PVarBV b v t -> t
ptype

instance (Ord b, F.Fixpoint b, Hashable b, F.PPrint b, Ord v, F.Fixpoint v, F.PPrint v) => F.PPrint (PVarBV b v a) where
  pprintTidy :: Tidy -> PVarBV b v a -> Doc
pprintTidy Tidy
_ = PVarBV b v a -> Doc
forall b v a.
(Ord b, Fixpoint b, Hashable b, PPrint b, Ord v, Fixpoint v,
 PPrint v) =>
PVarBV b v a -> Doc
pprPvar

pprPvar :: (Ord b, F.Fixpoint b, Hashable b, F.PPrint b, Ord v, F.Fixpoint v, F.PPrint v) => PVarBV b v a -> Doc
pprPvar :: forall b v a.
(Ord b, Fixpoint b, Hashable b, PPrint b, Ord v, Fixpoint v,
 PPrint v) =>
PVarBV b v a -> Doc
pprPvar (PV b
s a
_ b
_ [(a, b, ExprBV b v)]
xts) = b -> Doc
forall a. PPrint a => a -> Doc
F.pprint b
s Doc -> Doc -> Doc
<+> [Doc] -> Doc
hsep (ExprBV b v -> Doc
forall a. PPrint a => a -> Doc
F.pprint (ExprBV b v -> Doc)
-> ((a, b, ExprBV b v) -> ExprBV b v) -> (a, b, ExprBV b v) -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, b, ExprBV b v) -> ExprBV b v
forall a b c. (a, b, c) -> c
thd3 ((a, b, ExprBV b v) -> Doc) -> [(a, b, ExprBV b v)] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(a, b, ExprBV b v)]
xts)

-- | A map traversal that collects the local variables in scope
emapExprVM :: (Monad m, Hashable b) => ([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
emapExprVM :: forall (m :: * -> *) b v v'.
(Monad m, Hashable b) =>
([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
emapExprVM [b] -> v -> m v'
f = [b] -> ExprBV b v -> m (ExprBV b v')
go []
  where
    go :: [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc = \case
      ESym SymConst
c -> ExprBV b v' -> m (ExprBV b v')
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExprBV b v' -> m (ExprBV b v')) -> ExprBV b v' -> m (ExprBV b v')
forall a b. (a -> b) -> a -> b
$ SymConst -> ExprBV b v'
forall b v. SymConst -> ExprBV b v
ESym SymConst
c
      ECon Constant
c -> ExprBV b v' -> m (ExprBV b v')
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExprBV b v' -> m (ExprBV b v')) -> ExprBV b v' -> m (ExprBV b v')
forall a b. (a -> b) -> a -> b
$ Constant -> ExprBV b v'
forall b v. Constant -> ExprBV b v
ECon Constant
c
      EVar v
v -> v' -> ExprBV b v'
forall b v. v -> ExprBV b v
EVar (v' -> ExprBV b v') -> m v' -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> v -> m v'
f [b]
acc v
v
      EApp ExprBV b v
e0 ExprBV b v
e1 -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v -> ExprBV b v
EApp (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1
      ENeg ExprBV b v
e -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v
ENeg (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      EBin Bop
bop ExprBV b v
e0 ExprBV b v
e1 -> Bop -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. Bop -> ExprBV b v -> ExprBV b v -> ExprBV b v
EBin Bop
bop (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1
      EIte ExprBV b v
e0 ExprBV b v
e1 ExprBV b v
e2 -> ExprBV b v' -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v -> ExprBV b v -> ExprBV b v
EIte (ExprBV b v' -> ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e2
      ECst ExprBV b v
e Sort
s -> (ExprBV b v' -> Sort -> ExprBV b v')
-> Sort -> ExprBV b v' -> ExprBV b v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprBV b v' -> Sort -> ExprBV b v'
forall b v. ExprBV b v -> Sort -> ExprBV b v
ECst Sort
s (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      ELam (b
s,Sort
srt) ExprBV b v
e -> (b, Sort) -> ExprBV b v' -> ExprBV b v'
forall b v. (b, Sort) -> ExprBV b v -> ExprBV b v
ELam (b
s, Sort
srt) (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go (b
sb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
acc) ExprBV b v
e
      ETApp ExprBV b v
e Sort
s -> (ExprBV b v' -> Sort -> ExprBV b v')
-> Sort -> ExprBV b v' -> ExprBV b v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprBV b v' -> Sort -> ExprBV b v'
forall b v. ExprBV b v -> Sort -> ExprBV b v
ETApp Sort
s (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      ETAbs ExprBV b v
e b
s -> (ExprBV b v' -> b -> ExprBV b v')
-> b -> ExprBV b v' -> ExprBV b v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprBV b v' -> b -> ExprBV b v'
forall b v. ExprBV b v -> b -> ExprBV b v
ETAbs b
s (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      PAnd [ExprBV b v]
xs -> [ExprBV b v'] -> ExprBV b v'
forall b v. [ExprBV b v] -> ExprBV b v
PAnd ([ExprBV b v'] -> ExprBV b v')
-> m [ExprBV b v'] -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ExprBV b v -> m (ExprBV b v')) -> [ExprBV b v] -> m [ExprBV b v']
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc) [ExprBV b v]
xs
      POr [ExprBV b v]
xs -> [ExprBV b v'] -> ExprBV b v'
forall b v. [ExprBV b v] -> ExprBV b v
POr ([ExprBV b v'] -> ExprBV b v')
-> m [ExprBV b v'] -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ExprBV b v -> m (ExprBV b v')) -> [ExprBV b v] -> m [ExprBV b v']
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc) [ExprBV b v]
xs
      PNot ExprBV b v
e -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v
PNot (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      PImp ExprBV b v
e0 ExprBV b v
e1 -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v -> ExprBV b v
PImp (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1
      PIff ExprBV b v
e0 ExprBV b v
e1 -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. ExprBV b v -> ExprBV b v -> ExprBV b v
PIff (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1
      PAtom Brel
brel ExprBV b v
e0 ExprBV b v
e1 -> Brel -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. Brel -> ExprBV b v -> ExprBV b v -> ExprBV b v
PAtom Brel
brel (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e0 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1
      PKVar KVar
k TyVarSubst
tsu KVarSubst b v
su -> KVar -> TyVarSubst -> KVarSubst b v' -> ExprBV b v'
forall b v. KVar -> TyVarSubst -> KVarSubst b v -> ExprBV b v
PKVar KVar
k TyVarSubst
tsu (KVarSubst b v' -> ExprBV b v')
-> m (KVarSubst b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([b] -> v -> m v') -> KVarSubst b v -> m (KVarSubst b v')
forall (m :: * -> *) b v v'.
(Monad m, Hashable b) =>
([b] -> v -> m v') -> KVarSubst b v -> m (KVarSubst b v')
emapSubstVM ([b] -> v -> m v'
f ([b] -> v -> m v') -> ([b] -> [b]) -> [b] -> v -> m v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (KVarSubst b v -> [b]
forall {k} {v}. Hashable k => KVarSubst k v -> [k]
domain KVarSubst b v
su [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++) ([b] -> [b]) -> ([b] -> [b]) -> [b] -> [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([b]
acc [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++)) KVarSubst b v
su
      PAll [(b, Sort)]
bnds ExprBV b v
e -> [(b, Sort)] -> ExprBV b v' -> ExprBV b v'
forall b v. [(b, Sort)] -> ExprBV b v -> ExprBV b v
PAll [(b, Sort)]
bnds (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go (((b, Sort) -> b) -> [(b, Sort)] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map (b, Sort) -> b
forall a b. (a, b) -> a
fst [(b, Sort)]
bnds [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++ [b]
acc) ExprBV b v
e
      PExist [(b, Sort)]
bnds ExprBV b v
e -> [(b, Sort)] -> ExprBV b v' -> ExprBV b v'
forall b v. [(b, Sort)] -> ExprBV b v -> ExprBV b v
PExist [(b, Sort)]
bnds (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go (((b, Sort) -> b) -> [(b, Sort)] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map (b, Sort) -> b
forall a b. (a, b) -> a
fst [(b, Sort)]
bnds [b] -> [b] -> [b]
forall a. [a] -> [a] -> [a]
++ [b]
acc) ExprBV b v
e
      ECoerc Sort
srt0 Sort
srt1 ExprBV b v
e -> Sort -> Sort -> ExprBV b v' -> ExprBV b v'
forall b v. Sort -> Sort -> ExprBV b v -> ExprBV b v
ECoerc Sort
srt0 Sort
srt1 (ExprBV b v' -> ExprBV b v') -> m (ExprBV b v') -> m (ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e
      ELet b
x ExprBV b v
e1 ExprBV b v
e2 -> b -> ExprBV b v' -> ExprBV b v' -> ExprBV b v'
forall b v. b -> ExprBV b v -> ExprBV b v -> ExprBV b v
ELet b
x (ExprBV b v' -> ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v' -> ExprBV b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [b] -> ExprBV b v -> m (ExprBV b v')
go [b]
acc ExprBV b v
e1 m (ExprBV b v' -> ExprBV b v')
-> m (ExprBV b v') -> m (ExprBV b v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [b] -> ExprBV b v -> m (ExprBV b v')
go (b
xb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
acc) ExprBV b v
e2

    domain :: KVarSubst k v -> [k]
domain KVarSubst k v
m = HashMap k (ExprBV k v) -> [k]
forall k v. HashMap k v -> [k]
M.keys (HashMap k (ExprBV k v) -> [k]) -> HashMap k (ExprBV k v) -> [k]
forall a b. (a -> b) -> a -> b
$ KVarSubst k v -> HashMap k (ExprBV k v)
forall b v. Hashable b => KVarSubst b v -> HashMap b (ExprBV b v)
F.fromKVarSubst KVarSubst k v
m

emapSubstVM :: (Monad m, Hashable b) => ([b] -> v -> m v') -> KVarSubst b v -> m (KVarSubst b v')
emapSubstVM :: forall (m :: * -> *) b v v'.
(Monad m, Hashable b) =>
([b] -> v -> m v') -> KVarSubst b v -> m (KVarSubst b v')
emapSubstVM [b] -> v -> m v'
f KVarSubst b v
m = HashMap b (ExprBV b v') -> KVarSubst b v'
forall b v. HashMap b (ExprBV b v) -> KVarSubst b v
F.toKVarSubst (HashMap b (ExprBV b v') -> KVarSubst b v')
-> ([(b, ExprBV b v')] -> HashMap b (ExprBV b v'))
-> [(b, ExprBV b v')]
-> KVarSubst b v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(b, ExprBV b v')] -> HashMap b (ExprBV b v')
forall k v. Hashable k => [(k, v)] -> HashMap k v
M.fromList ([(b, ExprBV b v')] -> KVarSubst b v')
-> m [(b, ExprBV b v')] -> m (KVarSubst b v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((b, ExprBV b v) -> m (b, ExprBV b v'))
-> [(b, ExprBV b v)] -> m [(b, ExprBV b v')]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ExprBV b v -> m (ExprBV b v'))
-> (b, ExprBV b v) -> m (b, ExprBV b v')
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) -> (b, a) -> f (b, b)
traverse (([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
forall (m :: * -> *) b v v'.
(Monad m, Hashable b) =>
([b] -> v -> m v') -> ExprBV b v -> m (ExprBV b v')
emapExprVM [b] -> v -> m v'
f)) (HashMap b (ExprBV b v) -> [(b, ExprBV b v)]
forall k v. HashMap k v -> [(k, v)]
M.toList (HashMap b (ExprBV b v) -> [(b, ExprBV b v)])
-> HashMap b (ExprBV b v) -> [(b, ExprBV b v)]
forall a b. (a -> b) -> a -> b
$ KVarSubst b v -> HashMap b (ExprBV b v)
forall b v. Hashable b => KVarSubst b v -> HashMap b (ExprBV b v)
F.fromKVarSubst KVarSubst b v
m)

--------------------------------------------------------------------------------
-- | Predicates ----------------------------------------------------------------
--------------------------------------------------------------------------------

type UsedPVar    = UsedPVarV Symbol
type UsedPVarV v = UsedPVarBV Symbol v
type UsedPVarBV b v = PVarBV b v ()

type Predicate = PredicateV Symbol
type PredicateV v = PredicateBV Symbol v
newtype PredicateBV b v = Pr [UsedPVarBV b v]
  deriving ((forall x. PredicateBV b v -> Rep (PredicateBV b v) x)
-> (forall x. Rep (PredicateBV b v) x -> PredicateBV b v)
-> Generic (PredicateBV b v)
forall x. Rep (PredicateBV b v) x -> PredicateBV b v
forall x. PredicateBV b v -> Rep (PredicateBV b v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b v x. Rep (PredicateBV b v) x -> PredicateBV b v
forall b v x. PredicateBV b v -> Rep (PredicateBV b v) x
$cfrom :: forall b v x. PredicateBV b v -> Rep (PredicateBV b v) x
from :: forall x. PredicateBV b v -> Rep (PredicateBV b v) x
$cto :: forall b v x. Rep (PredicateBV b v) x -> PredicateBV b v
to :: forall x. Rep (PredicateBV b v) x -> PredicateBV b v
Generic, Typeable (PredicateBV b v)
Typeable (PredicateBV b v) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PredicateBV b v -> c (PredicateBV b v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PredicateBV b v))
-> (PredicateBV b v -> Constr)
-> (PredicateBV b v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PredicateBV b v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PredicateBV b v)))
-> ((forall b. Data b => b -> b)
    -> PredicateBV b v -> PredicateBV b v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PredicateBV b v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PredicateBV b v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PredicateBV b v -> m (PredicateBV b v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PredicateBV b v -> m (PredicateBV b v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PredicateBV b v -> m (PredicateBV b v))
-> Data (PredicateBV b v)
PredicateBV b v -> Constr
PredicateBV b v -> DataType
(forall b. Data b => b -> b) -> PredicateBV b v -> PredicateBV b v
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PredicateBV b v -> u
forall u. (forall d. Data d => d -> u) -> PredicateBV b v -> [u]
forall b v. (Data v, Data b) => Typeable (PredicateBV b v)
forall b v. (Data v, Data b) => PredicateBV b v -> Constr
forall b v. (Data v, Data b) => PredicateBV b v -> DataType
forall b v.
(Data v, Data b) =>
(forall b. Data b => b -> b) -> PredicateBV b v -> PredicateBV b v
forall b v u.
(Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> PredicateBV b v -> u
forall b v u.
(Data v, Data b) =>
(forall d. Data d => d -> u) -> PredicateBV b v -> [u]
forall b v r r'.
(Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
forall b v r r'.
(Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
forall b v (m :: * -> *).
(Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
forall b v (m :: * -> *).
(Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
forall b v (c :: * -> *).
(Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PredicateBV b v)
forall b v (c :: * -> *).
(Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PredicateBV b v -> c (PredicateBV b v)
forall b v (t :: * -> *) (c :: * -> *).
(Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PredicateBV b v))
forall b v (t :: * -> * -> *) (c :: * -> *).
(Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PredicateBV b v))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PredicateBV b v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PredicateBV b v -> c (PredicateBV b v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PredicateBV b v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PredicateBV b v))
$cgfoldl :: forall b v (c :: * -> *).
(Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PredicateBV b v -> c (PredicateBV b v)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PredicateBV b v -> c (PredicateBV b v)
$cgunfold :: forall b v (c :: * -> *).
(Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PredicateBV b v)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PredicateBV b v)
$ctoConstr :: forall b v. (Data v, Data b) => PredicateBV b v -> Constr
toConstr :: PredicateBV b v -> Constr
$cdataTypeOf :: forall b v. (Data v, Data b) => PredicateBV b v -> DataType
dataTypeOf :: PredicateBV b v -> DataType
$cdataCast1 :: forall b v (t :: * -> *) (c :: * -> *).
(Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PredicateBV b v))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PredicateBV b v))
$cdataCast2 :: forall b v (t :: * -> * -> *) (c :: * -> *).
(Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PredicateBV b v))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PredicateBV b v))
$cgmapT :: forall b v.
(Data v, Data b) =>
(forall b. Data b => b -> b) -> PredicateBV b v -> PredicateBV b v
gmapT :: (forall b. Data b => b -> b) -> PredicateBV b v -> PredicateBV b v
$cgmapQl :: forall b v r r'.
(Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
$cgmapQr :: forall b v r r'.
(Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PredicateBV b v -> r
$cgmapQ :: forall b v u.
(Data v, Data b) =>
(forall d. Data d => d -> u) -> PredicateBV b v -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PredicateBV b v -> [u]
$cgmapQi :: forall b v u.
(Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> PredicateBV b v -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PredicateBV b v -> u
$cgmapM :: forall b v (m :: * -> *).
(Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
$cgmapMp :: forall b v (m :: * -> *).
(Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
$cgmapMo :: forall b v (m :: * -> *).
(Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PredicateBV b v -> m (PredicateBV b v)
Data)
  deriving (Get (PredicateBV b v)
[PredicateBV b v] -> Put
PredicateBV b v -> Put
(PredicateBV b v -> Put)
-> Get (PredicateBV b v)
-> ([PredicateBV b v] -> Put)
-> Binary (PredicateBV b v)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall b v. (Binary v, Binary b) => Get (PredicateBV b v)
forall b v. (Binary v, Binary b) => [PredicateBV b v] -> Put
forall b v. (Binary v, Binary b) => PredicateBV b v -> Put
$cput :: forall b v. (Binary v, Binary b) => PredicateBV b v -> Put
put :: PredicateBV b v -> Put
$cget :: forall b v. (Binary v, Binary b) => Get (PredicateBV b v)
get :: Get (PredicateBV b v)
$cputList :: forall b v. (Binary v, Binary b) => [PredicateBV b v] -> Put
putList :: [PredicateBV b v] -> Put
B.Binary, Eq (PredicateBV b v)
Eq (PredicateBV b v) =>
(Int -> PredicateBV b v -> Int)
-> (PredicateBV b v -> Int) -> Hashable (PredicateBV b v)
Int -> PredicateBV b v -> Int
PredicateBV b v -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall b v. (Ord b, Ord v, Hashable b) => Eq (PredicateBV b v)
forall b v.
(Ord b, Ord v, Hashable b) =>
Int -> PredicateBV b v -> Int
forall b v. (Ord b, Ord v, Hashable b) => PredicateBV b v -> Int
$chashWithSalt :: forall b v.
(Ord b, Ord v, Hashable b) =>
Int -> PredicateBV b v -> Int
hashWithSalt :: Int -> PredicateBV b v -> Int
$chash :: forall b v. (Ord b, Ord v, Hashable b) => PredicateBV b v -> Int
hash :: PredicateBV b v -> Int
Hashable) via Generically (PredicateBV b v)

mapPredicateV :: (v -> v') -> PredicateV v -> PredicateV v'
mapPredicateV :: forall v v'. (v -> v') -> PredicateV v -> PredicateV v'
mapPredicateV v -> v'
f (Pr [UsedPVarBV Symbol v]
xs) = [UsedPVarBV Symbol v'] -> PredicateBV Symbol v'
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr ((UsedPVarBV Symbol v -> UsedPVarBV Symbol v')
-> [UsedPVarBV Symbol v] -> [UsedPVarBV Symbol v']
forall a b. (a -> b) -> [a] -> [b]
map ((v -> v')
-> (() -> ()) -> UsedPVarBV Symbol v -> UsedPVarBV Symbol v'
forall v v' t t' b.
(v -> v') -> (t -> t') -> PVarBV b v t -> PVarBV b v' t'
mapPVarV v -> v'
f (() -> () -> ()
forall a b. a -> b -> a
const ())) [UsedPVarBV Symbol v]
xs)

-- | A map traversal that collects the local variables in scope
emapPredicateVM :: Monad m => ([Symbol] -> v -> m v') -> PredicateV v -> m (PredicateV v')
emapPredicateVM :: forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> PredicateV v -> m (PredicateV v')
emapPredicateVM [Symbol] -> v -> m v'
f (Pr [UsedPVarBV Symbol v]
xs) = [UsedPVarBV Symbol v'] -> PredicateBV Symbol v'
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr ([UsedPVarBV Symbol v'] -> PredicateBV Symbol v')
-> m [UsedPVarBV Symbol v'] -> m (PredicateBV Symbol v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (UsedPVarBV Symbol v -> m (UsedPVarBV Symbol v'))
-> [UsedPVarBV Symbol v] -> m [UsedPVarBV Symbol v']
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (([Symbol] -> v -> m v')
-> ([Symbol] -> () -> m ())
-> UsedPVarBV Symbol v
-> m (UsedPVarBV Symbol v')
forall (m :: * -> *) b v v' t t'.
(Monad m, Hashable b) =>
([b] -> v -> m v')
-> ([b] -> t -> m t') -> PVarBV b v t -> m (PVarBV b v' t')
emapPVarVM [Symbol] -> v -> m v'
f (\[Symbol]
_ ()
_ -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())) [UsedPVarBV Symbol v]
xs

instance (Ord b, Ord v) => Eq (PredicateBV b v) where
  (Pr [UsedPVarBV b v]
vs) == :: PredicateBV b v -> PredicateBV b v -> Bool
== (Pr [UsedPVarBV b v]
ws)
      = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ ([UsedPVarBV b v] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [UsedPVarBV b v]
vs' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== [UsedPVarBV b v] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [UsedPVarBV b v]
ws') Bool -> [Bool] -> [Bool]
forall a. a -> [a] -> [a]
: [UsedPVarBV b v
v UsedPVarBV b v -> UsedPVarBV b v -> Bool
forall a. Eq a => a -> a -> Bool
== UsedPVarBV b v
w | (UsedPVarBV b v
v, UsedPVarBV b v
w) <- [UsedPVarBV b v]
-> [UsedPVarBV b v] -> [(UsedPVarBV b v, UsedPVarBV b v)]
forall a b. [a] -> [b] -> [(a, b)]
zip [UsedPVarBV b v]
vs' [UsedPVarBV b v]
ws']
        where
          vs' :: [UsedPVarBV b v]
vs' = [UsedPVarBV b v] -> [UsedPVarBV b v]
forall a. Ord a => [a] -> [a]
L.sort [UsedPVarBV b v]
vs
          ws' :: [UsedPVarBV b v]
ws' = [UsedPVarBV b v] -> [UsedPVarBV b v]
forall a. Ord a => [a] -> [a]
L.sort [UsedPVarBV b v]
ws

instance NFData Predicate where
  rnf :: Predicate -> ()
rnf Predicate
_ = ()

instance Monoid Predicate where
  mempty :: Predicate
mempty  = Predicate
forall b v. PredicateBV b v
pdTrue
  mappend :: Predicate -> Predicate -> Predicate
mappend = Predicate -> Predicate -> Predicate
forall a. Semigroup a => a -> a -> a
(<>)

instance Eq b => Semigroup (PredicateBV b v) where
  PredicateBV b v
p <> :: PredicateBV b v -> PredicateBV b v -> PredicateBV b v
<> PredicateBV b v
p' = [PredicateBV b v] -> PredicateBV b v
forall (t :: * -> *) b v.
(Foldable t, Eq b) =>
t (PredicateBV b v) -> PredicateBV b v
pdAnd [PredicateBV b v
p, PredicateBV b v
p']

instance (Ord b, F.Fixpoint b, Hashable b, F.PPrint b, Ord v, F.Fixpoint v, F.PPrint v) => F.PPrint (PredicateBV b v) where
  pprintTidy :: Tidy -> PredicateBV b v -> Doc
pprintTidy Tidy
_ (Pr [])  = String -> Doc
text String
"True"
  pprintTidy Tidy
k (Pr [UsedPVarBV b v]
pvs) = [Doc] -> Doc
hsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> [Doc] -> [Doc]
punctuate (String -> Doc
text String
"&") (Tidy -> UsedPVarBV b v -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (UsedPVarBV b v -> Doc) -> [UsedPVarBV b v] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarBV b v]
pvs)

instance (Semigroup a, Eq b) => Semigroup (UReftBV b v a) where
  MkUReft a
x PredicateBV b v
y <> :: UReftBV b v a -> UReftBV b v a -> UReftBV b v a
<> MkUReft a
x' PredicateBV b v
y' = a -> PredicateBV b v -> UReftBV b v a
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (a
x a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
x') (PredicateBV b v
y PredicateBV b v -> PredicateBV b v -> PredicateBV b v
forall a. Semigroup a => a -> a -> a
<> PredicateBV b v
y')

instance (Monoid a) => Monoid (UReft a) where
  mempty :: UReft a
mempty  = a -> Predicate -> UReft a
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft a
forall a. Monoid a => a
mempty Predicate
forall a. Monoid a => a
mempty
  mappend :: UReft a -> UReft a -> UReft a
mappend = UReft a -> UReft a -> UReft a
forall a. Semigroup a => a -> a -> a
(<>)


pdTrue :: PredicateBV b v
pdTrue :: forall b v. PredicateBV b v
pdTrue         = [UsedPVarBV b v] -> PredicateBV b v
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr []

pdAnd :: (Foldable t, Eq b) => t (PredicateBV b v) -> PredicateBV b v
pdAnd :: forall (t :: * -> *) b v.
(Foldable t, Eq b) =>
t (PredicateBV b v) -> PredicateBV b v
pdAnd t (PredicateBV b v)
ps       = [UsedPVarBV b v] -> PredicateBV b v
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr ([UsedPVarBV b v] -> [UsedPVarBV b v]
forall a. Eq a => [a] -> [a]
nub ([UsedPVarBV b v] -> [UsedPVarBV b v])
-> [UsedPVarBV b v] -> [UsedPVarBV b v]
forall a b. (a -> b) -> a -> b
$ (PredicateBV b v -> [UsedPVarBV b v])
-> t (PredicateBV b v) -> [UsedPVarBV b v]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap PredicateBV b v -> [UsedPVarBV b v]
forall b v. PredicateBV b v -> [UsedPVarBV b v]
pvars t (PredicateBV b v)
ps)

pvars :: PredicateBV b v -> [UsedPVarBV b v]
pvars :: forall b v. PredicateBV b v -> [UsedPVarBV b v]
pvars (Pr [UsedPVarBV b v]
pvs) = [UsedPVarBV b v]
pvs

instance Hashable v => F.Subable (UsedPVarBV v v) where
  type Variable (UsedPVarBV v v) = v
  syms :: UsedPVarBV v v -> [Variable (UsedPVarBV v v)]
syms UsedPVarBV v v
pv         = [ v
Variable (UsedPVarBV v v)
y | (()
_, v
x, F.EVar v
y) <- UsedPVarBV v v -> [((), v, ExprBV v v)]
forall b v t. PVarBV b v t -> [(t, b, ExprBV b v)]
pargs UsedPVarBV v v
pv, v
x v -> v -> Bool
forall a. Eq a => a -> a -> Bool
/= v
y ]
  subst :: HasCallStack =>
SubstV (Variable (UsedPVarBV v v))
-> UsedPVarBV v v -> UsedPVarBV v v
subst SubstV (Variable (UsedPVarBV v v))
s UsedPVarBV v v
pv      = UsedPVarBV v v
pv { pargs = mapThd3 (F.subst s)  <$> pargs pv }
  substf :: (Variable (UsedPVarBV v v)
 -> ExprBV (Variable (UsedPVarBV v v)) (Variable (UsedPVarBV v v)))
-> UsedPVarBV v v -> UsedPVarBV v v
substf Variable (UsedPVarBV v v)
-> ExprBV (Variable (UsedPVarBV v v)) (Variable (UsedPVarBV v v))
f UsedPVarBV v v
pv     = UsedPVarBV v v
pv { pargs = mapThd3 (F.substf f) <$> pargs pv }
  substa :: (Variable (UsedPVarBV v v) -> Variable (UsedPVarBV v v))
-> UsedPVarBV v v -> UsedPVarBV v v
substa Variable (UsedPVarBV v v) -> Variable (UsedPVarBV v v)
f UsedPVarBV v v
pv     = UsedPVarBV v v
pv { pargs = mapThd3 (F.substa f) <$> pargs pv }


instance Hashable v => F.Subable (PredicateBV v v) where
  type Variable (PredicateBV v v) = v
  syms :: PredicateBV v v -> [Variable (PredicateBV v v)]
syms     (Pr [UsedPVarBV v v]
pvs) = (UsedPVarBV v v -> [v]) -> [UsedPVarBV v v] -> [v]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap UsedPVarBV v v -> [v]
UsedPVarBV v v -> [Variable (UsedPVarBV v v)]
forall a. Subable a => a -> [Variable a]
F.syms   [UsedPVarBV v v]
pvs
  subst :: HasCallStack =>
SubstV (Variable (PredicateBV v v))
-> PredicateBV v v -> PredicateBV v v
subst  SubstV (Variable (PredicateBV v v))
s (Pr [UsedPVarBV v v]
pvs) = [UsedPVarBV v v] -> PredicateBV v v
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr (SubstV (Variable (UsedPVarBV v v))
-> UsedPVarBV v v -> UsedPVarBV v v
forall a.
(Subable a, HasCallStack) =>
SubstV (Variable a) -> a -> a
F.subst SubstV (Variable (PredicateBV v v))
SubstV (Variable (UsedPVarBV v v))
s  (UsedPVarBV v v -> UsedPVarBV v v)
-> [UsedPVarBV v v] -> [UsedPVarBV v v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarBV v v]
pvs)
  substf :: (Variable (PredicateBV v v)
 -> ExprBV
      (Variable (PredicateBV v v)) (Variable (PredicateBV v v)))
-> PredicateBV v v -> PredicateBV v v
substf Variable (PredicateBV v v)
-> ExprBV (Variable (PredicateBV v v)) (Variable (PredicateBV v v))
f (Pr [UsedPVarBV v v]
pvs) = [UsedPVarBV v v] -> PredicateBV v v
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr ((Variable (UsedPVarBV v v)
 -> ExprBV (Variable (UsedPVarBV v v)) (Variable (UsedPVarBV v v)))
-> UsedPVarBV v v -> UsedPVarBV v v
forall a.
Subable a =>
(Variable a -> ExprBV (Variable a) (Variable a)) -> a -> a
F.substf Variable (PredicateBV v v)
-> ExprBV (Variable (PredicateBV v v)) (Variable (PredicateBV v v))
Variable (UsedPVarBV v v)
-> ExprBV (Variable (UsedPVarBV v v)) (Variable (UsedPVarBV v v))
f (UsedPVarBV v v -> UsedPVarBV v v)
-> [UsedPVarBV v v] -> [UsedPVarBV v v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarBV v v]
pvs)
  substa :: (Variable (PredicateBV v v) -> Variable (PredicateBV v v))
-> PredicateBV v v -> PredicateBV v v
substa Variable (PredicateBV v v) -> Variable (PredicateBV v v)
f (Pr [UsedPVarBV v v]
pvs) = [UsedPVarBV v v] -> PredicateBV v v
forall b v. [UsedPVarBV b v] -> PredicateBV b v
Pr ((Variable (UsedPVarBV v v) -> Variable (UsedPVarBV v v))
-> UsedPVarBV v v -> UsedPVarBV v v
forall a. Subable a => (Variable a -> Variable a) -> a -> a
F.substa Variable (PredicateBV v v) -> Variable (PredicateBV v v)
Variable (UsedPVarBV v v) -> Variable (UsedPVarBV v v)
f (UsedPVarBV v v -> UsedPVarBV v v)
-> [UsedPVarBV v v] -> [UsedPVarBV v v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarBV v v]
pvs)

instance NFData r => NFData (UReft r)

newtype BTyVar = BTV F.LocSymbol
  deriving (Int -> BTyVar -> ShowS
[BTyVar] -> ShowS
BTyVar -> String
(Int -> BTyVar -> ShowS)
-> (BTyVar -> String) -> ([BTyVar] -> ShowS) -> Show BTyVar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BTyVar -> ShowS
showsPrec :: Int -> BTyVar -> ShowS
$cshow :: BTyVar -> String
show :: BTyVar -> String
$cshowList :: [BTyVar] -> ShowS
showList :: [BTyVar] -> ShowS
Show, (forall x. BTyVar -> Rep BTyVar x)
-> (forall x. Rep BTyVar x -> BTyVar) -> Generic BTyVar
forall x. Rep BTyVar x -> BTyVar
forall x. BTyVar -> Rep BTyVar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BTyVar -> Rep BTyVar x
from :: forall x. BTyVar -> Rep BTyVar x
$cto :: forall x. Rep BTyVar x -> BTyVar
to :: forall x. Rep BTyVar x -> BTyVar
Generic, Typeable BTyVar
Typeable BTyVar =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BTyVar -> c BTyVar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BTyVar)
-> (BTyVar -> Constr)
-> (BTyVar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BTyVar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyVar))
-> ((forall b. Data b => b -> b) -> BTyVar -> BTyVar)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BTyVar -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BTyVar -> r)
-> (forall u. (forall d. Data d => d -> u) -> BTyVar -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BTyVar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BTyVar -> m BTyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BTyVar -> m BTyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BTyVar -> m BTyVar)
-> Data BTyVar
BTyVar -> Constr
BTyVar -> DataType
(forall b. Data b => b -> b) -> BTyVar -> BTyVar
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BTyVar -> u
forall u. (forall d. Data d => d -> u) -> BTyVar -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyVar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyVar -> c BTyVar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyVar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyVar)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyVar -> c BTyVar
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyVar -> c BTyVar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyVar
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyVar
$ctoConstr :: BTyVar -> Constr
toConstr :: BTyVar -> Constr
$cdataTypeOf :: BTyVar -> DataType
dataTypeOf :: BTyVar -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyVar)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyVar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyVar)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyVar)
$cgmapT :: (forall b. Data b => b -> b) -> BTyVar -> BTyVar
gmapT :: (forall b. Data b => b -> b) -> BTyVar -> BTyVar
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyVar -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BTyVar -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BTyVar -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BTyVar -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BTyVar -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyVar -> m BTyVar
Data)
  deriving (Get BTyVar
[BTyVar] -> Put
BTyVar -> Put
(BTyVar -> Put) -> Get BTyVar -> ([BTyVar] -> Put) -> Binary BTyVar
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: BTyVar -> Put
put :: BTyVar -> Put
$cget :: Get BTyVar
get :: Get BTyVar
$cputList :: [BTyVar] -> Put
putList :: [BTyVar] -> Put
B.Binary, Eq BTyVar
Eq BTyVar =>
(Int -> BTyVar -> Int) -> (BTyVar -> Int) -> Hashable BTyVar
Int -> BTyVar -> Int
BTyVar -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> BTyVar -> Int
hashWithSalt :: Int -> BTyVar -> Int
$chash :: BTyVar -> Int
hash :: BTyVar -> Int
Hashable) via Generically BTyVar

newtype RTyVar = RTV TyVar deriving ((forall x. RTyVar -> Rep RTyVar x)
-> (forall x. Rep RTyVar x -> RTyVar) -> Generic RTyVar
forall x. Rep RTyVar x -> RTyVar
forall x. RTyVar -> Rep RTyVar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RTyVar -> Rep RTyVar x
from :: forall x. RTyVar -> Rep RTyVar x
$cto :: forall x. Rep RTyVar x -> RTyVar
to :: forall x. Rep RTyVar x -> RTyVar
Generic, Typeable RTyVar
Typeable RTyVar =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RTyVar -> c RTyVar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RTyVar)
-> (RTyVar -> Constr)
-> (RTyVar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RTyVar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyVar))
-> ((forall b. Data b => b -> b) -> RTyVar -> RTyVar)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RTyVar -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RTyVar -> r)
-> (forall u. (forall d. Data d => d -> u) -> RTyVar -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RTyVar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RTyVar -> m RTyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTyVar -> m RTyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTyVar -> m RTyVar)
-> Data RTyVar
RTyVar -> Constr
RTyVar -> DataType
(forall b. Data b => b -> b) -> RTyVar -> RTyVar
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RTyVar -> u
forall u. (forall d. Data d => d -> u) -> RTyVar -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyVar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyVar -> c RTyVar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyVar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyVar)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyVar -> c RTyVar
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyVar -> c RTyVar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyVar
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyVar
$ctoConstr :: RTyVar -> Constr
toConstr :: RTyVar -> Constr
$cdataTypeOf :: RTyVar -> DataType
dataTypeOf :: RTyVar -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyVar)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyVar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyVar)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyVar)
$cgmapT :: (forall b. Data b => b -> b) -> RTyVar -> RTyVar
gmapT :: (forall b. Data b => b -> b) -> RTyVar -> RTyVar
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyVar -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RTyVar -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RTyVar -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTyVar -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTyVar -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyVar -> m RTyVar
Data)

instance Eq BTyVar where
  (BTV Located Symbol
x) == :: BTyVar -> BTyVar -> Bool
== (BTV Located Symbol
y) = Located Symbol
x Located Symbol -> Located Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Located Symbol
y

instance Ord BTyVar where
  compare :: BTyVar -> BTyVar -> Ordering
compare (BTV Located Symbol
x) (BTV Located Symbol
y) = Located Symbol -> Located Symbol -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Located Symbol
x Located Symbol
y

instance NFData   BTyVar
instance NFData   RTyVar

instance F.Symbolic BTyVar where
  symbol :: BTyVar -> Symbol
symbol (BTV Located Symbol
tv) = Located Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol Located Symbol
tv

instance F.Symbolic RTyVar where
  symbol :: RTyVar -> Symbol
symbol (RTV Var
tv) = Var -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol Var
tv -- tyVarUniqueSymbol tv

instance CompatibleBinder (F.Located Symbol) BTyVar where
  coerceBinder :: BTyVar -> Located Symbol
coerceBinder (BTV Located Symbol
tv) = Located Symbol
tv

instance CompatibleBinder Symbol BTyVar where
  coerceBinder :: BTyVar -> Symbol
coerceBinder BTyVar
tv = Located Symbol -> Symbol
forall b b'. CompatibleBinder b b' => b' -> b
coerceBinder (BTyVar -> Located Symbol
forall b b'. CompatibleBinder b b' => b' -> b
coerceBinder BTyVar
tv :: F.Located Symbol)

-- instance F.Symbolic RTyVar where
  -- symbol (RTV tv) = F.symbol . getName $ tv
-- rtyVarUniqueSymbol  :: RTyVar -> Symbol
-- rtyVarUniqueSymbol (RTV tv) = tyVarUniqueSymbol tv
-- tyVarUniqueSymbol :: TyVar -> Symbol
-- tyVarUniqueSymbol tv = F.symbol $ show (getName tv) ++ "_" ++ show (varUnique tv)

data BTyCon = BTyCon
  { BTyCon -> Located LHName
btc_tc    :: !(F.Located LHName)  -- ^ TyCon name with location information
  , BTyCon -> Bool
btc_class :: !Bool           -- ^ Is this a class type constructor?
  , BTyCon -> Bool
btc_prom  :: !Bool           -- ^ Is Promoted Data Con?
  }
  deriving ((forall x. BTyCon -> Rep BTyCon x)
-> (forall x. Rep BTyCon x -> BTyCon) -> Generic BTyCon
forall x. Rep BTyCon x -> BTyCon
forall x. BTyCon -> Rep BTyCon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BTyCon -> Rep BTyCon x
from :: forall x. BTyCon -> Rep BTyCon x
$cto :: forall x. Rep BTyCon x -> BTyCon
to :: forall x. Rep BTyCon x -> BTyCon
Generic, Typeable BTyCon
Typeable BTyCon =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BTyCon -> c BTyCon)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BTyCon)
-> (BTyCon -> Constr)
-> (BTyCon -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BTyCon))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyCon))
-> ((forall b. Data b => b -> b) -> BTyCon -> BTyCon)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BTyCon -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BTyCon -> r)
-> (forall u. (forall d. Data d => d -> u) -> BTyCon -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BTyCon -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BTyCon -> m BTyCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BTyCon -> m BTyCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BTyCon -> m BTyCon)
-> Data BTyCon
BTyCon -> Constr
BTyCon -> DataType
(forall b. Data b => b -> b) -> BTyCon -> BTyCon
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BTyCon -> u
forall u. (forall d. Data d => d -> u) -> BTyCon -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyCon
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyCon -> c BTyCon
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyCon)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyCon)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyCon -> c BTyCon
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BTyCon -> c BTyCon
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyCon
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BTyCon
$ctoConstr :: BTyCon -> Constr
toConstr :: BTyCon -> Constr
$cdataTypeOf :: BTyCon -> DataType
dataTypeOf :: BTyCon -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyCon)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BTyCon)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyCon)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BTyCon)
$cgmapT :: (forall b. Data b => b -> b) -> BTyCon -> BTyCon
gmapT :: (forall b. Data b => b -> b) -> BTyCon -> BTyCon
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BTyCon -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BTyCon -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BTyCon -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BTyCon -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BTyCon -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BTyCon -> m BTyCon
Data)
  deriving (Get BTyCon
[BTyCon] -> Put
BTyCon -> Put
(BTyCon -> Put) -> Get BTyCon -> ([BTyCon] -> Put) -> Binary BTyCon
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: BTyCon -> Put
put :: BTyCon -> Put
$cget :: Get BTyCon
get :: Get BTyCon
$cputList :: [BTyCon] -> Put
putList :: [BTyCon] -> Put
B.Binary, Eq BTyCon
Eq BTyCon =>
(Int -> BTyCon -> Int) -> (BTyCon -> Int) -> Hashable BTyCon
Int -> BTyCon -> Int
BTyCon -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> BTyCon -> Int
hashWithSalt :: Int -> BTyCon -> Int
$chash :: BTyCon -> Int
hash :: BTyCon -> Int
Hashable) via Generically BTyCon

data RTyCon = RTyCon
  { RTyCon -> TyCon
rtc_tc    :: TyCon         -- ^ GHC Type Constructor
  , RTyCon -> [PVar RSort]
rtc_pvars :: ![RPVar]      -- ^ Predicate Parameters
  , RTyCon -> TyConInfo
rtc_info  :: !TyConInfo    -- ^ TyConInfo
  }
  deriving ((forall x. RTyCon -> Rep RTyCon x)
-> (forall x. Rep RTyCon x -> RTyCon) -> Generic RTyCon
forall x. Rep RTyCon x -> RTyCon
forall x. RTyCon -> Rep RTyCon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RTyCon -> Rep RTyCon x
from :: forall x. RTyCon -> Rep RTyCon x
$cto :: forall x. Rep RTyCon x -> RTyCon
to :: forall x. Rep RTyCon x -> RTyCon
Generic, Typeable RTyCon
Typeable RTyCon =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RTyCon -> c RTyCon)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RTyCon)
-> (RTyCon -> Constr)
-> (RTyCon -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RTyCon))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyCon))
-> ((forall b. Data b => b -> b) -> RTyCon -> RTyCon)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RTyCon -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RTyCon -> r)
-> (forall u. (forall d. Data d => d -> u) -> RTyCon -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RTyCon -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RTyCon -> m RTyCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTyCon -> m RTyCon)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTyCon -> m RTyCon)
-> Data RTyCon
RTyCon -> Constr
RTyCon -> DataType
(forall b. Data b => b -> b) -> RTyCon -> RTyCon
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RTyCon -> u
forall u. (forall d. Data d => d -> u) -> RTyCon -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyCon
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyCon -> c RTyCon
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyCon)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyCon)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyCon -> c RTyCon
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTyCon -> c RTyCon
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyCon
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RTyCon
$ctoConstr :: RTyCon -> Constr
toConstr :: RTyCon -> Constr
$cdataTypeOf :: RTyCon -> DataType
dataTypeOf :: RTyCon -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyCon)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RTyCon)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyCon)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RTyCon)
$cgmapT :: (forall b. Data b => b -> b) -> RTyCon -> RTyCon
gmapT :: (forall b. Data b => b -> b) -> RTyCon -> RTyCon
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RTyCon -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RTyCon -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RTyCon -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTyCon -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTyCon -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTyCon -> m RTyCon
Data)

instance F.Symbolic RTyCon where
  symbol :: RTyCon -> Symbol
symbol = TyCon -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol (TyCon -> Symbol) -> (RTyCon -> TyCon) -> RTyCon -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc

instance NFData BTyCon

instance NFData RTyCon


mkBTyCon :: F.Located LHName -> BTyCon
mkBTyCon :: Located LHName -> BTyCon
mkBTyCon Located LHName
x = Located LHName -> Bool -> Bool -> BTyCon
BTyCon Located LHName
x Bool
False Bool
False


-- | Accessors for @RTyCon@

isBool :: RType RTyCon t t1 -> Bool
isBool :: forall t t1. RType RTyCon t t1 -> Bool
isBool (RApp RTyCon{rtc_tc :: RTyCon -> TyCon
rtc_tc = TyCon
c} [RTypeBV Symbol Symbol RTyCon t t1]
_ [RTPropBV Symbol Symbol RTyCon t t1]
_ t1
_) = TyCon
c TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== TyCon
boolTyCon
isBool RTypeBV Symbol Symbol RTyCon t t1
_                                 = Bool
False

isRVar :: RType c tv r -> Bool
isRVar :: forall c tv r. RType c tv r -> Bool
isRVar (RVar tv
_ r
_) = Bool
True
isRVar RTypeBV Symbol Symbol c tv r
_          = Bool
False

isClassBTyCon :: BTyCon -> Bool
isClassBTyCon :: BTyCon -> Bool
isClassBTyCon = BTyCon -> Bool
btc_class

-- isClassRTyCon :: RTyCon -> Bool
-- isClassRTyCon x = (isClassTyCon $ rtc_tc x) || (rtc_tc x == eqPrimTyCon)

rTyConPVs :: RTyCon -> [RPVar]
rTyConPVs :: RTyCon -> [PVar RSort]
rTyConPVs     = RTyCon -> [PVar RSort]
rtc_pvars

isEqType :: TyConable c => RTypeV v c t t1 -> Bool
isEqType :: forall c v t t1. TyConable c => RTypeV v c t t1 -> Bool
isEqType (RApp c
c [RTypeBV Symbol v c t t1]
_ [RTPropBV Symbol v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isEqual c
c
isEqType RTypeBV Symbol v c t t1
_              = Bool
False


isClassType :: TyConable c => RTypeV v c t t1 -> Bool
isClassType :: forall c v t t1. TyConable c => RTypeV v c t t1 -> Bool
isClassType (RApp c
c [RTypeBV Symbol v c t t1]
_ [RTPropBV Symbol v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isClass c
c
isClassType RTypeBV Symbol v c t t1
_              = Bool
False

isEmbeddedClass :: TyConable c => RTypeV v c t t1 -> Bool
isEmbeddedClass :: forall c v t t1. TyConable c => RTypeV v c t t1 -> Bool
isEmbeddedClass (RApp c
c [RTypeBV Symbol v c t t1]
_ [RTPropBV Symbol v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isEmbeddedDict c
c
isEmbeddedClass RTypeBV Symbol v c t t1
_              = Bool
False


class (Eq c) => TyConable c where
  isFun    :: c -> Bool
  isList   :: c -> Bool
  isTuple  :: c -> Bool
  ppTycon  :: c -> Doc
  isClass  :: c -> Bool
  isEmbeddedDict :: c -> Bool
  isEqual  :: c -> Bool
  isOrdCls  :: c -> Bool
  isEqCls   :: c -> Bool

  isNumCls  :: c -> Bool
  isFracCls :: c -> Bool

  isClass   = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False
  isEmbeddedDict c
c = c -> Bool
forall c. TyConable c => c -> Bool
isNumCls c
c Bool -> Bool -> Bool
|| c -> Bool
forall c. TyConable c => c -> Bool
isEqual c
c Bool -> Bool -> Bool
|| c -> Bool
forall c. TyConable c => c -> Bool
isOrdCls c
c Bool -> Bool -> Bool
|| c -> Bool
forall c. TyConable c => c -> Bool
isEqCls c
c
  isOrdCls  = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False
  isEqCls   = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False
  isEqual   = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False
  isNumCls  = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False
  isFracCls = Bool -> c -> Bool
forall a b. a -> b -> a
const Bool
False


-------------------------------------------------------------------------------
-- | TyConable Instances -------------------------------------------------------
-------------------------------------------------------------------------------

instance TyConable RTyCon where
  isFun :: RTyCon -> Bool
isFun      = TyCon -> Bool
isArrowTyCon (TyCon -> Bool) -> (RTyCon -> TyCon) -> RTyCon -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc
  isList :: RTyCon -> Bool
isList     = (TyCon
listTyCon TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
==) (TyCon -> Bool) -> (RTyCon -> TyCon) -> RTyCon -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc
  isTuple :: RTyCon -> Bool
isTuple    = TyCon -> Bool
Ghc.isTupleTyCon   (TyCon -> Bool) -> (RTyCon -> TyCon) -> RTyCon -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc
  isClass :: RTyCon -> Bool
isClass    = TyCon -> Bool
forall c. TyConable c => c -> Bool
isClass (TyCon -> Bool) -> (RTyCon -> TyCon) -> RTyCon -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc -- isClassRTyCon
  isEqual :: RTyCon -> Bool
isEqual    = TyCon -> Bool
forall c. TyConable c => c -> Bool
isEqual (TyCon -> Bool) -> (RTyCon -> TyCon) -> RTyCon -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc
  ppTycon :: RTyCon -> Doc
ppTycon    = RTyCon -> Doc
forall a. Fixpoint a => a -> Doc
F.toFix

  isNumCls :: RTyCon -> Bool
isNumCls RTyCon
c  = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
isNumericClass)
                (TyCon -> Maybe Class
tyConClass_maybe (TyCon -> Maybe Class) -> TyCon -> Maybe Class
forall a b. (a -> b) -> a -> b
$ RTyCon -> TyCon
rtc_tc RTyCon
c)
  isFracCls :: RTyCon -> Bool
isFracCls RTyCon
c = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
isFractionalClass)
                (TyCon -> Maybe Class
tyConClass_maybe (TyCon -> Maybe Class) -> TyCon -> Maybe Class
forall a b. (a -> b) -> a -> b
$ RTyCon -> TyCon
rtc_tc RTyCon
c)
  isOrdCls :: RTyCon -> Bool
isOrdCls  RTyCon
c = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False Class -> Bool
isOrdClass (TyCon -> Maybe Class
tyConClass_maybe (TyCon -> Maybe Class) -> TyCon -> Maybe Class
forall a b. (a -> b) -> a -> b
$ RTyCon -> TyCon
rtc_tc RTyCon
c)
  isEqCls :: RTyCon -> Bool
isEqCls   RTyCon
c = TyCon -> Bool
forall c. TyConable c => c -> Bool
isEqCls (RTyCon -> TyCon
rtc_tc RTyCon
c)


instance TyConable TyCon where
  isFun :: TyCon -> Bool
isFun      = TyCon -> Bool
isArrowTyCon
  isList :: TyCon -> Bool
isList     = (TyCon
listTyCon TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
==)
  isTuple :: TyCon -> Bool
isTuple    = TyCon -> Bool
Ghc.isTupleTyCon
  isClass :: TyCon -> Bool
isClass TyCon
c  = TyCon -> Bool
isClassTyCon TyCon
c   Bool -> Bool -> Bool
|| TyCon -> Bool
forall c. TyConable c => c -> Bool
isEqual TyCon
c -- c == eqPrimTyCon
  isEqual :: TyCon -> Bool
isEqual TyCon
c  = TyCon
c TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== TyCon
eqPrimTyCon Bool -> Bool -> Bool
|| TyCon
c TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== TyCon
eqReprPrimTyCon
  ppTycon :: TyCon -> Doc
ppTycon    = String -> Doc
text (String -> Doc) -> (TyCon -> String) -> TyCon -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyCon -> String
forall a. Outputable a => a -> String
showPpr

  isNumCls :: TyCon -> Bool
isNumCls TyCon
c  = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
isNumericClass)
                (TyCon -> Maybe Class
tyConClass_maybe TyCon
c)
  isFracCls :: TyCon -> Bool
isFracCls TyCon
c = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
isFractionalClass)
                (TyCon -> Maybe Class
tyConClass_maybe TyCon
c)
  isOrdCls :: TyCon -> Bool
isOrdCls TyCon
c  = Bool -> (Class -> Bool) -> Maybe Class -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False Class -> Bool
isOrdClass
                (TyCon -> Maybe Class
tyConClass_maybe TyCon
c)
  isEqCls :: TyCon -> Bool
isEqCls  TyCon
c  = TyCon -> Bool
isPrelEqTyCon TyCon
c

isClassOrSubClass :: (Class -> Bool) -> Class -> Bool
isClassOrSubClass :: (Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
p Class
cls
  = Class -> Bool
p Class
cls Bool -> Bool -> Bool
|| ((Class, [Type]) -> Bool) -> [(Class, [Type])] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((Class -> Bool) -> Class -> Bool
isClassOrSubClass Class -> Bool
p (Class -> Bool)
-> ((Class, [Type]) -> Class) -> (Class, [Type]) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Class, [Type]) -> Class
forall a b. (a, b) -> a
fst)
                 ((Type -> Maybe (Class, [Type])) -> [Type] -> [(Class, [Type])]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Type -> Maybe (Class, [Type])
getClassPredTys_maybe (Class -> [Type]
classSCTheta Class
cls))

-- MOVE TO TYPES
instance TyConable Symbol where
  isFun :: Symbol -> Bool
isFun   Symbol
s = Symbol
F.funConName Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
s
  isList :: Symbol -> Bool
isList  Symbol
s = Symbol
F.listConName Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
s
  isTuple :: Symbol -> Bool
isTuple = Symbol -> Bool
isTupleSymbol
  ppTycon :: Symbol -> Doc
ppTycon   = String -> Doc
text (String -> Doc) -> (Symbol -> String) -> Symbol -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> String
F.symbolString

instance TyConable F.LocSymbol where
  isFun :: Located Symbol -> Bool
isFun   = Symbol -> Bool
forall c. TyConable c => c -> Bool
isFun   (Symbol -> Bool)
-> (Located Symbol -> Symbol) -> Located Symbol -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located Symbol -> Symbol
forall a. Located a -> a
F.val
  isList :: Located Symbol -> Bool
isList  = Symbol -> Bool
forall c. TyConable c => c -> Bool
isList  (Symbol -> Bool)
-> (Located Symbol -> Symbol) -> Located Symbol -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located Symbol -> Symbol
forall a. Located a -> a
F.val
  isTuple :: Located Symbol -> Bool
isTuple = Symbol -> Bool
forall c. TyConable c => c -> Bool
isTuple (Symbol -> Bool)
-> (Located Symbol -> Symbol) -> Located Symbol -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located Symbol -> Symbol
forall a. Located a -> a
F.val
  ppTycon :: Located Symbol -> Doc
ppTycon = Symbol -> Doc
forall c. TyConable c => c -> Doc
ppTycon (Symbol -> Doc)
-> (Located Symbol -> Symbol) -> Located Symbol -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located Symbol -> Symbol
forall a. Located a -> a
F.val

instance TyConable BTyCon where
  isFun :: BTyCon -> Bool
isFun BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> Symbol -> Bool
forall c. TyConable c => c -> Bool
isFun Symbol
s
    LHNResolved (LHRGHC Name
n) Symbol
_ -> Name
n Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
unrestrictedFunTyConName
    LHName
_ -> Bool
False

  isList :: BTyCon -> Bool
isList BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> Symbol -> Bool
forall c. TyConable c => c -> Bool
isList Symbol
s
    LHNResolved (LHRGHC Name
n) Symbol
_ -> Name
n Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
listTyConName
    LHName
_ -> Bool
False

  isTuple :: BTyCon -> Bool
isTuple BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> Symbol -> Bool
forall c. TyConable c => c -> Bool
isTuple Symbol
s
    LHNResolved (LHRGHC Name
n) Symbol
_ -> Name -> Bool
Ghc.isTupleTyConName Name
n
    LHName
_ -> Bool
False

  isClass :: BTyCon -> Bool
isClass = BTyCon -> Bool
isClassBTyCon

  ppTycon :: BTyCon -> Doc
ppTycon BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> Symbol -> Doc
forall c. TyConable c => c -> Doc
ppTycon Symbol
s
    LHNResolved LHResolvedName
rn Symbol
_ -> case LHResolvedName
rn of
      LHRGHC Name
n -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Name -> String
forall a. Outputable a => a -> String
showPpr Name
n
      LHRLocal Symbol
s -> Symbol -> Doc
forall c. TyConable c => c -> Doc
ppTycon Symbol
s
      LHRIndex Word
i -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
"(Unknown LHRIndex " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
show Word
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
      LHRLogic LogicName
_ -> Symbol -> Doc
forall c. TyConable c => c -> Doc
ppTycon (Symbol -> Doc) -> Symbol -> Doc
forall a b. (a -> b) -> a -> b
$ LHName -> Symbol
lhNameToResolvedSymbol (LHName -> Symbol) -> LHName -> Symbol
forall a b. (a -> b) -> a -> b
$ Located LHName -> LHName
forall a. Located a -> a
F.val (Located LHName -> LHName) -> Located LHName -> LHName
forall a b. (a -> b) -> a -> b
$ BTyCon -> Located LHName
btc_tc BTyCon
b

instance Eq RTyCon where
  RTyCon
x == :: RTyCon -> RTyCon -> Bool
== RTyCon
y = RTyCon -> TyCon
rtc_tc RTyCon
x TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== RTyCon -> TyCon
rtc_tc RTyCon
y

instance Eq BTyCon where
  BTyCon
x == :: BTyCon -> BTyCon -> Bool
== BTyCon
y = BTyCon -> Located LHName
btc_tc BTyCon
x Located LHName -> Located LHName -> Bool
forall a. Eq a => a -> a -> Bool
== BTyCon -> Located LHName
btc_tc BTyCon
y

instance Ord BTyCon where
  compare :: BTyCon -> BTyCon -> Ordering
compare BTyCon
x BTyCon
y = Located LHName -> Located LHName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (BTyCon -> Located LHName
btc_tc BTyCon
x) (BTyCon -> Located LHName
btc_tc BTyCon
y)

instance F.Fixpoint RTyCon where
  toFix :: RTyCon -> Doc
toFix (RTyCon TyCon
c [PVar RSort]
_ TyConInfo
_) = String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ TyCon -> String
forall a. Outputable a => a -> String
showPpr TyCon
c

instance F.Fixpoint BTyCon where
  toFix :: BTyCon -> Doc
toFix BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString Symbol
s
    LHNResolved LHResolvedName
rn Symbol
_ -> case LHResolvedName
rn of
      LHRGHC Name
n -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString (Symbol -> String) -> Symbol -> String
forall a b. (a -> b) -> a -> b
$ Name -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol Name
n
      LHRLocal Symbol
s -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString Symbol
s
      LHRIndex Word
i -> Maybe SrcSpan -> String -> Doc
forall a. HasCallStack => Maybe SrcSpan -> String -> a
panic (SrcSpan -> Maybe SrcSpan
forall a. a -> Maybe a
Just (SrcSpan -> Maybe SrcSpan) -> SrcSpan -> Maybe SrcSpan
forall a b. (a -> b) -> a -> b
$ BTyCon -> SrcSpan
forall a. Loc a => a -> SrcSpan
fSrcSpan BTyCon
b) (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
"toFix BTyCon: Unknown LHRIndex " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
show Word
i
      LHRLogic LogicName
_ -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString (Symbol -> String) -> Symbol -> String
forall a b. (a -> b) -> a -> b
$ LHName -> Symbol
lhNameToResolvedSymbol (LHName -> Symbol) -> LHName -> Symbol
forall a b. (a -> b) -> a -> b
$ Located LHName -> LHName
forall a. Located a -> a
F.val (Located LHName -> LHName) -> Located LHName -> LHName
forall a b. (a -> b) -> a -> b
$ BTyCon -> Located LHName
btc_tc BTyCon
b

instance F.PPrint RTyCon where
  pprintTidy :: Tidy -> RTyCon -> Doc
pprintTidy Tidy
k RTyCon
c
    | PPEnv -> Bool
ppDebug PPEnv
ppEnv = Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k Symbol
tc  Doc -> Doc -> Doc
<-> Doc -> Doc
angleBrackets (Tidy -> [PVar RSort] -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k [PVar RSort]
pvs)
    | Bool
otherwise     = String -> Doc
text (String -> Doc) -> (RTyCon -> String) -> RTyCon -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyCon -> String
forall a. Outputable a => a -> String
showPpr (TyCon -> String) -> (RTyCon -> TyCon) -> RTyCon -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTyCon -> TyCon
rtc_tc (RTyCon -> Doc) -> RTyCon -> Doc
forall a b. (a -> b) -> a -> b
$ RTyCon
c
    where
      tc :: Symbol
tc            = TyCon -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol (RTyCon -> TyCon
rtc_tc RTyCon
c)
      pvs :: [PVar RSort]
pvs           = RTyCon -> [PVar RSort]
rtc_pvars RTyCon
c

instance F.PPrint BTyCon where
  pprintTidy :: Tidy -> BTyCon -> Doc
pprintTidy Tidy
_ BTyCon
b = case Located LHName -> LHName
forall a. Located a -> a
F.val (BTyCon -> Located LHName
btc_tc BTyCon
b) of
    LHNUnresolved LHNameSpace
_ Symbol
s -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString Symbol
s
    LHNResolved LHResolvedName
rn Symbol
_ -> case LHResolvedName
rn of
      LHRGHC Name
n -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString (Symbol -> String) -> Symbol -> String
forall a b. (a -> b) -> a -> b
$ Name -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol Name
n
      LHRLocal Symbol
s -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString Symbol
s
      LHRIndex Word
i -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
"(Unknown LHRIndex " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
show Word
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
      LHRLogic LogicName
_ -> String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
F.symbolString (Symbol -> String) -> Symbol -> String
forall a b. (a -> b) -> a -> b
$ LHName -> Symbol
lhNameToResolvedSymbol (LHName -> Symbol) -> LHName -> Symbol
forall a b. (a -> b) -> a -> b
$ Located LHName -> LHName
forall a. Located a -> a
F.val (Located LHName -> LHName) -> Located LHName -> LHName
forall a b. (a -> b) -> a -> b
$ BTyCon -> Located LHName
btc_tc BTyCon
b

instance F.PPrint v => F.PPrint (RTVar v s) where
  pprintTidy :: Tidy -> RTVar v s -> Doc
pprintTidy Tidy
k (RTVar v
x RTVInfo s
_) = Tidy -> v -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k v
x

instance Show RTyCon where
  show :: RTyCon -> String
show = RTyCon -> String
forall a. PPrint a => a -> String
F.showpp

instance Show BTyCon where
  show :: BTyCon -> String
show = BTyCon -> String
forall a. PPrint a => a -> String
F.showpp

instance F.Loc BTyCon where
  srcSpan :: BTyCon -> SrcSpan
srcSpan = Located LHName -> SrcSpan
forall a. Loc a => a -> SrcSpan
F.srcSpan (Located LHName -> SrcSpan)
-> (BTyCon -> Located LHName) -> BTyCon -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BTyCon -> Located LHName
btc_tc

defaultTyConInfo :: TyConInfo
defaultTyConInfo :: TyConInfo
defaultTyConInfo = VarianceInfo -> VarianceInfo -> Maybe SizeFun -> TyConInfo
TyConInfo [] [] Maybe SizeFun
forall a. Maybe a
Nothing


-----------------------------------------------------------------------
-- | Co- and Contra-variance for TyCon --------------------------------
-----------------------------------------------------------------------

-- | Indexes start from 0 and type or predicate arguments can be both
--   covariant and contravaariant e.g., for the below Foo dataType
--
--     data Foo a b c d <p :: b -> Prop, q :: Int -> Prop, r :: a -> Prop>
--       = F (a<r> -> b<p>) | Q (c -> a) | G (Int<q> -> a<r>)
--
--  there will be:
--
--    varianceTyArgs     = [Bivariant , Covariant, Contravatiant, Invariant]
--    variancePsArgs     = [Covariant, Contravatiant, Bivariant]
--

data TyConInfo = TyConInfo
  { TyConInfo -> VarianceInfo
varianceTyArgs  :: !VarianceInfo      -- ^ variance info for type variables
  , TyConInfo -> VarianceInfo
variancePsArgs  :: !VarianceInfo      -- ^ variance info for predicate variables
  , TyConInfo -> Maybe SizeFun
sizeFunction    :: !(Maybe SizeFun)   -- ^ logical UNARY function that computes the size of the structure
  } deriving ((forall x. TyConInfo -> Rep TyConInfo x)
-> (forall x. Rep TyConInfo x -> TyConInfo) -> Generic TyConInfo
forall x. Rep TyConInfo x -> TyConInfo
forall x. TyConInfo -> Rep TyConInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyConInfo -> Rep TyConInfo x
from :: forall x. TyConInfo -> Rep TyConInfo x
$cto :: forall x. Rep TyConInfo x -> TyConInfo
to :: forall x. Rep TyConInfo x -> TyConInfo
Generic, Typeable TyConInfo
Typeable TyConInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TyConInfo -> c TyConInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyConInfo)
-> (TyConInfo -> Constr)
-> (TyConInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyConInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConInfo))
-> ((forall b. Data b => b -> b) -> TyConInfo -> TyConInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TyConInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyConInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TyConInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo)
-> Data TyConInfo
TyConInfo -> Constr
TyConInfo -> DataType
(forall b. Data b => b -> b) -> TyConInfo -> TyConInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TyConInfo -> u
forall u. (forall d. Data d => d -> u) -> TyConInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConInfo -> c TyConInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConInfo -> c TyConInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyConInfo -> c TyConInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyConInfo
$ctoConstr :: TyConInfo -> Constr
toConstr :: TyConInfo -> Constr
$cdataTypeOf :: TyConInfo -> DataType
dataTypeOf :: TyConInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyConInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyConInfo)
$cgmapT :: (forall b. Data b => b -> b) -> TyConInfo -> TyConInfo
gmapT :: (forall b. Data b => b -> b) -> TyConInfo -> TyConInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyConInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyConInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyConInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyConInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyConInfo -> m TyConInfo
Data)

instance NFData TyConInfo

instance Show TyConInfo where
  show :: TyConInfo -> String
show (TyConInfo VarianceInfo
x VarianceInfo
y Maybe SizeFun
_) = VarianceInfo -> String
forall a. Show a => a -> String
show VarianceInfo
x String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++ VarianceInfo -> String
forall a. Show a => a -> String
show VarianceInfo
y

--------------------------------------------------------------------------------
-- | Unified Representation of Refinement Types --------------------------------
--------------------------------------------------------------------------------

type RTVU c tv = RTVUV Symbol c tv
type RTVUV v c tv = RTVUBV Symbol v c tv
type RTVUBV b v c tv = RTVar tv (RTypeBV b v c tv (NoReftB b))
type PVU c tv = PVUV Symbol c tv
type PVUV v c tv = PVarV v (RTypeV v c tv NoReft)
type PVUBV b v c tv = PVarBV b v (RTypeBV b v c tv (NoReftB b))

instance Show tv => Show (RTVU c tv) where
  show :: RTVU c tv -> String
show (RTVar tv
t RTVInfo (RTypeBV Symbol Symbol c tv (NoReftB Symbol))
_) = tv -> String
forall a. Show a => a -> String
show tv
t

type RType c tv r = RTypeV Symbol c tv r
type RTypeV v c tv = RTypeBV Symbol v c tv
data RTypeBV b v c tv r
  = RVar {
      forall b v c tv r. RTypeBV b v c tv r -> tv
rt_var    :: !tv
    , forall b v c tv r. RTypeBV b v c tv r -> r
rt_reft   :: !r
    }

  | RFun  {
      forall b v c tv r. RTypeBV b v c tv r -> b
rt_bind   :: !b
    , forall b v c tv r. RTypeBV b v c tv r -> RFInfo
rt_rinfo  :: !RFInfo
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_in     :: !(RTypeBV b v c tv r)
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_out    :: !(RTypeBV b v c tv r)
    , rt_reft   :: !r
    }

  | RAllT {
      forall b v c tv r. RTypeBV b v c tv r -> RTVUBV b v c tv
rt_tvbind :: !(RTVUBV b v c tv) -- RTVar tv (RType c tv ()))
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_ty     :: !(RTypeBV b v c tv r)
    , forall b v c tv r. RTypeBV b v c tv r -> r
rt_ref    :: !r
    }

  -- | "forall x y <z :: Nat, w :: Int> . TYPE"
  --               ^^^^^^^^^^^^^^^^^^^ (rt_pvbind)
  | RAllP {
      forall b v c tv r. RTypeBV b v c tv r -> PVUBV b v c tv
rt_pvbind :: !(PVUBV b v c tv)
    , rt_ty     :: !(RTypeBV b v c tv r)
    }

  -- | For example, in [a]<{\h -> v > h}>, we apply (via `RApp`)
  --   * the `RProp`  denoted by `{\h -> v > h}` to
  --   * the `RTyCon` denoted by `[]`.
  | RApp  {
      forall b v c tv r. RTypeBV b v c tv r -> c
rt_tycon  :: !c
    , forall b v c tv r. RTypeBV b v c tv r -> [RTypeBV b v c tv r]
rt_args   :: ![RTypeBV b v c tv r]
    , forall b v c tv r. RTypeBV b v c tv r -> [RTPropBV b v c tv r]
rt_pargs  :: ![RTPropBV b v c tv r]
    , rt_reft   :: !r
    }

  | RAllE {
      rt_bind   :: !b
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_allarg :: !(RTypeBV b v c tv r)
    , rt_ty     :: !(RTypeBV b v c tv r)
    }

  | REx {
      rt_bind   :: !b
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_exarg  :: !(RTypeBV b v c tv r)
    , rt_ty     :: !(RTypeBV b v c tv r)
    }

  | RExprArg (F.Located (ExprBV b v))           -- ^ For expression arguments to type aliases
                                                --   see tests/pos/vector2.hs
  | RAppTy{
      forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_arg   :: !(RTypeBV b v c tv r)
    , forall b v c tv r. RTypeBV b v c tv r -> RTypeBV b v c tv r
rt_res   :: !(RTypeBV b v c tv r)
    , rt_reft  :: !r
    }

  | RRTy  {
      forall b v c tv r. RTypeBV b v c tv r -> [(b, RTypeBV b v c tv r)]
rt_env   :: ![(b, RTypeBV b v c tv r)]
    , rt_ref   :: !r
    , forall b v c tv r. RTypeBV b v c tv r -> Oblig
rt_obl   :: !Oblig
    , rt_ty    :: !(RTypeBV b v c tv r)
    }

  | RHole r -- ^ let LH match against the Haskell type and add k-vars, e.g. `x:_`
            --   see tests/pos/Holes.hs
  deriving (RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
(RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool)
-> (RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool)
-> Eq (RTypeBV b v c tv r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall b v c tv r.
(Eq tv, Eq c, Eq v, Eq b, Eq r) =>
RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
$c== :: forall b v c tv r.
(Eq tv, Eq c, Eq v, Eq b, Eq r) =>
RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
== :: RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
$c/= :: forall b v c tv r.
(Eq tv, Eq c, Eq v, Eq b, Eq r) =>
RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
/= :: RTypeBV b v c tv r -> RTypeBV b v c tv r -> Bool
Eq, (forall x. RTypeBV b v c tv r -> Rep (RTypeBV b v c tv r) x)
-> (forall x. Rep (RTypeBV b v c tv r) x -> RTypeBV b v c tv r)
-> Generic (RTypeBV b v c tv r)
forall x. Rep (RTypeBV b v c tv r) x -> RTypeBV b v c tv r
forall x. RTypeBV b v c tv r -> Rep (RTypeBV b v c tv r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b v c tv r x.
Rep (RTypeBV b v c tv r) x -> RTypeBV b v c tv r
forall b v c tv r x.
RTypeBV b v c tv r -> Rep (RTypeBV b v c tv r) x
$cfrom :: forall b v c tv r x.
RTypeBV b v c tv r -> Rep (RTypeBV b v c tv r) x
from :: forall x. RTypeBV b v c tv r -> Rep (RTypeBV b v c tv r) x
$cto :: forall b v c tv r x.
Rep (RTypeBV b v c tv r) x -> RTypeBV b v c tv r
to :: forall x. Rep (RTypeBV b v c tv r) x -> RTypeBV b v c tv r
Generic, Typeable (RTypeBV b v c tv r)
Typeable (RTypeBV b v c tv r) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> RTypeBV b v c tv r
 -> c (RTypeBV b v c tv r))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RTypeBV b v c tv r))
-> (RTypeBV b v c tv r -> Constr)
-> (RTypeBV b v c tv r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RTypeBV b v c tv r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RTypeBV b v c tv r)))
-> ((forall b. Data b => b -> b)
    -> RTypeBV b v c tv r -> RTypeBV b v c tv r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RTypeBV b v c tv r -> m (RTypeBV b v c tv r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RTypeBV b v c tv r -> m (RTypeBV b v c tv r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RTypeBV b v c tv r -> m (RTypeBV b v c tv r))
-> Data (RTypeBV b v c tv r)
RTypeBV b v c tv r -> Constr
RTypeBV b v c tv r -> DataType
(forall b. Data b => b -> b)
-> RTypeBV b v c tv r -> RTypeBV b v c tv r
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> u
forall u. (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
Typeable (RTypeBV b v c tv r)
forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
RTypeBV b v c tv r -> Constr
forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
RTypeBV b v c tv r -> DataType
forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
(forall b. Data b => b -> b)
-> RTypeBV b v c tv r -> RTypeBV b v c tv r
forall b v c tv r u.
(Data tv, Data c, Data v, Data b, Data r) =>
Int -> (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> u
forall b v c tv r u.
(Data tv, Data c, Data v, Data b, Data r) =>
(forall d. Data d => d -> u) -> RTypeBV b v c tv r -> [u]
forall b v c tv r r r'.
(Data tv, Data c, Data v, Data b, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
forall b v c tv r r r'.
(Data tv, Data c, Data v, Data b, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
forall b v c tv r (m :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
forall b v c tv r (m :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
forall b v c tv r (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTypeBV b v c tv r)
forall b v c tv r (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RTypeBV b v c tv r
-> c (RTypeBV b v c tv r)
forall b v c tv r (t :: * -> *) (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTypeBV b v c tv r))
forall b v c tv r (t :: * -> * -> *) (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTypeBV b v c tv r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTypeBV b v c tv r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RTypeBV b v c tv r
-> c (RTypeBV b v c tv r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTypeBV b v c tv r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTypeBV b v c tv r))
$cgfoldl :: forall b v c tv r (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RTypeBV b v c tv r
-> c (RTypeBV b v c tv r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> RTypeBV b v c tv r
-> c (RTypeBV b v c tv r)
$cgunfold :: forall b v c tv r (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTypeBV b v c tv r)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTypeBV b v c tv r)
$ctoConstr :: forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
RTypeBV b v c tv r -> Constr
toConstr :: RTypeBV b v c tv r -> Constr
$cdataTypeOf :: forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
RTypeBV b v c tv r -> DataType
dataTypeOf :: RTypeBV b v c tv r -> DataType
$cdataCast1 :: forall b v c tv r (t :: * -> *) (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTypeBV b v c tv r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTypeBV b v c tv r))
$cdataCast2 :: forall b v c tv r (t :: * -> * -> *) (c :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTypeBV b v c tv r))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTypeBV b v c tv r))
$cgmapT :: forall b v c tv r.
(Data tv, Data c, Data v, Data b, Data r) =>
(forall b. Data b => b -> b)
-> RTypeBV b v c tv r -> RTypeBV b v c tv r
gmapT :: (forall b. Data b => b -> b)
-> RTypeBV b v c tv r -> RTypeBV b v c tv r
$cgmapQl :: forall b v c tv r r r'.
(Data tv, Data c, Data v, Data b, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
$cgmapQr :: forall b v c tv r r r'.
(Data tv, Data c, Data v, Data b, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTypeBV b v c tv r -> r
$cgmapQ :: forall b v c tv r u.
(Data tv, Data c, Data v, Data b, Data r) =>
(forall d. Data d => d -> u) -> RTypeBV b v c tv r -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> [u]
$cgmapQi :: forall b v c tv r u.
(Data tv, Data c, Data v, Data b, Data r) =>
Int -> (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RTypeBV b v c tv r -> u
$cgmapM :: forall b v c tv r (m :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
$cgmapMp :: forall b v c tv r (m :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
$cgmapMo :: forall b v c tv r (m :: * -> *).
(Data tv, Data c, Data v, Data b, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RTypeBV b v c tv r -> m (RTypeBV b v c tv r)
Data, (forall a b. (a -> b) -> RTypeBV b v c tv a -> RTypeBV b v c tv b)
-> (forall a b. a -> RTypeBV b v c tv b -> RTypeBV b v c tv a)
-> Functor (RTypeBV b v c tv)
forall a b. a -> RTypeBV b v c tv b -> RTypeBV b v c tv a
forall a b. (a -> b) -> RTypeBV b v c tv a -> RTypeBV b v c tv b
forall b v c tv a b. a -> RTypeBV b v c tv b -> RTypeBV b v c tv a
forall b v c tv a b.
(a -> b) -> RTypeBV b v c tv a -> RTypeBV b v c tv b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall b v c tv a b.
(a -> b) -> RTypeBV b v c tv a -> RTypeBV b v c tv b
fmap :: forall a b. (a -> b) -> RTypeBV b v c tv a -> RTypeBV b v c tv b
$c<$ :: forall b v c tv a b. a -> RTypeBV b v c tv b -> RTypeBV b v c tv a
<$ :: forall a b. a -> RTypeBV b v c tv b -> RTypeBV b v c tv a
Functor, (forall m. Monoid m => RTypeBV b v c tv m -> m)
-> (forall m a. Monoid m => (a -> m) -> RTypeBV b v c tv a -> m)
-> (forall m a. Monoid m => (a -> m) -> RTypeBV b v c tv a -> m)
-> (forall a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b)
-> (forall a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b)
-> (forall a. (a -> a -> a) -> RTypeBV b v c tv a -> a)
-> (forall a. (a -> a -> a) -> RTypeBV b v c tv a -> a)
-> (forall a. RTypeBV b v c tv a -> [a])
-> (forall a. RTypeBV b v c tv a -> Bool)
-> (forall a. RTypeBV b v c tv a -> Int)
-> (forall a. Eq a => a -> RTypeBV b v c tv a -> Bool)
-> (forall a. Ord a => RTypeBV b v c tv a -> a)
-> (forall a. Ord a => RTypeBV b v c tv a -> a)
-> (forall a. Num a => RTypeBV b v c tv a -> a)
-> (forall a. Num a => RTypeBV b v c tv a -> a)
-> Foldable (RTypeBV b v c tv)
forall a. Eq a => a -> RTypeBV b v c tv a -> Bool
forall a. Num a => RTypeBV b v c tv a -> a
forall a. Ord a => RTypeBV b v c tv a -> a
forall m. Monoid m => RTypeBV b v c tv m -> m
forall a. RTypeBV b v c tv a -> Bool
forall a. RTypeBV b v c tv a -> Int
forall a. RTypeBV b v c tv a -> [a]
forall a. (a -> a -> a) -> RTypeBV b v c tv a -> a
forall m a. Monoid m => (a -> m) -> RTypeBV b v c tv a -> m
forall b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
forall a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
forall b v c tv a. Eq a => a -> RTypeBV b v c tv a -> Bool
forall b v c tv a. Num a => RTypeBV b v c tv a -> a
forall b v c tv a. Ord a => RTypeBV b v c tv a -> a
forall b v c tv m. Monoid m => RTypeBV b v c tv m -> m
forall b v c tv a. RTypeBV b v c tv a -> Bool
forall b v c tv a. RTypeBV b v c tv a -> Int
forall b v c tv a. RTypeBV b v c tv a -> [a]
forall b v c tv a. (a -> a -> a) -> RTypeBV b v c tv a -> a
forall b v c tv m a.
Monoid m =>
(a -> m) -> RTypeBV b v c tv a -> m
forall b v c tv b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
forall b v c tv a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall b v c tv m. Monoid m => RTypeBV b v c tv m -> m
fold :: forall m. Monoid m => RTypeBV b v c tv m -> m
$cfoldMap :: forall b v c tv m a.
Monoid m =>
(a -> m) -> RTypeBV b v c tv a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RTypeBV b v c tv a -> m
$cfoldMap' :: forall b v c tv m a.
Monoid m =>
(a -> m) -> RTypeBV b v c tv a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RTypeBV b v c tv a -> m
$cfoldr :: forall b v c tv a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
$cfoldr' :: forall b v c tv a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RTypeBV b v c tv a -> b
$cfoldl :: forall b v c tv b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
$cfoldl' :: forall b v c tv b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RTypeBV b v c tv a -> b
$cfoldr1 :: forall b v c tv a. (a -> a -> a) -> RTypeBV b v c tv a -> a
foldr1 :: forall a. (a -> a -> a) -> RTypeBV b v c tv a -> a
$cfoldl1 :: forall b v c tv a. (a -> a -> a) -> RTypeBV b v c tv a -> a
foldl1 :: forall a. (a -> a -> a) -> RTypeBV b v c tv a -> a
$ctoList :: forall b v c tv a. RTypeBV b v c tv a -> [a]
toList :: forall a. RTypeBV b v c tv a -> [a]
$cnull :: forall b v c tv a. RTypeBV b v c tv a -> Bool
null :: forall a. RTypeBV b v c tv a -> Bool
$clength :: forall b v c tv a. RTypeBV b v c tv a -> Int
length :: forall a. RTypeBV b v c tv a -> Int
$celem :: forall b v c tv a. Eq a => a -> RTypeBV b v c tv a -> Bool
elem :: forall a. Eq a => a -> RTypeBV b v c tv a -> Bool
$cmaximum :: forall b v c tv a. Ord a => RTypeBV b v c tv a -> a
maximum :: forall a. Ord a => RTypeBV b v c tv a -> a
$cminimum :: forall b v c tv a. Ord a => RTypeBV b v c tv a -> a
minimum :: forall a. Ord a => RTypeBV b v c tv a -> a
$csum :: forall b v c tv a. Num a => RTypeBV b v c tv a -> a
sum :: forall a. Num a => RTypeBV b v c tv a -> a
$cproduct :: forall b v c tv a. Num a => RTypeBV b v c tv a -> a
product :: forall a. Num a => RTypeBV b v c tv a -> a
Foldable, Functor (RTypeBV b v c tv)
Foldable (RTypeBV b v c tv)
(Functor (RTypeBV b v c tv), Foldable (RTypeBV b v c tv)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RTypeBV b v c tv a -> f (RTypeBV b v c tv b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RTypeBV b v c tv (f a) -> f (RTypeBV b v c tv a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RTypeBV b v c tv a -> m (RTypeBV b v c tv b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RTypeBV b v c tv (m a) -> m (RTypeBV b v c tv a))
-> Traversable (RTypeBV b v c tv)
forall b v c tv. Functor (RTypeBV b v c tv)
forall b v c tv. Foldable (RTypeBV b v c tv)
forall b v c tv (m :: * -> *) a.
Monad m =>
RTypeBV b v c tv (m a) -> m (RTypeBV b v c tv a)
forall b v c tv (f :: * -> *) a.
Applicative f =>
RTypeBV b v c tv (f a) -> f (RTypeBV b v c tv a)
forall b v c tv (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTypeBV b v c tv a -> m (RTypeBV b v c tv b)
forall b v c tv (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTypeBV b v c tv a -> f (RTypeBV b v c tv b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
RTypeBV b v c tv (m a) -> m (RTypeBV b v c tv a)
forall (f :: * -> *) a.
Applicative f =>
RTypeBV b v c tv (f a) -> f (RTypeBV b v c tv a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTypeBV b v c tv a -> m (RTypeBV b v c tv b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTypeBV b v c tv a -> f (RTypeBV b v c tv b)
$ctraverse :: forall b v c tv (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTypeBV b v c tv a -> f (RTypeBV b v c tv b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTypeBV b v c tv a -> f (RTypeBV b v c tv b)
$csequenceA :: forall b v c tv (f :: * -> *) a.
Applicative f =>
RTypeBV b v c tv (f a) -> f (RTypeBV b v c tv a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RTypeBV b v c tv (f a) -> f (RTypeBV b v c tv a)
$cmapM :: forall b v c tv (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTypeBV b v c tv a -> m (RTypeBV b v c tv b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTypeBV b v c tv a -> m (RTypeBV b v c tv b)
$csequence :: forall b v c tv (m :: * -> *) a.
Monad m =>
RTypeBV b v c tv (m a) -> m (RTypeBV b v c tv a)
sequence :: forall (m :: * -> *) a.
Monad m =>
RTypeBV b v c tv (m a) -> m (RTypeBV b v c tv a)
Traversable)
  deriving (Get (RTypeBV b v c tv r)
[RTypeBV b v c tv r] -> Put
RTypeBV b v c tv r -> Put
(RTypeBV b v c tv r -> Put)
-> Get (RTypeBV b v c tv r)
-> ([RTypeBV b v c tv r] -> Put)
-> Binary (RTypeBV b v c tv r)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
Get (RTypeBV b v c tv r)
forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
[RTypeBV b v c tv r] -> Put
forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
RTypeBV b v c tv r -> Put
$cput :: forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
RTypeBV b v c tv r -> Put
put :: RTypeBV b v c tv r -> Put
$cget :: forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
Get (RTypeBV b v c tv r)
get :: Get (RTypeBV b v c tv r)
$cputList :: forall b v c tv r.
(Binary v, Binary tv, Binary r, Binary b, Binary c) =>
[RTypeBV b v c tv r] -> Put
putList :: [RTypeBV b v c tv r] -> Put
B.Binary, Eq (RTypeBV b v c tv r)
Eq (RTypeBV b v c tv r) =>
(Int -> RTypeBV b v c tv r -> Int)
-> (RTypeBV b v c tv r -> Int) -> Hashable (RTypeBV b v c tv r)
Int -> RTypeBV b v c tv r -> Int
RTypeBV b v c tv r -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall b v c tv r.
(Hashable r, Hashable tv, Hashable c, Hashable v, Hashable b) =>
Eq (RTypeBV b v c tv r)
forall b v c tv r.
(Hashable r, Hashable tv, Hashable c, Hashable v, Hashable b) =>
Int -> RTypeBV b v c tv r -> Int
forall b v c tv r.
(Hashable r, Hashable tv, Hashable c, Hashable v, Hashable b) =>
RTypeBV b v c tv r -> Int
$chashWithSalt :: forall b v c tv r.
(Hashable r, Hashable tv, Hashable c, Hashable v, Hashable b) =>
Int -> RTypeBV b v c tv r -> Int
hashWithSalt :: Int -> RTypeBV b v c tv r -> Int
$chash :: forall b v c tv r.
(Hashable r, Hashable tv, Hashable c, Hashable v, Hashable b) =>
RTypeBV b v c tv r -> Int
hash :: RTypeBV b v c tv r -> Int
Hashable) via Generically (RTypeBV b v c tv r)

instance (NFData c, NFData tv, NFData r)       => NFData (RType c tv r)

makeRTVar :: tv -> RTVar tv s
makeRTVar :: forall tv s. tv -> RTVar tv s
makeRTVar tv
a = tv -> RTVInfo s -> RTVar tv s
forall tv s. tv -> RTVInfo s -> RTVar tv s
RTVar tv
a (Bool -> RTVInfo s
forall s. Bool -> RTVInfo s
RTVNoInfo Bool
True)

notExprArg :: RTypeV v c tv r -> Bool
notExprArg :: forall v c tv r. RTypeV v c tv r -> Bool
notExprArg (RExprArg Located (ExprBV Symbol v)
_) = Bool
False
notExprArg RTypeBV Symbol v c tv r
_            = Bool
True

instance (Eq tv) => Eq (RTVar tv s) where
  RTVar tv s
t1 == :: RTVar tv s -> RTVar tv s -> Bool
== RTVar tv s
t2 = RTVar tv s -> tv
forall tv s. RTVar tv s -> tv
ty_var_value RTVar tv s
t1 tv -> tv -> Bool
forall a. Eq a => a -> a -> Bool
== RTVar tv s -> tv
forall tv s. RTVar tv s -> tv
ty_var_value RTVar tv s
t2

data RTVar tv s = RTVar
  { forall tv s. RTVar tv s -> tv
ty_var_value :: tv
  , forall tv s. RTVar tv s -> RTVInfo s
ty_var_info  :: RTVInfo s
  } deriving ((forall x. RTVar tv s -> Rep (RTVar tv s) x)
-> (forall x. Rep (RTVar tv s) x -> RTVar tv s)
-> Generic (RTVar tv s)
forall x. Rep (RTVar tv s) x -> RTVar tv s
forall x. RTVar tv s -> Rep (RTVar tv s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall tv s x. Rep (RTVar tv s) x -> RTVar tv s
forall tv s x. RTVar tv s -> Rep (RTVar tv s) x
$cfrom :: forall tv s x. RTVar tv s -> Rep (RTVar tv s) x
from :: forall x. RTVar tv s -> Rep (RTVar tv s) x
$cto :: forall tv s x. Rep (RTVar tv s) x -> RTVar tv s
to :: forall x. Rep (RTVar tv s) x -> RTVar tv s
Generic, Typeable (RTVar tv s)
Typeable (RTVar tv s) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RTVar tv s -> c (RTVar tv s))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RTVar tv s))
-> (RTVar tv s -> Constr)
-> (RTVar tv s -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RTVar tv s)))
-> ((forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r)
-> (forall u. (forall d. Data d => d -> u) -> RTVar tv s -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s))
-> Data (RTVar tv s)
RTVar tv s -> Constr
RTVar tv s -> DataType
(forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u
forall u. (forall d. Data d => d -> u) -> RTVar tv s -> [u]
forall tv s. (Data tv, Data s) => Typeable (RTVar tv s)
forall tv s. (Data tv, Data s) => RTVar tv s -> Constr
forall tv s. (Data tv, Data s) => RTVar tv s -> DataType
forall tv s.
(Data tv, Data s) =>
(forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s
forall tv s u.
(Data tv, Data s) =>
Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u
forall tv s u.
(Data tv, Data s) =>
(forall d. Data d => d -> u) -> RTVar tv s -> [u]
forall tv s r r'.
(Data tv, Data s) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall tv s r r'.
(Data tv, Data s) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall tv s (m :: * -> *).
(Data tv, Data s, Monad m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall tv s (m :: * -> *).
(Data tv, Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall tv s (c :: * -> *).
(Data tv, Data s) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVar tv s)
forall tv s (c :: * -> *).
(Data tv, Data s) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVar tv s -> c (RTVar tv s)
forall tv s (t :: * -> *) (c :: * -> *).
(Data tv, Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s))
forall tv s (t :: * -> * -> *) (c :: * -> *).
(Data tv, Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVar tv s))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVar tv s)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVar tv s -> c (RTVar tv s)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVar tv s))
$cgfoldl :: forall tv s (c :: * -> *).
(Data tv, Data s) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVar tv s -> c (RTVar tv s)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVar tv s -> c (RTVar tv s)
$cgunfold :: forall tv s (c :: * -> *).
(Data tv, Data s) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVar tv s)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVar tv s)
$ctoConstr :: forall tv s. (Data tv, Data s) => RTVar tv s -> Constr
toConstr :: RTVar tv s -> Constr
$cdataTypeOf :: forall tv s. (Data tv, Data s) => RTVar tv s -> DataType
dataTypeOf :: RTVar tv s -> DataType
$cdataCast1 :: forall tv s (t :: * -> *) (c :: * -> *).
(Data tv, Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s))
$cdataCast2 :: forall tv s (t :: * -> * -> *) (c :: * -> *).
(Data tv, Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVar tv s))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVar tv s))
$cgmapT :: forall tv s.
(Data tv, Data s) =>
(forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s
gmapT :: (forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s
$cgmapQl :: forall tv s r r'.
(Data tv, Data s) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
$cgmapQr :: forall tv s r r'.
(Data tv, Data s) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
$cgmapQ :: forall tv s u.
(Data tv, Data s) =>
(forall d. Data d => d -> u) -> RTVar tv s -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RTVar tv s -> [u]
$cgmapQi :: forall tv s u.
(Data tv, Data s) =>
Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u
$cgmapM :: forall tv s (m :: * -> *).
(Data tv, Data s, Monad m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
$cgmapMp :: forall tv s (m :: * -> *).
(Data tv, Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
$cgmapMo :: forall tv s (m :: * -> *).
(Data tv, Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
Data, (forall a b. (a -> b) -> RTVar tv a -> RTVar tv b)
-> (forall a b. a -> RTVar tv b -> RTVar tv a)
-> Functor (RTVar tv)
forall a b. a -> RTVar tv b -> RTVar tv a
forall a b. (a -> b) -> RTVar tv a -> RTVar tv b
forall tv a b. a -> RTVar tv b -> RTVar tv a
forall tv a b. (a -> b) -> RTVar tv a -> RTVar tv b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall tv a b. (a -> b) -> RTVar tv a -> RTVar tv b
fmap :: forall a b. (a -> b) -> RTVar tv a -> RTVar tv b
$c<$ :: forall tv a b. a -> RTVar tv b -> RTVar tv a
<$ :: forall a b. a -> RTVar tv b -> RTVar tv a
Functor, (forall m. Monoid m => RTVar tv m -> m)
-> (forall m a. Monoid m => (a -> m) -> RTVar tv a -> m)
-> (forall m a. Monoid m => (a -> m) -> RTVar tv a -> m)
-> (forall a b. (a -> b -> b) -> b -> RTVar tv a -> b)
-> (forall a b. (a -> b -> b) -> b -> RTVar tv a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTVar tv a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTVar tv a -> b)
-> (forall a. (a -> a -> a) -> RTVar tv a -> a)
-> (forall a. (a -> a -> a) -> RTVar tv a -> a)
-> (forall a. RTVar tv a -> [a])
-> (forall a. RTVar tv a -> Bool)
-> (forall a. RTVar tv a -> Int)
-> (forall a. Eq a => a -> RTVar tv a -> Bool)
-> (forall a. Ord a => RTVar tv a -> a)
-> (forall a. Ord a => RTVar tv a -> a)
-> (forall a. Num a => RTVar tv a -> a)
-> (forall a. Num a => RTVar tv a -> a)
-> Foldable (RTVar tv)
forall a. Eq a => a -> RTVar tv a -> Bool
forall a. Num a => RTVar tv a -> a
forall a. Ord a => RTVar tv a -> a
forall m. Monoid m => RTVar tv m -> m
forall a. RTVar tv a -> Bool
forall a. RTVar tv a -> Int
forall a. RTVar tv a -> [a]
forall a. (a -> a -> a) -> RTVar tv a -> a
forall tv a. Eq a => a -> RTVar tv a -> Bool
forall tv a. Num a => RTVar tv a -> a
forall tv a. Ord a => RTVar tv a -> a
forall tv m. Monoid m => RTVar tv m -> m
forall m a. Monoid m => (a -> m) -> RTVar tv a -> m
forall tv a. RTVar tv a -> Bool
forall tv a. RTVar tv a -> Int
forall tv a. RTVar tv a -> [a]
forall b a. (b -> a -> b) -> b -> RTVar tv a -> b
forall a b. (a -> b -> b) -> b -> RTVar tv a -> b
forall tv a. (a -> a -> a) -> RTVar tv a -> a
forall tv m a. Monoid m => (a -> m) -> RTVar tv a -> m
forall tv b a. (b -> a -> b) -> b -> RTVar tv a -> b
forall tv a b. (a -> b -> b) -> b -> RTVar tv a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall tv m. Monoid m => RTVar tv m -> m
fold :: forall m. Monoid m => RTVar tv m -> m
$cfoldMap :: forall tv m a. Monoid m => (a -> m) -> RTVar tv a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RTVar tv a -> m
$cfoldMap' :: forall tv m a. Monoid m => (a -> m) -> RTVar tv a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RTVar tv a -> m
$cfoldr :: forall tv a b. (a -> b -> b) -> b -> RTVar tv a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RTVar tv a -> b
$cfoldr' :: forall tv a b. (a -> b -> b) -> b -> RTVar tv a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RTVar tv a -> b
$cfoldl :: forall tv b a. (b -> a -> b) -> b -> RTVar tv a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RTVar tv a -> b
$cfoldl' :: forall tv b a. (b -> a -> b) -> b -> RTVar tv a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RTVar tv a -> b
$cfoldr1 :: forall tv a. (a -> a -> a) -> RTVar tv a -> a
foldr1 :: forall a. (a -> a -> a) -> RTVar tv a -> a
$cfoldl1 :: forall tv a. (a -> a -> a) -> RTVar tv a -> a
foldl1 :: forall a. (a -> a -> a) -> RTVar tv a -> a
$ctoList :: forall tv a. RTVar tv a -> [a]
toList :: forall a. RTVar tv a -> [a]
$cnull :: forall tv a. RTVar tv a -> Bool
null :: forall a. RTVar tv a -> Bool
$clength :: forall tv a. RTVar tv a -> Int
length :: forall a. RTVar tv a -> Int
$celem :: forall tv a. Eq a => a -> RTVar tv a -> Bool
elem :: forall a. Eq a => a -> RTVar tv a -> Bool
$cmaximum :: forall tv a. Ord a => RTVar tv a -> a
maximum :: forall a. Ord a => RTVar tv a -> a
$cminimum :: forall tv a. Ord a => RTVar tv a -> a
minimum :: forall a. Ord a => RTVar tv a -> a
$csum :: forall tv a. Num a => RTVar tv a -> a
sum :: forall a. Num a => RTVar tv a -> a
$cproduct :: forall tv a. Num a => RTVar tv a -> a
product :: forall a. Num a => RTVar tv a -> a
Foldable, Functor (RTVar tv)
Foldable (RTVar tv)
(Functor (RTVar tv), Foldable (RTVar tv)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RTVar tv a -> f (RTVar tv b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RTVar tv (f a) -> f (RTVar tv a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RTVar tv a -> m (RTVar tv b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RTVar tv (m a) -> m (RTVar tv a))
-> Traversable (RTVar tv)
forall tv. Functor (RTVar tv)
forall tv. Foldable (RTVar tv)
forall tv (m :: * -> *) a.
Monad m =>
RTVar tv (m a) -> m (RTVar tv a)
forall tv (f :: * -> *) a.
Applicative f =>
RTVar tv (f a) -> f (RTVar tv a)
forall tv (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVar tv a -> m (RTVar tv b)
forall tv (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVar tv a -> f (RTVar tv b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RTVar tv (m a) -> m (RTVar tv a)
forall (f :: * -> *) a.
Applicative f =>
RTVar tv (f a) -> f (RTVar tv a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVar tv a -> m (RTVar tv b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVar tv a -> f (RTVar tv b)
$ctraverse :: forall tv (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVar tv a -> f (RTVar tv b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVar tv a -> f (RTVar tv b)
$csequenceA :: forall tv (f :: * -> *) a.
Applicative f =>
RTVar tv (f a) -> f (RTVar tv a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RTVar tv (f a) -> f (RTVar tv a)
$cmapM :: forall tv (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVar tv a -> m (RTVar tv b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVar tv a -> m (RTVar tv b)
$csequence :: forall tv (m :: * -> *) a.
Monad m =>
RTVar tv (m a) -> m (RTVar tv a)
sequence :: forall (m :: * -> *) a. Monad m => RTVar tv (m a) -> m (RTVar tv a)
Traversable)
    deriving (Get (RTVar tv s)
[RTVar tv s] -> Put
RTVar tv s -> Put
(RTVar tv s -> Put)
-> Get (RTVar tv s) -> ([RTVar tv s] -> Put) -> Binary (RTVar tv s)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall tv s. (Binary s, Binary tv) => Get (RTVar tv s)
forall tv s. (Binary s, Binary tv) => [RTVar tv s] -> Put
forall tv s. (Binary s, Binary tv) => RTVar tv s -> Put
$cput :: forall tv s. (Binary s, Binary tv) => RTVar tv s -> Put
put :: RTVar tv s -> Put
$cget :: forall tv s. (Binary s, Binary tv) => Get (RTVar tv s)
get :: Get (RTVar tv s)
$cputList :: forall tv s. (Binary s, Binary tv) => [RTVar tv s] -> Put
putList :: [RTVar tv s] -> Put
B.Binary, Eq (RTVar tv s)
Eq (RTVar tv s) =>
(Int -> RTVar tv s -> Int)
-> (RTVar tv s -> Int) -> Hashable (RTVar tv s)
Int -> RTVar tv s -> Int
RTVar tv s -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall tv s. (Hashable tv, Hashable s) => Eq (RTVar tv s)
forall tv s. (Hashable tv, Hashable s) => Int -> RTVar tv s -> Int
forall tv s. (Hashable tv, Hashable s) => RTVar tv s -> Int
$chashWithSalt :: forall tv s. (Hashable tv, Hashable s) => Int -> RTVar tv s -> Int
hashWithSalt :: Int -> RTVar tv s -> Int
$chash :: forall tv s. (Hashable tv, Hashable s) => RTVar tv s -> Int
hash :: RTVar tv s -> Int
Hashable) via Generically (RTVar tv s)

mapTyVarValue :: (tv1 -> tv2) -> RTVar tv1 s -> RTVar tv2 s
mapTyVarValue :: forall tv1 tv2 s. (tv1 -> tv2) -> RTVar tv1 s -> RTVar tv2 s
mapTyVarValue tv1 -> tv2
f RTVar tv1 s
v = RTVar tv1 s
v {ty_var_value = f $ ty_var_value v}

dropTyVarInfo :: RTVar tv s1 -> RTVar tv s2
dropTyVarInfo :: forall tv s1 s2. RTVar tv s1 -> RTVar tv s2
dropTyVarInfo RTVar tv s1
v = RTVar tv s1
v{ty_var_info = RTVNoInfo True }

data RTVInfo s
  = RTVNoInfo { forall s. RTVInfo s -> Bool
rtv_is_pol :: Bool }
  | RTVInfo { forall s. RTVInfo s -> Symbol
rtv_name   :: Symbol
            , forall s. RTVInfo s -> s
rtv_kind   :: s
            , forall s. RTVInfo s -> Bool
rtv_is_val :: Bool
            , rtv_is_pol :: Bool -- true iff the type variable gets instantiated with
                                 -- any refinement (ie is polymorphic on refinements),
                                 -- false iff instantiation is with true refinement
            } deriving ((forall x. RTVInfo s -> Rep (RTVInfo s) x)
-> (forall x. Rep (RTVInfo s) x -> RTVInfo s)
-> Generic (RTVInfo s)
forall x. Rep (RTVInfo s) x -> RTVInfo s
forall x. RTVInfo s -> Rep (RTVInfo s) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall s x. Rep (RTVInfo s) x -> RTVInfo s
forall s x. RTVInfo s -> Rep (RTVInfo s) x
$cfrom :: forall s x. RTVInfo s -> Rep (RTVInfo s) x
from :: forall x. RTVInfo s -> Rep (RTVInfo s) x
$cto :: forall s x. Rep (RTVInfo s) x -> RTVInfo s
to :: forall x. Rep (RTVInfo s) x -> RTVInfo s
Generic, Typeable (RTVInfo s)
Typeable (RTVInfo s) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RTVInfo s -> c (RTVInfo s))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RTVInfo s))
-> (RTVInfo s -> Constr)
-> (RTVInfo s -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RTVInfo s)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RTVInfo s)))
-> ((forall b. Data b => b -> b) -> RTVInfo s -> RTVInfo s)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r)
-> (forall u. (forall d. Data d => d -> u) -> RTVInfo s -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RTVInfo s -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s))
-> Data (RTVInfo s)
RTVInfo s -> Constr
RTVInfo s -> DataType
(forall b. Data b => b -> b) -> RTVInfo s -> RTVInfo s
forall s. Data s => Typeable (RTVInfo s)
forall s. Data s => RTVInfo s -> Constr
forall s. Data s => RTVInfo s -> DataType
forall s.
Data s =>
(forall b. Data b => b -> b) -> RTVInfo s -> RTVInfo s
forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> RTVInfo s -> u
forall s u.
Data s =>
(forall d. Data d => d -> u) -> RTVInfo s -> [u]
forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVInfo s)
forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVInfo s -> c (RTVInfo s)
forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVInfo s))
forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVInfo s))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RTVInfo s -> u
forall u. (forall d. Data d => d -> u) -> RTVInfo s -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVInfo s)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVInfo s -> c (RTVInfo s)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVInfo s))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVInfo s))
$cgfoldl :: forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVInfo s -> c (RTVInfo s)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RTVInfo s -> c (RTVInfo s)
$cgunfold :: forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVInfo s)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RTVInfo s)
$ctoConstr :: forall s. Data s => RTVInfo s -> Constr
toConstr :: RTVInfo s -> Constr
$cdataTypeOf :: forall s. Data s => RTVInfo s -> DataType
dataTypeOf :: RTVInfo s -> DataType
$cdataCast1 :: forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVInfo s))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVInfo s))
$cdataCast2 :: forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVInfo s))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RTVInfo s))
$cgmapT :: forall s.
Data s =>
(forall b. Data b => b -> b) -> RTVInfo s -> RTVInfo s
gmapT :: (forall b. Data b => b -> b) -> RTVInfo s -> RTVInfo s
$cgmapQl :: forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
$cgmapQr :: forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVInfo s -> r
$cgmapQ :: forall s u.
Data s =>
(forall d. Data d => d -> u) -> RTVInfo s -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RTVInfo s -> [u]
$cgmapQi :: forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> RTVInfo s -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RTVInfo s -> u
$cgmapM :: forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
$cgmapMp :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
$cgmapMo :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RTVInfo s -> m (RTVInfo s)
Data, (forall a b. (a -> b) -> RTVInfo a -> RTVInfo b)
-> (forall a b. a -> RTVInfo b -> RTVInfo a) -> Functor RTVInfo
forall a b. a -> RTVInfo b -> RTVInfo a
forall a b. (a -> b) -> RTVInfo a -> RTVInfo b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> RTVInfo a -> RTVInfo b
fmap :: forall a b. (a -> b) -> RTVInfo a -> RTVInfo b
$c<$ :: forall a b. a -> RTVInfo b -> RTVInfo a
<$ :: forall a b. a -> RTVInfo b -> RTVInfo a
Functor, RTVInfo s -> RTVInfo s -> Bool
(RTVInfo s -> RTVInfo s -> Bool)
-> (RTVInfo s -> RTVInfo s -> Bool) -> Eq (RTVInfo s)
forall s. Eq s => RTVInfo s -> RTVInfo s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall s. Eq s => RTVInfo s -> RTVInfo s -> Bool
== :: RTVInfo s -> RTVInfo s -> Bool
$c/= :: forall s. Eq s => RTVInfo s -> RTVInfo s -> Bool
/= :: RTVInfo s -> RTVInfo s -> Bool
Eq, (forall m. Monoid m => RTVInfo m -> m)
-> (forall m a. Monoid m => (a -> m) -> RTVInfo a -> m)
-> (forall m a. Monoid m => (a -> m) -> RTVInfo a -> m)
-> (forall a b. (a -> b -> b) -> b -> RTVInfo a -> b)
-> (forall a b. (a -> b -> b) -> b -> RTVInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTVInfo a -> b)
-> (forall b a. (b -> a -> b) -> b -> RTVInfo a -> b)
-> (forall a. (a -> a -> a) -> RTVInfo a -> a)
-> (forall a. (a -> a -> a) -> RTVInfo a -> a)
-> (forall a. RTVInfo a -> [a])
-> (forall s. RTVInfo s -> Bool)
-> (forall a. RTVInfo a -> Int)
-> (forall a. Eq a => a -> RTVInfo a -> Bool)
-> (forall a. Ord a => RTVInfo a -> a)
-> (forall a. Ord a => RTVInfo a -> a)
-> (forall a. Num a => RTVInfo a -> a)
-> (forall a. Num a => RTVInfo a -> a)
-> Foldable RTVInfo
forall a. Eq a => a -> RTVInfo a -> Bool
forall a. Num a => RTVInfo a -> a
forall a. Ord a => RTVInfo a -> a
forall m. Monoid m => RTVInfo m -> m
forall s. RTVInfo s -> Bool
forall a. RTVInfo a -> Int
forall a. RTVInfo a -> [a]
forall a. (a -> a -> a) -> RTVInfo a -> a
forall m a. Monoid m => (a -> m) -> RTVInfo a -> m
forall b a. (b -> a -> b) -> b -> RTVInfo a -> b
forall a b. (a -> b -> b) -> b -> RTVInfo a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => RTVInfo m -> m
fold :: forall m. Monoid m => RTVInfo m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RTVInfo a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RTVInfo a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RTVInfo a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RTVInfo a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> RTVInfo a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RTVInfo a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RTVInfo a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RTVInfo a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RTVInfo a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RTVInfo a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RTVInfo a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RTVInfo a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> RTVInfo a -> a
foldr1 :: forall a. (a -> a -> a) -> RTVInfo a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RTVInfo a -> a
foldl1 :: forall a. (a -> a -> a) -> RTVInfo a -> a
$ctoList :: forall a. RTVInfo a -> [a]
toList :: forall a. RTVInfo a -> [a]
$cnull :: forall s. RTVInfo s -> Bool
null :: forall s. RTVInfo s -> Bool
$clength :: forall a. RTVInfo a -> Int
length :: forall a. RTVInfo a -> Int
$celem :: forall a. Eq a => a -> RTVInfo a -> Bool
elem :: forall a. Eq a => a -> RTVInfo a -> Bool
$cmaximum :: forall a. Ord a => RTVInfo a -> a
maximum :: forall a. Ord a => RTVInfo a -> a
$cminimum :: forall a. Ord a => RTVInfo a -> a
minimum :: forall a. Ord a => RTVInfo a -> a
$csum :: forall a. Num a => RTVInfo a -> a
sum :: forall a. Num a => RTVInfo a -> a
$cproduct :: forall a. Num a => RTVInfo a -> a
product :: forall a. Num a => RTVInfo a -> a
Foldable, Functor RTVInfo
Foldable RTVInfo
(Functor RTVInfo, Foldable RTVInfo) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RTVInfo a -> f (RTVInfo b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RTVInfo (f a) -> f (RTVInfo a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RTVInfo a -> m (RTVInfo b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RTVInfo (m a) -> m (RTVInfo a))
-> Traversable RTVInfo
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RTVInfo (m a) -> m (RTVInfo a)
forall (f :: * -> *) a.
Applicative f =>
RTVInfo (f a) -> f (RTVInfo a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVInfo a -> m (RTVInfo b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVInfo a -> f (RTVInfo b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVInfo a -> f (RTVInfo b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RTVInfo a -> f (RTVInfo b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RTVInfo (f a) -> f (RTVInfo a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RTVInfo (f a) -> f (RTVInfo a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVInfo a -> m (RTVInfo b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RTVInfo a -> m (RTVInfo b)
$csequence :: forall (m :: * -> *) a. Monad m => RTVInfo (m a) -> m (RTVInfo a)
sequence :: forall (m :: * -> *) a. Monad m => RTVInfo (m a) -> m (RTVInfo a)
Traversable)
              deriving (Get (RTVInfo s)
[RTVInfo s] -> Put
RTVInfo s -> Put
(RTVInfo s -> Put)
-> Get (RTVInfo s) -> ([RTVInfo s] -> Put) -> Binary (RTVInfo s)
forall s. Binary s => Get (RTVInfo s)
forall s. Binary s => [RTVInfo s] -> Put
forall s. Binary s => RTVInfo s -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall s. Binary s => RTVInfo s -> Put
put :: RTVInfo s -> Put
$cget :: forall s. Binary s => Get (RTVInfo s)
get :: Get (RTVInfo s)
$cputList :: forall s. Binary s => [RTVInfo s] -> Put
putList :: [RTVInfo s] -> Put
B.Binary, Eq (RTVInfo s)
Eq (RTVInfo s) =>
(Int -> RTVInfo s -> Int)
-> (RTVInfo s -> Int) -> Hashable (RTVInfo s)
Int -> RTVInfo s -> Int
RTVInfo s -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall s. Hashable s => Eq (RTVInfo s)
forall s. Hashable s => Int -> RTVInfo s -> Int
forall s. Hashable s => RTVInfo s -> Int
$chashWithSalt :: forall s. Hashable s => Int -> RTVInfo s -> Int
hashWithSalt :: Int -> RTVInfo s -> Int
$chash :: forall s. Hashable s => RTVInfo s -> Int
hash :: RTVInfo s -> Int
Hashable) via Generically (RTVInfo s)


setRtvPol :: RTVar tv a -> Bool -> RTVar tv a
setRtvPol :: forall tv a. RTVar tv a -> Bool -> RTVar tv a
setRtvPol (RTVar tv
a RTVInfo a
i) Bool
b = tv -> RTVInfo a -> RTVar tv a
forall tv s. tv -> RTVInfo s -> RTVar tv s
RTVar tv
a (RTVInfo a
i{rtv_is_pol = b})

rTVarToBind :: RTVar RTyVar s  -> Maybe (Symbol, s)
rTVarToBind :: forall s. RTVar RTyVar s -> Maybe (Symbol, s)
rTVarToBind = RTVInfo s -> Maybe (Symbol, s)
forall {b}. RTVInfo b -> Maybe (Symbol, b)
go (RTVInfo s -> Maybe (Symbol, s))
-> (RTVar RTyVar s -> RTVInfo s)
-> RTVar RTyVar s
-> Maybe (Symbol, s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RTVar RTyVar s -> RTVInfo s
forall tv s. RTVar tv s -> RTVInfo s
ty_var_info
  where
    go :: RTVInfo b -> Maybe (Symbol, b)
go RTVInfo{b
Bool
Symbol
rtv_is_pol :: forall s. RTVInfo s -> Bool
rtv_name :: forall s. RTVInfo s -> Symbol
rtv_kind :: forall s. RTVInfo s -> s
rtv_is_val :: forall s. RTVInfo s -> Bool
rtv_name :: Symbol
rtv_kind :: b
rtv_is_val :: Bool
rtv_is_pol :: Bool
..} | Bool
rtv_is_val = (Symbol, b) -> Maybe (Symbol, b)
forall a. a -> Maybe a
Just (Symbol
rtv_name, b
rtv_kind)
    go RTVInfo b
_                        = Maybe (Symbol, b)
forall a. Maybe a
Nothing

instance (NFData tv, NFData s)     => NFData   (RTVar tv s)
instance (NFData s)                => NFData   (RTVInfo s)

type Ref τ t = RefB Symbol τ t

-- | @Ref@ describes `Prop τ` and `HProp` arguments applied to type constructors.
--   For example, in [a]<{\h -> v > h}>, we apply (via `RApp`)
--   * the `RProp`  denoted by `{\h -> v > h}` to
--   * the `RTyCon` denoted by `[]`.
--   Thus, @Ref@ is used for abstract-predicate (arguments) that are associated
--   with _type constructors_ i.e. whose semantics are _dependent upon_ the data-type.
--   In contrast, the `Predicate` argument in `ur_pred` in the @UReft@ applies
--   directly to any type and has semantics _independent of_ the data-type.

data RefB b τ t = RProp
  { forall b τ t. RefB b τ t -> [(b, τ)]
rf_args :: [(b, τ)] -- ^ arguments. e.g. @h@ in the above example
  , forall b τ t. RefB b τ t -> t
rf_body :: t -- ^ Abstract refinement associated with `RTyCon`. e.g. @v > h@ in the above example
  } deriving (RefB b τ t -> RefB b τ t -> Bool
(RefB b τ t -> RefB b τ t -> Bool)
-> (RefB b τ t -> RefB b τ t -> Bool) -> Eq (RefB b τ t)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall b τ t.
(Eq b, Eq τ, Eq t) =>
RefB b τ t -> RefB b τ t -> Bool
$c== :: forall b τ t.
(Eq b, Eq τ, Eq t) =>
RefB b τ t -> RefB b τ t -> Bool
== :: RefB b τ t -> RefB b τ t -> Bool
$c/= :: forall b τ t.
(Eq b, Eq τ, Eq t) =>
RefB b τ t -> RefB b τ t -> Bool
/= :: RefB b τ t -> RefB b τ t -> Bool
Eq, (forall x. RefB b τ t -> Rep (RefB b τ t) x)
-> (forall x. Rep (RefB b τ t) x -> RefB b τ t)
-> Generic (RefB b τ t)
forall x. Rep (RefB b τ t) x -> RefB b τ t
forall x. RefB b τ t -> Rep (RefB b τ t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b τ t x. Rep (RefB b τ t) x -> RefB b τ t
forall b τ t x. RefB b τ t -> Rep (RefB b τ t) x
$cfrom :: forall b τ t x. RefB b τ t -> Rep (RefB b τ t) x
from :: forall x. RefB b τ t -> Rep (RefB b τ t) x
$cto :: forall b τ t x. Rep (RefB b τ t) x -> RefB b τ t
to :: forall x. Rep (RefB b τ t) x -> RefB b τ t
Generic, Typeable (RefB b τ t)
Typeable (RefB b τ t) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RefB b τ t -> c (RefB b τ t))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (RefB b τ t))
-> (RefB b τ t -> Constr)
-> (RefB b τ t -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (RefB b τ t)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (RefB b τ t)))
-> ((forall b. Data b => b -> b) -> RefB b τ t -> RefB b τ t)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r)
-> (forall u. (forall d. Data d => d -> u) -> RefB b τ t -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RefB b τ t -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t))
-> Data (RefB b τ t)
RefB b τ t -> Constr
RefB b τ t -> DataType
(forall b. Data b => b -> b) -> RefB b τ t -> RefB b τ t
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RefB b τ t -> u
forall u. (forall d. Data d => d -> u) -> RefB b τ t -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
forall b τ t. (Data b, Data τ, Data t) => Typeable (RefB b τ t)
forall b τ t. (Data b, Data τ, Data t) => RefB b τ t -> Constr
forall b τ t. (Data b, Data τ, Data t) => RefB b τ t -> DataType
forall b τ t.
(Data b, Data τ, Data t) =>
(forall b. Data b => b -> b) -> RefB b τ t -> RefB b τ t
forall b τ t u.
(Data b, Data τ, Data t) =>
Int -> (forall d. Data d => d -> u) -> RefB b τ t -> u
forall b τ t u.
(Data b, Data τ, Data t) =>
(forall d. Data d => d -> u) -> RefB b τ t -> [u]
forall b τ t r r'.
(Data b, Data τ, Data t) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
forall b τ t r r'.
(Data b, Data τ, Data t) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
forall b τ t (m :: * -> *).
(Data b, Data τ, Data t, Monad m) =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
forall b τ t (m :: * -> *).
(Data b, Data τ, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
forall b τ t (c :: * -> *).
(Data b, Data τ, Data t) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RefB b τ t)
forall b τ t (c :: * -> *).
(Data b, Data τ, Data t) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefB b τ t -> c (RefB b τ t)
forall b τ t (t :: * -> *) (c :: * -> *).
(Data b, Data τ, Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RefB b τ t))
forall b τ t (t :: * -> * -> *) (c :: * -> *).
(Data b, Data τ, Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RefB b τ t))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RefB b τ t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefB b τ t -> c (RefB b τ t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RefB b τ t))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RefB b τ t))
$cgfoldl :: forall b τ t (c :: * -> *).
(Data b, Data τ, Data t) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefB b τ t -> c (RefB b τ t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefB b τ t -> c (RefB b τ t)
$cgunfold :: forall b τ t (c :: * -> *).
(Data b, Data τ, Data t) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RefB b τ t)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (RefB b τ t)
$ctoConstr :: forall b τ t. (Data b, Data τ, Data t) => RefB b τ t -> Constr
toConstr :: RefB b τ t -> Constr
$cdataTypeOf :: forall b τ t. (Data b, Data τ, Data t) => RefB b τ t -> DataType
dataTypeOf :: RefB b τ t -> DataType
$cdataCast1 :: forall b τ t (t :: * -> *) (c :: * -> *).
(Data b, Data τ, Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RefB b τ t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (RefB b τ t))
$cdataCast2 :: forall b τ t (t :: * -> * -> *) (c :: * -> *).
(Data b, Data τ, Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RefB b τ t))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (RefB b τ t))
$cgmapT :: forall b τ t.
(Data b, Data τ, Data t) =>
(forall b. Data b => b -> b) -> RefB b τ t -> RefB b τ t
gmapT :: (forall b. Data b => b -> b) -> RefB b τ t -> RefB b τ t
$cgmapQl :: forall b τ t r r'.
(Data b, Data τ, Data t) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
$cgmapQr :: forall b τ t r r'.
(Data b, Data τ, Data t) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefB b τ t -> r
$cgmapQ :: forall b τ t u.
(Data b, Data τ, Data t) =>
(forall d. Data d => d -> u) -> RefB b τ t -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RefB b τ t -> [u]
$cgmapQi :: forall b τ t u.
(Data b, Data τ, Data t) =>
Int -> (forall d. Data d => d -> u) -> RefB b τ t -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RefB b τ t -> u
$cgmapM :: forall b τ t (m :: * -> *).
(Data b, Data τ, Data t, Monad m) =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
$cgmapMp :: forall b τ t (m :: * -> *).
(Data b, Data τ, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
$cgmapMo :: forall b τ t (m :: * -> *).
(Data b, Data τ, Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefB b τ t -> m (RefB b τ t)
Data, (forall a b. (a -> b) -> RefB b τ a -> RefB b τ b)
-> (forall a b. a -> RefB b τ b -> RefB b τ a)
-> Functor (RefB b τ)
forall a b. a -> RefB b τ b -> RefB b τ a
forall a b. (a -> b) -> RefB b τ a -> RefB b τ b
forall b τ a b. a -> RefB b τ b -> RefB b τ a
forall b τ a b. (a -> b) -> RefB b τ a -> RefB b τ b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall b τ a b. (a -> b) -> RefB b τ a -> RefB b τ b
fmap :: forall a b. (a -> b) -> RefB b τ a -> RefB b τ b
$c<$ :: forall b τ a b. a -> RefB b τ b -> RefB b τ a
<$ :: forall a b. a -> RefB b τ b -> RefB b τ a
Functor, (forall m. Monoid m => RefB b τ m -> m)
-> (forall m a. Monoid m => (a -> m) -> RefB b τ a -> m)
-> (forall m a. Monoid m => (a -> m) -> RefB b τ a -> m)
-> (forall a b. (a -> b -> b) -> b -> RefB b τ a -> b)
-> (forall a b. (a -> b -> b) -> b -> RefB b τ a -> b)
-> (forall b a. (b -> a -> b) -> b -> RefB b τ a -> b)
-> (forall b a. (b -> a -> b) -> b -> RefB b τ a -> b)
-> (forall a. (a -> a -> a) -> RefB b τ a -> a)
-> (forall a. (a -> a -> a) -> RefB b τ a -> a)
-> (forall a. RefB b τ a -> [a])
-> (forall a. RefB b τ a -> Bool)
-> (forall a. RefB b τ a -> Int)
-> (forall a. Eq a => a -> RefB b τ a -> Bool)
-> (forall a. Ord a => RefB b τ a -> a)
-> (forall a. Ord a => RefB b τ a -> a)
-> (forall a. Num a => RefB b τ a -> a)
-> (forall a. Num a => RefB b τ a -> a)
-> Foldable (RefB b τ)
forall a. Eq a => a -> RefB b τ a -> Bool
forall a. Num a => RefB b τ a -> a
forall a. Ord a => RefB b τ a -> a
forall m. Monoid m => RefB b τ m -> m
forall a. RefB b τ a -> Bool
forall a. RefB b τ a -> Int
forall a. RefB b τ a -> [a]
forall a. (a -> a -> a) -> RefB b τ a -> a
forall m a. Monoid m => (a -> m) -> RefB b τ a -> m
forall b a. (b -> a -> b) -> b -> RefB b τ a -> b
forall a b. (a -> b -> b) -> b -> RefB b τ a -> b
forall b τ a. Eq a => a -> RefB b τ a -> Bool
forall b τ a. Num a => RefB b τ a -> a
forall b τ a. Ord a => RefB b τ a -> a
forall b τ m. Monoid m => RefB b τ m -> m
forall b τ a. RefB b τ a -> Bool
forall b τ a. RefB b τ a -> Int
forall b τ a. RefB b τ a -> [a]
forall b τ a. (a -> a -> a) -> RefB b τ a -> a
forall b τ m a. Monoid m => (a -> m) -> RefB b τ a -> m
forall b τ b a. (b -> a -> b) -> b -> RefB b τ a -> b
forall b τ a b. (a -> b -> b) -> b -> RefB b τ a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall b τ m. Monoid m => RefB b τ m -> m
fold :: forall m. Monoid m => RefB b τ m -> m
$cfoldMap :: forall b τ m a. Monoid m => (a -> m) -> RefB b τ a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RefB b τ a -> m
$cfoldMap' :: forall b τ m a. Monoid m => (a -> m) -> RefB b τ a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> RefB b τ a -> m
$cfoldr :: forall b τ a b. (a -> b -> b) -> b -> RefB b τ a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RefB b τ a -> b
$cfoldr' :: forall b τ a b. (a -> b -> b) -> b -> RefB b τ a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RefB b τ a -> b
$cfoldl :: forall b τ b a. (b -> a -> b) -> b -> RefB b τ a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RefB b τ a -> b
$cfoldl' :: forall b τ b a. (b -> a -> b) -> b -> RefB b τ a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> RefB b τ a -> b
$cfoldr1 :: forall b τ a. (a -> a -> a) -> RefB b τ a -> a
foldr1 :: forall a. (a -> a -> a) -> RefB b τ a -> a
$cfoldl1 :: forall b τ a. (a -> a -> a) -> RefB b τ a -> a
foldl1 :: forall a. (a -> a -> a) -> RefB b τ a -> a
$ctoList :: forall b τ a. RefB b τ a -> [a]
toList :: forall a. RefB b τ a -> [a]
$cnull :: forall b τ a. RefB b τ a -> Bool
null :: forall a. RefB b τ a -> Bool
$clength :: forall b τ a. RefB b τ a -> Int
length :: forall a. RefB b τ a -> Int
$celem :: forall b τ a. Eq a => a -> RefB b τ a -> Bool
elem :: forall a. Eq a => a -> RefB b τ a -> Bool
$cmaximum :: forall b τ a. Ord a => RefB b τ a -> a
maximum :: forall a. Ord a => RefB b τ a -> a
$cminimum :: forall b τ a. Ord a => RefB b τ a -> a
minimum :: forall a. Ord a => RefB b τ a -> a
$csum :: forall b τ a. Num a => RefB b τ a -> a
sum :: forall a. Num a => RefB b τ a -> a
$cproduct :: forall b τ a. Num a => RefB b τ a -> a
product :: forall a. Num a => RefB b τ a -> a
Foldable, Functor (RefB b τ)
Foldable (RefB b τ)
(Functor (RefB b τ), Foldable (RefB b τ)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> RefB b τ a -> f (RefB b τ b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RefB b τ (f a) -> f (RefB b τ a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RefB b τ a -> m (RefB b τ b))
-> (forall (m :: * -> *) a.
    Monad m =>
    RefB b τ (m a) -> m (RefB b τ a))
-> Traversable (RefB b τ)
forall b τ. Functor (RefB b τ)
forall b τ. Foldable (RefB b τ)
forall b τ (m :: * -> *) a.
Monad m =>
RefB b τ (m a) -> m (RefB b τ a)
forall b τ (f :: * -> *) a.
Applicative f =>
RefB b τ (f a) -> f (RefB b τ a)
forall b τ (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RefB b τ a -> m (RefB b τ b)
forall b τ (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RefB b τ a -> f (RefB b τ b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => RefB b τ (m a) -> m (RefB b τ a)
forall (f :: * -> *) a.
Applicative f =>
RefB b τ (f a) -> f (RefB b τ a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RefB b τ a -> m (RefB b τ b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RefB b τ a -> f (RefB b τ b)
$ctraverse :: forall b τ (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RefB b τ a -> f (RefB b τ b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RefB b τ a -> f (RefB b τ b)
$csequenceA :: forall b τ (f :: * -> *) a.
Applicative f =>
RefB b τ (f a) -> f (RefB b τ a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RefB b τ (f a) -> f (RefB b τ a)
$cmapM :: forall b τ (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RefB b τ a -> m (RefB b τ b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RefB b τ a -> m (RefB b τ b)
$csequence :: forall b τ (m :: * -> *) a.
Monad m =>
RefB b τ (m a) -> m (RefB b τ a)
sequence :: forall (m :: * -> *) a. Monad m => RefB b τ (m a) -> m (RefB b τ a)
Traversable)
    deriving (Get (RefB b τ t)
[RefB b τ t] -> Put
RefB b τ t -> Put
(RefB b τ t -> Put)
-> Get (RefB b τ t) -> ([RefB b τ t] -> Put) -> Binary (RefB b τ t)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall b τ t. (Binary b, Binary τ, Binary t) => Get (RefB b τ t)
forall b τ t. (Binary b, Binary τ, Binary t) => [RefB b τ t] -> Put
forall b τ t. (Binary b, Binary τ, Binary t) => RefB b τ t -> Put
$cput :: forall b τ t. (Binary b, Binary τ, Binary t) => RefB b τ t -> Put
put :: RefB b τ t -> Put
$cget :: forall b τ t. (Binary b, Binary τ, Binary t) => Get (RefB b τ t)
get :: Get (RefB b τ t)
$cputList :: forall b τ t. (Binary b, Binary τ, Binary t) => [RefB b τ t] -> Put
putList :: [RefB b τ t] -> Put
B.Binary, Eq (RefB b τ t)
Eq (RefB b τ t) =>
(Int -> RefB b τ t -> Int)
-> (RefB b τ t -> Int) -> Hashable (RefB b τ t)
Int -> RefB b τ t -> Int
RefB b τ t -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall b τ t.
(Hashable b, Hashable τ, Hashable t) =>
Eq (RefB b τ t)
forall b τ t.
(Hashable b, Hashable τ, Hashable t) =>
Int -> RefB b τ t -> Int
forall b τ t.
(Hashable b, Hashable τ, Hashable t) =>
RefB b τ t -> Int
$chashWithSalt :: forall b τ t.
(Hashable b, Hashable τ, Hashable t) =>
Int -> RefB b τ t -> Int
hashWithSalt :: Int -> RefB b τ t -> Int
$chash :: forall b τ t.
(Hashable b, Hashable τ, Hashable t) =>
RefB b τ t -> Int
hash :: RefB b τ t -> Int
Hashable) via Generically (RefB b τ t)

instance (NFData τ,   NFData t)   => NFData   (Ref τ t)

rPropP :: [(b, τ)] -> r -> RefB b τ (RTypeV v c tv r)
rPropP :: forall b τ r v c tv. [(b, τ)] -> r -> RefB b τ (RTypeV v c tv r)
rPropP [(b, τ)]
τ r
r = [(b, τ)] -> RTypeV v c tv r -> RefB b τ (RTypeV v c tv r)
forall b τ t. [(b, τ)] -> t -> RefB b τ t
RProp [(b, τ)]
τ (r -> RTypeV v c tv r
forall b v c tv r. r -> RTypeBV b v c tv r
RHole r
r)

-- | @RTProp@ is a convenient alias for @Ref@ that will save a bunch of typing.
--   In general, perhaps we need not expose @Ref@ directly at all.
type RTProp c tv r = RTPropV Symbol c tv r
type RTPropV v c tv r = RTPropBV Symbol v c tv r
type RTPropBV b v c tv r = RefB b (RTypeBV b v c tv (NoReftB b)) (RTypeBV b v c tv r)

type UReft r = UReftV F.Symbol r
type UReftV v r = UReftBV F.Symbol v r
data UReftBV b v r = MkUReft
  { forall b v r. UReftBV b v r -> r
ur_reft   :: !r
  , forall b v r. UReftBV b v r -> PredicateBV b v
ur_pred   :: !(PredicateBV b v)
  }
  deriving (UReftBV b v r -> UReftBV b v r -> Bool
(UReftBV b v r -> UReftBV b v r -> Bool)
-> (UReftBV b v r -> UReftBV b v r -> Bool) -> Eq (UReftBV b v r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall b v r.
(Ord b, Ord v, Eq r) =>
UReftBV b v r -> UReftBV b v r -> Bool
$c== :: forall b v r.
(Ord b, Ord v, Eq r) =>
UReftBV b v r -> UReftBV b v r -> Bool
== :: UReftBV b v r -> UReftBV b v r -> Bool
$c/= :: forall b v r.
(Ord b, Ord v, Eq r) =>
UReftBV b v r -> UReftBV b v r -> Bool
/= :: UReftBV b v r -> UReftBV b v r -> Bool
Eq, (forall x. UReftBV b v r -> Rep (UReftBV b v r) x)
-> (forall x. Rep (UReftBV b v r) x -> UReftBV b v r)
-> Generic (UReftBV b v r)
forall x. Rep (UReftBV b v r) x -> UReftBV b v r
forall x. UReftBV b v r -> Rep (UReftBV b v r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b v r x. Rep (UReftBV b v r) x -> UReftBV b v r
forall b v r x. UReftBV b v r -> Rep (UReftBV b v r) x
$cfrom :: forall b v r x. UReftBV b v r -> Rep (UReftBV b v r) x
from :: forall x. UReftBV b v r -> Rep (UReftBV b v r) x
$cto :: forall b v r x. Rep (UReftBV b v r) x -> UReftBV b v r
to :: forall x. Rep (UReftBV b v r) x -> UReftBV b v r
Generic, Typeable (UReftBV b v r)
Typeable (UReftBV b v r) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UReftBV b v r -> c (UReftBV b v r))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (UReftBV b v r))
-> (UReftBV b v r -> Constr)
-> (UReftBV b v r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (UReftBV b v r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (UReftBV b v r)))
-> ((forall b. Data b => b -> b) -> UReftBV b v r -> UReftBV b v r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r)
-> (forall u. (forall d. Data d => d -> u) -> UReftBV b v r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UReftBV b v r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UReftBV b v r -> m (UReftBV b v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UReftBV b v r -> m (UReftBV b v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UReftBV b v r -> m (UReftBV b v r))
-> Data (UReftBV b v r)
UReftBV b v r -> Constr
UReftBV b v r -> DataType
(forall b. Data b => b -> b) -> UReftBV b v r -> UReftBV b v r
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UReftBV b v r -> u
forall u. (forall d. Data d => d -> u) -> UReftBV b v r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
forall b v r. (Data r, Data v, Data b) => Typeable (UReftBV b v r)
forall b v r. (Data r, Data v, Data b) => UReftBV b v r -> Constr
forall b v r. (Data r, Data v, Data b) => UReftBV b v r -> DataType
forall b v r.
(Data r, Data v, Data b) =>
(forall b. Data b => b -> b) -> UReftBV b v r -> UReftBV b v r
forall b v r u.
(Data r, Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> UReftBV b v r -> u
forall b v r u.
(Data r, Data v, Data b) =>
(forall d. Data d => d -> u) -> UReftBV b v r -> [u]
forall b v r r r'.
(Data r, Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
forall b v r r r'.
(Data r, Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
forall b v r (m :: * -> *).
(Data r, Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
forall b v r (m :: * -> *).
(Data r, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
forall b v r (c :: * -> *).
(Data r, Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UReftBV b v r)
forall b v r (c :: * -> *).
(Data r, Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UReftBV b v r -> c (UReftBV b v r)
forall b v r (t :: * -> *) (c :: * -> *).
(Data r, Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (UReftBV b v r))
forall b v r (t :: * -> * -> *) (c :: * -> *).
(Data r, Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UReftBV b v r))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UReftBV b v r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UReftBV b v r -> c (UReftBV b v r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (UReftBV b v r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UReftBV b v r))
$cgfoldl :: forall b v r (c :: * -> *).
(Data r, Data v, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UReftBV b v r -> c (UReftBV b v r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UReftBV b v r -> c (UReftBV b v r)
$cgunfold :: forall b v r (c :: * -> *).
(Data r, Data v, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UReftBV b v r)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UReftBV b v r)
$ctoConstr :: forall b v r. (Data r, Data v, Data b) => UReftBV b v r -> Constr
toConstr :: UReftBV b v r -> Constr
$cdataTypeOf :: forall b v r. (Data r, Data v, Data b) => UReftBV b v r -> DataType
dataTypeOf :: UReftBV b v r -> DataType
$cdataCast1 :: forall b v r (t :: * -> *) (c :: * -> *).
(Data r, Data v, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (UReftBV b v r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (UReftBV b v r))
$cdataCast2 :: forall b v r (t :: * -> * -> *) (c :: * -> *).
(Data r, Data v, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UReftBV b v r))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UReftBV b v r))
$cgmapT :: forall b v r.
(Data r, Data v, Data b) =>
(forall b. Data b => b -> b) -> UReftBV b v r -> UReftBV b v r
gmapT :: (forall b. Data b => b -> b) -> UReftBV b v r -> UReftBV b v r
$cgmapQl :: forall b v r r r'.
(Data r, Data v, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
$cgmapQr :: forall b v r r r'.
(Data r, Data v, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UReftBV b v r -> r
$cgmapQ :: forall b v r u.
(Data r, Data v, Data b) =>
(forall d. Data d => d -> u) -> UReftBV b v r -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UReftBV b v r -> [u]
$cgmapQi :: forall b v r u.
(Data r, Data v, Data b) =>
Int -> (forall d. Data d => d -> u) -> UReftBV b v r -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UReftBV b v r -> u
$cgmapM :: forall b v r (m :: * -> *).
(Data r, Data v, Data b, Monad m) =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
$cgmapMp :: forall b v r (m :: * -> *).
(Data r, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
$cgmapMo :: forall b v r (m :: * -> *).
(Data r, Data v, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UReftBV b v r -> m (UReftBV b v r)
Data, (forall a b. (a -> b) -> UReftBV b v a -> UReftBV b v b)
-> (forall a b. a -> UReftBV b v b -> UReftBV b v a)
-> Functor (UReftBV b v)
forall a b. a -> UReftBV b v b -> UReftBV b v a
forall a b. (a -> b) -> UReftBV b v a -> UReftBV b v b
forall b v a b. a -> UReftBV b v b -> UReftBV b v a
forall b v a b. (a -> b) -> UReftBV b v a -> UReftBV b v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall b v a b. (a -> b) -> UReftBV b v a -> UReftBV b v b
fmap :: forall a b. (a -> b) -> UReftBV b v a -> UReftBV b v b
$c<$ :: forall b v a b. a -> UReftBV b v b -> UReftBV b v a
<$ :: forall a b. a -> UReftBV b v b -> UReftBV b v a
Functor, (forall m. Monoid m => UReftBV b v m -> m)
-> (forall m a. Monoid m => (a -> m) -> UReftBV b v a -> m)
-> (forall m a. Monoid m => (a -> m) -> UReftBV b v a -> m)
-> (forall a b. (a -> b -> b) -> b -> UReftBV b v a -> b)
-> (forall a b. (a -> b -> b) -> b -> UReftBV b v a -> b)
-> (forall b a. (b -> a -> b) -> b -> UReftBV b v a -> b)
-> (forall b a. (b -> a -> b) -> b -> UReftBV b v a -> b)
-> (forall a. (a -> a -> a) -> UReftBV b v a -> a)
-> (forall a. (a -> a -> a) -> UReftBV b v a -> a)
-> (forall a. UReftBV b v a -> [a])
-> (forall a. UReftBV b v a -> Bool)
-> (forall a. UReftBV b v a -> Int)
-> (forall a. Eq a => a -> UReftBV b v a -> Bool)
-> (forall a. Ord a => UReftBV b v a -> a)
-> (forall a. Ord a => UReftBV b v a -> a)
-> (forall a. Num a => UReftBV b v a -> a)
-> (forall a. Num a => UReftBV b v a -> a)
-> Foldable (UReftBV b v)
forall a. Eq a => a -> UReftBV b v a -> Bool
forall a. Num a => UReftBV b v a -> a
forall a. Ord a => UReftBV b v a -> a
forall m. Monoid m => UReftBV b v m -> m
forall a. UReftBV b v a -> Bool
forall a. UReftBV b v a -> Int
forall a. UReftBV b v a -> [a]
forall a. (a -> a -> a) -> UReftBV b v a -> a
forall m a. Monoid m => (a -> m) -> UReftBV b v a -> m
forall b a. (b -> a -> b) -> b -> UReftBV b v a -> b
forall a b. (a -> b -> b) -> b -> UReftBV b v a -> b
forall b v a. Eq a => a -> UReftBV b v a -> Bool
forall b v a. Num a => UReftBV b v a -> a
forall b v a. Ord a => UReftBV b v a -> a
forall b v m. Monoid m => UReftBV b v m -> m
forall b v a. UReftBV b v a -> Bool
forall b v a. UReftBV b v a -> Int
forall b v a. UReftBV b v a -> [a]
forall b v a. (a -> a -> a) -> UReftBV b v a -> a
forall b v m a. Monoid m => (a -> m) -> UReftBV b v a -> m
forall b v b a. (b -> a -> b) -> b -> UReftBV b v a -> b
forall b v a b. (a -> b -> b) -> b -> UReftBV b v a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall b v m. Monoid m => UReftBV b v m -> m
fold :: forall m. Monoid m => UReftBV b v m -> m
$cfoldMap :: forall b v m a. Monoid m => (a -> m) -> UReftBV b v a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> UReftBV b v a -> m
$cfoldMap' :: forall b v m a. Monoid m => (a -> m) -> UReftBV b v a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> UReftBV b v a -> m
$cfoldr :: forall b v a b. (a -> b -> b) -> b -> UReftBV b v a -> b
foldr :: forall a b. (a -> b -> b) -> b -> UReftBV b v a -> b
$cfoldr' :: forall b v a b. (a -> b -> b) -> b -> UReftBV b v a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> UReftBV b v a -> b
$cfoldl :: forall b v b a. (b -> a -> b) -> b -> UReftBV b v a -> b
foldl :: forall b a. (b -> a -> b) -> b -> UReftBV b v a -> b
$cfoldl' :: forall b v b a. (b -> a -> b) -> b -> UReftBV b v a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> UReftBV b v a -> b
$cfoldr1 :: forall b v a. (a -> a -> a) -> UReftBV b v a -> a
foldr1 :: forall a. (a -> a -> a) -> UReftBV b v a -> a
$cfoldl1 :: forall b v a. (a -> a -> a) -> UReftBV b v a -> a
foldl1 :: forall a. (a -> a -> a) -> UReftBV b v a -> a
$ctoList :: forall b v a. UReftBV b v a -> [a]
toList :: forall a. UReftBV b v a -> [a]
$cnull :: forall b v a. UReftBV b v a -> Bool
null :: forall a. UReftBV b v a -> Bool
$clength :: forall b v a. UReftBV b v a -> Int
length :: forall a. UReftBV b v a -> Int
$celem :: forall b v a. Eq a => a -> UReftBV b v a -> Bool
elem :: forall a. Eq a => a -> UReftBV b v a -> Bool
$cmaximum :: forall b v a. Ord a => UReftBV b v a -> a
maximum :: forall a. Ord a => UReftBV b v a -> a
$cminimum :: forall b v a. Ord a => UReftBV b v a -> a
minimum :: forall a. Ord a => UReftBV b v a -> a
$csum :: forall b v a. Num a => UReftBV b v a -> a
sum :: forall a. Num a => UReftBV b v a -> a
$cproduct :: forall b v a. Num a => UReftBV b v a -> a
product :: forall a. Num a => UReftBV b v a -> a
Foldable, Functor (UReftBV b v)
Foldable (UReftBV b v)
(Functor (UReftBV b v), Foldable (UReftBV b v)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> UReftBV b v a -> f (UReftBV b v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    UReftBV b v (f a) -> f (UReftBV b v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UReftBV b v a -> m (UReftBV b v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    UReftBV b v (m a) -> m (UReftBV b v a))
-> Traversable (UReftBV b v)
forall b v. Functor (UReftBV b v)
forall b v. Foldable (UReftBV b v)
forall b v (m :: * -> *) a.
Monad m =>
UReftBV b v (m a) -> m (UReftBV b v a)
forall b v (f :: * -> *) a.
Applicative f =>
UReftBV b v (f a) -> f (UReftBV b v a)
forall b v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UReftBV b v a -> m (UReftBV b v b)
forall b v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UReftBV b v a -> f (UReftBV b v b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
UReftBV b v (m a) -> m (UReftBV b v a)
forall (f :: * -> *) a.
Applicative f =>
UReftBV b v (f a) -> f (UReftBV b v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UReftBV b v a -> m (UReftBV b v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UReftBV b v a -> f (UReftBV b v b)
$ctraverse :: forall b v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UReftBV b v a -> f (UReftBV b v b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UReftBV b v a -> f (UReftBV b v b)
$csequenceA :: forall b v (f :: * -> *) a.
Applicative f =>
UReftBV b v (f a) -> f (UReftBV b v a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
UReftBV b v (f a) -> f (UReftBV b v a)
$cmapM :: forall b v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UReftBV b v a -> m (UReftBV b v b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UReftBV b v a -> m (UReftBV b v b)
$csequence :: forall b v (m :: * -> *) a.
Monad m =>
UReftBV b v (m a) -> m (UReftBV b v a)
sequence :: forall (m :: * -> *) a.
Monad m =>
UReftBV b v (m a) -> m (UReftBV b v a)
Traversable)
  deriving (Get (UReftBV b v r)
[UReftBV b v r] -> Put
UReftBV b v r -> Put
(UReftBV b v r -> Put)
-> Get (UReftBV b v r)
-> ([UReftBV b v r] -> Put)
-> Binary (UReftBV b v r)
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall b v r. (Binary v, Binary b, Binary r) => Get (UReftBV b v r)
forall b v r.
(Binary v, Binary b, Binary r) =>
[UReftBV b v r] -> Put
forall b v r.
(Binary v, Binary b, Binary r) =>
UReftBV b v r -> Put
$cput :: forall b v r.
(Binary v, Binary b, Binary r) =>
UReftBV b v r -> Put
put :: UReftBV b v r -> Put
$cget :: forall b v r. (Binary v, Binary b, Binary r) => Get (UReftBV b v r)
get :: Get (UReftBV b v r)
$cputList :: forall b v r.
(Binary v, Binary b, Binary r) =>
[UReftBV b v r] -> Put
putList :: [UReftBV b v r] -> Put
B.Binary, Eq (UReftBV b v r)
Eq (UReftBV b v r) =>
(Int -> UReftBV b v r -> Int)
-> (UReftBV b v r -> Int) -> Hashable (UReftBV b v r)
Int -> UReftBV b v r -> Int
UReftBV b v r -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall b v r.
(Ord b, Ord v, Hashable r, Hashable b) =>
Eq (UReftBV b v r)
forall b v r.
(Ord b, Ord v, Hashable r, Hashable b) =>
Int -> UReftBV b v r -> Int
forall b v r.
(Ord b, Ord v, Hashable r, Hashable b) =>
UReftBV b v r -> Int
$chashWithSalt :: forall b v r.
(Ord b, Ord v, Hashable r, Hashable b) =>
Int -> UReftBV b v r -> Int
hashWithSalt :: Int -> UReftBV b v r -> Int
$chash :: forall b v r.
(Ord b, Ord v, Hashable r, Hashable b) =>
UReftBV b v r -> Int
hash :: UReftBV b v r -> Int
Hashable) via Generically (UReftBV b v r)

mapUReftV :: (v -> v') -> (r -> r') -> UReftV v r -> UReftV v' r'
mapUReftV :: forall v v' r r'.
(v -> v') -> (r -> r') -> UReftV v r -> UReftV v' r'
mapUReftV v -> v'
f r -> r'
g (MkUReft r
r PredicateBV Symbol v
p) = r' -> PredicateBV Symbol v' -> UReftBV Symbol v' r'
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (r -> r'
g r
r) ((v -> v') -> PredicateBV Symbol v -> PredicateBV Symbol v'
forall v v'. (v -> v') -> PredicateV v -> PredicateV v'
mapPredicateV v -> v'
f PredicateBV Symbol v
p)

emapUReftVM
  :: Monad m
  => ([Symbol] -> v -> m v') -> (r -> m r') -> UReftV v r -> m (UReftV v' r')
emapUReftVM :: forall (m :: * -> *) v v' r r'.
Monad m =>
([Symbol] -> v -> m v')
-> (r -> m r') -> UReftV v r -> m (UReftV v' r')
emapUReftVM [Symbol] -> v -> m v'
f r -> m r'
g (MkUReft r
r PredicateBV Symbol v
p) = r' -> PredicateBV Symbol v' -> UReftBV Symbol v' r'
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (r' -> PredicateBV Symbol v' -> UReftBV Symbol v' r')
-> m r' -> m (PredicateBV Symbol v' -> UReftBV Symbol v' r')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> r -> m r'
g r
r m (PredicateBV Symbol v' -> UReftBV Symbol v' r')
-> m (PredicateBV Symbol v') -> m (UReftBV Symbol v' r')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Symbol] -> v -> m v')
-> PredicateBV Symbol v -> m (PredicateBV Symbol v')
forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> PredicateV v -> m (PredicateV v')
emapPredicateVM [Symbol] -> v -> m v'
f PredicateBV Symbol v
p

type NoReft = NoReftB Symbol
data NoReftB b = NoReft
  deriving (NoReftB b -> NoReftB b -> Bool
(NoReftB b -> NoReftB b -> Bool)
-> (NoReftB b -> NoReftB b -> Bool) -> Eq (NoReftB b)
forall b. NoReftB b -> NoReftB b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall b. NoReftB b -> NoReftB b -> Bool
== :: NoReftB b -> NoReftB b -> Bool
$c/= :: forall b. NoReftB b -> NoReftB b -> Bool
/= :: NoReftB b -> NoReftB b -> Bool
Eq, (forall x. NoReftB b -> Rep (NoReftB b) x)
-> (forall x. Rep (NoReftB b) x -> NoReftB b)
-> Generic (NoReftB b)
forall x. Rep (NoReftB b) x -> NoReftB b
forall x. NoReftB b -> Rep (NoReftB b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall b x. Rep (NoReftB b) x -> NoReftB b
forall b x. NoReftB b -> Rep (NoReftB b) x
$cfrom :: forall b x. NoReftB b -> Rep (NoReftB b) x
from :: forall x. NoReftB b -> Rep (NoReftB b) x
$cto :: forall b x. Rep (NoReftB b) x -> NoReftB b
to :: forall x. Rep (NoReftB b) x -> NoReftB b
Generic, Typeable (NoReftB b)
Typeable (NoReftB b) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NoReftB b -> c (NoReftB b))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NoReftB b))
-> (NoReftB b -> Constr)
-> (NoReftB b -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NoReftB b)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NoReftB b)))
-> ((forall b. Data b => b -> b) -> NoReftB b -> NoReftB b)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoReftB b -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoReftB b -> r)
-> (forall u. (forall d. Data d => d -> u) -> NoReftB b -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NoReftB b -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b))
-> Data (NoReftB b)
NoReftB b -> Constr
NoReftB b -> DataType
(forall b. Data b => b -> b) -> NoReftB b -> NoReftB b
forall b. Data b => Typeable (NoReftB b)
forall b. Data b => NoReftB b -> Constr
forall b. Data b => NoReftB b -> DataType
forall b.
Data b =>
(forall b. Data b => b -> b) -> NoReftB b -> NoReftB b
forall b u.
Data b =>
Int -> (forall d. Data d => d -> u) -> NoReftB b -> u
forall b u.
Data b =>
(forall d. Data d => d -> u) -> NoReftB b -> [u]
forall b r r'.
Data b =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
forall b r r'.
Data b =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
forall b (m :: * -> *).
(Data b, Monad m) =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
forall b (c :: * -> *).
Data b =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NoReftB b)
forall b (c :: * -> *).
Data b =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoReftB b -> c (NoReftB b)
forall b (t :: * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NoReftB b))
forall b (t :: * -> * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NoReftB b))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NoReftB b -> u
forall u. (forall d. Data d => d -> u) -> NoReftB b -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NoReftB b)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoReftB b -> c (NoReftB b)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NoReftB b))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NoReftB b))
$cgfoldl :: forall b (c :: * -> *).
Data b =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoReftB b -> c (NoReftB b)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NoReftB b -> c (NoReftB b)
$cgunfold :: forall b (c :: * -> *).
Data b =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NoReftB b)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NoReftB b)
$ctoConstr :: forall b. Data b => NoReftB b -> Constr
toConstr :: NoReftB b -> Constr
$cdataTypeOf :: forall b. Data b => NoReftB b -> DataType
dataTypeOf :: NoReftB b -> DataType
$cdataCast1 :: forall b (t :: * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NoReftB b))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NoReftB b))
$cdataCast2 :: forall b (t :: * -> * -> *) (c :: * -> *).
(Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NoReftB b))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NoReftB b))
$cgmapT :: forall b.
Data b =>
(forall b. Data b => b -> b) -> NoReftB b -> NoReftB b
gmapT :: (forall b. Data b => b -> b) -> NoReftB b -> NoReftB b
$cgmapQl :: forall b r r'.
Data b =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
$cgmapQr :: forall b r r'.
Data b =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NoReftB b -> r
$cgmapQ :: forall b u.
Data b =>
(forall d. Data d => d -> u) -> NoReftB b -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NoReftB b -> [u]
$cgmapQi :: forall b u.
Data b =>
Int -> (forall d. Data d => d -> u) -> NoReftB b -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoReftB b -> u
$cgmapM :: forall b (m :: * -> *).
(Data b, Monad m) =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
$cgmapMp :: forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
$cgmapMo :: forall b (m :: * -> *).
(Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NoReftB b -> m (NoReftB b)
Data, (forall a b. (a -> b) -> NoReftB a -> NoReftB b)
-> (forall a b. a -> NoReftB b -> NoReftB a) -> Functor NoReftB
forall a b. a -> NoReftB b -> NoReftB a
forall a b. (a -> b) -> NoReftB a -> NoReftB b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> NoReftB a -> NoReftB b
fmap :: forall a b. (a -> b) -> NoReftB a -> NoReftB b
$c<$ :: forall a b. a -> NoReftB b -> NoReftB a
<$ :: forall a b. a -> NoReftB b -> NoReftB a
Functor, (forall m. Monoid m => NoReftB m -> m)
-> (forall m a. Monoid m => (a -> m) -> NoReftB a -> m)
-> (forall m a. Monoid m => (a -> m) -> NoReftB a -> m)
-> (forall a b. (a -> b -> b) -> b -> NoReftB a -> b)
-> (forall a b. (a -> b -> b) -> b -> NoReftB a -> b)
-> (forall b a. (b -> a -> b) -> b -> NoReftB a -> b)
-> (forall b a. (b -> a -> b) -> b -> NoReftB a -> b)
-> (forall a. (a -> a -> a) -> NoReftB a -> a)
-> (forall a. (a -> a -> a) -> NoReftB a -> a)
-> (forall a. NoReftB a -> [a])
-> (forall a. NoReftB a -> Bool)
-> (forall a. NoReftB a -> Int)
-> (forall a. Eq a => a -> NoReftB a -> Bool)
-> (forall a. Ord a => NoReftB a -> a)
-> (forall a. Ord a => NoReftB a -> a)
-> (forall a. Num a => NoReftB a -> a)
-> (forall a. Num a => NoReftB a -> a)
-> Foldable NoReftB
forall a. Eq a => a -> NoReftB a -> Bool
forall a. Num a => NoReftB a -> a
forall a. Ord a => NoReftB a -> a
forall m. Monoid m => NoReftB m -> m
forall a. NoReftB a -> Bool
forall a. NoReftB a -> Int
forall a. NoReftB a -> [a]
forall a. (a -> a -> a) -> NoReftB a -> a
forall m a. Monoid m => (a -> m) -> NoReftB a -> m
forall b a. (b -> a -> b) -> b -> NoReftB a -> b
forall a b. (a -> b -> b) -> b -> NoReftB a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => NoReftB m -> m
fold :: forall m. Monoid m => NoReftB m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NoReftB a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NoReftB a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NoReftB a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NoReftB a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NoReftB a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NoReftB a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NoReftB a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NoReftB a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NoReftB a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NoReftB a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NoReftB a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NoReftB a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NoReftB a -> a
foldr1 :: forall a. (a -> a -> a) -> NoReftB a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NoReftB a -> a
foldl1 :: forall a. (a -> a -> a) -> NoReftB a -> a
$ctoList :: forall a. NoReftB a -> [a]
toList :: forall a. NoReftB a -> [a]
$cnull :: forall a. NoReftB a -> Bool
null :: forall a. NoReftB a -> Bool
$clength :: forall a. NoReftB a -> Int
length :: forall a. NoReftB a -> Int
$celem :: forall a. Eq a => a -> NoReftB a -> Bool
elem :: forall a. Eq a => a -> NoReftB a -> Bool
$cmaximum :: forall a. Ord a => NoReftB a -> a
maximum :: forall a. Ord a => NoReftB a -> a
$cminimum :: forall a. Ord a => NoReftB a -> a
minimum :: forall a. Ord a => NoReftB a -> a
$csum :: forall a. Num a => NoReftB a -> a
sum :: forall a. Num a => NoReftB a -> a
$cproduct :: forall a. Num a => NoReftB a -> a
product :: forall a. Num a => NoReftB a -> a
Foldable, Functor NoReftB
Foldable NoReftB
(Functor NoReftB, Foldable NoReftB) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NoReftB a -> f (NoReftB b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NoReftB (f a) -> f (NoReftB a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NoReftB a -> m (NoReftB b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NoReftB (m a) -> m (NoReftB a))
-> Traversable NoReftB
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => NoReftB (m a) -> m (NoReftB a)
forall (f :: * -> *) a.
Applicative f =>
NoReftB (f a) -> f (NoReftB a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NoReftB a -> m (NoReftB b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NoReftB a -> f (NoReftB b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NoReftB a -> f (NoReftB b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NoReftB a -> f (NoReftB b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NoReftB (f a) -> f (NoReftB a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NoReftB (f a) -> f (NoReftB a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NoReftB a -> m (NoReftB b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NoReftB a -> m (NoReftB b)
$csequence :: forall (m :: * -> *) a. Monad m => NoReftB (m a) -> m (NoReftB a)
sequence :: forall (m :: * -> *) a. Monad m => NoReftB (m a) -> m (NoReftB a)
Traversable)
  deriving (Get (NoReftB b)
[NoReftB b] -> Put
NoReftB b -> Put
(NoReftB b -> Put)
-> Get (NoReftB b) -> ([NoReftB b] -> Put) -> Binary (NoReftB b)
forall b. Get (NoReftB b)
forall b. [NoReftB b] -> Put
forall b. NoReftB b -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall b. NoReftB b -> Put
put :: NoReftB b -> Put
$cget :: forall b. Get (NoReftB b)
get :: Get (NoReftB b)
$cputList :: forall b. [NoReftB b] -> Put
putList :: [NoReftB b] -> Put
B.Binary, Eq (NoReftB b)
Eq (NoReftB b) =>
(Int -> NoReftB b -> Int)
-> (NoReftB b -> Int) -> Hashable (NoReftB b)
Int -> NoReftB b -> Int
NoReftB b -> Int
forall b. Eq (NoReftB b)
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall b. Int -> NoReftB b -> Int
forall a. NoReftB a -> Int
$chashWithSalt :: forall b. Int -> NoReftB b -> Int
hashWithSalt :: Int -> NoReftB b -> Int
$chash :: forall a. NoReftB a -> Int
hash :: NoReftB b -> Int
Hashable) via Generically (NoReftB b)

instance NFData (NoReftB b)

instance F.PPrint (NoReftB b) where
  pprintTidy :: Tidy -> NoReftB b -> Doc
pprintTidy Tidy
_ NoReftB b
_ = String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ () -> String
forall a. Show a => a -> String
show ()

instance Hashable b => F.Subable (NoReftB b) where
  type Variable (NoReftB b) = b
  syms :: NoReftB b -> [Variable (NoReftB b)]
syms NoReftB b
_   = []
  substa :: (Variable (NoReftB b) -> Variable (NoReftB b))
-> NoReftB b -> NoReftB b
substa Variable (NoReftB b) -> Variable (NoReftB b)
_ = NoReftB b -> NoReftB b
forall a. a -> a
id
  substf :: (Variable (NoReftB b)
 -> ExprBV (Variable (NoReftB b)) (Variable (NoReftB b)))
-> NoReftB b -> NoReftB b
substf Variable (NoReftB b)
-> ExprBV (Variable (NoReftB b)) (Variable (NoReftB b))
_ = NoReftB b -> NoReftB b
forall a. a -> a
id
  subst :: HasCallStack =>
SubstV (Variable (NoReftB b)) -> NoReftB b -> NoReftB b
subst SubstV (Variable (NoReftB b))
_  = NoReftB b -> NoReftB b
forall a. a -> a
id
  subst1 :: NoReftB b
-> (Variable (NoReftB b),
    ExprBV (Variable (NoReftB b)) (Variable (NoReftB b)))
-> NoReftB b
subst1 NoReftB b
r = NoReftB b -> (b, ExprBV b b) -> NoReftB b
forall a b. a -> b -> a
const NoReftB b
r

instance Semigroup (NoReftB b) where
  NoReftB b
_ <> :: NoReftB b -> NoReftB b -> NoReftB b
<> NoReftB b
_ = NoReftB b
forall b. NoReftB b
NoReft

instance Monoid (NoReftB b) where
  mempty :: NoReftB b
mempty = NoReftB b
forall b. NoReftB b
NoReft

type BRType      = RTypeV Symbol BTyCon BTyVar    -- ^ "Bare" parsed version
type BRTypeV v   = RTypeV v      BTyCon BTyVar    -- ^ "Bare" parsed version
type RRType      = RTypeV Symbol RTyCon RTyVar    -- ^ "Resolved" version
type BSort       = BRType    NoReft
type BSortV v    = BRTypeV v NoReft
type RSort       = RRType    NoReft
type BPVar       = PVar      BSort
type RPVar       = PVar      RSort
type RReft       = RReftV    F.Symbol
type RReftV v    = RReftBV Symbol v
type RReftBV b v = UReftBV b v (F.ReftBV b v)
type BareType    = BareTypeV F.Symbol
type BareTypeParsed = BareTypeV F.LocSymbol
type BareTypeLHName = BareTypeV LHName
type BareTypeV v = BRTypeV v (RReftV v)
type SpecType    = RRType    RReft
type SpecProp    = RRProp    RReft
type RRProp r    = Ref       RSort (RRType r)
type BRProp r    = BRPropV Symbol r
type BRPropV v r = Ref       (BSortV v) (BRTypeV v r)
type SpecRTVar   = RTVar     RTyVar RSort



type LocBareType = F.Located BareType
type LocBareTypeLHName = F.Located BareTypeLHName
type LocBareTypeParsed = F.Located BareTypeParsed
type LocSpecType = F.Located SpecType


--------------------------------------------------------------------------------
-- | Printing Refinement Types -------------------------------------------------
--------------------------------------------------------------------------------

instance Show RTyVar where
  show :: RTyVar -> String
show = RTyVar -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint (UReft r) => Show (UReft r) where
  show :: UReft r -> String
show = UReft r -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint (RType c tv r) => Show (RType c tv r) where
  show :: RType c tv r -> String
show = RType c tv r -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint (RTProp c tv r) => Show (RTProp c tv r) where
  show :: RTProp c tv r -> String
show = RTProp c tv r -> String
forall a. PPrint a => a -> String
F.showpp

instance F.PPrint BTyVar where
  pprintTidy :: Tidy -> BTyVar -> Doc
pprintTidy Tidy
_ (BTV Located Symbol
α) = String -> Doc
text (Symbol -> String
F.symbolString (Symbol -> String) -> Symbol -> String
forall a b. (a -> b) -> a -> b
$ Located Symbol -> Symbol
forall a. Located a -> a
F.val Located Symbol
α)

instance F.PPrint RTyVar where
  pprintTidy :: Tidy -> RTyVar -> Doc
pprintTidy Tidy
k (RTV Var
α)
   | PPEnv -> Bool
ppTyVar PPEnv
ppEnv  = Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (Var -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol Var
α) -- shows full tyvar
   | Bool
otherwise      = Var -> Doc
ppr_tyvar_short Var
α           -- drops the unique-suffix
   where
     ppr_tyvar_short :: TyVar -> Doc
     ppr_tyvar_short :: Var -> Doc
ppr_tyvar_short = String -> Doc
text (String -> Doc) -> (Var -> String) -> Var -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Var -> String
forall a. Outputable a => a -> String
showPpr

instance (F.PPrint r, F.PPrint t, F.PPrint (RType c tv r)) => F.PPrint (Ref t (RType c tv r)) where
  pprintTidy :: Tidy -> Ref t (RType c tv r) -> Doc
pprintTidy Tidy
k (RProp [(Symbol, t)]
ss RType c tv r
s) = Tidy -> [Symbol] -> Doc
ppRefArgs Tidy
k ((Symbol, t) -> Symbol
forall a b. (a, b) -> a
fst ((Symbol, t) -> Symbol) -> [(Symbol, t)] -> [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Symbol, t)]
ss) Doc -> Doc -> Doc
<+> Tidy -> RType c tv r -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k RType c tv r
s

ppRefArgs :: F.Tidy -> [Symbol] -> Doc
ppRefArgs :: Tidy -> [Symbol] -> Doc
ppRefArgs Tidy
_ [] = Doc
empty
ppRefArgs Tidy
k [Symbol]
ss = String -> Doc
text String
"\\" Doc -> Doc -> Doc
<-> [Doc] -> Doc
hsep (Tidy -> Symbol -> Doc
forall a. (Eq a, IsString a, PPrint a) => Tidy -> a -> Doc
ppRefSym Tidy
k (Symbol -> Doc) -> [Symbol] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol]
ss [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ [Maybe Integer -> Symbol
F.vv Maybe Integer
forall a. Maybe a
Nothing]) Doc -> Doc -> Doc
<+> Doc
"->"

ppRefSym :: (Eq a, IsString a, F.PPrint a) => F.Tidy -> a -> Doc
ppRefSym :: forall a. (Eq a, IsString a, PPrint a) => Tidy -> a -> Doc
ppRefSym Tidy
_ a
"" = String -> Doc
text String
"_"
ppRefSym Tidy
k a
s  = Tidy -> a -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k a
s

-------------------------------------------

-- Should just make this a @Pretty@ instance but its too damn tedious
-- to figure out all the constraints.

type OkRT c tv r =
  ( TyConable c
  , F.PPrint tv, F.PPrint c, F.PPrint r, F.PPrint (ReftVar r)
  , F.Fixpoint (ReftVar r)
  , ToReft r
  , ReftBind r ~ F.Symbol
  , Eq c, Eq tv, Ord (ReftVar r)
  , Hashable tv
  )

type OkRTBV b v c tv r =
  ( TyConable c
  , F.PPrint b, F.PPrint v, F.PPrint tv, F.PPrint c, F.PPrint r, F.PPrint (ReftVar r)
  , F.Fixpoint b, F.Fixpoint v, F.Fixpoint (ReftVar r)
  , F.Binder b
  , ToReft r
  , ReftBind r ~ b
  , Eq c, Eq tv, Ord b, Ord v, Ord (ReftVar r)
  , Hashable tv
  )

-- | Types that have one associated refinement representible by a 'F.ReftBV'
class (F.Binder (ReftBind r), Eq (ReftVar r)) => ToReft r where
  type ReftVar r
  type ReftBind r
  type ReftBind r = Symbol
  toReft :: r -> F.ReftBV (ReftBind r) (ReftVar r)
  toUReft :: r -> UReftBV (ReftBind r) (ReftVar r) (F.ReftBV (ReftBind r) (ReftVar r))
  toUReft r
r = ReftBV (ReftBind r) (ReftVar r)
-> PredicateBV (ReftBind r) (ReftVar r)
-> UReftBV
     (ReftBind r) (ReftVar r) (ReftBV (ReftBind r) (ReftVar r))
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (r -> ReftBV (ReftBind r) (ReftVar r)
forall r. ToReft r => r -> ReftBV (ReftBind r) (ReftVar r)
toReft r
r) PredicateBV (ReftBind r) (ReftVar r)
forall b v. PredicateBV b v
pdTrue

-- | Types that can be combined conjunctively in some sense
class Semigroup r => Meet r where
  meet :: r -> r -> r
  meet = r -> r -> r
forall a. Semigroup a => a -> a -> a
(<>)

-- | Types whose refinements can be cleared to true
class Top r where
  top :: r -> r

-- | Types that can be constructed from a 'F.ReftBV'
class (ToReft r, Meet r, Top r) => IsReft r where
  ofReft :: F.ReftBV (ReftBind r) (ReftVar r) -> r

trueReft :: IsReft r => r
trueReft :: forall r. IsReft r => r
trueReft = ReftBV (ReftBind r) (ReftVar r) -> r
forall r. IsReft r => ReftBV (ReftBind r) (ReftVar r) -> r
ofReft ReftBV (ReftBind r) (ReftVar r)
forall b v. Binder b => ReftBV b v
F.trueReft

isTauto :: ToReft r => r -> Bool
isTauto :: forall r. ToReft r => r -> Bool
isTauto r
r0 = ReftBV (ReftBind r) (ReftVar r) -> Bool
forall b v. (Eq b, Eq v) => ReftBV b v -> Bool
F.isTautoReft ReftBV (ReftBind r) (ReftVar r)
r Bool -> Bool -> Bool
&& [UsedPVarBV (ReftBind r) (ReftVar r)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UsedPVarBV (ReftBind r) (ReftVar r)]
ps
 where
  MkUReft ReftBV (ReftBind r) (ReftVar r)
r (Pr [UsedPVarBV (ReftBind r) (ReftVar r)]
ps) = r
-> UReftBV
     (ReftBind r) (ReftVar r) (ReftBV (ReftBind r) (ReftVar r))
forall r.
ToReft r =>
r
-> UReftBV
     (ReftBind r) (ReftVar r) (ReftBV (ReftBind r) (ReftVar r))
toUReft r
r0

instance (ToReft r, ReftBind r ~ b, ReftVar r ~ v) => ToReft (UReftBV b v r) where
  type ReftVar (UReftBV b v r) = ReftVar r
  type ReftBind (UReftBV b v r) = ReftBind r
  toReft :: UReftBV b v r
-> ReftBV (ReftBind (UReftBV b v r)) (ReftVar (UReftBV b v r))
toReft = r -> ReftBV b v
r -> ReftBV (ReftBind r) (ReftVar r)
forall r. ToReft r => r -> ReftBV (ReftBind r) (ReftVar r)
toReft (r -> ReftBV b v)
-> (UReftBV b v r -> r) -> UReftBV b v r -> ReftBV b v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UReftBV b v r -> r
forall b v r. UReftBV b v r -> r
ur_reft
  toUReft :: UReftBV b v r
-> UReftBV
     (ReftBind (UReftBV b v r))
     (ReftVar (UReftBV b v r))
     (ReftBV (ReftBind (UReftBV b v r)) (ReftVar (UReftBV b v r)))
toUReft (MkUReft r
r PredicateBV b v
p) = ReftBV b v -> PredicateBV b v -> UReftBV b v (ReftBV b v)
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (r -> ReftBV (ReftBind r) (ReftVar r)
forall r. ToReft r => r -> ReftBV (ReftBind r) (ReftVar r)
toReft r
r) PredicateBV b v
p

instance Top r => Top (UReftBV b v r) where
  top :: UReftBV b v r -> UReftBV b v r
top (MkUReft r
r PredicateBV b v
_) = r -> PredicateBV b v -> UReftBV b v r
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (r -> r
forall r. Top r => r -> r
top r
r) PredicateBV b v
forall b v. PredicateBV b v
pdTrue

instance (IsReft r, F.Binder v, ReftBind r ~ v, ReftVar r ~ v) => IsReft (UReftBV v v r) where
  ofReft :: ReftBV (ReftBind (UReftBV v v r)) (ReftVar (UReftBV v v r))
-> UReftBV v v r
ofReft ReftBV (ReftBind (UReftBV v v r)) (ReftVar (UReftBV v v r))
r = r -> PredicateBV v v -> UReftBV v v r
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (ReftBV (ReftBind r) (ReftVar r) -> r
forall r. IsReft r => ReftBV (ReftBind r) (ReftVar r) -> r
ofReft ReftBV (ReftBind r) (ReftVar r)
ReftBV (ReftBind (UReftBV v v r)) (ReftVar (UReftBV v v r))
r) PredicateBV v v
forall b v. PredicateBV b v
pdTrue

instance (F.Binder b, Eq v) => ToReft (F.ReftBV b v) where
  type ReftVar (F.ReftBV b v) = v
  type ReftBind (F.ReftBV b v) = b
  toReft :: ReftBV b v -> ReftBV (ReftBind (ReftBV b v)) (ReftVar (ReftBV b v))
toReft = ReftBV b v -> ReftBV b v
ReftBV b v -> ReftBV (ReftBind (ReftBV b v)) (ReftVar (ReftBV b v))
forall a. a -> a
id

instance (F.Binder b) => Top (F.ReftBV b v) where
  top :: ReftBV b v -> ReftBV b v
top ReftBV b v
_ = ReftBV b v
forall b v. Binder b => ReftBV b v
F.trueReft

instance (F.Binder v, F.Fixpoint v) => Meet (F.ReftBV v v) where

instance (F.Binder v, F.Fixpoint v, Eq v) => IsReft (F.ReftBV v v) where
  ofReft :: ReftBV (ReftBind (ReftBV v v)) (ReftVar (ReftBV v v)) -> ReftBV v v
ofReft = ReftBV v v -> ReftBV v v
ReftBV (ReftBind (ReftBV v v)) (ReftVar (ReftBV v v)) -> ReftBV v v
forall a. a -> a
id

instance ToReft () where
  type ReftVar () = Symbol
  toReft :: () -> ReftBV (ReftBind ()) (ReftVar ())
toReft ()
_ = ReftBV Symbol Symbol
ReftBV (ReftBind ()) (ReftVar ())
forall b v. Binder b => ReftBV b v
F.trueReft

instance Top () where
  top :: () -> ()
top ()
_ = ()

instance IsReft () where
  ofReft :: ReftBV (ReftBind ()) (ReftVar ()) -> ()
ofReft ReftBV (ReftBind ()) (ReftVar ())
_ = ()

instance F.Binder b => ToReft (NoReftB b) where
  type ReftVar (NoReftB b) = Symbol
  type ReftBind (NoReftB b) = b
  toReft :: NoReftB b -> ReftBV (ReftBind (NoReftB b)) (ReftVar (NoReftB b))
toReft NoReftB b
_ = ReftBV b Symbol
ReftBV (ReftBind (NoReftB b)) (ReftVar (NoReftB b))
forall b v. Binder b => ReftBV b v
F.trueReft

instance Top (NoReftB b) where
  top :: NoReftB b -> NoReftB b
top NoReftB b
_ = NoReftB b
forall b. NoReftB b
NoReft

instance F.Binder b => IsReft (NoReftB b) where
  ofReft :: ReftBV (ReftBind (NoReftB b)) (ReftVar (NoReftB b)) -> NoReftB b
ofReft ReftBV (ReftBind (NoReftB b)) (ReftVar (NoReftB b))
_ = NoReftB b
forall b. NoReftB b
NoReft

instance ToReft t => ToReft (RefB b τ t) where
  type ReftVar (RefB b τ t) = ReftVar t
  type ReftBind (RefB b τ t) = ReftBind t
  toReft :: RefB b τ t -> ReftBV (ReftBind (RefB b τ t)) (ReftVar (RefB b τ t))
toReft (RProp [(b, τ)]
_ t
t) = t -> ReftBV (ReftBind t) (ReftVar t)
forall r. ToReft r => r -> ReftBV (ReftBind r) (ReftVar r)
toReft t
t

instance Top t => Top (RefB b τ t) where
  top :: RefB b τ t -> RefB b τ t
top (RProp [(b, τ)]
args t
t) = [(b, τ)] -> t -> RefB b τ t
forall b τ t. [(b, τ)] -> t -> RefB b τ t
RProp [(b, τ)]
args (t -> t
forall r. Top r => r -> r
top t
t)

instance (F.Binder b, Ord v, PredicateCompat b v) => ToReft (PredicateBV b v) where
  type ReftVar (PredicateBV b v) = v
  type ReftBind (PredicateBV b v) = b
  toReft :: PredicateBV b v
-> ReftBV (ReftBind (PredicateBV b v)) (ReftVar (PredicateBV b v))
toReft (Pr [])       = ReftBV b v
ReftBV (ReftBind (PredicateBV b v)) (ReftVar (PredicateBV b v))
forall b v. Binder b => ReftBV b v
F.trueReft
  toReft (Pr ps :: [UsedPVarBV b v]
ps@(UsedPVarBV b v
p:[UsedPVarBV b v]
_)) = (b, ExprBV b v) -> ReftBV b v
forall b v. (b, ExprBV b v) -> ReftBV b v
F.Reft (UsedPVarBV b v -> b
forall b v t. PVarBV b v t -> b
parg UsedPVarBV b v
p, ListNE (ExprBV b v) -> ExprBV b v
forall b v.
(Ord b, Hashable b, Ord v) =>
ListNE (ExprBV b v) -> ExprBV b v
F.pAnd (ListNE (ExprBV b v) -> ExprBV b v)
-> ListNE (ExprBV b v) -> ExprBV b v
forall a b. (a -> b) -> a -> b
$ UsedPVarBV b v -> ExprBV b v
forall b v a. PredicateCompat b v => PVarBV b v a -> ExprBV b v
pToRef (UsedPVarBV b v -> ExprBV b v)
-> [UsedPVarBV b v] -> ListNE (ExprBV b v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarBV b v]
ps)
  toUReft :: PredicateBV b v
-> UReftBV
     (ReftBind (PredicateBV b v))
     (ReftVar (PredicateBV b v))
     (ReftBV (ReftBind (PredicateBV b v)) (ReftVar (PredicateBV b v)))
toUReft PredicateBV b v
p = ReftBV b v -> PredicateBV b v -> UReftBV b v (ReftBV b v)
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft ReftBV b v
forall b v. Binder b => ReftBV b v
F.trueReft PredicateBV b v
p

instance Top (PredicateBV b v) where
  top :: PredicateBV b v -> PredicateBV b v
top PredicateBV b v
_ = PredicateBV b v
forall b v. PredicateBV b v
pdTrue

instance (F.Binder v, F.Fixpoint v) => Semigroup (F.ReftBV v v) where
  <> :: ReftBV v v -> ReftBV v v -> ReftBV v v
(<>) = ReftBV v v -> ReftBV v v -> ReftBV v v
forall v. Binder v => ReftBV v v -> ReftBV v v -> ReftBV v v
F.meetReft

instance Monoid F.Reft where
  mempty :: ReftBV Symbol Symbol
mempty  = ReftBV Symbol Symbol
forall b v. Binder b => ReftBV b v
F.trueReft
  mappend :: ReftBV Symbol Symbol
-> ReftBV Symbol Symbol -> ReftBV Symbol Symbol
mappend = ReftBV Symbol Symbol
-> ReftBV Symbol Symbol -> ReftBV Symbol Symbol
forall a. Semigroup a => a -> a -> a
(<>)

instance Meet ()

instance Meet (NoReftB b)

instance (Meet r, Eq v) => Meet (UReftBV v v r)

instance (F.Subable r, F.Variable r ~ v) => F.Subable (UReftBV v v r) where
  type Variable (UReftBV v v r) = v
  syms :: UReftBV v v r -> [Variable (UReftBV v v r)]
syms (MkUReft r
r PredicateBV v v
p)     = r -> [Variable r]
forall a. Subable a => a -> [Variable a]
F.syms r
r [v] -> [v] -> [v]
forall a. [a] -> [a] -> [a]
++ PredicateBV v v -> [Variable (PredicateBV v v)]
forall a. Subable a => a -> [Variable a]
F.syms PredicateBV v v
p
  subst :: HasCallStack =>
SubstV (Variable (UReftBV v v r)) -> UReftBV v v r -> UReftBV v v r
subst SubstV (Variable (UReftBV v v r))
s (MkUReft r
r PredicateBV v v
z)  = r -> PredicateBV v v -> UReftBV v v r
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft (SubstV (Variable r) -> r -> r
forall a.
(Subable a, HasCallStack) =>
SubstV (Variable a) -> a -> a
F.subst SubstV (Variable r)
SubstV (Variable (UReftBV v v r))
s r
r)  (SubstV (Variable (PredicateBV v v))
-> PredicateBV v v -> PredicateBV v v
forall a.
(Subable a, HasCallStack) =>
SubstV (Variable a) -> a -> a
F.subst SubstV (Variable (UReftBV v v r))
SubstV (Variable (PredicateBV v v))
s PredicateBV v v
z)
  substf :: (Variable (UReftBV v v r)
 -> ExprBV (Variable (UReftBV v v r)) (Variable (UReftBV v v r)))
-> UReftBV v v r -> UReftBV v v r
substf Variable (UReftBV v v r)
-> ExprBV (Variable (UReftBV v v r)) (Variable (UReftBV v v r))
f (MkUReft r
r PredicateBV v v
z) = r -> PredicateBV v v -> UReftBV v v r
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft ((Variable r -> ExprBV (Variable r) (Variable r)) -> r -> r
forall a.
Subable a =>
(Variable a -> ExprBV (Variable a) (Variable a)) -> a -> a
F.substf Variable r -> ExprBV (Variable r) (Variable r)
Variable (UReftBV v v r)
-> ExprBV (Variable (UReftBV v v r)) (Variable (UReftBV v v r))
f r
r) ((Variable (PredicateBV v v)
 -> ExprBV
      (Variable (PredicateBV v v)) (Variable (PredicateBV v v)))
-> PredicateBV v v -> PredicateBV v v
forall a.
Subable a =>
(Variable a -> ExprBV (Variable a) (Variable a)) -> a -> a
F.substf Variable (UReftBV v v r)
-> ExprBV (Variable (UReftBV v v r)) (Variable (UReftBV v v r))
Variable (PredicateBV v v)
-> ExprBV (Variable (PredicateBV v v)) (Variable (PredicateBV v v))
f PredicateBV v v
z)
  substa :: (Variable (UReftBV v v r) -> Variable (UReftBV v v r))
-> UReftBV v v r -> UReftBV v v r
substa Variable (UReftBV v v r) -> Variable (UReftBV v v r)
f (MkUReft r
r PredicateBV v v
z) = r -> PredicateBV v v -> UReftBV v v r
forall b v r. r -> PredicateBV b v -> UReftBV b v r
MkUReft ((Variable r -> Variable r) -> r -> r
forall a. Subable a => (Variable a -> Variable a) -> a -> a
F.substa Variable r -> Variable r
Variable (UReftBV v v r) -> Variable (UReftBV v v r)
f r
r) ((Variable (PredicateBV v v) -> Variable (PredicateBV v v))
-> PredicateBV v v -> PredicateBV v v
forall a. Subable a => (Variable a -> Variable a) -> a -> a
F.substa Variable (UReftBV v v r) -> Variable (UReftBV v v r)
Variable (PredicateBV v v) -> Variable (PredicateBV v v)
f PredicateBV v v
z)

instance F.Expression (UReft ()) where
  expr :: UReft () -> Expr
expr = ReftBV Symbol Symbol -> Expr
forall a. Expression a => a -> Expr
F.expr (ReftBV Symbol Symbol -> Expr)
-> (UReft () -> ReftBV Symbol Symbol) -> UReft () -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UReft () -> ReftBV Symbol Symbol
UReft () -> ReftBV (ReftBind (UReft ())) (ReftVar (UReft ()))
forall r. ToReft r => r -> ReftBV (ReftBind r) (ReftVar r)
toReft

instance Meet Predicate

pToRef :: PredicateCompat b v => PVarBV b v a -> F.ExprBV b v
pToRef :: forall b v a. PredicateCompat b v => PVarBV b v a -> ExprBV b v
pToRef PVarBV b v a
p = v -> [ExprBV b v] -> ExprBV b v
forall b v. PredicateCompat b v => v -> [ExprBV b v] -> ExprBV b v
pApp (PVarBV b v a -> v
forall a. PVarBV b v a -> v
forall b v a. PredicateCompat b v => PVarBV b v a -> v
pnameV PVarBV b v a
p) ([ExprBV b v] -> ExprBV b v) -> [ExprBV b v] -> ExprBV b v
forall a b. (a -> b) -> a -> b
$ v -> ExprBV b v
forall b v. v -> ExprBV b v
F.EVar (PVarBV b v a -> v
forall a. PVarBV b v a -> v
forall b v a. PredicateCompat b v => PVarBV b v a -> v
pargV PVarBV b v a
p) ExprBV b v -> [ExprBV b v] -> [ExprBV b v]
forall a. a -> [a] -> [a]
: ((a, b, ExprBV b v) -> ExprBV b v
forall a b c. (a, b, c) -> c
thd3 ((a, b, ExprBV b v) -> ExprBV b v)
-> [(a, b, ExprBV b v)] -> [ExprBV b v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PVarBV b v a -> [(a, b, ExprBV b v)]
forall b v t. PVarBV b v t -> [(t, b, ExprBV b v)]
pargs PVarBV b v a
p)

pApp      :: forall b v . PredicateCompat b v => v -> [ExprBV b v] -> ExprBV b v
pApp :: forall b v. PredicateCompat b v => v -> [ExprBV b v] -> ExprBV b v
pApp v
p [ExprBV b v]
es = Located v -> [ExprBV b v] -> ExprBV b v
forall v b. Located v -> [ExprBV b v] -> ExprBV b v
F.mkEApp Located v
fn (v -> ExprBV b v
forall b v. v -> ExprBV b v
F.EVar v
pExprBV b v -> [ExprBV b v] -> [ExprBV b v]
forall a. a -> [a] -> [a]
:[ExprBV b v]
es)
  where
    fn :: Located v
fn    = v -> Located v
forall a. a -> Located a
F.dummyLoc (Proxy b -> Int -> v
forall b v. PredicateCompat b v => Proxy b -> Int -> v
pappV (Proxy b
forall {k} (t :: k). Proxy t
Proxy :: Proxy b) Int
n)
    n :: Int
n     = [ExprBV b v] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ExprBV b v]
es

class PredicateCompat b v where
  pappV :: Proxy b -> Int -> v
  pnameV :: PVarBV b v a -> v
  pargV :: PVarBV b v a -> v

instance PredicateCompat Symbol Symbol where
  pappV :: Proxy Symbol -> Int -> Symbol
pappV Proxy Symbol
_ Int
n = String -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol (String -> Symbol) -> String -> Symbol
forall a b. (a -> b) -> a -> b
$ String
"papp" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n
  pnameV :: forall a. PVarBV Symbol Symbol a -> Symbol
pnameV PVarBV Symbol Symbol a
p = PVarBV Symbol Symbol a -> Symbol
forall b v t. PVarBV b v t -> b
pname PVarBV Symbol Symbol a
p
  pargV :: forall a. PVarBV Symbol Symbol a -> Symbol
pargV PVarBV Symbol Symbol a
p = PVarBV Symbol Symbol a -> Symbol
forall b v t. PVarBV b v t -> b
parg PVarBV Symbol Symbol a
p

instance PredicateCompat Symbol F.LocSymbol where
  pappV :: Proxy Symbol -> Int -> Located Symbol
pappV Proxy Symbol
_ Int
n = Symbol -> Located Symbol
forall a. a -> Located a
F.dummyLoc (Symbol -> Located Symbol) -> Symbol -> Located Symbol
forall a b. (a -> b) -> a -> b
$ String -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol (String -> Symbol) -> String -> Symbol
forall a b. (a -> b) -> a -> b
$ String
"papp" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n
  pnameV :: forall a. PVarBV Symbol (Located Symbol) a -> Located Symbol
pnameV PVarBV Symbol (Located Symbol) a
p = Symbol -> Located Symbol
forall a. a -> Located a
F.dummyLoc (Symbol -> Located Symbol) -> Symbol -> Located Symbol
forall a b. (a -> b) -> a -> b
$ PVarBV Symbol (Located Symbol) a -> Symbol
forall b v t. PVarBV b v t -> b
pname PVarBV Symbol (Located Symbol) a
p
  pargV :: forall a. PVarBV Symbol (Located Symbol) a -> Located Symbol
pargV PVarBV Symbol (Located Symbol) a
p = Symbol -> Located Symbol
forall a. a -> Located a
F.dummyLoc (Symbol -> Located Symbol) -> Symbol -> Located Symbol
forall a b. (a -> b) -> a -> b
$ PVarBV Symbol (Located Symbol) a -> Symbol
forall b v t. PVarBV b v t -> b
parg PVarBV Symbol (Located Symbol) a
p