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

{-# 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 (..), Ref(..), RTProp, RTPropV, rPropP
  , RTyVar (..)
  , OkRT

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

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

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

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

  -- * Refinements
  , UReft
  , UReftV(..)
  , mapUReftV
  , emapUReftVM

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

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

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

  -- * Reftable/UReftable Instances
  , Reftable(..)
  , UReftable(..)
  , ToReftV(..)
  )
  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.Typeable                          (Typeable)
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           Text.PrettyPrint.HughesPJ              hiding (first, (<>))
import           Language.Fixpoint.Misc

import qualified Language.Fixpoint.Types as F
import           Language.Fixpoint.Types (Expr, ExprV(..), SubstV(..), 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, Typeable, 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, Typeable)

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

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

-- | A map traversal that collects the local variables in scope
emapPVarVM :: Monad m => ([Symbol] -> v -> m v') -> ([Symbol] -> t -> m t') -> PVarV v t -> m (PVarV v' t')
emapPVarVM :: forall (m :: * -> *) v v' t t'.
Monad m =>
([Symbol] -> v -> m v')
-> ([Symbol] -> t -> m t') -> PVarV v t -> m (PVarV v' t')
emapPVarVM [Symbol] -> v -> m v'
f [Symbol] -> t -> m t'
g PVarV v t
pv = do
    ptype <- [Symbol] -> t -> m t'
g ([(t, Symbol, ExprV v)] -> [Symbol]
forall {a} {b} {c}. [(a, b, c)] -> [b]
argSyms (PVarV v t -> [(t, Symbol, ExprV v)]
forall v t. PVarV v t -> [(t, Symbol, ExprV v)]
pargs PVarV v t
pv)) (PVarV v t -> t
forall v t. PVarV v t -> t
ptype PVarV v t
pv)
    (_, pargs) <- forAccumM [] (pargs pv) $ \[Symbol]
ss (t
t, Symbol
s, ExprV v
e) -> do
      (Symbol
sSymbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[Symbol]
ss,) ((t', Symbol, ExprV v') -> ([Symbol], (t', Symbol, ExprV v')))
-> m (t', Symbol, ExprV v') -> m ([Symbol], (t', Symbol, ExprV v'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((,,) (t' -> Symbol -> ExprV v' -> (t', Symbol, ExprV v'))
-> m t' -> m (Symbol -> ExprV v' -> (t', Symbol, ExprV v'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> t -> m t'
g (Symbol
sSymbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[Symbol]
ss) t
t m (Symbol -> ExprV v' -> (t', Symbol, ExprV v'))
-> m Symbol -> m (ExprV v' -> (t', Symbol, ExprV v'))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Symbol -> m Symbol
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Symbol
s m (ExprV v' -> (t', Symbol, ExprV v'))
-> m (ExprV v') -> m (t', Symbol, ExprV v')
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') -> ExprV v -> m (ExprV v')
forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> ExprV v -> m (ExprV v')
emapExprVM ([Symbol] -> v -> m v'
f ([Symbol] -> v -> m v')
-> ([Symbol] -> [Symbol]) -> [Symbol] -> v -> m v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Symbol
sSymbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[Symbol]
ss) [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++)) ExprV 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 (PVarV v t) where
  PVarV v t
pv == :: PVarV v t -> PVarV v t -> Bool
== PVarV v t
pv' = PVarV v t -> Symbol
forall v t. PVarV v t -> Symbol
pname PVarV v t
pv Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== PVarV v t -> Symbol
forall v t. PVarV v t -> Symbol
pname PVarV v t
pv' {- UNIFY: What about: && eqArgs pv pv' -}

instance Ord (PVarV v t) where
  compare :: PVarV v t -> PVarV v t -> Ordering
compare (PV Symbol
n t
_ Symbol
_ [(t, Symbol, ExprV v)]
_)  (PV Symbol
n' t
_ Symbol
_ [(t, Symbol, ExprV v)]
_) = Symbol -> Symbol -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Symbol
n Symbol
n'

instance (NFData v, NFData t) => NFData   (PVarV v t)

instance Hashable (PVarV v a) where
  hashWithSalt :: Int -> PVarV v a -> Int
hashWithSalt Int
i (PV Symbol
n a
_ Symbol
_ [(a, Symbol, ExprV v)]
_) = Int -> Symbol -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
i Symbol
n

pvType :: PVarV v t -> t
pvType :: forall v t. PVarV v t -> t
pvType = PVarV v t -> t
forall v t. PVarV v t -> t
ptype

instance F.PPrint (PVar a) where
  pprintTidy :: Tidy -> PVar a -> Doc
pprintTidy Tidy
_ = PVar a -> Doc
forall a. PVar a -> Doc
pprPvar

pprPvar :: PVar a -> Doc
pprPvar :: forall a. PVar a -> Doc
pprPvar (PV Symbol
s a
_ Symbol
_ [(a, Symbol, Expr)]
xts) = Symbol -> Doc
forall a. PPrint a => a -> Doc
F.pprint Symbol
s Doc -> Doc -> Doc
<+> [Doc] -> Doc
hsep (Expr -> Doc
forall a. PPrint a => a -> Doc
F.pprint (Expr -> Doc) -> [Expr] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(a, Symbol, Expr)] -> [Expr]
forall {a}. [(a, Symbol, Expr)] -> [Expr]
dargs [(a, Symbol, Expr)]
xts)
  where
    dargs :: [(a, Symbol, Expr)] -> [Expr]
dargs              = ((a, Symbol, Expr) -> Expr) -> [(a, Symbol, Expr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (a, Symbol, Expr) -> Expr
forall a b c. (a, b, c) -> c
thd3 ([(a, Symbol, Expr)] -> [Expr])
-> ([(a, Symbol, Expr)] -> [(a, Symbol, Expr)])
-> [(a, Symbol, Expr)]
-> [Expr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, Symbol, Expr) -> Bool)
-> [(a, Symbol, Expr)] -> [(a, Symbol, Expr)]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\(a
_, Symbol
x, Expr
y) -> Symbol -> Expr
forall v. v -> ExprV v
F.EVar Symbol
x Expr -> Expr -> Bool
forall a. Eq a => a -> a -> Bool
/= Expr
y)

-- | A map traversal that collects the local variables in scope
emapExprVM :: Monad m => ([Symbol] -> v -> m v') -> ExprV v -> m (ExprV v')
emapExprVM :: forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> ExprV v -> m (ExprV v')
emapExprVM [Symbol] -> v -> m v'
f = [Symbol] -> ExprV v -> m (ExprV v')
go []
  where
    go :: [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc = \case
      ESym SymConst
c -> ExprV v' -> m (ExprV v')
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExprV v' -> m (ExprV v')) -> ExprV v' -> m (ExprV v')
forall a b. (a -> b) -> a -> b
$ SymConst -> ExprV v'
forall v. SymConst -> ExprV v
ESym SymConst
c
      ECon Constant
c -> ExprV v' -> m (ExprV v')
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExprV v' -> m (ExprV v')) -> ExprV v' -> m (ExprV v')
forall a b. (a -> b) -> a -> b
$ Constant -> ExprV v'
forall v. Constant -> ExprV v
ECon Constant
c
      EVar v
v -> v' -> ExprV v'
forall v. v -> ExprV v
EVar (v' -> ExprV v') -> m v' -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> v -> m v'
f [Symbol]
acc v
v
      EApp ExprV v
e0 ExprV v
e1 -> ExprV v' -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v -> ExprV v
EApp (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1
      ENeg ExprV v
e -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v
ENeg (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e
      EBin Bop
bop ExprV v
e0 ExprV v
e1 -> Bop -> ExprV v' -> ExprV v' -> ExprV v'
forall v. Bop -> ExprV v -> ExprV v -> ExprV v
EBin Bop
bop (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1
      EIte ExprV v
e0 ExprV v
e1 ExprV v
e2 -> ExprV v' -> ExprV v' -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v -> ExprV v -> ExprV v
EIte (ExprV v' -> ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e2
      ECst ExprV v
e Sort
s -> (ExprV v' -> Sort -> ExprV v') -> Sort -> ExprV v' -> ExprV v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprV v' -> Sort -> ExprV v'
forall v. ExprV v -> Sort -> ExprV v
ECst Sort
s (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e
      ELam (Symbol
s,Sort
srt) ExprV v
e -> (Symbol, Sort) -> ExprV v' -> ExprV v'
forall v. (Symbol, Sort) -> ExprV v -> ExprV v
ELam (Symbol
s, Sort
srt) (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go (Symbol
sSymbol -> [Symbol] -> [Symbol]
forall a. a -> [a] -> [a]
:[Symbol]
acc) ExprV v
e
      ETApp ExprV v
e Sort
s -> (ExprV v' -> Sort -> ExprV v') -> Sort -> ExprV v' -> ExprV v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprV v' -> Sort -> ExprV v'
forall v. ExprV v -> Sort -> ExprV v
ETApp Sort
s (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e
      ETAbs ExprV v
e Symbol
s -> (ExprV v' -> Symbol -> ExprV v') -> Symbol -> ExprV v' -> ExprV v'
forall a b c. (a -> b -> c) -> b -> a -> c
flip ExprV v' -> Symbol -> ExprV v'
forall v. ExprV v -> Symbol -> ExprV v
ETAbs Symbol
s (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e
      PAnd [ExprV v]
xs -> [ExprV v'] -> ExprV v'
forall v. [ExprV v] -> ExprV v
PAnd ([ExprV v'] -> ExprV v') -> m [ExprV v'] -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ExprV v -> m (ExprV v')) -> [ExprV v] -> m [ExprV 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] -> ExprV v -> m (ExprV v')
go [Symbol]
acc) [ExprV v]
xs
      POr [ExprV v]
xs -> [ExprV v'] -> ExprV v'
forall v. [ExprV v] -> ExprV v
POr ([ExprV v'] -> ExprV v') -> m [ExprV v'] -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ExprV v -> m (ExprV v')) -> [ExprV v] -> m [ExprV 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] -> ExprV v -> m (ExprV v')
go [Symbol]
acc) [ExprV v]
xs
      PNot ExprV v
e -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v
PNot (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e
      PImp ExprV v
e0 ExprV v
e1 -> ExprV v' -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v -> ExprV v
PImp (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1
      PIff ExprV v
e0 ExprV v
e1 -> ExprV v' -> ExprV v' -> ExprV v'
forall v. ExprV v -> ExprV v -> ExprV v
PIff (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1
      PAtom Brel
brel ExprV v
e0 ExprV v
e1 -> Brel -> ExprV v' -> ExprV v' -> ExprV v'
forall v. Brel -> ExprV v -> ExprV v -> ExprV v
PAtom Brel
brel (ExprV v' -> ExprV v' -> ExprV v')
-> m (ExprV v') -> m (ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e0 m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e1
      PKVar KVar
k SubstV v
su -> KVar -> SubstV v' -> ExprV v'
forall v. KVar -> SubstV v -> ExprV v
PKVar KVar
k (SubstV v' -> ExprV v') -> m (SubstV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
emapSubstVM ([Symbol] -> v -> m v'
f ([Symbol] -> v -> m v')
-> ([Symbol] -> [Symbol]) -> [Symbol] -> v -> m v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SubstV v -> [Symbol]
forall {v}. SubstV v -> [Symbol]
domain SubstV v
su [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++) ([Symbol] -> [Symbol])
-> ([Symbol] -> [Symbol]) -> [Symbol] -> [Symbol]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Symbol]
acc [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++)) SubstV v
su
      PAll [(Symbol, Sort)]
bnds ExprV v
e -> [(Symbol, Sort)] -> ExprV v' -> ExprV v'
forall v. [(Symbol, Sort)] -> ExprV v -> ExprV v
PAll [(Symbol, Sort)]
bnds (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go (((Symbol, Sort) -> Symbol) -> [(Symbol, Sort)] -> [Symbol]
forall a b. (a -> b) -> [a] -> [b]
map (Symbol, Sort) -> Symbol
forall a b. (a, b) -> a
fst [(Symbol, Sort)]
bnds [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ [Symbol]
acc) ExprV v
e
      PExist [(Symbol, Sort)]
bnds ExprV v
e -> [(Symbol, Sort)] -> ExprV v' -> ExprV v'
forall v. [(Symbol, Sort)] -> ExprV v -> ExprV v
PExist [(Symbol, Sort)]
bnds (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go (((Symbol, Sort) -> Symbol) -> [(Symbol, Sort)] -> [Symbol]
forall a b. (a -> b) -> [a] -> [b]
map (Symbol, Sort) -> Symbol
forall a b. (a, b) -> a
fst [(Symbol, Sort)]
bnds [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ [Symbol]
acc) ExprV v
e
      PGrad KVar
k SubstV v
su GradInfo
gi ExprV v
e ->
        KVar -> SubstV v' -> GradInfo -> ExprV v' -> ExprV v'
forall v. KVar -> SubstV v -> GradInfo -> ExprV v -> ExprV v
PGrad KVar
k (SubstV v' -> GradInfo -> ExprV v' -> ExprV v')
-> m (SubstV v') -> m (GradInfo -> ExprV v' -> ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
emapSubstVM ([Symbol] -> v -> m v'
f ([Symbol] -> v -> m v')
-> ([Symbol] -> [Symbol]) -> [Symbol] -> v -> m v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Symbol]
acc [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++)) SubstV v
su m (GradInfo -> ExprV v' -> ExprV v')
-> m GradInfo -> m (ExprV v' -> ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GradInfo -> m GradInfo
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure GradInfo
gi m (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Symbol] -> ExprV v -> m (ExprV v')
go (SubstV v -> [Symbol]
forall {v}. SubstV v -> [Symbol]
domain SubstV v
su [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ [Symbol]
acc) ExprV v
e
      ECoerc Sort
srt0 Sort
srt1 ExprV v
e -> Sort -> Sort -> ExprV v' -> ExprV v'
forall v. Sort -> Sort -> ExprV v -> ExprV v
ECoerc Sort
srt0 Sort
srt1 (ExprV v' -> ExprV v') -> m (ExprV v') -> m (ExprV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol] -> ExprV v -> m (ExprV v')
go [Symbol]
acc ExprV v
e

    domain :: SubstV v -> [Symbol]
domain (Su HashMap Symbol (ExprV v)
m) = HashMap Symbol (ExprV v) -> [Symbol]
forall k v. HashMap k v -> [k]
M.keys HashMap Symbol (ExprV v)
m

emapSubstVM :: Monad m => ([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
emapSubstVM :: forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> SubstV v -> m (SubstV v')
emapSubstVM [Symbol] -> v -> m v'
f (Su HashMap Symbol (ExprV v)
m) = HashMap Symbol (ExprV v') -> SubstV v'
forall v. HashMap Symbol (ExprV v) -> SubstV v
Su (HashMap Symbol (ExprV v') -> SubstV v')
-> ([(Symbol, ExprV v')] -> HashMap Symbol (ExprV v'))
-> [(Symbol, ExprV v')]
-> SubstV v'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Symbol, ExprV v')] -> HashMap Symbol (ExprV v')
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList ([(Symbol, ExprV v')] -> SubstV v')
-> m [(Symbol, ExprV v')] -> m (SubstV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Symbol, ExprV v) -> m (Symbol, ExprV v'))
-> [(Symbol, ExprV v)] -> m [(Symbol, ExprV 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 ((ExprV v -> m (ExprV v'))
-> (Symbol, ExprV v) -> m (Symbol, ExprV 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) -> (Symbol, a) -> f (Symbol, b)
traverse (([Symbol] -> v -> m v') -> ExprV v -> m (ExprV v')
forall (m :: * -> *) v v'.
Monad m =>
([Symbol] -> v -> m v') -> ExprV v -> m (ExprV v')
emapExprVM [Symbol] -> v -> m v'
f)) (HashMap Symbol (ExprV v) -> [(Symbol, ExprV v)]
forall k v. HashMap k v -> [(k, v)]
M.toList HashMap Symbol (ExprV v)
m)

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

type UsedPVar    = UsedPVarV Symbol
type UsedPVarV v = PVarV v ()

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

mapPredicateV :: (v -> v') -> PredicateV v -> PredicateV v'
mapPredicateV :: forall v v'. (v -> v') -> PredicateV v -> PredicateV v'
mapPredicateV v -> v'
f (Pr [UsedPVarV v]
xs) = [UsedPVarV v'] -> PredicateV v'
forall v. [UsedPVarV v] -> PredicateV v
Pr ((UsedPVarV v -> UsedPVarV v') -> [UsedPVarV v] -> [UsedPVarV v']
forall a b. (a -> b) -> [a] -> [b]
map ((v -> v') -> (() -> ()) -> UsedPVarV v -> UsedPVarV v'
forall v v' t t'.
(v -> v') -> (t -> t') -> PVarV v t -> PVarV v' t'
mapPVarV v -> v'
f (() -> () -> ()
forall a b. a -> b -> a
const ())) [UsedPVarV 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 [UsedPVarV v]
xs) = [UsedPVarV v'] -> PredicateV v'
forall v. [UsedPVarV v] -> PredicateV v
Pr ([UsedPVarV v'] -> PredicateV v')
-> m [UsedPVarV v'] -> m (PredicateV v')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (UsedPVarV v -> m (UsedPVarV v'))
-> [UsedPVarV v] -> m [UsedPVarV 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 ()) -> UsedPVarV v -> m (UsedPVarV v')
forall (m :: * -> *) v v' t t'.
Monad m =>
([Symbol] -> v -> m v')
-> ([Symbol] -> t -> m t') -> PVarV v t -> m (PVarV v' t')
emapPVarVM [Symbol] -> v -> m v'
f (\[Symbol]
_ ()
_ -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())) [UsedPVarV v]
xs

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

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

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

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

instance F.PPrint Predicate where
  pprintTidy :: Tidy -> Predicate -> Doc
pprintTidy Tidy
_ (Pr [])  = String -> Doc
text String
"True"
  pprintTidy Tidy
k (Pr [UsedPVarV Symbol]
pvs) = [Doc] -> Doc
hsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> [Doc] -> [Doc]
punctuate (String -> Doc
text String
"&") (Tidy -> UsedPVarV Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (UsedPVarV Symbol -> Doc) -> [UsedPVarV Symbol] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarV Symbol]
pvs)

instance Semigroup a => Semigroup (UReft a) where
  MkUReft a
x Predicate
y <> :: UReft a -> UReft a -> UReft a
<> MkUReft a
x' Predicate
y' = a -> Predicate -> UReft a
forall v r. r -> PredicateV v -> UReftV v r
MkUReft (a
x a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
x') (Predicate
y Predicate -> Predicate -> Predicate
forall a. Semigroup a => a -> a -> a
<> Predicate
y')

instance (Monoid a) => Monoid (UReft a) where
  mempty :: UReft a
mempty  = a -> Predicate -> UReft a
forall v r. r -> PredicateV v -> UReftV 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 :: Predicate
pdTrue :: Predicate
pdTrue         = [UsedPVarV Symbol] -> Predicate
forall v. [UsedPVarV v] -> PredicateV v
Pr []

pdAnd :: Foldable t => t Predicate -> Predicate
pdAnd :: forall (t :: * -> *). Foldable t => t Predicate -> Predicate
pdAnd t Predicate
ps       = [UsedPVarV Symbol] -> Predicate
forall v. [UsedPVarV v] -> PredicateV v
Pr ([UsedPVarV Symbol] -> [UsedPVarV Symbol]
forall a. Eq a => [a] -> [a]
nub ([UsedPVarV Symbol] -> [UsedPVarV Symbol])
-> [UsedPVarV Symbol] -> [UsedPVarV Symbol]
forall a b. (a -> b) -> a -> b
$ (Predicate -> [UsedPVarV Symbol])
-> t Predicate -> [UsedPVarV Symbol]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Predicate -> [UsedPVarV Symbol]
pvars t Predicate
ps)

pvars :: Predicate -> [UsedPVar]
pvars :: Predicate -> [UsedPVarV Symbol]
pvars (Pr [UsedPVarV Symbol]
pvs) = [UsedPVarV Symbol]
pvs

instance F.Subable UsedPVar where
  syms :: UsedPVarV Symbol -> [Symbol]
syms UsedPVarV Symbol
pv         = [ Symbol
y | (()
_, Symbol
x, F.EVar Symbol
y) <- UsedPVarV Symbol -> [((), Symbol, Expr)]
forall v t. PVarV v t -> [(t, Symbol, ExprV v)]
pargs UsedPVarV Symbol
pv, Symbol
x Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
/= Symbol
y ]
  subst :: Subst -> UsedPVarV Symbol -> UsedPVarV Symbol
subst Subst
s UsedPVarV Symbol
pv      = UsedPVarV Symbol
pv { pargs = mapThd3 (F.subst s)  <$> pargs pv }
  substf :: (Symbol -> Expr) -> UsedPVarV Symbol -> UsedPVarV Symbol
substf Symbol -> Expr
f UsedPVarV Symbol
pv     = UsedPVarV Symbol
pv { pargs = mapThd3 (F.substf f) <$> pargs pv }
  substa :: (Symbol -> Symbol) -> UsedPVarV Symbol -> UsedPVarV Symbol
substa Symbol -> Symbol
f UsedPVarV Symbol
pv     = UsedPVarV Symbol
pv { pargs = mapThd3 (F.substa f) <$> pargs pv }


instance F.Subable Predicate where
  syms :: Predicate -> [Symbol]
syms     (Pr [UsedPVarV Symbol]
pvs) = (UsedPVarV Symbol -> [Symbol]) -> [UsedPVarV Symbol] -> [Symbol]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap UsedPVarV Symbol -> [Symbol]
forall a. Subable a => a -> [Symbol]
F.syms   [UsedPVarV Symbol]
pvs
  subst :: Subst -> Predicate -> Predicate
subst  Subst
s (Pr [UsedPVarV Symbol]
pvs) = [UsedPVarV Symbol] -> Predicate
forall v. [UsedPVarV v] -> PredicateV v
Pr (Subst -> UsedPVarV Symbol -> UsedPVarV Symbol
forall a. Subable a => Subst -> a -> a
F.subst Subst
s  (UsedPVarV Symbol -> UsedPVarV Symbol)
-> [UsedPVarV Symbol] -> [UsedPVarV Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarV Symbol]
pvs)
  substf :: (Symbol -> Expr) -> Predicate -> Predicate
substf Symbol -> Expr
f (Pr [UsedPVarV Symbol]
pvs) = [UsedPVarV Symbol] -> Predicate
forall v. [UsedPVarV v] -> PredicateV v
Pr ((Symbol -> Expr) -> UsedPVarV Symbol -> UsedPVarV Symbol
forall a. Subable a => (Symbol -> Expr) -> a -> a
F.substf Symbol -> Expr
f (UsedPVarV Symbol -> UsedPVarV Symbol)
-> [UsedPVarV Symbol] -> [UsedPVarV Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarV Symbol]
pvs)
  substa :: (Symbol -> Symbol) -> Predicate -> Predicate
substa Symbol -> Symbol
f (Pr [UsedPVarV Symbol]
pvs) = [UsedPVarV Symbol] -> Predicate
forall v. [UsedPVarV v] -> PredicateV v
Pr ((Symbol -> Symbol) -> UsedPVarV Symbol -> UsedPVarV Symbol
forall a. Subable a => (Symbol -> Symbol) -> a -> a
F.substa Symbol -> Symbol
f (UsedPVarV Symbol -> UsedPVarV Symbol)
-> [UsedPVarV Symbol] -> [UsedPVarV Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarV Symbol]
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, Typeable)
  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, Typeable)

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 TyVar
tv) = TyVar -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol TyVar
tv -- tyVarUniqueSymbol tv

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

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} [RTypeV Symbol RTyCon t t1]
_ [RTPropV Symbol RTyCon t t1]
_ t1
_) = TyCon
c TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== TyCon
boolTyCon
isBool RTypeV 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 RTypeV 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 [RTypeV v c t t1]
_ [RTPropV v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isEqual c
c
isEqType RTypeV 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 [RTypeV v c t t1]
_ [RTPropV v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isClass c
c
isClassType RTypeV 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 [RTypeV v c t t1]
_ [RTPropV v c t t1]
_ t1
_) = c -> Bool
forall c. TyConable c => c -> Bool
isEmbeddedDict c
c
isEmbeddedClass RTypeV 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, Typeable)

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 = RTVar tv (RTypeV v c tv ())
type PVU c tv = PVUV Symbol c tv
type PVUV v c tv = PVarV v (RTypeV v c tv ())

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

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

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

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

  -- | "forall x y <z :: Nat, w :: Int> . TYPE"
  --               ^^^^^^^^^^^^^^^^^^^ (rt_pvbind)
  | RAllP {
      forall v c tv r. RTypeV v c tv r -> PVUV v c tv
rt_pvbind :: !(PVUV v c tv)
    , rt_ty     :: !(RTypeV 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 v c tv r. RTypeV v c tv r -> c
rt_tycon  :: !c
    , forall v c tv r. RTypeV v c tv r -> [RTypeV v c tv r]
rt_args   :: ![RTypeV v c tv r]
    , forall v c tv r. RTypeV v c tv r -> [RTPropV v c tv r]
rt_pargs  :: ![RTPropV v c tv r]
    , rt_reft   :: !r
    }

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

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

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

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

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 s, Data tv) => Typeable (RTVar tv s)
forall tv s. (Data s, Data tv) => RTVar tv s -> Constr
forall tv s. (Data s, Data tv) => RTVar tv s -> DataType
forall tv s.
(Data s, Data tv) =>
(forall b. Data b => b -> b) -> RTVar tv s -> RTVar tv s
forall tv s u.
(Data s, Data tv) =>
Int -> (forall d. Data d => d -> u) -> RTVar tv s -> u
forall tv s u.
(Data s, Data tv) =>
(forall d. Data d => d -> u) -> RTVar tv s -> [u]
forall tv s r r'.
(Data s, Data tv) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall tv s r r'.
(Data s, Data tv) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RTVar tv s -> r
forall tv s (m :: * -> *).
(Data s, Data tv, Monad m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall tv s (m :: * -> *).
(Data s, Data tv, MonadPlus m) =>
(forall d. Data d => d -> m d) -> RTVar tv s -> m (RTVar tv s)
forall tv s (c :: * -> *).
(Data s, Data tv) =>
(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 s, Data tv) =>
(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 s, Data tv, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (RTVar tv s))
forall tv s (t :: * -> * -> *) (c :: * -> *).
(Data s, Data tv, 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 s, Data tv) =>
(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 s, Data tv) =>
(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 s, Data tv) => RTVar tv s -> Constr
toConstr :: RTVar tv s -> Constr
$cdataTypeOf :: forall tv s. (Data s, Data tv) => RTVar tv s -> DataType
dataTypeOf :: RTVar tv s -> DataType
$cdataCast1 :: forall tv s (t :: * -> *) (c :: * -> *).
(Data s, Data tv, 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 s, Data tv, 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 s, Data tv) =>
(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 s, Data tv) =>
(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 s, Data tv) =>
(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 s, Data tv) =>
(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 s, Data tv) =>
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 s, Data tv, 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 s, Data tv, 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 s, Data tv, 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, Typeable, (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 tv, Binary s) => Get (RTVar tv s)
forall tv s. (Binary tv, Binary s) => [RTVar tv s] -> Put
forall tv s. (Binary tv, Binary s) => RTVar tv s -> Put
$cput :: forall tv s. (Binary tv, Binary s) => RTVar tv s -> Put
put :: RTVar tv s -> Put
$cget :: forall tv s. (Binary tv, Binary s) => Get (RTVar tv s)
get :: Get (RTVar tv s)
$cputList :: forall tv s. (Binary tv, Binary s) => [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, Typeable, (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)

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

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

rPropP :: [(Symbol, τ)] -> r -> Ref τ (RTypeV v c tv r)
rPropP :: forall τ r v c tv. [(Symbol, τ)] -> r -> Ref τ (RTypeV v c tv r)
rPropP [(Symbol, τ)]
τ r
r = [(Symbol, τ)] -> RTypeV v c tv r -> Ref τ (RTypeV v c tv r)
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp [(Symbol, τ)]
τ (r -> RTypeV v c tv r
forall v c tv r. r -> RTypeV 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 = Ref (RTypeV v c tv ()) (RTypeV v c tv r)

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

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    ()
type BSortV v    = BRTypeV v ()
type RSort       = RRType    ()
type BPVar       = PVar      BSort
type RPVar       = PVar      RSort
type RReft       = RReftV    F.Symbol
type RReftV v    = UReftV v (F.ReftV 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 TyVar
α)
   | PPEnv -> Bool
ppTyVar PPEnv
ppEnv  = Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
F.pprintTidy Tidy
k (TyVar -> Symbol
forall a. Symbolic a => a -> Symbol
F.symbol TyVar
α) -- shows full tyvar
   | Bool
otherwise      = TyVar -> Doc
ppr_tyvar_short TyVar
α           -- drops the unique-suffix
   where
     ppr_tyvar_short :: TyVar -> Doc
     ppr_tyvar_short :: TyVar -> Doc
ppr_tyvar_short = String -> Doc
text (String -> Doc) -> (TyVar -> String) -> TyVar -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TyVar -> 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
                   , Reftable r, Reftable (RTProp c tv ()), Reftable (RTProp c tv r)
                   , Eq c, Eq tv
                   , Hashable tv
                   )

class Reftable r => UReftable r where
  ofUReft :: UReft F.Reft -> r
  ofUReft (MkUReft Reft
r Predicate
_) = Reft -> r
forall r. Reftable r => Reft -> r
ofReft Reft
r


instance UReftable (UReft F.Reft) where
   ofUReft :: UReft Reft -> UReft Reft
ofUReft UReft Reft
r = UReft Reft
r

instance UReftable () where
   ofUReft :: UReft Reft -> ()
ofUReft UReft Reft
_ = ()
forall a. Monoid a => a
mempty

class ToReftV r where
  type ReftVar r
  toReftV  :: r -> F.ReftV (ReftVar r)

instance ToReftV r => ToReftV (UReftV v r) where
  type ReftVar (UReftV v r) = ReftVar r
  toReftV :: UReftV v r -> ReftV (ReftVar (UReftV v r))
toReftV = r -> ReftV (ReftVar r)
forall r. ToReftV r => r -> ReftV (ReftVar r)
toReftV (r -> ReftV (ReftVar r))
-> (UReftV v r -> r) -> UReftV v r -> ReftV (ReftVar r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UReftV v r -> r
forall v r. UReftV v r -> r
ur_reft

instance ToReftV (F.ReftV v) where
  type ReftVar (F.ReftV v) = v
  toReftV :: ReftV v -> ReftV (ReftVar (ReftV v))
toReftV = ReftV v -> ReftV v
ReftV v -> ReftV (ReftVar (ReftV v))
forall a. a -> a
id

instance ToReftV () where
  type ReftVar () = Symbol
  toReftV :: () -> ReftV (ReftVar ())
toReftV ()
_ = Reft
ReftV (ReftVar ())
forall v. ReftV v
F.trueReft

class (Monoid r, F.Subable r) => Reftable r where
  isTauto :: r -> Bool
  ppTy    :: r -> Doc -> Doc

  top     :: r -> r
  top r
_   =  r
forall a. Monoid a => a
mempty

  meet    :: r -> r -> r
  meet    = r -> r -> r
forall a. Monoid a => a -> a -> a
mappend

  toReft  :: r -> F.Reft
  ofReft  :: F.Reft -> r

instance Semigroup F.Reft where
  <> :: Reft -> Reft -> Reft
(<>) = Reft -> Reft -> Reft
F.meetReft

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

instance Reftable () where
  isTauto :: () -> Bool
isTauto ()
_ = Bool
True
  ppTy :: () -> Doc -> Doc
ppTy ()
_  Doc
d = Doc
d
  top :: () -> ()
top  ()
_    = ()
  meet :: () -> () -> ()
meet ()
_ ()
_  = ()
  toReft :: () -> Reft
toReft ()
_  = Reft
forall v. ReftV v
F.trueReft
  ofReft :: Reft -> ()
ofReft Reft
_  = ()

instance Reftable F.Reft where
  isTauto :: Reft -> Bool
isTauto  = (Expr -> Bool) -> [Expr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Expr -> Bool
forall v. Eq v => ExprV v -> Bool
F.isTautoPred ([Expr] -> Bool) -> (Reft -> [Expr]) -> Reft -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr -> [Expr]
forall v. Eq v => ExprV v -> [ExprV v]
F.conjuncts (Expr -> [Expr]) -> (Reft -> Expr) -> Reft -> [Expr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reft -> Expr
forall v. ReftV v -> ExprV v
F.reftPred
  ppTy :: Reft -> Doc -> Doc
ppTy     = Reft -> Doc -> Doc
forall r. Reftable r => r -> Doc -> Doc
pprReft
  toReft :: Reft -> Reft
toReft   = Reft -> Reft
forall a. a -> a
id
  ofReft :: Reft -> Reft
ofReft   = Reft -> Reft
forall a. a -> a
id
  top :: Reft -> Reft
top (F.Reft (Symbol
v,Expr
_)) = (Symbol, Expr) -> Reft
forall v. (Symbol, ExprV v) -> ReftV v
F.Reft (Symbol
v, Expr
forall v. ExprV v
F.PTrue)

instance F.Subable r => F.Subable (UReft r) where
  syms :: UReft r -> [Symbol]
syms (MkUReft r
r Predicate
p)     = r -> [Symbol]
forall a. Subable a => a -> [Symbol]
F.syms r
r [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ Predicate -> [Symbol]
forall a. Subable a => a -> [Symbol]
F.syms Predicate
p
  subst :: Subst -> UReft r -> UReft r
subst Subst
s (MkUReft r
r Predicate
z)  = r -> Predicate -> UReft r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft (Subst -> r -> r
forall a. Subable a => Subst -> a -> a
F.subst Subst
s r
r)  (Subst -> Predicate -> Predicate
forall a. Subable a => Subst -> a -> a
F.subst Subst
s Predicate
z)
  substf :: (Symbol -> Expr) -> UReft r -> UReft r
substf Symbol -> Expr
f (MkUReft r
r Predicate
z) = r -> Predicate -> UReft r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft ((Symbol -> Expr) -> r -> r
forall a. Subable a => (Symbol -> Expr) -> a -> a
F.substf Symbol -> Expr
f r
r) ((Symbol -> Expr) -> Predicate -> Predicate
forall a. Subable a => (Symbol -> Expr) -> a -> a
F.substf Symbol -> Expr
f Predicate
z)
  substa :: (Symbol -> Symbol) -> UReft r -> UReft r
substa Symbol -> Symbol
f (MkUReft r
r Predicate
z) = r -> Predicate -> UReft r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft ((Symbol -> Symbol) -> r -> r
forall a. Subable a => (Symbol -> Symbol) -> a -> a
F.substa Symbol -> Symbol
f r
r) ((Symbol -> Symbol) -> Predicate -> Predicate
forall a. Subable a => (Symbol -> Symbol) -> a -> a
F.substa Symbol -> Symbol
f Predicate
z)

instance (F.PPrint r, Reftable r) => Reftable (UReft r) where
  isTauto :: UReft r -> Bool
isTauto               = UReft r -> Bool
forall r. Reftable r => UReft r -> Bool
isTautoUreft
  ppTy :: UReft r -> Doc -> Doc
ppTy                  = UReft r -> Doc -> Doc
forall r. Reftable r => UReft r -> Doc -> Doc
ppTyUreft
  toReft :: UReft r -> Reft
toReft (MkUReft r
r Predicate
ps) = r -> Reft
forall r. Reftable r => r -> Reft
toReft r
r Reft -> Reft -> Reft
forall r. Reftable r => r -> r -> r
`meet` Predicate -> Reft
forall r. Reftable r => r -> Reft
toReft Predicate
ps
  top :: UReft r -> UReft r
top (MkUReft r
r Predicate
p)     = r -> Predicate -> UReft r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft (r -> r
forall r. Reftable r => r -> r
top r
r) (Predicate -> Predicate
forall r. Reftable r => r -> r
top Predicate
p)
  ofReft :: Reft -> UReft r
ofReft Reft
r              = r -> Predicate -> UReft r
forall v r. r -> PredicateV v -> UReftV v r
MkUReft (Reft -> r
forall r. Reftable r => Reft -> r
ofReft Reft
r) Predicate
forall a. Monoid a => a
mempty

instance F.Expression (UReft ()) where
  expr :: UReft () -> Expr
expr = Reft -> Expr
forall a. Expression a => a -> Expr
F.expr (Reft -> Expr) -> (UReft () -> Reft) -> UReft () -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UReft () -> Reft
forall r. Reftable r => r -> Reft
toReft

ppTyUreft :: Reftable r => UReft r -> Doc -> Doc
ppTyUreft :: forall r. Reftable r => UReft r -> Doc -> Doc
ppTyUreft u :: UReft r
u@(MkUReft r
r Predicate
p) Doc
d
  | UReft r -> Bool
forall r. Reftable r => UReft r -> Bool
isTautoUreft UReft r
u = Doc
d
  | Bool
otherwise      = r -> Doc -> Doc
forall r. Reftable r => r -> Doc -> Doc
pprReft r
r (Predicate -> Doc -> Doc
forall r. Reftable r => r -> Doc -> Doc
ppTy Predicate
p Doc
d)

pprReft :: (Reftable r) => r -> Doc -> Doc
pprReft :: forall r. Reftable r => r -> Doc -> Doc
pprReft r
r Doc
d = Doc -> Doc
braces (Symbol -> Doc
forall a. PPrint a => a -> Doc
F.pprint Symbol
v Doc -> Doc -> Doc
<+> Doc
colon Doc -> Doc -> Doc
<+> Doc
d Doc -> Doc -> Doc
<+> String -> Doc
text String
"|" Doc -> Doc -> Doc
<+> Reft -> Doc
forall a. PPrint a => a -> Doc
F.pprint Reft
r')
  where
    r' :: Reft
r'@(F.Reft (Symbol
v, Expr
_)) = r -> Reft
forall r. Reftable r => r -> Reft
toReft r
r

isTautoUreft :: Reftable r => UReft r -> Bool
isTautoUreft :: forall r. Reftable r => UReft r -> Bool
isTautoUreft UReft r
u = r -> Bool
forall r. Reftable r => r -> Bool
isTauto (UReft r -> r
forall v r. UReftV v r -> r
ur_reft UReft r
u) Bool -> Bool -> Bool
&& Predicate -> Bool
forall r. Reftable r => r -> Bool
isTauto (UReft r -> Predicate
forall v r. UReftV v r -> PredicateV v
ur_pred UReft r
u)

instance Reftable Predicate where
  isTauto :: Predicate -> Bool
isTauto (Pr [UsedPVarV Symbol]
ps)      = [UsedPVarV Symbol] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UsedPVarV Symbol]
ps

  ppTy :: Predicate -> Doc -> Doc
ppTy Predicate
r Doc
d | Predicate -> Bool
forall r. Reftable r => r -> Bool
isTauto Predicate
r      = Doc
d
           | Bool -> Bool
not (PPEnv -> Bool
ppPs PPEnv
ppEnv) = Doc
d
           | Bool
otherwise        = Doc
d Doc -> Doc -> Doc
<-> Doc -> Doc
angleBrackets (Predicate -> Doc
forall a. PPrint a => a -> Doc
F.pprint Predicate
r)

  toReft :: Predicate -> Reft
toReft (Pr ps :: [UsedPVarV Symbol]
ps@(UsedPVarV Symbol
p:[UsedPVarV Symbol]
_))        = (Symbol, Expr) -> Reft
forall v. (Symbol, ExprV v) -> ReftV v
F.Reft (UsedPVarV Symbol -> Symbol
forall v t. PVarV v t -> Symbol
parg UsedPVarV Symbol
p, [Expr] -> Expr
forall v. (Fixpoint v, Ord v) => ListNE (ExprV v) -> ExprV v
F.pAnd ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ UsedPVarV Symbol -> Expr
forall a. PVar a -> Expr
pToRef (UsedPVarV Symbol -> Expr) -> [UsedPVarV Symbol] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [UsedPVarV Symbol]
ps)
  toReft Predicate
_                    = Reft
forall v. ReftV v
F.trueReft

  ofReft :: Reft -> Predicate
ofReft = Maybe SrcSpan -> String -> Reft -> Predicate
forall a. Maybe SrcSpan -> String -> a
todo Maybe SrcSpan
forall a. Maybe a
Nothing String
"TODO: Predicate.ofReft"

pToRef :: PVar a -> F.Expr
pToRef :: forall a. PVar a -> Expr
pToRef PVar a
p = Symbol -> [Expr] -> Expr
pApp (PVar a -> Symbol
forall v t. PVarV v t -> Symbol
pname PVar a
p) ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ Symbol -> Expr
forall v. v -> ExprV v
F.EVar (PVar a -> Symbol
forall v t. PVarV v t -> Symbol
parg PVar a
p) Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: ((a, Symbol, Expr) -> Expr
forall a b c. (a, b, c) -> c
thd3 ((a, Symbol, Expr) -> Expr) -> [(a, Symbol, Expr)] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PVar a -> [(a, Symbol, Expr)]
forall v t. PVarV v t -> [(t, Symbol, ExprV v)]
pargs PVar a
p)

pApp      :: Symbol -> [Expr] -> Expr
pApp :: Symbol -> [Expr] -> Expr
pApp Symbol
p [Expr]
es = Located Symbol -> [Expr] -> Expr
F.mkEApp Located Symbol
fn (Symbol -> Expr
forall v. v -> ExprV v
F.EVar Symbol
pExpr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
:[Expr]
es)
  where
    fn :: Located Symbol
fn    = Symbol -> Located Symbol
forall a. a -> Located a
F.dummyLoc (Int -> Symbol
forall a. Show a => a -> Symbol
pappSym Int
n)
    n :: Int
n     = [Expr] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr]
es

pappSym :: Show a => a -> Symbol
pappSym :: forall a. Show a => a -> Symbol
pappSym a
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]
++ a -> String
forall a. Show a => a -> String
show a
n