Language.PureScript.Sugar.Names.Env

Documentation

data ImportRecord a

The details for an import: the name of the thing that is being imported (x if importing from A), the module that the thing was originally defined in (for re-export resolution), and the import provenance (see below).

Constructors

ImportRecord

Fields

importName :: Qualified a

importSourceModule :: ModuleName

importProvenance :: ImportProvenance

Instances

Eq a => Eq (ImportRecord a)

Ord a => Ord (ImportRecord a)

Read a => Read (ImportRecord a)

Show a => Show (ImportRecord a)

data ImportProvenance

Used to track how an import was introduced into scope. This allows us to handle the one-open-import special case that allows a name conflict to become a warning rather than being an unresolvable situation.

Constructors

FromImplicit

FromExplicit

Local

Instances

Eq ImportProvenance

Ord ImportProvenance

Read ImportProvenance

Show ImportProvenance

data Imports

The imported declarations for a module, including the module's own members.

Constructors

Imports

Fields

importedTypes :: Map (Qualified (ProperName TypeName)) [ImportRecord (ProperName TypeName)]

Local names for types within a module mapped to to their qualified names

importedDataConstructors :: Map (Qualified (ProperName ConstructorName)) [ImportRecord (ProperName ConstructorName)]

Local names for data constructors within a module mapped to to their qualified names

importedTypeClasses :: Map (Qualified (ProperName ClassName)) [ImportRecord (ProperName ClassName)]

Local names for classes within a module mapped to to their qualified names

importedValues :: Map (Qualified Ident) [ImportRecord Ident]

Local names for values within a module mapped to to their qualified names

importedModules :: Set ModuleName

The modules that have been imported into the current scope.

importedVirtualModules :: Set ModuleName

The names of "virtual" modules that come into existence when "import as" is used.

Instances

Read Imports

Show Imports

nullImports :: Imports

An empty Imports value.

data Exports

The exported declarations from a module.

Constructors

Exports

Fields

exportedTypes :: [((ProperName TypeName, [ProperName ConstructorName]), ModuleName)]

The types exported from each module along with the module they originally came from.

exportedTypeClasses :: [(ProperName ClassName, ModuleName)]

The classes exported from each module along with the module they originally came from.

exportedValues :: [(Ident, ModuleName)]

The values exported from each module along with the module they originally came from.

Instances

Read Exports

Show Exports

nullExports :: Exports

An empty Exports value.

type Env = Map ModuleName (SourceSpan, Imports, Exports)

The imports and exports for a collection of modules. The SourceSpan is used to store the source location of the module with a given name, used to provide useful information when there is a duplicate module definition.

primEnv :: Env

Environment which only contains the Prim module.

envModuleSourceSpan :: (SourceSpan, a, b) -> SourceSpan

Extracts the SourceSpan from an Env value.

envModuleImports :: (a, Imports, b) -> Imports

Extracts the Imports from an Env value.

envModuleExports :: (a, b, Exports) -> Exports

Extracts the Exports from an Env value.

exportType :: MonadError MultipleErrors m => Exports -> ProperName TypeName -> [ProperName ConstructorName] -> ModuleName -> m Exports

Safely adds a type and its data constructors to some exports, returning an error if a conflict occurs.

exportTypeClass :: MonadError MultipleErrors m => Exports -> ProperName ClassName -> ModuleName -> m Exports

Safely adds a class to some exports, returning an error if a conflict occurs.

exportValue :: MonadError MultipleErrors m => Exports -> Ident -> ModuleName -> m Exports

Safely adds a value to some exports, returning an error if a conflict occurs.

getExports :: MonadError MultipleErrors m => Env -> ModuleName -> m Exports

checkImportConflicts :: forall m a. (Show a, MonadError MultipleErrors m, MonadWriter MultipleErrors m, Ord a) => ModuleName -> (a -> String) -> [ImportRecord a] -> m (ModuleName, ModuleName)

When reading a value from the imports, check that there are no conflicts in scope.