License	BSD-3-Clause
Safe Haskell	None
Language	Haskell2010

Swarm.Language.Context

Description

Generic contexts (mappings from variables to other things, such as types, values, or capability sets) used throughout the codebase. For example, while typechecking we use a context to store a mapping from variables in scope to their types. As another example, at runtime, robots store an Env which contains several contexts, mapping variables to things like their current value, any requirements associated with using the variable, and so on.

The implementation here goes to some effort to make it possible to serialize and deserialize contexts so that sharing is preserved and the encoding of serialized contexts does not blow up due to repeated values.

Synopsis

newtype CtxHash = CtxHash {
- getCtxHash :: Int
}
singletonHash :: (Hashable v, Hashable t) => v -> t -> CtxHash
mapHash :: (Hashable v, Hashable t) => Map v t -> CtxHash
data CtxF (f :: Type -> Type -> Type) v t
- = CtxEmpty
- | CtxSingle v t
- | CtxDelete v t (f v t)
- | CtxUnion (f v t) (f v t)
restructureCtx :: (f v t -> g v t) -> CtxF f v t -> CtxF g v t
data CtxTree v t = CtxTree CtxHash (CtxF CtxTree v t)
data Ctx v t = Ctx {
- unCtx :: Map v t
- ctxStruct :: CtxTree v t
}
ctxHash :: Ctx v t -> CtxHash
ctxFromTree :: Ord v => CtxTree v t -> Ctx v t
rollCtx :: (Ord v, Hashable v, Hashable t) => CtxF Ctx v t -> Ctx v t
empty :: Ctx v t
singleton :: (Ord v, Hashable v, Hashable t) => v -> t -> Ctx v t
fromMap :: (Ord v, Hashable v, Hashable t) => Map v t -> Ctx v t
lookup :: Ord v => v -> Ctx v t -> Maybe t
lookupR :: forall v t (sig :: (Type -> Type) -> Type -> Type) m. (Ord v, Has (Reader (Ctx v t)) sig m) => v -> m (Maybe t)
delete :: (Ord v, Hashable v, Hashable t) => v -> Ctx v t -> Ctx v t
assocs :: Ctx v t -> [(v, t)]
vars :: Ctx v t -> [v]
addBinding :: (Ord v, Hashable v, Hashable t) => v -> t -> Ctx v t -> Ctx v t
union :: (Ord v, Hashable v, Hashable t) => Ctx v t -> Ctx v t -> Ctx v t
withBinding :: forall v t (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader (Ctx v t)) sig m, Ord v, Hashable v, Hashable t) => v -> t -> m a -> m a
withBindings :: forall v t (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Reader (Ctx v t)) sig m, Ord v, Hashable v, Hashable t) => Ctx v t -> m a -> m a
type CtxMap (f :: Type -> Type -> Type) v t = Map CtxHash (CtxF f v t)
getCtx :: Ord v => CtxHash -> CtxMap CtxTree v t -> Maybe (Ctx v t)
toCtxMap :: Ord v => Ctx v t -> CtxMap CtxTree v t
buildCtxMap :: forall v t m (sig :: (Type -> Type) -> Type -> Type). (Ord v, Has (State (CtxMap CtxTree v t)) sig m) => Map v t -> CtxTree v t -> m ()
newtype ConstHash v t = ConstHash CtxHash
dehydrate :: CtxMap CtxTree v t -> CtxMap ConstHash v t
rehydrate :: CtxMap ConstHash v t -> CtxMap CtxTree v t

Documentation

newtype CtxHash Source #

A context hash is a hash value used to identify contexts without having to compare them for equality. Hash values are computed homomorphically, so that two equal contexts will be guaranteed to have the same hash value, even if they were constructed with a different sequence of operations.

The downside of this approach is that, in theory, there could be hash collisions, that is, two different contexts which nonetheless have the same hash value. However, this is extremely unlikely. The benefit is that everything can be purely functional, without the need to thread around some kind of globally unique ID generation effect.

Constructors

CtxHash
Fields getCtxHash :: Int

Instances

Instances details

FromJSON CtxHash Source #

Instance details

CtxEmpty
CtxSingle v t
CtxDelete v t (f v t)
CtxUnion (f v t) (f v t)

Ctx
Fields unCtx :: Map v t ctxStruct :: CtxTree v t