Language.Fixpoint.Types.Environments

Environments

data SEnv a

Instances

Functor SEnv

Methods

fmap :: (a -> b) -> SEnv a -> SEnv b

(<$) :: a -> SEnv b -> SEnv a

Foldable SEnv

Methods

fold :: Monoid m => SEnv m -> m

foldMap :: Monoid m => (a -> m) -> SEnv a -> m

foldr :: (a -> b -> b) -> b -> SEnv a -> b

foldr' :: (a -> b -> b) -> b -> SEnv a -> b

foldl :: (b -> a -> b) -> b -> SEnv a -> b

foldl' :: (b -> a -> b) -> b -> SEnv a -> b

foldr1 :: (a -> a -> a) -> SEnv a -> a

foldl1 :: (a -> a -> a) -> SEnv a -> a

toList :: SEnv a -> [a]

null :: SEnv a -> Bool

length :: SEnv a -> Int

elem :: Eq a => a -> SEnv a -> Bool

maximum :: Ord a => SEnv a -> a

minimum :: Ord a => SEnv a -> a

sum :: Num a => SEnv a -> a

product :: Num a => SEnv a -> a

Traversable SEnv

Methods

traverse :: Applicative f => (a -> f b) -> SEnv a -> f (SEnv b)

sequenceA :: Applicative f => SEnv (f a) -> f (SEnv a)

mapM :: Monad m => (a -> m b) -> SEnv a -> m (SEnv b)

sequence :: Monad m => SEnv (m a) -> m (SEnv a)

Eq a => Eq (SEnv a)

Methods

(==) :: SEnv a -> SEnv a -> Bool

(/=) :: SEnv a -> SEnv a -> Bool

Data a => Data (SEnv a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SEnv a -> c (SEnv a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SEnv a)

toConstr :: SEnv a -> Constr

dataTypeOf :: SEnv a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SEnv a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SEnv a))

gmapT :: (forall b. Data b => b -> b) -> SEnv a -> SEnv a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SEnv a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SEnv a -> r

gmapQ :: (forall d. Data d => d -> u) -> SEnv a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SEnv a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SEnv a -> m (SEnv a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SEnv a -> m (SEnv a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SEnv a -> m (SEnv a)

Fixpoint (SEnv a) => Show (SEnv a)

Methods

showsPrec :: Int -> SEnv a -> ShowS

show :: SEnv a -> String

showList :: [SEnv a] -> ShowS

Generic (SEnv a)

Associated Types

type Rep (SEnv a) :: * -> *

Methods

from :: SEnv a -> Rep (SEnv a) x

to :: Rep (SEnv a) x -> SEnv a

Monoid (SEnv a)

Methods

mempty :: SEnv a

mappend :: SEnv a -> SEnv a -> SEnv a

mconcat :: [SEnv a] -> SEnv a

Binary a => Binary (SEnv a)

Methods

put :: SEnv a -> Put

get :: Get (SEnv a)

putList :: [SEnv a] -> Put

NFData a => NFData (SEnv a)

Methods

rnf :: SEnv a -> ()

PPrint a => PPrint (SEnv a)

Methods

pprintTidy :: Tidy -> SEnv a -> Doc

pprintPrec :: Int -> Tidy -> SEnv a -> Doc

Fixpoint a => Fixpoint (SEnv a)

Methods

toFix :: SEnv a -> Doc

simplify :: SEnv a -> SEnv a

Defunc a => Defunc (SEnv a)

Methods

defunc :: SEnv a -> DF (SEnv a)

type Rep (SEnv a)

type Rep (SEnv a) = D1 (MetaData "SEnv" "Language.Fixpoint.Types.Environments" "liquid-fixpoint-0.7.0.2-3repHVQ2bkqGganvJ6cFNP" True) (C1 (MetaCons "SE" PrefixI True) (S1 (MetaSel (Just Symbol "seBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (HashMap Symbol a))))

data SESearch a

Constructors

Found a

Alts [Symbol]

emptySEnv :: SEnv a

toListSEnv :: SEnv a -> [(Symbol, a)]

fromListSEnv :: [(Symbol, a)] -> SEnv a

fromMapSEnv :: HashMap Symbol a -> SEnv a

mapSEnvWithKey :: ((Symbol, a) -> (Symbol, b)) -> SEnv a -> SEnv b

mapSEnv :: (a -> b) -> SEnv a -> SEnv b

mapMSEnv :: Monad m => (a -> m b) -> SEnv a -> m (SEnv b)

insertSEnv :: Symbol -> a -> SEnv a -> SEnv a

deleteSEnv :: Symbol -> SEnv a -> SEnv a

memberSEnv :: Symbol -> SEnv a -> Bool

lookupSEnv :: Symbol -> SEnv a -> Maybe a

unionSEnv :: SEnv a -> HashMap Symbol a -> SEnv a

unionSEnv' :: SEnv a -> SEnv a -> SEnv a

intersectWithSEnv :: (v1 -> v2 -> a) -> SEnv v1 -> SEnv v2 -> SEnv a

differenceSEnv :: SEnv a -> SEnv w -> SEnv a

filterSEnv :: (a -> Bool) -> SEnv a -> SEnv a

lookupSEnvWithDistance :: Symbol -> SEnv a -> SESearch a

envCs :: BindEnv -> IBindEnv -> [(Symbol, SortedReft)]

Local Constraint Environments

data IBindEnv

Instances

Eq IBindEnv

Methods

(==) :: IBindEnv -> IBindEnv -> Bool

(/=) :: IBindEnv -> IBindEnv -> Bool

Data IBindEnv

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IBindEnv -> c IBindEnv

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IBindEnv

toConstr :: IBindEnv -> Constr

dataTypeOf :: IBindEnv -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IBindEnv)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IBindEnv)

gmapT :: (forall b. Data b => b -> b) -> IBindEnv -> IBindEnv

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IBindEnv -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IBindEnv -> r

gmapQ :: (forall d. Data d => d -> u) -> IBindEnv -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IBindEnv -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IBindEnv -> m IBindEnv

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IBindEnv -> m IBindEnv

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IBindEnv -> m IBindEnv

Generic IBindEnv

Associated Types

type Rep IBindEnv :: * -> *

Methods

from :: IBindEnv -> Rep IBindEnv x

to :: Rep IBindEnv x -> IBindEnv

Monoid IBindEnv

Functions for Indexed Bind Environment

Methods

mempty :: IBindEnv

mappend :: IBindEnv -> IBindEnv -> IBindEnv

mconcat :: [IBindEnv] -> IBindEnv

Binary IBindEnv

Methods

put :: IBindEnv -> Put

get :: Get IBindEnv

putList :: [IBindEnv] -> Put

NFData IBindEnv

Methods

rnf :: IBindEnv -> ()

PPrint IBindEnv

Methods

pprintTidy :: Tidy -> IBindEnv -> Doc

pprintPrec :: Int -> Tidy -> IBindEnv -> Doc

Fixpoint IBindEnv

Methods

toFix :: IBindEnv -> Doc

simplify :: IBindEnv -> IBindEnv

type Rep IBindEnv

type Rep IBindEnv = D1 (MetaData "IBindEnv" "Language.Fixpoint.Types.Environments" "liquid-fixpoint-0.7.0.2-3repHVQ2bkqGganvJ6cFNP" True) (C1 (MetaCons "FB" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (HashSet BindId))))

type BindId = Int

type BindMap a = HashMap BindId a

emptyIBindEnv :: IBindEnv

insertsIBindEnv :: [BindId] -> IBindEnv -> IBindEnv

deleteIBindEnv :: BindId -> IBindEnv -> IBindEnv

elemsIBindEnv :: IBindEnv -> [BindId]

fromListIBindEnv :: [BindId] -> IBindEnv

memberIBindEnv :: BindId -> IBindEnv -> Bool

unionIBindEnv :: IBindEnv -> IBindEnv -> IBindEnv

diffIBindEnv :: IBindEnv -> IBindEnv -> IBindEnv

intersectionIBindEnv :: IBindEnv -> IBindEnv -> IBindEnv

nullIBindEnv :: IBindEnv -> Bool

filterIBindEnv :: (BindId -> Bool) -> IBindEnv -> IBindEnv

Global Binder Environments

type BindEnv = SizedEnv (Symbol, SortedReft)

beBinds :: SizedEnv a -> BindMap a

emptyBindEnv :: BindEnv

insertBindEnv :: Symbol -> SortedReft -> BindEnv -> (BindId, BindEnv)

Functions for Global Binder Environment

lookupBindEnv :: BindId -> BindEnv -> (Symbol, SortedReft)

filterBindEnv :: (BindId -> Symbol -> SortedReft -> Bool) -> BindEnv -> BindEnv

mapBindEnv :: (BindId -> (Symbol, SortedReft) -> (Symbol, SortedReft)) -> BindEnv -> BindEnv

mapWithKeyMBindEnv :: Monad m => ((BindId, (Symbol, SortedReft)) -> m (BindId, (Symbol, SortedReft))) -> BindEnv -> m BindEnv

adjustBindEnv :: ((Symbol, SortedReft) -> (Symbol, SortedReft)) -> BindId -> BindEnv -> BindEnv

bindEnvFromList :: [(BindId, Symbol, SortedReft)] -> BindEnv

bindEnvToList :: BindEnv -> [(BindId, Symbol, SortedReft)]

elemsBindEnv :: BindEnv -> [BindId]

Information needed to lookup and update Solutions

data SolEnv

Constructors

SolEnv

Fields

• soeBinds :: !BindEnv

Instances

Eq SolEnv

Methods

(==) :: SolEnv -> SolEnv -> Bool

(/=) :: SolEnv -> SolEnv -> Bool

Show SolEnv

Methods

showsPrec :: Int -> SolEnv -> ShowS

show :: SolEnv -> String

showList :: [SolEnv] -> ShowS

Generic SolEnv

Associated Types

type Rep SolEnv :: * -> *

Methods

from :: SolEnv -> Rep SolEnv x

to :: Rep SolEnv x -> SolEnv

type Rep SolEnv

type Rep SolEnv = D1 (MetaData "SolEnv" "Language.Fixpoint.Types.Environments" "liquid-fixpoint-0.7.0.2-3repHVQ2bkqGganvJ6cFNP" False) (C1 (MetaCons "SolEnv" PrefixI True) (S1 (MetaSel (Just Symbol "soeBinds") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 BindEnv)))

Groups of KVars (needed by eliminate)

newtype Packs

Constraint Pack Sets ------------------------------------------------------

Constructors

Packs

Fields

• packm :: HashMap KVar Int

Instances

Eq Packs

Methods

(==) :: Packs -> Packs -> Bool

(/=) :: Packs -> Packs -> Bool

Show Packs

Methods

showsPrec :: Int -> Packs -> ShowS

show :: Packs -> String

showList :: [Packs] -> ShowS

Generic Packs

Associated Types

type Rep Packs :: * -> *

Methods

from :: Packs -> Rep Packs x

to :: Rep Packs x -> Packs

Monoid Packs

Methods

mempty :: Packs

mappend :: Packs -> Packs -> Packs

mconcat :: [Packs] -> Packs

Binary Packs

Methods

put :: Packs -> Put

get :: Get Packs

putList :: [Packs] -> Put

NFData Packs

Methods

rnf :: Packs -> ()

PPrint Packs

Methods

pprintTidy :: Tidy -> Packs -> Doc

pprintPrec :: Int -> Tidy -> Packs -> Doc

Fixpoint Packs

Methods

toFix :: Packs -> Doc

simplify :: Packs -> Packs

type Rep Packs

type Rep Packs = D1 (MetaData "Packs" "Language.Fixpoint.Types.Environments" "liquid-fixpoint-0.7.0.2-3repHVQ2bkqGganvJ6cFNP" True) (C1 (MetaCons "Packs" PrefixI True) (S1 (MetaSel (Just Symbol "packm") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (HashMap KVar Int))))

getPack :: KVar -> Packs -> Maybe Int

makePack :: [HashSet KVar] -> Packs

Orphan instances

(Hashable a, Eq a, Binary a) => Binary (HashSet a)

Methods

put :: HashSet a -> Put

get :: Get (HashSet a)

putList :: [HashSet a] -> Put