Safe Haskell	None
Language	Haskell2010

Language.PureScript

Description

The main compiler module

Synopsis

data Text
type Supply = SupplyT Identity
newtype SupplyT m a = SupplyT {
- unSupplyT :: StateT Integer m a
}
runSupplyT :: Integer -> SupplyT m a -> m (a, Integer)
evalSupplyT :: Functor m => Integer -> SupplyT m a -> m a
runSupply :: Integer -> Supply a -> (a, Integer)
evalSupply :: Integer -> Supply a -> a
data Comment
- = LineComment Text
- | BlockComment Text
data SourceSpan = SourceSpan {
- spanName :: String
- spanStart :: SourcePos
- spanEnd :: SourcePos
}
data SourcePos = SourcePos {
- sourcePosLine :: Int
- sourcePosColumn :: Int
}
type SourceAnn = (SourceSpan, [Comment])
pattern NullSourceAnn :: SourceAnn
pattern NullSourceSpan :: SourceSpan
displaySourcePos :: SourcePos -> Text
displaySourcePosShort :: SourcePos -> Text
displayStartEndPos :: SourceSpan -> Text
displayStartEndPosShort :: SourceSpan -> Text
displaySourceSpan :: FilePath -> SourceSpan -> Text
internalModuleSourceSpan :: String -> SourceSpan
nullSourceSpan :: SourceSpan
nullSourceAnn :: SourceAnn
nonEmptySpan :: SourceAnn -> Maybe SourceSpan
widenSourceSpan :: SourceSpan -> SourceSpan -> SourceSpan
widenSourceAnn :: SourceAnn -> SourceAnn -> SourceAnn
type HasCallStack = HasCallStack
internalError :: HasCallStack => String -> a
data Fixity = Fixity Associativity Precedence
data Associativity
- = Infixl
- | Infixr
- | Infix
type Precedence = Integer
showAssoc :: Associativity -> String
readAssoc :: String -> Associativity
data Qualified a = Qualified (Maybe ModuleName) a
newtype ModuleName = ModuleName [ProperName Namespace]
data ProperNameType
- = TypeName
- | ConstructorName
- | ClassName
- | KindName
- | Namespace
newtype ProperName (a :: ProperNameType) = ProperName {
- runProperName :: Text
}
data OpNameType
- = ValueOpName
- | TypeOpName
- | AnyOpName
newtype OpName (a :: OpNameType) = OpName {
- runOpName :: Text
}
data Ident
- = Ident Text
- | GenIdent (Maybe Text) Integer
- | UnusedIdent
data Name
- = IdentName Ident
- | ValOpName (OpName ValueOpName)
- | TyName (ProperName TypeName)
- | TyOpName (OpName TypeOpName)
- | DctorName (ProperName ConstructorName)
- | TyClassName (ProperName ClassName)
- | ModName ModuleName
- | KiName (ProperName KindName)
getIdentName :: Name -> Maybe Ident
getValOpName :: Name -> Maybe (OpName ValueOpName)
getTypeName :: Name -> Maybe (ProperName TypeName)
getKindName :: Name -> Maybe (ProperName KindName)
getTypeOpName :: Name -> Maybe (OpName TypeOpName)
getDctorName :: Name -> Maybe (ProperName ConstructorName)
getClassName :: Name -> Maybe (ProperName ClassName)
getModName :: Name -> Maybe ModuleName
runIdent :: Ident -> Text
showIdent :: Ident -> Text
freshIdent :: MonadSupply m => Text -> m Ident
freshIdent' :: MonadSupply m => m Ident
showOp :: OpName a -> Text
eraseOpName :: OpName a -> OpName AnyOpName
coerceProperName :: ProperName a -> ProperName b
runModuleName :: ModuleName -> Text
moduleNameFromString :: Text -> ModuleName
isBuiltinModuleName :: ModuleName -> Bool
showQualified :: (a -> Text) -> Qualified a -> Text
getQual :: Qualified a -> Maybe ModuleName
qualify :: ModuleName -> Qualified a -> (ModuleName, a)
mkQualified :: a -> ModuleName -> Qualified a
disqualify :: Qualified a -> a
disqualifyFor :: Maybe ModuleName -> Qualified a -> Maybe a
isQualified :: Qualified a -> Bool
isUnqualified :: Qualified a -> Bool
isQualifiedWith :: ModuleName -> Qualified a -> Bool
data Kind a
- = KUnknown a Int
- | Row a (Kind a)
- | FunKind a (Kind a) (Kind a)
- | NamedKind a (Qualified (ProperName KindName))
type SourceKind = Kind SourceAnn
srcKUnknown :: Int -> SourceKind
srcRow :: SourceKind -> SourceKind
srcFunKind :: SourceKind -> SourceKind -> SourceKind
srcNamedKind :: Qualified (ProperName KindName) -> SourceKind
kindToJSON :: forall a. (a -> Value) -> Kind a -> Value
kindFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Kind a)
everywhereOnKinds :: (Kind a -> Kind a) -> Kind a -> Kind a
everywhereOnKindsM :: Monad m => (Kind a -> m (Kind a)) -> Kind a -> m (Kind a)
everythingOnKinds :: (r -> r -> r) -> (Kind a -> r) -> Kind a -> r
annForKind :: Lens' (Kind a) a
getAnnForKind :: Kind a -> a
setAnnForKind :: a -> Kind a -> Kind a
eqKind :: Kind a -> Kind b -> Bool
eqMaybeKind :: Maybe (Kind a) -> Maybe (Kind b) -> Bool
compareKind :: Kind a -> Kind b -> Ordering
compareMaybeKind :: Maybe (Kind a) -> Maybe (Kind b) -> Ordering
data CodegenTarget
- = JS
- | JSSourceMap
- | CoreFn
- | Docs
data Options = Options {
- optionsVerboseErrors :: Bool
- optionsNoComments :: Bool
- optionsCodegenTargets :: Set CodegenTarget
}
defaultOptions :: Options
codegenTargets :: Map String CodegenTarget
prettyPrintString :: PSString -> Text
data Literal a
- = NumericLiteral (Either Integer Double)
- | StringLiteral PSString
- | CharLiteral Char
- | BooleanLiteral Bool
- | ArrayLiteral [a]
- | ObjectLiteral [(PSString, a)]
data RowListItem a = RowListItem {
- rowListAnn :: a
- rowListLabel :: Label
- rowListType :: Type a
}
data Constraint a = Constraint {
- constraintAnn :: a
- constraintClass :: Qualified (ProperName ClassName)
- constraintArgs :: [Type a]
- constraintData :: Maybe ConstraintData
}
data ConstraintData = PartialConstraintData [[Text]] Bool
data Type a
- = TUnknown a Int
- | TypeVar a Text
- | TypeLevelString a PSString
- | TypeWildcard a (Maybe Text)
- | TypeConstructor a (Qualified (ProperName TypeName))
- | TypeOp a (Qualified (OpName TypeOpName))
- | TypeApp a (Type a) (Type a)
- | ForAll a Text (Maybe (Kind a)) (Type a) (Maybe SkolemScope)
- | ConstrainedType a (Constraint a) (Type a)
- | Skolem a Text Int SkolemScope
- | REmpty a
- | RCons a Label (Type a) (Type a)
- | KindedType a (Type a) (Kind a)
- | BinaryNoParensType a (Type a) (Type a) (Type a)
- | ParensInType a (Type a)
newtype SkolemScope = SkolemScope {
- runSkolemScope :: Int
}
type SourceConstraint = Constraint SourceAnn
type SourceType = Type SourceAnn
srcTUnknown :: Int -> SourceType
srcTypeVar :: Text -> SourceType
srcTypeLevelString :: PSString -> SourceType
srcTypeWildcard :: SourceType
srcTypeConstructor :: Qualified (ProperName TypeName) -> SourceType
srcTypeOp :: Qualified (OpName TypeOpName) -> SourceType
srcTypeApp :: SourceType -> SourceType -> SourceType
srcForAll :: Text -> Maybe SourceKind -> SourceType -> Maybe SkolemScope -> SourceType
srcConstrainedType :: SourceConstraint -> SourceType -> SourceType
srcSkolem :: Text -> Int -> SkolemScope -> SourceType
srcREmpty :: SourceType
srcRCons :: Label -> SourceType -> SourceType -> SourceType
srcKindedType :: SourceType -> SourceKind -> SourceType
srcBinaryNoParensType :: SourceType -> SourceType -> SourceType -> SourceType
srcParensInType :: SourceType -> SourceType
srcConstraint :: Qualified (ProperName ClassName) -> [SourceType] -> Maybe ConstraintData -> SourceConstraint
mapConstraintArgs :: ([Type a] -> [Type a]) -> Constraint a -> Constraint a
overConstraintArgs :: Functor f => ([Type a] -> f [Type a]) -> Constraint a -> f (Constraint a)
constraintDataToJSON :: ConstraintData -> Value
constraintToJSON :: (a -> Value) -> Constraint a -> Value
typeToJSON :: forall a. (a -> Value) -> Type a -> Value
constraintDataFromJSON :: Value -> Parser ConstraintData
constraintFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Constraint a)
typeFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Type a)
srcRowListItem :: Label -> SourceType -> RowListItem SourceAnn
rowToList :: Type a -> ([RowListItem a], Type a)
rowToSortedList :: Type a -> ([RowListItem a], Type a)
rowFromList :: ([RowListItem a], Type a) -> Type a
isMonoType :: Type a -> Bool
mkForAll :: [(a, (Text, Maybe (Kind a)))] -> Type a -> Type a
replaceTypeVars :: Text -> Type a -> Type a -> Type a
replaceAllTypeVars :: [(Text, Type a)] -> Type a -> Type a
usedTypeVariables :: Type a -> [Text]
freeTypeVariables :: Type a -> [Text]
quantify :: Type a -> Type a
moveQuantifiersToFront :: Type a -> Type a
containsWildcards :: Type a -> Bool
containsForAll :: Type a -> Bool
everywhereOnTypes :: (Type a -> Type a) -> Type a -> Type a
everywhereOnTypesTopDown :: (Type a -> Type a) -> Type a -> Type a
everywhereOnTypesM :: Monad m => (Type a -> m (Type a)) -> Type a -> m (Type a)
everywhereOnTypesTopDownM :: Monad m => (Type a -> m (Type a)) -> Type a -> m (Type a)
everythingOnTypes :: (r -> r -> r) -> (Type a -> r) -> Type a -> r
everythingWithContextOnTypes :: s -> r -> (r -> r -> r) -> (s -> Type a -> (s, r)) -> Type a -> r
annForType :: Lens' (Type a) a
getAnnForType :: Type a -> a
setAnnForType :: a -> Type a -> Type a
eqType :: Type a -> Type b -> Bool
compareType :: Type a -> Type b -> Ordering
eqConstraint :: Constraint a -> Constraint b -> Bool
compareConstraint :: Constraint a -> Constraint b -> Ordering
data DataDeclType
- = Data
- | Newtype
data TypeKind
- = DataType [(Text, Maybe SourceKind)] [(ProperName ConstructorName, [SourceType])]
- | TypeSynonym
- | ExternData
- | LocalTypeVariable
- | ScopedTypeVar
data NameKind
- = Private
- | Public
- | External
data NameVisibility
- = Undefined
- | Defined
data FunctionalDependency = FunctionalDependency {
- fdDeterminers :: [Int]
- fdDetermined :: [Int]
}
data TypeClassData = TypeClassData {
- typeClassArguments :: [(Text, Maybe SourceKind)]
- typeClassMembers :: [(Ident, SourceType)]
- typeClassSuperclasses :: [SourceConstraint]
- typeClassDependencies :: [FunctionalDependency]
- typeClassDeterminedArguments :: Set Int
- typeClassCoveringSets :: Set (Set Int)
}
data Environment = Environment {
- names :: Map (Qualified Ident) (SourceType, NameKind, NameVisibility)
- types :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
- dataConstructors :: Map (Qualified (ProperName ConstructorName)) (DataDeclType, ProperName TypeName, SourceType, [Ident])
- typeSynonyms :: Map (Qualified (ProperName TypeName)) ([(Text, Maybe SourceKind)], SourceType)
- typeClassDictionaries :: Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))
- typeClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
- kinds :: Set (Qualified (ProperName KindName))
}
initEnvironment :: Environment
makeTypeClassData :: [(Text, Maybe SourceKind)] -> [(Ident, SourceType)] -> [SourceConstraint] -> [FunctionalDependency] -> TypeClassData
showDataDeclType :: DataDeclType -> Text
primName :: Text -> Qualified (ProperName a)
primSubName :: Text -> Text -> Qualified (ProperName a)
primKind :: Text -> SourceKind
primSubKind :: Text -> Text -> SourceKind
kindType :: SourceKind
kindConstraint :: SourceKind
isKindType :: Kind a -> Bool
(-:>) :: SourceKind -> SourceKind -> SourceKind
kindSymbol :: SourceKind
kindDoc :: SourceKind
kindBoolean :: SourceKind
kindOrdering :: SourceKind
kindRowList :: SourceKind
kindRow :: SourceKind -> SourceKind
primTy :: Text -> SourceType
tyFunction :: SourceType
tyString :: SourceType
tyChar :: SourceType
tyNumber :: SourceType
tyInt :: SourceType
tyBoolean :: SourceType
tyArray :: SourceType
tyRecord :: SourceType
isObject :: Type a -> Bool
isFunction :: Type a -> Bool
isTypeOrApplied :: Type a -> Type b -> Bool
function :: SourceType -> SourceType -> SourceType
primKinds :: Set (Qualified (ProperName KindName))
primBooleanKinds :: Set (Qualified (ProperName KindName))
primOrderingKinds :: Set (Qualified (ProperName KindName))
primRowListKinds :: Set (Qualified (ProperName KindName))
primTypeErrorKinds :: Set (Qualified (ProperName KindName))
allPrimKinds :: Set (Qualified (ProperName KindName))
primTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
allPrimTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primBooleanTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primOrderingTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primRowTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primRowListTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primSymbolTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primTypeErrorTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
primClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
allPrimClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
primRowClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
primRowListClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
primSymbolClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
primTypeErrorClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
lookupConstructor :: Environment -> Qualified (ProperName ConstructorName) -> (DataDeclType, ProperName TypeName, SourceType, [Ident])
isNewtypeConstructor :: Environment -> Qualified (ProperName ConstructorName) -> Bool
lookupValue :: Environment -> Qualified Ident -> Maybe (SourceType, NameKind, NameVisibility)
data Binder
- = NullBinder
- | LiteralBinder SourceSpan (Literal Binder)
- | VarBinder SourceSpan Ident
- | ConstructorBinder SourceSpan (Qualified (ProperName ConstructorName)) [Binder]
- | OpBinder SourceSpan (Qualified (OpName ValueOpName))
- | BinaryNoParensBinder Binder Binder Binder
- | ParensInBinder Binder
- | NamedBinder SourceSpan Ident Binder
- | PositionedBinder SourceSpan [Comment] Binder
- | TypedBinder SourceType Binder
binderNames :: Binder -> [Ident]
isIrrefutable :: Binder -> Bool
newtype AssocList k t = AssocList {
- runAssocList :: [(k, t)]
}
data PathNode t
- = Leaf t
- | Branch (PathTree t)
newtype PathTree t = PathTree (AssocList PSString (PathNode t))
data DoNotationElement
- = DoNotationValue Expr
- | DoNotationBind Binder Expr
- | DoNotationLet [Declaration]
- | PositionedDoNotationElement SourceSpan [Comment] DoNotationElement
data CaseAlternative = CaseAlternative {
- caseAlternativeBinders :: [Binder]
- caseAlternativeResult :: [GuardedExpr]
}
data WhereProvenance
- = FromWhere
- | FromLet
data Expr
- = Literal SourceSpan (Literal Expr)
- | UnaryMinus SourceSpan Expr
- | BinaryNoParens Expr Expr Expr
- | Parens Expr
- | Accessor PSString Expr
- | ObjectUpdate Expr [(PSString, Expr)]
- | ObjectUpdateNested Expr (PathTree Expr)
- | Abs Binder Expr
- | App Expr Expr
- | Var SourceSpan (Qualified Ident)
- | Op SourceSpan (Qualified (OpName ValueOpName))
- | IfThenElse Expr Expr Expr
- | Constructor SourceSpan (Qualified (ProperName ConstructorName))
- | Case [Expr] [CaseAlternative]
- | TypedValue Bool Expr SourceType
- | Let WhereProvenance [Declaration] Expr
- | Do (Maybe ModuleName) [DoNotationElement]
- | Ado (Maybe ModuleName) [DoNotationElement] Expr
- | TypeClassDictionaryConstructorApp (Qualified (ProperName ClassName)) Expr
- | TypeClassDictionary SourceConstraint (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))) [ErrorMessageHint]
- | TypeClassDictionaryAccessor (Qualified (ProperName ClassName)) Ident
- | DeferredDictionary (Qualified (ProperName ClassName)) [SourceType]
- | AnonymousArgument
- | Hole Text
- | PositionedValue SourceSpan [Comment] Expr
data GuardedExpr = GuardedExpr [Guard] Expr
data Guard
- = ConditionGuard Expr
- | PatternGuard Binder Expr
data TypeInstanceBody
- = DerivedInstance
- | NewtypeInstance
- | NewtypeInstanceWithDictionary Expr
- | ExplicitInstance [Declaration]
data TypeFixity = TypeFixity Fixity (Qualified (ProperName TypeName)) (OpName TypeOpName)
data ValueFixity = ValueFixity Fixity (Qualified (Either Ident (ProperName ConstructorName))) (OpName ValueOpName)
data Declaration
- = DataDeclaration SourceAnn DataDeclType (ProperName TypeName) [(Text, Maybe SourceKind)] [(ProperName ConstructorName, [(Ident, SourceType)])]
- | DataBindingGroupDeclaration (NonEmpty Declaration)
- | TypeSynonymDeclaration SourceAnn (ProperName TypeName) [(Text, Maybe SourceKind)] SourceType
- | TypeDeclaration !TypeDeclarationData
- | ValueDeclaration !(ValueDeclarationData [GuardedExpr])
- | BoundValueDeclaration SourceAnn Binder Expr
- | BindingGroupDeclaration (NonEmpty ((SourceAnn, Ident), NameKind, Expr))
- | ExternDeclaration SourceAnn Ident SourceType
- | ExternDataDeclaration SourceAnn (ProperName TypeName) SourceKind
- | ExternKindDeclaration SourceAnn (ProperName KindName)
- | FixityDeclaration SourceAnn (Either ValueFixity TypeFixity)
- | ImportDeclaration SourceAnn ModuleName ImportDeclarationType (Maybe ModuleName)
- | TypeClassDeclaration SourceAnn (ProperName ClassName) [(Text, Maybe SourceKind)] [SourceConstraint] [FunctionalDependency] [Declaration]
- | TypeInstanceDeclaration SourceAnn [Ident] Integer Ident [SourceConstraint] (Qualified (ProperName ClassName)) [SourceType] TypeInstanceBody
data ValueDeclarationData a = ValueDeclarationData {
- valdeclSourceAnn :: !SourceAnn
- valdeclIdent :: !Ident
- valdeclName :: !NameKind
- valdeclBinders :: ![Binder]
- valdeclExpression :: !a
}
data TypeDeclarationData = TypeDeclarationData {
- tydeclSourceAnn :: !SourceAnn
- tydeclIdent :: !Ident
- tydeclType :: !SourceType
}
data ImportDeclarationType
- = Implicit
- | Explicit [DeclarationRef]
- | Hiding [DeclarationRef]
data ExportSource = ExportSource {
- exportSourceImportedFrom :: Maybe ModuleName
- exportSourceDefinedIn :: ModuleName
}
data DeclarationRef
- = TypeRef SourceSpan (ProperName TypeName) (Maybe [ProperName ConstructorName])
- | TypeOpRef SourceSpan (OpName TypeOpName)
- | ValueRef SourceSpan Ident
- | ValueOpRef SourceSpan (OpName ValueOpName)
- | TypeClassRef SourceSpan (ProperName ClassName)
- | TypeInstanceRef SourceSpan Ident
- | ModuleRef SourceSpan ModuleName
- | KindRef SourceSpan (ProperName KindName)
- | ReExportRef SourceSpan ExportSource DeclarationRef
data Module = Module SourceSpan [Comment] ModuleName [Declaration] (Maybe [DeclarationRef])
data ErrorMessage = ErrorMessage [ErrorMessageHint] SimpleErrorMessage
data HintCategory
- = ExprHint
- | KindHint
- | CheckHint
- | PositionHint
- | SolverHint
- | OtherHint
data ErrorMessageHint
- = ErrorUnifyingTypes SourceType SourceType
- | ErrorInExpression Expr
- | ErrorInModule ModuleName
- | ErrorInInstance (Qualified (ProperName ClassName)) [SourceType]
- | ErrorInSubsumption SourceType SourceType
- | ErrorCheckingAccessor Expr PSString
- | ErrorCheckingType Expr SourceType
- | ErrorCheckingKind SourceType
- | ErrorCheckingGuard
- | ErrorInferringType Expr
- | ErrorInApplication Expr SourceType Expr
- | ErrorInDataConstructor (ProperName ConstructorName)
- | ErrorInTypeConstructor (ProperName TypeName)
- | ErrorInBindingGroup (NonEmpty Ident)
- | ErrorInDataBindingGroup [ProperName TypeName]
- | ErrorInTypeSynonym (ProperName TypeName)
- | ErrorInValueDeclaration Ident
- | ErrorInTypeDeclaration Ident
- | ErrorInTypeClassDeclaration (ProperName ClassName)
- | ErrorInForeignImport Ident
- | ErrorSolvingConstraint SourceConstraint
- | PositionedError (NonEmpty SourceSpan)
data SimpleErrorMessage
- = ModuleNotFound ModuleName
- | ErrorParsingFFIModule FilePath (Maybe ErrorMessage)
- | ErrorParsingModule ParseError
- | ErrorParsingCSTModule ParserError
- | MissingFFIModule ModuleName
- | UnnecessaryFFIModule ModuleName FilePath
- | MissingFFIImplementations ModuleName [Ident]
- | UnusedFFIImplementations ModuleName [Ident]
- | InvalidFFIIdentifier ModuleName Text
- | CannotGetFileInfo FilePath
- | CannotReadFile FilePath
- | CannotWriteFile FilePath
- | InfiniteType SourceType
- | InfiniteKind SourceKind
- | MultipleValueOpFixities (OpName ValueOpName)
- | MultipleTypeOpFixities (OpName TypeOpName)
- | OrphanTypeDeclaration Ident
- | RedefinedIdent Ident
- | OverlappingNamesInLet
- | UnknownName (Qualified Name)
- | UnknownImport ModuleName Name
- | UnknownImportDataConstructor ModuleName (ProperName TypeName) (ProperName ConstructorName)
- | UnknownExport Name
- | UnknownExportDataConstructor (ProperName TypeName) (ProperName ConstructorName)
- | ScopeConflict Name [ModuleName]
- | ScopeShadowing Name (Maybe ModuleName) [ModuleName]
- | DeclConflict Name Name
- | ExportConflict (Qualified Name) (Qualified Name)
- | DuplicateModule ModuleName
- | DuplicateTypeClass (ProperName ClassName) SourceSpan
- | DuplicateInstance Ident SourceSpan
- | DuplicateTypeArgument Text
- | InvalidDoBind
- | InvalidDoLet
- | CycleInDeclaration Ident
- | CycleInTypeSynonym (Maybe (ProperName TypeName))
- | CycleInTypeClassDeclaration [Qualified (ProperName ClassName)]
- | CycleInModules [ModuleName]
- | NameIsUndefined Ident
- | UndefinedTypeVariable (ProperName TypeName)
- | PartiallyAppliedSynonym (Qualified (ProperName TypeName))
- | EscapedSkolem Text (Maybe SourceSpan) SourceType
- | TypesDoNotUnify SourceType SourceType
- | KindsDoNotUnify SourceKind SourceKind
- | ConstrainedTypeUnified SourceType SourceType
- | OverlappingInstances (Qualified (ProperName ClassName)) [SourceType] [Qualified Ident]
- | NoInstanceFound SourceConstraint
- | AmbiguousTypeVariables SourceType SourceConstraint
- | UnknownClass (Qualified (ProperName ClassName))
- | PossiblyInfiniteInstance (Qualified (ProperName ClassName)) [SourceType]
- | CannotDerive (Qualified (ProperName ClassName)) [SourceType]
- | InvalidDerivedInstance (Qualified (ProperName ClassName)) [SourceType] Int
- | ExpectedTypeConstructor (Qualified (ProperName ClassName)) [SourceType] SourceType
- | InvalidNewtypeInstance (Qualified (ProperName ClassName)) [SourceType]
- | MissingNewtypeSuperclassInstance (Qualified (ProperName ClassName)) (Qualified (ProperName ClassName)) [SourceType]
- | UnverifiableSuperclassInstance (Qualified (ProperName ClassName)) (Qualified (ProperName ClassName)) [SourceType]
- | CannotFindDerivingType (ProperName TypeName)
- | DuplicateLabel Label (Maybe Expr)
- | DuplicateValueDeclaration Ident
- | ArgListLengthsDiffer Ident
- | OverlappingArgNames (Maybe Ident)
- | MissingClassMember (NonEmpty (Ident, SourceType))
- | ExtraneousClassMember Ident (Qualified (ProperName ClassName))
- | ExpectedType SourceType SourceKind
- | IncorrectConstructorArity (Qualified (ProperName ConstructorName)) Int Int
- | ExprDoesNotHaveType Expr SourceType
- | PropertyIsMissing Label
- | AdditionalProperty Label
- | TypeSynonymInstance
- | OrphanInstance Ident (Qualified (ProperName ClassName)) (Set ModuleName) [SourceType]
- | InvalidNewtype (ProperName TypeName)
- | InvalidInstanceHead SourceType
- | TransitiveExportError DeclarationRef [DeclarationRef]
- | TransitiveDctorExportError DeclarationRef (ProperName ConstructorName)
- | ShadowedName Ident
- | ShadowedTypeVar Text
- | UnusedTypeVar Text
- | WildcardInferredType SourceType Context
- | HoleInferredType Text SourceType Context (Maybe TypeSearch)
- | MissingTypeDeclaration Ident SourceType
- | OverlappingPattern [[Binder]] Bool
- | IncompleteExhaustivityCheck
- | MisleadingEmptyTypeImport ModuleName (ProperName TypeName)
- | ImportHidingModule ModuleName
- | UnusedImport ModuleName
- | UnusedExplicitImport ModuleName [Name] (Maybe ModuleName) [DeclarationRef]
- | UnusedDctorImport ModuleName (ProperName TypeName) (Maybe ModuleName) [DeclarationRef]
- | UnusedDctorExplicitImport ModuleName (ProperName TypeName) [ProperName ConstructorName] (Maybe ModuleName) [DeclarationRef]
- | DuplicateSelectiveImport ModuleName
- | DuplicateImport ModuleName ImportDeclarationType (Maybe ModuleName)
- | DuplicateImportRef Name
- | DuplicateExportRef Name
- | IntOutOfRange Integer Text Integer Integer
- | ImplicitQualifiedImport ModuleName ModuleName [DeclarationRef]
- | ImplicitQualifiedImportReExport ModuleName ModuleName [DeclarationRef]
- | ImplicitImport ModuleName [DeclarationRef]
- | HidingImport ModuleName [DeclarationRef]
- | CaseBinderLengthDiffers Int [Binder]
- | IncorrectAnonymousArgument
- | InvalidOperatorInBinder (Qualified (OpName ValueOpName)) (Qualified Ident)
- | CannotGeneralizeRecursiveFunction Ident SourceType
- | CannotDeriveNewtypeForData (ProperName TypeName)
- | ExpectedWildcard (ProperName TypeName)
- | CannotUseBindWithDo Ident
- | ClassInstanceArityMismatch Ident (Qualified (ProperName ClassName)) Int Int
- | UserDefinedWarning SourceType
- | UnusableDeclaration Ident [[Text]]
- | CannotDefinePrimModules ModuleName
- | MixedAssociativityError (NonEmpty (Qualified (OpName AnyOpName), Associativity))
- | NonAssociativeError (NonEmpty (Qualified (OpName AnyOpName)))
data TypeSearch
- = TSBefore Environment
- | TSAfter {
  - tsAfterIdentifiers :: [(Qualified Text, SourceType)]
  - tsAfterRecordFields :: Maybe [(Label, SourceType)]
  }
type Context = [(Ident, SourceType)]
pattern MkUnguarded :: Expr -> GuardedExpr
pattern TypeFixityDeclaration :: SourceAnn -> Fixity -> Qualified (ProperName TypeName) -> OpName TypeOpName -> Declaration
pattern ValueFixityDeclaration :: SourceAnn -> Fixity -> Qualified (Either Ident (ProperName ConstructorName)) -> OpName ValueOpName -> Declaration
pattern ValueDecl :: SourceAnn -> Ident -> NameKind -> [Binder] -> [GuardedExpr] -> Declaration
onTypeSearchTypes :: (SourceType -> SourceType) -> TypeSearch -> TypeSearch
onTypeSearchTypesM :: Applicative m => (SourceType -> m SourceType) -> TypeSearch -> m TypeSearch
getModuleName :: Module -> ModuleName
getModuleSourceSpan :: Module -> SourceSpan
getModuleDeclarations :: Module -> [Declaration]
addDefaultImport :: Qualified ModuleName -> Module -> Module
importPrim :: Module -> Module
compDecRef :: DeclarationRef -> DeclarationRef -> Ordering
declRefSourceSpan :: DeclarationRef -> SourceSpan
declRefName :: DeclarationRef -> Name
getTypeRef :: DeclarationRef -> Maybe (ProperName TypeName, Maybe [ProperName ConstructorName])
getTypeOpRef :: DeclarationRef -> Maybe (OpName TypeOpName)
getValueRef :: DeclarationRef -> Maybe Ident
getValueOpRef :: DeclarationRef -> Maybe (OpName ValueOpName)
getTypeClassRef :: DeclarationRef -> Maybe (ProperName ClassName)
getKindRef :: DeclarationRef -> Maybe (ProperName KindName)
isModuleRef :: DeclarationRef -> Bool
isImplicit :: ImportDeclarationType -> Bool
isExplicit :: ImportDeclarationType -> Bool
overTypeDeclaration :: (TypeDeclarationData -> TypeDeclarationData) -> Declaration -> Declaration
getTypeDeclaration :: Declaration -> Maybe TypeDeclarationData
unwrapTypeDeclaration :: TypeDeclarationData -> (Ident, SourceType)
overValueDeclaration :: (ValueDeclarationData [GuardedExpr] -> ValueDeclarationData [GuardedExpr]) -> Declaration -> Declaration
getValueDeclaration :: Declaration -> Maybe (ValueDeclarationData [GuardedExpr])
mapTypeInstanceBody :: ([Declaration] -> [Declaration]) -> TypeInstanceBody -> TypeInstanceBody
traverseTypeInstanceBody :: Applicative f => ([Declaration] -> f [Declaration]) -> TypeInstanceBody -> f TypeInstanceBody
declSourceAnn :: Declaration -> SourceAnn
declSourceSpan :: Declaration -> SourceSpan
declName :: Declaration -> Maybe Name
isValueDecl :: Declaration -> Bool
isDataDecl :: Declaration -> Bool
isImportDecl :: Declaration -> Bool
isExternDataDecl :: Declaration -> Bool
isExternKindDecl :: Declaration -> Bool
isFixityDecl :: Declaration -> Bool
getFixityDecl :: Declaration -> Maybe (Either ValueFixity TypeFixity)
isExternDecl :: Declaration -> Bool
isTypeClassInstanceDeclaration :: Declaration -> Bool
isTypeClassDeclaration :: Declaration -> Bool
flattenDecls :: [Declaration] -> [Declaration]
isTrueExpr :: Expr -> Bool
data ScopedIdent
- = LocalIdent Ident
- | ToplevelIdent Ident
guardedExprM :: Applicative m => (Guard -> m Guard) -> (Expr -> m Expr) -> GuardedExpr -> m GuardedExpr
mapGuardedExpr :: (Guard -> Guard) -> (Expr -> Expr) -> GuardedExpr -> GuardedExpr
litM :: Monad m => (a -> m a) -> Literal a -> m (Literal a)
everywhereOnValues :: (Declaration -> Declaration) -> (Expr -> Expr) -> (Binder -> Binder) -> (Declaration -> Declaration, Expr -> Expr, Binder -> Binder)
everywhereOnValuesTopDownM :: forall m. Monad m => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder)
everywhereOnValuesM :: forall m. Monad m => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder)
everythingOnValues :: forall r. (r -> r -> r) -> (Declaration -> r) -> (Expr -> r) -> (Binder -> r) -> (CaseAlternative -> r) -> (DoNotationElement -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)
everythingWithContextOnValues :: forall s r. s -> r -> (r -> r -> r) -> (s -> Declaration -> (s, r)) -> (s -> Expr -> (s, r)) -> (s -> Binder -> (s, r)) -> (s -> CaseAlternative -> (s, r)) -> (s -> DoNotationElement -> (s, r)) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)
everywhereWithContextOnValuesM :: forall m s. Monad m => s -> (s -> Declaration -> m (s, Declaration)) -> (s -> Expr -> m (s, Expr)) -> (s -> Binder -> m (s, Binder)) -> (s -> CaseAlternative -> m (s, CaseAlternative)) -> (s -> DoNotationElement -> m (s, DoNotationElement)) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder, CaseAlternative -> m CaseAlternative, DoNotationElement -> m DoNotationElement)
inScope :: Ident -> Set ScopedIdent -> Bool
everythingWithScope :: forall r. Monoid r => (Set ScopedIdent -> Declaration -> r) -> (Set ScopedIdent -> Expr -> r) -> (Set ScopedIdent -> Binder -> r) -> (Set ScopedIdent -> CaseAlternative -> r) -> (Set ScopedIdent -> DoNotationElement -> r) -> (Set ScopedIdent -> Declaration -> r, Set ScopedIdent -> Expr -> r, Set ScopedIdent -> Binder -> r, Set ScopedIdent -> CaseAlternative -> r, Set ScopedIdent -> DoNotationElement -> r)
accumTypes :: Monoid r => (SourceType -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)
accumKinds :: Monoid r => (SourceKind -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r)
overTypes :: (SourceType -> SourceType) -> Expr -> Expr
exportedDeclarations :: Module -> [Declaration]
isExported :: Maybe [DeclarationRef] -> Declaration -> Bool
desugarLetPatternModule :: Module -> Module
prettyPrintKind :: Kind a -> Text
type PrettyPrintConstraint = (Qualified (ProperName ClassName), [PrettyPrintType])
data PrettyPrintType
- = PPTUnknown Int
- | PPTypeVar Text
- | PPTypeLevelString PSString
- | PPTypeWildcard (Maybe Text)
- | PPTypeConstructor (Qualified (ProperName TypeName))
- | PPTypeOp (Qualified (OpName TypeOpName))
- | PPSkolem Text Int
- | PPTypeApp PrettyPrintType PrettyPrintType
- | PPConstrainedType PrettyPrintConstraint PrettyPrintType
- | PPKindedType PrettyPrintType (Kind ())
- | PPBinaryNoParensType PrettyPrintType PrettyPrintType PrettyPrintType
- | PPParensInType PrettyPrintType
- | PPForAll [(Text, Maybe (Kind ()))] PrettyPrintType
- | PPFunction PrettyPrintType PrettyPrintType
- | PPRecord [(Label, PrettyPrintType)] (Maybe PrettyPrintType)
- | PPRow [(Label, PrettyPrintType)] (Maybe PrettyPrintType)
- | PPTruncated
convertPrettyPrintType :: Int -> Type a -> PrettyPrintType
typeAtomAsBox :: Int -> Type a -> Box
prettyPrintTypeAtom :: Int -> Type a -> String
typeAsBox :: Int -> Type a -> Box
suggestedTypeAsBox :: PrettyPrintType -> Box
prettyPrintType :: Int -> Type a -> String
prettyPrintTypeWithUnicode :: Int -> Type a -> String
prettyPrintSuggestedType :: Type a -> String
prettyPrintLabel :: Label -> Text
prettyPrintObjectKey :: PSString -> Text
prettyPrintValue :: Int -> Expr -> Box
prettyPrintBinderAtom :: Binder -> Text
prettyPrintBinder :: Binder -> Text
data ExternsDeclaration
- = EDType {
  - edTypeName :: ProperName TypeName
  - edTypeKind :: SourceKind
  - edTypeDeclarationKind :: TypeKind
  }
- | EDTypeSynonym {
  - edTypeSynonymName :: ProperName TypeName
  - edTypeSynonymArguments :: [(Text, Maybe SourceKind)]
  - edTypeSynonymType :: SourceType
  }
- | EDDataConstructor {
  - edDataCtorName :: ProperName ConstructorName
  - edDataCtorOrigin :: DataDeclType
  - edDataCtorTypeCtor :: ProperName TypeName
  - edDataCtorType :: SourceType
  - edDataCtorFields :: [Ident]
  }
- | EDValue {
  - edValueName :: Ident
  - edValueType :: SourceType
  }
- | EDClass {
  - edClassName :: ProperName ClassName
  - edClassTypeArguments :: [(Text, Maybe SourceKind)]
  - edClassMembers :: [(Ident, SourceType)]
  - edClassConstraints :: [SourceConstraint]
  - edFunctionalDependencies :: [FunctionalDependency]
  }
- | EDInstance {
  - edInstanceClassName :: Qualified (ProperName ClassName)
  - edInstanceName :: Ident
  - edInstanceTypes :: [SourceType]
  - edInstanceConstraints :: Maybe [SourceConstraint]
  - edInstanceChain :: [Qualified Ident]
  - edInstanceChainIndex :: Integer
  }
- | EDKind {
  - edKindName :: ProperName KindName
  }
data ExternsTypeFixity = ExternsTypeFixity {
- efTypeAssociativity :: Associativity
- efTypePrecedence :: Precedence
- efTypeOperator :: OpName TypeOpName
- efTypeAlias :: Qualified (ProperName TypeName)
}
data ExternsFixity = ExternsFixity {
- efAssociativity :: Associativity
- efPrecedence :: Precedence
- efOperator :: OpName ValueOpName
- efAlias :: Qualified (Either Ident (ProperName ConstructorName))
}
data ExternsImport = ExternsImport {
- eiModule :: ModuleName
- eiImportType :: ImportDeclarationType
- eiImportedAs :: Maybe ModuleName
}
data ExternsFile = ExternsFile {
- efVersion :: Text
- efModuleName :: ModuleName
- efExports :: [DeclarationRef]
- efImports :: [ExternsImport]
- efFixities :: [ExternsFixity]
- efTypeFixities :: [ExternsTypeFixity]
- efDeclarations :: [ExternsDeclaration]
- efSourceSpan :: SourceSpan
}
applyExternsFileToEnvironment :: ExternsFile -> Environment -> Environment
moduleToExternsFile :: Module -> Environment -> ExternsFile
decodeExterns :: ByteString -> Maybe ExternsFile
data PPEOptions = PPEOptions {
- ppeCodeColor :: Maybe (ColorIntensity, Color)
- ppeFull :: Bool
- ppeLevel :: Level
- ppeShowDocs :: Bool
- ppeRelativeDirectory :: FilePath
}
data Level
- = Error
- | Warning
data TypeMap = TypeMap {
- umSkolemMap :: Map Int (String, Int, Maybe SourceSpan)
- umUnknownMap :: Map Int Int
- umNextIndex :: Int
}
newtype MultipleErrors = MultipleErrors {
- runMultipleErrors :: [ErrorMessage]
}
newtype ErrorSuggestion = ErrorSuggestion Text
errorSpan :: ErrorMessage -> Maybe (NonEmpty SourceSpan)
errorModule :: ErrorMessage -> Maybe ModuleName
findHint :: (ErrorMessageHint -> Maybe a) -> ErrorMessage -> Maybe a
stripModuleAndSpan :: ErrorMessage -> ErrorMessage
errorCode :: ErrorMessage -> Text
nonEmpty :: MultipleErrors -> Bool
errorMessage :: SimpleErrorMessage -> MultipleErrors
errorMessage' :: SourceSpan -> SimpleErrorMessage -> MultipleErrors
errorMessage'' :: NonEmpty SourceSpan -> SimpleErrorMessage -> MultipleErrors
errorMessage''' :: [SourceSpan] -> SimpleErrorMessage -> MultipleErrors
singleError :: ErrorMessage -> MultipleErrors
onErrorMessages :: (ErrorMessage -> ErrorMessage) -> MultipleErrors -> MultipleErrors
addHint :: ErrorMessageHint -> MultipleErrors -> MultipleErrors
addHints :: [ErrorMessageHint] -> MultipleErrors -> MultipleErrors
defaultUnknownMap :: TypeMap
unwrapErrorMessage :: ErrorMessage -> SimpleErrorMessage
replaceUnknowns :: SourceType -> State TypeMap SourceType
onTypesInErrorMessage :: (SourceType -> SourceType) -> ErrorMessage -> ErrorMessage
onTypesInErrorMessageM :: Applicative m => (SourceType -> m SourceType) -> ErrorMessage -> m ErrorMessage
errorDocUri :: ErrorMessage -> Text
errorSuggestion :: SimpleErrorMessage -> Maybe ErrorSuggestion
suggestionSpan :: ErrorMessage -> Maybe SourceSpan
showSuggestion :: SimpleErrorMessage -> Text
ansiColor :: (ColorIntensity, Color) -> String
ansiColorReset :: String
colorCode :: Maybe (ColorIntensity, Color) -> Text -> Text
colorCodeBox :: Maybe (ColorIntensity, Color) -> Box -> Box
defaultCodeColor :: (ColorIntensity, Color)
defaultPPEOptions :: PPEOptions
prettyPrintSingleError :: PPEOptions -> ErrorMessage -> Box
prettyPrintExport :: DeclarationRef -> Text
prettyPrintImport :: ModuleName -> ImportDeclarationType -> Maybe ModuleName -> Text
prettyPrintRef :: DeclarationRef -> Maybe Text
prettyPrintMultipleErrors :: PPEOptions -> MultipleErrors -> String
prettyPrintMultipleWarnings :: PPEOptions -> MultipleErrors -> String
prettyPrintMultipleWarningsBox :: PPEOptions -> MultipleErrors -> [Box]
prettyPrintMultipleErrorsBox :: PPEOptions -> MultipleErrors -> [Box]
prettyPrintMultipleErrorsWith :: PPEOptions -> String -> String -> MultipleErrors -> [Box]
prettyPrintParseError :: ParseError -> Box
prettyPrintParseErrorMessages :: String -> String -> String -> String -> String -> [Message] -> Box
line :: Text -> Box
lineS :: String -> Box
renderBox :: Box -> String
toTypelevelString :: Type a -> Maybe Box
rethrow :: MonadError e m => (e -> e) -> m a -> m a
reifyErrors :: MonadError e m => m a -> m (Either e a)
reflectErrors :: MonadError e m => m (Either e a) -> m a
warnAndRethrow :: (MonadError e m, MonadWriter e m) => (e -> e) -> m a -> m a
rethrowWithPosition :: MonadError MultipleErrors m => SourceSpan -> m a -> m a
warnWithPosition :: MonadWriter MultipleErrors m => SourceSpan -> m a -> m a
warnAndRethrowWithPosition :: (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => SourceSpan -> m a -> m a
withPosition :: SourceSpan -> ErrorMessage -> ErrorMessage
positionedError :: SourceSpan -> ErrorMessageHint
filterErrors :: (ErrorMessage -> Bool) -> MultipleErrors -> MultipleErrors
escalateWarningWhen :: (MonadWriter MultipleErrors m, MonadError MultipleErrors m) => (ErrorMessage -> Bool) -> m a -> m a
parU :: forall m a b. MonadError MultipleErrors m => [a] -> (a -> m b) -> m [b]
type Unknown = Int
data CheckState = CheckState {
- checkEnv :: Environment
- checkNextType :: Int
- checkNextKind :: Int
- checkNextSkolem :: Int
- checkNextSkolemScope :: Int
- checkCurrentModule :: Maybe ModuleName
- checkSubstitution :: Substitution
- checkHints :: [ErrorMessageHint]
}
data Substitution = Substitution {
- substType :: Map Int SourceType
- substKind :: Map Int SourceKind
}
emptySubstitution :: Substitution
emptyCheckState :: Environment -> CheckState
bindNames :: MonadState CheckState m => Map (Qualified Ident) (SourceType, NameKind, NameVisibility) -> m a -> m a
bindTypes :: MonadState CheckState m => Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) -> m a -> m a
withScopedTypeVars :: (MonadState CheckState m, MonadWriter MultipleErrors m) => ModuleName -> [(Text, SourceKind)] -> m a -> m a
withErrorMessageHint :: (MonadState CheckState m, MonadError MultipleErrors m) => ErrorMessageHint -> m a -> m a
getHints :: MonadState CheckState m => m [ErrorMessageHint]
rethrowWithPositionTC :: (MonadState CheckState m, MonadError MultipleErrors m) => SourceSpan -> m a -> m a
warnAndRethrowWithPositionTC :: (MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => SourceSpan -> m a -> m a
withTypeClassDictionaries :: MonadState CheckState m => [NamedDict] -> m a -> m a
getTypeClassDictionaries :: MonadState CheckState m => m (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict))))
lookupTypeClassDictionaries :: MonadState CheckState m => Maybe ModuleName -> m (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))
lookupTypeClassDictionariesForClass :: MonadState CheckState m => Maybe ModuleName -> Qualified (ProperName ClassName) -> m (Map (Qualified Ident) (NonEmpty NamedDict))
bindLocalVariables :: MonadState CheckState m => [(Ident, SourceType, NameVisibility)] -> m a -> m a
bindLocalTypeVariables :: MonadState CheckState m => ModuleName -> [(ProperName TypeName, SourceKind)] -> m a -> m a
makeBindingGroupVisible :: MonadState CheckState m => m ()
withBindingGroupVisible :: MonadState CheckState m => m a -> m a
preservingNames :: MonadState CheckState m => m a -> m a
lookupVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m SourceType
getVisibility :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m NameVisibility
checkVisibility :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m ()
lookupTypeVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => ModuleName -> Qualified (ProperName TypeName) -> m SourceKind
getEnv :: MonadState CheckState m => m Environment
getLocalContext :: MonadState CheckState m => m Context
putEnv :: MonadState CheckState m => Environment -> m ()
modifyEnv :: MonadState CheckState m => (Environment -> Environment) -> m ()
runCheck :: Functor m => StateT CheckState m a -> m (a, Environment)
runCheck' :: Functor m => CheckState -> StateT CheckState m a -> m (a, Environment)
guardWith :: MonadError e m => e -> Bool -> m ()
captureSubstitution :: MonadState CheckState m => m a -> m (a, Substitution)
capturingSubstitution :: MonadState CheckState m => (a -> Substitution -> b) -> m a -> m b
withFreshSubstitution :: MonadState CheckState m => m a -> m a
withoutWarnings :: MonadWriter w m => m a -> m (a, w)
unsafeCheckCurrentModule :: forall m. (MonadError MultipleErrors m, MonadState CheckState m) => m ModuleName
type SynonymMap = Map (Qualified (ProperName TypeName)) ([(Text, Maybe SourceKind)], SourceType)
replaceAllTypeSynonyms :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => SourceType -> m SourceType
replaceAllTypeSynonymsM :: MonadError MultipleErrors m => SynonymMap -> SourceType -> m SourceType
kindOf :: (MonadError MultipleErrors m, MonadState CheckState m) => SourceType -> m SourceKind
kindOfWithScopedVars :: (MonadError MultipleErrors m, MonadState CheckState m) => SourceType -> m (SourceKind, [(Text, SourceKind)])
kindsOf :: (MonadError MultipleErrors m, MonadState CheckState m) => Bool -> ModuleName -> ProperName TypeName -> [(Text, Maybe SourceKind)] -> [SourceType] -> m SourceKind
kindsOfAll :: (MonadError MultipleErrors m, MonadState CheckState m) => ModuleName -> [(SourceAnn, ProperName TypeName, [(Text, Maybe SourceKind)], SourceType)] -> [(SourceAnn, ProperName TypeName, [(Text, Maybe SourceKind)], [SourceType])] -> m ([SourceKind], [SourceKind])
data BindingGroupType
- = RecursiveBindingGroup
- | NonRecursiveBindingGroup
typesOf :: (MonadSupply m, MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => BindingGroupType -> ModuleName -> [((SourceAnn, Ident), Expr)] -> m [((SourceAnn, Ident), (Expr, SourceType))]
desugarTypeDeclarationsModule :: forall m. MonadError MultipleErrors m => Module -> m Module
desugarSignedLiterals :: Module -> Module
rebracket :: forall m. MonadError MultipleErrors m => [ExternsFile] -> [Module] -> m [Module]
rebracketFiltered :: forall m. MonadError MultipleErrors m => (Declaration -> Bool) -> [ExternsFile] -> [Module] -> m [Module]
checkFixityExports :: forall m. MonadError MultipleErrors m => Module -> m Module
desugarObjectConstructors :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module
desugarDecl :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Declaration -> m Declaration
type Env = Map ModuleName (SourceSpan, Imports, Exports)
data Exports = Exports {
- exportedTypes :: Map (ProperName TypeName) ([ProperName ConstructorName], ExportSource)
- exportedTypeOps :: Map (OpName TypeOpName) ExportSource
- exportedTypeClasses :: Map (ProperName ClassName) ExportSource
- exportedValues :: Map Ident ExportSource
- exportedValueOps :: Map (OpName ValueOpName) ExportSource
- exportedKinds :: Map (ProperName KindName) ExportSource
}
data Imports = Imports {
- importedTypes :: ImportMap (ProperName TypeName)
- importedTypeOps :: ImportMap (OpName TypeOpName)
- importedDataConstructors :: ImportMap (ProperName ConstructorName)
- importedTypeClasses :: ImportMap (ProperName ClassName)
- importedValues :: ImportMap Ident
- importedValueOps :: ImportMap (OpName ValueOpName)
- importedModules :: Set ModuleName
- importedQualModules :: Set ModuleName
- importedKinds :: ImportMap (ProperName KindName)
}
data ImportProvenance
- = FromImplicit
- | FromExplicit
- | Local
- | Prim
data ImportRecord a = ImportRecord {
- importName :: Qualified a
- importSourceModule :: ModuleName
- importSourceSpan :: SourceSpan
- importProvenance :: ImportProvenance
}
primEnv :: Env
desugarDoModule :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module
desugarCasesModule :: (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module
desugarCaseGuards :: forall m. (MonadSupply m, MonadError MultipleErrors m) => [Declaration] -> m [Declaration]
desugarCases :: forall m. (MonadSupply m, MonadError MultipleErrors m) => [Declaration] -> m [Declaration]
desugarTypeClasses :: (MonadSupply m, MonadError MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module]
typeClassMemberName :: Declaration -> Text
superClassDictionaryNames :: [Constraint a] -> [Text]
createBindingGroupsModule :: MonadError MultipleErrors m => Module -> m Module
collapseBindingGroupsModule :: [Module] -> [Module]
createBindingGroups :: forall m. MonadError MultipleErrors m => ModuleName -> [Declaration] -> m [Declaration]
collapseBindingGroups :: [Declaration] -> [Declaration]
desugarAdoModule :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module
data ModuleSignature = ModuleSignature {
- sigSourceSpan :: SourceSpan
- sigModuleName :: ModuleName
- sigImports :: [(ModuleName, SourceSpan)]
}
type ModuleGraph = [(ModuleName, [ModuleName])]
sortModules :: forall m a. MonadError MultipleErrors m => (a -> ModuleSignature) -> [a] -> m ([a], ModuleGraph)
moduleSignature :: Module -> ModuleSignature
newtype Make a = Make {
- unMake :: ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a
}
runMake :: Options -> Make a -> IO (Either MultipleErrors a, MultipleErrors)
makeIO :: (IOError -> ErrorMessage) -> IO a -> Make a
readTextFile :: FilePath -> Make ByteString
type UsedImports = Map ModuleName [Qualified Name]
lintImports :: forall m. MonadWriter MultipleErrors m => Module -> Env -> UsedImports -> m ()
desugarImports :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module]
desugarImportsWithEnv :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m (Env, [Module])
checkExhaustiveExpr :: forall m. (MonadWriter MultipleErrors m, MonadSupply m) => SourceSpan -> Environment -> ModuleName -> Expr -> m Expr
lint :: forall m. MonadWriter MultipleErrors m => Module -> m ()
checkNewtype :: forall m. MonadError MultipleErrors m => ProperName TypeName -> [(ProperName ConstructorName, [(Ident, SourceType)])] -> m ()
typeCheckModule :: forall m. (MonadSupply m, MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => Module -> m Module
deriveInstances :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m, MonadSupply m) => [ExternsFile] -> Module -> m Module
desugar :: (MonadSupply m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module]
renameInModules :: [Module Ann] -> [Module Ann]
data MakeActions m = MakeActions {
- getInputTimestamp :: ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))
- getOutputTimestamp :: ModuleName -> m (Maybe UTCTime)
- readExterns :: ModuleName -> m (FilePath, Externs)
- codegen :: Module Ann -> Module -> Externs -> SupplyT m ()
- ffiCodegen :: Module Ann -> m ()
- progress :: ProgressMessage -> m ()
}
type Externs = ByteString
data ProgressMessage = CompilingModule ModuleName
data RebuildPolicy
- = RebuildNever
- | RebuildAlways
buildMakeActions :: FilePath -> Map ModuleName (Either RebuildPolicy FilePath) -> Map ModuleName FilePath -> Bool -> MakeActions Make
checkForeignDecls :: Module ann -> FilePath -> Make ()
rebuildModule :: forall m. (Monad m, MonadBaseControl IO m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => MakeActions m -> [ExternsFile] -> Module -> m ExternsFile
make :: forall m. (Monad m, MonadBaseControl IO m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => MakeActions m -> [PartialResult Module] -> m [ExternsFile]
inferForeignModules :: forall m. MonadIO m => Map ModuleName (Either RebuildPolicy FilePath) -> m (Map ModuleName FilePath)
version :: Version

Documentation

data Text #

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
ToJSON Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding #
KeyValue Pair
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair #
ToJSONKey Text
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text # toJSONKeyList :: ToJSONKeyFunction [Text] #
FromJSON Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] #
FromJSONKey Text
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text # fromJSONKeyList :: FromJSONKeyFunction [Text] #
Chunk Text
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem Text :: Type # Methods nullChunk :: Text -> Bool # pappendChunk :: State Text -> Text -> State Text # atBufferEnd :: Text -> State Text -> Pos # bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int) # chunkElemToChar :: Text -> ChunkElem Text -> Char #
ToValue Text
Instance details Defined in Text.Blaze Methods toValue :: Text -> AttributeValue # preEscapedToValue :: Text -> AttributeValue #
ToMarkup Text
Instance details Defined in Text.Blaze Methods toMarkup :: Text -> Markup # preEscapedToMarkup :: Text -> Markup #
ToLogStr Text
Instance details Defined in System.Log.FastLogger.LogStr Methods toLogStr :: Text -> LogStr #
Print Text
Instance details Defined in Protolude.Show Methods hPutStr :: MonadIO m => Handle -> Text -> m () # putStr :: MonadIO m => Text -> m () # hPutStrLn :: MonadIO m => Handle -> Text -> m () # putStrLn :: MonadIO m => Text -> m () # putErrLn :: MonadIO m => Text -> m () #
StringConv ByteString Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> ByteString -> Text #
StringConv ByteString Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> ByteString -> Text #
StringConv String Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> String -> Text #
StringConv Text ByteString
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text -> ByteString #
StringConv Text ByteString
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text -> ByteString #
StringConv Text String
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text -> String #
StringConv Text Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text -> Text #
StringConv Text Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text0 -> Text #
StringConv Text Text
Instance details Defined in Protolude.Conv Methods strConv :: Leniency -> Text -> Text0 #
Monad m => Stream Text m Char
Instance details Defined in Text.Parsec.Prim Methods uncons :: Text -> m (Maybe (Char, Text)) #
FromPairs Value (DList Pair)
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromPairs :: DList Pair -> Value
ToJSON v => GKeyValue v (DList Pair)
Instance details Defined in Data.Aeson.Types.ToJSON Methods gPair :: String -> v -> DList Pair
type State Text
Instance details Defined in Data.Attoparsec.Internal.Types type State Text = Buffer
type ChunkElem Text
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem Text = Char
type Item Text
Instance details Defined in Data.Text type Item Text = Char
type Index Text
Instance details Defined in Lens.Micro.Platform type Index Text = Int
type IxValue Text
Instance details Defined in Lens.Micro.Platform type IxValue Text = Char

type Supply = SupplyT Identity Source #

newtype SupplyT m a Source #

Constructors

SupplyT
Fields unSupplyT :: StateT Integer m a

Instances

MonadTrans SupplyT Source #
Instance details Defined in Control.Monad.Supply Methods lift :: Monad m => m a -> SupplyT m a #
MonadError e m => MonadError e (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods throwError :: e -> SupplyT m a # catchError :: SupplyT m a -> (e -> SupplyT m a) -> SupplyT m a #
MonadReader r m => MonadReader r (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods ask :: SupplyT m r # local :: (r -> r) -> SupplyT m a -> SupplyT m a # reader :: (r -> a) -> SupplyT m a #
MonadWriter w m => MonadWriter w (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods writer :: (a, w) -> SupplyT m a # tell :: w -> SupplyT m () # listen :: SupplyT m a -> SupplyT m (a, w) # pass :: SupplyT m (a, w -> w) -> SupplyT m a #
Monad m => Monad (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods (>>=) :: SupplyT m a -> (a -> SupplyT m b) -> SupplyT m b # (>>) :: SupplyT m a -> SupplyT m b -> SupplyT m b # return :: a -> SupplyT m a # fail :: String -> SupplyT m a #
Functor m => Functor (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods fmap :: (a -> b) -> SupplyT m a -> SupplyT m b # (<$) :: a -> SupplyT m b -> SupplyT m a #
Monad m => Applicative (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods pure :: a -> SupplyT m a # (<>) :: SupplyT m (a -> b) -> SupplyT m a -> SupplyT m b # liftA2 :: (a -> b -> c) -> SupplyT m a -> SupplyT m b -> SupplyT m c # (>) :: SupplyT m a -> SupplyT m b -> SupplyT m b # (<*) :: SupplyT m a -> SupplyT m b -> SupplyT m a #
MonadPlus m => MonadPlus (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods mzero :: SupplyT m a # mplus :: SupplyT m a -> SupplyT m a -> SupplyT m a #
MonadPlus m => Alternative (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply Methods empty :: SupplyT m a # (<\|>) :: SupplyT m a -> SupplyT m a -> SupplyT m a # some :: SupplyT m a -> SupplyT m [a] # many :: SupplyT m a -> SupplyT m [a] #
Monad m => MonadSupply (SupplyT m) Source #
Instance details Defined in Control.Monad.Supply.Class Methods fresh :: SupplyT m Integer Source # peek :: SupplyT m Integer Source #

runSupplyT :: Integer -> SupplyT m a -> m (a, Integer) Source #

evalSupplyT :: Functor m => Integer -> SupplyT m a -> m a Source #

runSupply :: Integer -> Supply a -> (a, Integer) Source #

evalSupply :: Integer -> Supply a -> a Source #

data Comment Source #

Constructors

LineComment Text
BlockComment Text

Instances

Eq Comment Source #
Instance details Defined in Language.PureScript.Comments Methods (==) :: Comment -> Comment -> Bool # (/=) :: Comment -> Comment -> Bool #
Ord Comment Source #
Instance details Defined in Language.PureScript.Comments Methods compare :: Comment -> Comment -> Ordering # (<) :: Comment -> Comment -> Bool # (<=) :: Comment -> Comment -> Bool # (>) :: Comment -> Comment -> Bool # (>=) :: Comment -> Comment -> Bool # max :: Comment -> Comment -> Comment # min :: Comment -> Comment -> Comment #
Show Comment Source #
Instance details Defined in Language.PureScript.Comments Methods showsPrec :: Int -> Comment -> ShowS # show :: Comment -> String # showList :: [Comment] -> ShowS #
Generic Comment Source #
Instance details Defined in Language.PureScript.Comments Associated Types type Rep Comment :: Type -> Type # Methods from :: Comment -> Rep Comment x # to :: Rep Comment x -> Comment #
NFData Comment Source #
Instance details Defined in Language.PureScript.Comments Methods rnf :: Comment -> () #
ToJSON Comment Source #
Instance details Defined in Language.PureScript.Comments Methods toJSON :: Comment -> Value # toEncoding :: Comment -> Encoding # toJSONList :: [Comment] -> Value # toEncodingList :: [Comment] -> Encoding #
FromJSON Comment Source #
Instance details Defined in Language.PureScript.Comments Methods parseJSON :: Value -> Parser Comment # parseJSONList :: Value -> Parser [Comment] #
FromJSON (Kind SourceAnn) Source #
Instance details Defined in Language.PureScript.Kinds Methods parseJSON :: Value -> Parser (Kind SourceAnn) # parseJSONList :: Value -> Parser [Kind SourceAnn] #
FromJSON (Constraint SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Constraint SourceAnn) # parseJSONList :: Value -> Parser [Constraint SourceAnn] #
FromJSON (Type SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Type SourceAnn) # parseJSONList :: Value -> Parser [Type SourceAnn] #
type Rep Comment Source #
Instance details Defined in Language.PureScript.Comments type Rep Comment = D1 (MetaData "Comment" "Language.PureScript.Comments" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "LineComment" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) :+: C1 (MetaCons "BlockComment" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data SourceSpan Source #

Constructors

SourceSpan
Fields spanName :: String Source name spanStart :: SourcePos Start of the span spanEnd :: SourcePos End of the span

Instances

Eq SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods (==) :: SourceSpan -> SourceSpan -> Bool # (/=) :: SourceSpan -> SourceSpan -> Bool #
Ord SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods compare :: SourceSpan -> SourceSpan -> Ordering # (<) :: SourceSpan -> SourceSpan -> Bool # (<=) :: SourceSpan -> SourceSpan -> Bool # (>) :: SourceSpan -> SourceSpan -> Bool # (>=) :: SourceSpan -> SourceSpan -> Bool # max :: SourceSpan -> SourceSpan -> SourceSpan # min :: SourceSpan -> SourceSpan -> SourceSpan #
Show SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods showsPrec :: Int -> SourceSpan -> ShowS # show :: SourceSpan -> String # showList :: [SourceSpan] -> ShowS #
Generic SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Associated Types type Rep SourceSpan :: Type -> Type # Methods from :: SourceSpan -> Rep SourceSpan x # to :: Rep SourceSpan x -> SourceSpan #
NFData SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods rnf :: SourceSpan -> () #
ToJSON SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods toJSON :: SourceSpan -> Value # toEncoding :: SourceSpan -> Encoding # toJSONList :: [SourceSpan] -> Value # toEncodingList :: [SourceSpan] -> Encoding #
FromJSON SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods parseJSON :: Value -> Parser SourceSpan # parseJSONList :: Value -> Parser [SourceSpan] #
FromJSON (Kind SourceAnn) Source #
Instance details Defined in Language.PureScript.Kinds Methods parseJSON :: Value -> Parser (Kind SourceAnn) # parseJSONList :: Value -> Parser [Kind SourceAnn] #
FromJSON (Constraint SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Constraint SourceAnn) # parseJSONList :: Value -> Parser [Constraint SourceAnn] #
FromJSON (Type SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Type SourceAnn) # parseJSONList :: Value -> Parser [Type SourceAnn] #
type Rep SourceSpan Source #
Instance details Defined in Language.PureScript.AST.SourcePos type Rep SourceSpan = D1 (MetaData "SourceSpan" "Language.PureScript.AST.SourcePos" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "SourceSpan" PrefixI True) (S1 (MetaSel (Just "spanName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :: (S1 (MetaSel (Just "spanStart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourcePos) :: S1 (MetaSel (Just "spanEnd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourcePos))))

data SourcePos Source #

Source position information

Constructors

SourcePos
Fields sourcePosLine :: Int Line number sourcePosColumn :: Int Column number

Instances

Eq SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods (==) :: SourcePos -> SourcePos -> Bool # (/=) :: SourcePos -> SourcePos -> Bool #
Ord SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods compare :: SourcePos -> SourcePos -> Ordering # (<) :: SourcePos -> SourcePos -> Bool # (<=) :: SourcePos -> SourcePos -> Bool # (>) :: SourcePos -> SourcePos -> Bool # (>=) :: SourcePos -> SourcePos -> Bool # max :: SourcePos -> SourcePos -> SourcePos # min :: SourcePos -> SourcePos -> SourcePos #
Show SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods showsPrec :: Int -> SourcePos -> ShowS # show :: SourcePos -> String # showList :: [SourcePos] -> ShowS #
Generic SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Associated Types type Rep SourcePos :: Type -> Type # Methods from :: SourcePos -> Rep SourcePos x # to :: Rep SourcePos x -> SourcePos #
NFData SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods rnf :: SourcePos -> () #
ToJSON SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods toJSON :: SourcePos -> Value # toEncoding :: SourcePos -> Encoding # toJSONList :: [SourcePos] -> Value # toEncodingList :: [SourcePos] -> Encoding #
FromJSON SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos Methods parseJSON :: Value -> Parser SourcePos # parseJSONList :: Value -> Parser [SourcePos] #
type Rep SourcePos Source #
Instance details Defined in Language.PureScript.AST.SourcePos type Rep SourcePos = D1 (MetaData "SourcePos" "Language.PureScript.AST.SourcePos" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "SourcePos" PrefixI True) (S1 (MetaSel (Just "sourcePosLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "sourcePosColumn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

type SourceAnn = (SourceSpan, [Comment]) Source #

Source annotation - position information and comments.

pattern NullSourceAnn :: SourceAnn Source #

pattern NullSourceSpan :: SourceSpan Source #

displaySourcePos :: SourcePos -> Text Source #

displaySourcePosShort :: SourcePos -> Text Source #

displayStartEndPos :: SourceSpan -> Text Source #

displayStartEndPosShort :: SourceSpan -> Text Source #

displaySourceSpan :: FilePath -> SourceSpan -> Text Source #

internalModuleSourceSpan :: String -> SourceSpan Source #

nullSourceSpan :: SourceSpan Source #

nullSourceAnn :: SourceAnn Source #

nonEmptySpan :: SourceAnn -> Maybe SourceSpan Source #

widenSourceSpan :: SourceSpan -> SourceSpan -> SourceSpan Source #

widenSourceAnn :: SourceAnn -> SourceAnn -> SourceAnn Source #

type HasCallStack = HasCallStack Source #

A compatibility wrapper for the GHC.Stack.HasCallStack constraint.

internalError :: HasCallStack => String -> a Source #

Exit with an error message and a crash report link.

data Fixity Source #

Fixity data for infix operators

Constructors

Fixity Associativity Precedence

Instances

Eq Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Ord Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Show Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Generic Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
NFData Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods rnf :: Fixity -> () #
ToJSON Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods toJSON :: Fixity -> Value # toEncoding :: Fixity -> Encoding # toJSONList :: [Fixity] -> Value # toEncodingList :: [Fixity] -> Encoding #
type Rep Fixity Source #
Instance details Defined in Language.PureScript.AST.Operators type Rep Fixity = D1 (MetaData "Fixity" "Language.PureScript.AST.Operators" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Fixity" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Associativity) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Precedence)))

data Associativity Source #

Associativity for infix operators

Constructors

Infixl
Infixr
Infix

Instances

Eq Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Ord Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # max :: Associativity -> Associativity -> Associativity # min :: Associativity -> Associativity -> Associativity #
Show Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Generic Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
NFData Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods rnf :: Associativity -> () #
ToJSON Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods toJSON :: Associativity -> Value # toEncoding :: Associativity -> Encoding # toJSONList :: [Associativity] -> Value # toEncodingList :: [Associativity] -> Encoding #
FromJSON Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators Methods parseJSON :: Value -> Parser Associativity # parseJSONList :: Value -> Parser [Associativity] #
type Rep Associativity Source #
Instance details Defined in Language.PureScript.AST.Operators type Rep Associativity = D1 (MetaData "Associativity" "Language.PureScript.AST.Operators" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Infixl" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Infixr" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Infix" PrefixI False) (U1 :: Type -> Type)))

type Precedence = Integer Source #

A precedence level for an infix operator

showAssoc :: Associativity -> String Source #

readAssoc :: String -> Associativity Source #

data Qualified a Source #

A qualified name, i.e. a name with an optional module name

Constructors

Qualified (Maybe ModuleName) a

Instances

Functor Qualified Source #
Instance details Defined in Language.PureScript.Names Methods fmap :: (a -> b) -> Qualified a -> Qualified b # (<$) :: a -> Qualified b -> Qualified a #
Foldable Qualified Source #
Instance details Defined in Language.PureScript.Names Methods fold :: Monoid m => Qualified m -> m # foldMap :: Monoid m => (a -> m) -> Qualified a -> m # foldr :: (a -> b -> b) -> b -> Qualified a -> b # foldr' :: (a -> b -> b) -> b -> Qualified a -> b # foldl :: (b -> a -> b) -> b -> Qualified a -> b # foldl' :: (b -> a -> b) -> b -> Qualified a -> b # foldr1 :: (a -> a -> a) -> Qualified a -> a # foldl1 :: (a -> a -> a) -> Qualified a -> a # toList :: Qualified a -> [a] # null :: Qualified a -> Bool # length :: Qualified a -> Int # elem :: Eq a => a -> Qualified a -> Bool # maximum :: Ord a => Qualified a -> a # minimum :: Ord a => Qualified a -> a # sum :: Num a => Qualified a -> a # product :: Num a => Qualified a -> a #
Traversable Qualified Source #
Instance details Defined in Language.PureScript.Names Methods traverse :: Applicative f => (a -> f b) -> Qualified a -> f (Qualified b) # sequenceA :: Applicative f => Qualified (f a) -> f (Qualified a) # mapM :: Monad m => (a -> m b) -> Qualified a -> m (Qualified b) # sequence :: Monad m => Qualified (m a) -> m (Qualified a) #
Eq a => Eq (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: Qualified a -> Qualified a -> Bool # (/=) :: Qualified a -> Qualified a -> Bool #
Ord a => Ord (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods compare :: Qualified a -> Qualified a -> Ordering # (<) :: Qualified a -> Qualified a -> Bool # (<=) :: Qualified a -> Qualified a -> Bool # (>) :: Qualified a -> Qualified a -> Bool # (>=) :: Qualified a -> Qualified a -> Bool # max :: Qualified a -> Qualified a -> Qualified a # min :: Qualified a -> Qualified a -> Qualified a #
Show a => Show (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> Qualified a -> ShowS # show :: Qualified a -> String # showList :: [Qualified a] -> ShowS #
Generic (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep (Qualified a) :: Type -> Type # Methods from :: Qualified a -> Rep (Qualified a) x # to :: Rep (Qualified a) x -> Qualified a #
NFData a => NFData (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: Qualified a -> () #
ToJSON a => ToJSON (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods toJSON :: Qualified a -> Value # toEncoding :: Qualified a -> Encoding # toJSONList :: [Qualified a] -> Value # toEncodingList :: [Qualified a] -> Encoding #
FromJSON a => FromJSON (Qualified a) Source #
Instance details Defined in Language.PureScript.Names Methods parseJSON :: Value -> Parser (Qualified a) # parseJSONList :: Value -> Parser [Qualified a] #
type Rep (Qualified a) Source #
Instance details Defined in Language.PureScript.Names type Rep (Qualified a) = D1 (MetaData "Qualified" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Qualified" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ModuleName)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype ModuleName Source #

Module names

Constructors

ModuleName [ProperName Namespace]

Instances

Eq ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Ord ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods compare :: ModuleName -> ModuleName -> Ordering # (<) :: ModuleName -> ModuleName -> Bool # (<=) :: ModuleName -> ModuleName -> Bool # (>) :: ModuleName -> ModuleName -> Bool # (>=) :: ModuleName -> ModuleName -> Bool # max :: ModuleName -> ModuleName -> ModuleName # min :: ModuleName -> ModuleName -> ModuleName #
Show ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> ModuleName -> ShowS # show :: ModuleName -> String # showList :: [ModuleName] -> ShowS #
Generic ModuleName Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep ModuleName :: Type -> Type # Methods from :: ModuleName -> Rep ModuleName x # to :: Rep ModuleName x -> ModuleName #
NFData ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: ModuleName -> () #
ToJSON ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods toJSON :: ModuleName -> Value # toEncoding :: ModuleName -> Encoding # toJSONList :: [ModuleName] -> Value # toEncodingList :: [ModuleName] -> Encoding #
FromJSON ModuleName Source #
Instance details Defined in Language.PureScript.Names Methods parseJSON :: Value -> Parser ModuleName # parseJSONList :: Value -> Parser [ModuleName] #
type Rep ModuleName Source #
Instance details Defined in Language.PureScript.Names type Rep ModuleName = D1 (MetaData "ModuleName" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" True) (C1 (MetaCons "ModuleName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ProperName Namespace])))

data ProperNameType Source #

The closed set of proper name types.

Constructors

TypeName
ConstructorName
ClassName
KindName
Namespace

newtype ProperName (a :: ProperNameType) Source #

Proper names, i.e. capitalized names for e.g. module names, type//data constructors.

Constructors

ProperName
Fields runProperName :: Text

Instances

Eq (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: ProperName a -> ProperName a -> Bool # (/=) :: ProperName a -> ProperName a -> Bool #
Ord (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods compare :: ProperName a -> ProperName a -> Ordering # (<) :: ProperName a -> ProperName a -> Bool # (<=) :: ProperName a -> ProperName a -> Bool # (>) :: ProperName a -> ProperName a -> Bool # (>=) :: ProperName a -> ProperName a -> Bool # max :: ProperName a -> ProperName a -> ProperName a # min :: ProperName a -> ProperName a -> ProperName a #
Show (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> ProperName a -> ShowS # show :: ProperName a -> String # showList :: [ProperName a] -> ShowS #
Generic (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep (ProperName a) :: Type -> Type # Methods from :: ProperName a -> Rep (ProperName a) x # to :: Rep (ProperName a) x -> ProperName a #
NFData (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: ProperName a -> () #
ToJSON (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods toJSON :: ProperName a -> Value # toEncoding :: ProperName a -> Encoding # toJSONList :: [ProperName a] -> Value # toEncodingList :: [ProperName a] -> Encoding #
FromJSON (ProperName a) Source #
Instance details Defined in Language.PureScript.Names Methods parseJSON :: Value -> Parser (ProperName a) # parseJSONList :: Value -> Parser [ProperName a] #
type Rep (ProperName a) Source #
Instance details Defined in Language.PureScript.Names type Rep (ProperName a) = D1 (MetaData "ProperName" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" True) (C1 (MetaCons "ProperName" PrefixI True) (S1 (MetaSel (Just "runProperName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data OpNameType Source #

The closed set of operator alias types.

Constructors

ValueOpName
TypeOpName
AnyOpName

newtype OpName (a :: OpNameType) Source #

Operator alias names.

Constructors

OpName
Fields runOpName :: Text

Instances

Eq (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: OpName a -> OpName a -> Bool # (/=) :: OpName a -> OpName a -> Bool #
Ord (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods compare :: OpName a -> OpName a -> Ordering # (<) :: OpName a -> OpName a -> Bool # (<=) :: OpName a -> OpName a -> Bool # (>) :: OpName a -> OpName a -> Bool # (>=) :: OpName a -> OpName a -> Bool # max :: OpName a -> OpName a -> OpName a # min :: OpName a -> OpName a -> OpName a #
Show (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> OpName a -> ShowS # show :: OpName a -> String # showList :: [OpName a] -> ShowS #
Generic (OpName a) Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep (OpName a) :: Type -> Type # Methods from :: OpName a -> Rep (OpName a) x # to :: Rep (OpName a) x -> OpName a #
NFData (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: OpName a -> () #
ToJSON (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods toJSON :: OpName a -> Value # toEncoding :: OpName a -> Encoding # toJSONList :: [OpName a] -> Value # toEncodingList :: [OpName a] -> Encoding #
FromJSON (OpName a) Source #
Instance details Defined in Language.PureScript.Names Methods parseJSON :: Value -> Parser (OpName a) # parseJSONList :: Value -> Parser [OpName a] #
type Rep (OpName a) Source #
Instance details Defined in Language.PureScript.Names type Rep (OpName a) = D1 (MetaData "OpName" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" True) (C1 (MetaCons "OpName" PrefixI True) (S1 (MetaSel (Just "runOpName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

data Ident Source #

Names for value identifiers

Constructors

Ident Text	An alphanumeric identifier
GenIdent (Maybe Text) Integer	A generated name for an identifier
UnusedIdent	A generated name used only for type-checking

Instances

Eq Ident Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: Ident -> Ident -> Bool # (/=) :: Ident -> Ident -> Bool #
Ord Ident Source #
Instance details Defined in Language.PureScript.Names Methods compare :: Ident -> Ident -> Ordering # (<) :: Ident -> Ident -> Bool # (<=) :: Ident -> Ident -> Bool # (>) :: Ident -> Ident -> Bool # (>=) :: Ident -> Ident -> Bool # max :: Ident -> Ident -> Ident # min :: Ident -> Ident -> Ident #
Show Ident Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> Ident -> ShowS # show :: Ident -> String # showList :: [Ident] -> ShowS #
Generic Ident Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep Ident :: Type -> Type # Methods from :: Ident -> Rep Ident x # to :: Rep Ident x -> Ident #
NFData Ident Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: Ident -> () #
ToJSON Ident Source #
Instance details Defined in Language.PureScript.Names Methods toJSON :: Ident -> Value # toEncoding :: Ident -> Encoding # toJSONList :: [Ident] -> Value # toEncodingList :: [Ident] -> Encoding #
FromJSON Ident Source #
Instance details Defined in Language.PureScript.Names Methods parseJSON :: Value -> Parser Ident # parseJSONList :: Value -> Parser [Ident] #
type Rep Ident Source #
Instance details Defined in Language.PureScript.Names type Rep Ident = D1 (MetaData "Ident" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Ident" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) :+: (C1 (MetaCons "GenIdent" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: C1 (MetaCons "UnusedIdent" PrefixI False) (U1 :: Type -> Type)))

data Name Source #

A sum of the possible name types, useful for error and lint messages.

Instances

Eq Name Source #
Instance details Defined in Language.PureScript.Names Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Ord Name Source #
Instance details Defined in Language.PureScript.Names Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Show Name Source #
Instance details Defined in Language.PureScript.Names Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Generic Name Source #
Instance details Defined in Language.PureScript.Names Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
NFData Name Source #
Instance details Defined in Language.PureScript.Names Methods rnf :: Name -> () #
type Rep Name Source #
Instance details Defined in Language.PureScript.Names type Rep Name = D1 (MetaData "Name" "Language.PureScript.Names" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (((C1 (MetaCons "IdentName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) :+: C1 (MetaCons "ValOpName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (OpName ValueOpName)))) :+: (C1 (MetaCons "TyName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName TypeName))) :+: C1 (MetaCons "TyOpName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (OpName TypeOpName))))) :+: ((C1 (MetaCons "DctorName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName ConstructorName))) :+: C1 (MetaCons "TyClassName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName ClassName)))) :+: (C1 (MetaCons "ModName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModuleName)) :+: C1 (MetaCons "KiName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName KindName))))))

getIdentName :: Name -> Maybe Ident Source #

getValOpName :: Name -> Maybe (OpName ValueOpName) Source #

getTypeName :: Name -> Maybe (ProperName TypeName) Source #

getKindName :: Name -> Maybe (ProperName KindName) Source #

getTypeOpName :: Name -> Maybe (OpName TypeOpName) Source #

getDctorName :: Name -> Maybe (ProperName ConstructorName) Source #

getClassName :: Name -> Maybe (ProperName ClassName) Source #

getModName :: Name -> Maybe ModuleName Source #

runIdent :: Ident -> Text Source #

showIdent :: Ident -> Text Source #

freshIdent :: MonadSupply m => Text -> m Ident Source #

freshIdent' :: MonadSupply m => m Ident Source #

showOp :: OpName a -> Text Source #

eraseOpName :: OpName a -> OpName AnyOpName Source #

coerceProperName :: ProperName a -> ProperName b Source #

Coerces a ProperName from one ProperNameType to another. This should be used with care, and is primarily used to convert ClassNames into TypeNames after classes have been desugared.

runModuleName :: ModuleName -> Text Source #

moduleNameFromString :: Text -> ModuleName Source #

isBuiltinModuleName :: ModuleName -> Bool Source #

showQualified :: (a -> Text) -> Qualified a -> Text Source #

getQual :: Qualified a -> Maybe ModuleName Source #

qualify :: ModuleName -> Qualified a -> (ModuleName, a) Source #

Provide a default module name, if a name is unqualified

mkQualified :: a -> ModuleName -> Qualified a Source #

Makes a qualified value from a name and module name.

disqualify :: Qualified a -> a Source #

Remove the module name from a qualified name

disqualifyFor :: Maybe ModuleName -> Qualified a -> Maybe a Source #

Remove the qualification from a value when it is qualified with a particular module name.

isQualified :: Qualified a -> Bool Source #

Checks whether a qualified value is actually qualified with a module reference

isUnqualified :: Qualified a -> Bool Source #

Checks whether a qualified value is not actually qualified with a module reference

isQualifiedWith :: ModuleName -> Qualified a -> Bool Source #

Checks whether a qualified value is qualified with a particular module

data Kind a Source #

The data type of kinds

Constructors

KUnknown a Int	Unification variable of type Kind
Row a (Kind a)	Kinds for labelled, unordered rows without duplicates
FunKind a (Kind a) (Kind a)	Function kinds
NamedKind a (Qualified (ProperName KindName))	A named kind

Instances

Functor Kind Source #
Instance details Defined in Language.PureScript.Kinds Methods fmap :: (a -> b) -> Kind a -> Kind b # (<$) :: a -> Kind b -> Kind a #
Foldable Kind Source #
Instance details Defined in Language.PureScript.Kinds Methods fold :: Monoid m => Kind m -> m # foldMap :: Monoid m => (a -> m) -> Kind a -> m # foldr :: (a -> b -> b) -> b -> Kind a -> b # foldr' :: (a -> b -> b) -> b -> Kind a -> b # foldl :: (b -> a -> b) -> b -> Kind a -> b # foldl' :: (b -> a -> b) -> b -> Kind a -> b # foldr1 :: (a -> a -> a) -> Kind a -> a # foldl1 :: (a -> a -> a) -> Kind a -> a # toList :: Kind a -> [a] # null :: Kind a -> Bool # length :: Kind a -> Int # elem :: Eq a => a -> Kind a -> Bool # maximum :: Ord a => Kind a -> a # minimum :: Ord a => Kind a -> a # sum :: Num a => Kind a -> a # product :: Num a => Kind a -> a #
Traversable Kind Source #
Instance details Defined in Language.PureScript.Kinds Methods traverse :: Applicative f => (a -> f b) -> Kind a -> f (Kind b) # sequenceA :: Applicative f => Kind (f a) -> f (Kind a) # mapM :: Monad m => (a -> m b) -> Kind a -> m (Kind b) # sequence :: Monad m => Kind (m a) -> m (Kind a) #
Eq (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods (==) :: Kind a -> Kind a -> Bool # (/=) :: Kind a -> Kind a -> Bool #
Ord (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods compare :: Kind a -> Kind a -> Ordering # (<) :: Kind a -> Kind a -> Bool # (<=) :: Kind a -> Kind a -> Bool # (>) :: Kind a -> Kind a -> Bool # (>=) :: Kind a -> Kind a -> Bool # max :: Kind a -> Kind a -> Kind a # min :: Kind a -> Kind a -> Kind a #
Show a => Show (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods showsPrec :: Int -> Kind a -> ShowS # show :: Kind a -> String # showList :: [Kind a] -> ShowS #
Generic (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Associated Types type Rep (Kind a) :: Type -> Type # Methods from :: Kind a -> Rep (Kind a) x # to :: Rep (Kind a) x -> Kind a #
NFData a => NFData (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods rnf :: Kind a -> () #
ToJSON a => ToJSON (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods toJSON :: Kind a -> Value # toEncoding :: Kind a -> Encoding # toJSONList :: [Kind a] -> Value # toEncodingList :: [Kind a] -> Encoding #
FromJSON (Kind ()) Source #
Instance details Defined in Language.PureScript.Kinds Methods parseJSON :: Value -> Parser (Kind ()) # parseJSONList :: Value -> Parser [Kind ()] #
FromJSON a => FromJSON (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds Methods parseJSON :: Value -> Parser (Kind a) # parseJSONList :: Value -> Parser [Kind a] #
FromJSON (Kind SourceAnn) Source #
Instance details Defined in Language.PureScript.Kinds Methods parseJSON :: Value -> Parser (Kind SourceAnn) # parseJSONList :: Value -> Parser [Kind SourceAnn] #
type Rep (Kind a) Source #
Instance details Defined in Language.PureScript.Kinds type Rep (Kind a) = D1 (MetaData "Kind" "Language.PureScript.Kinds" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) ((C1 (MetaCons "KUnknown" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "Row" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind a)))) :+: (C1 (MetaCons "FunKind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind a)))) :+: C1 (MetaCons "NamedKind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Qualified (ProperName KindName))))))

type SourceKind = Kind SourceAnn Source #

srcKUnknown :: Int -> SourceKind Source #

srcRow :: SourceKind -> SourceKind Source #

srcFunKind :: SourceKind -> SourceKind -> SourceKind Source #

srcNamedKind :: Qualified (ProperName KindName) -> SourceKind Source #

kindToJSON :: forall a. (a -> Value) -> Kind a -> Value Source #

kindFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Kind a) Source #

everywhereOnKinds :: (Kind a -> Kind a) -> Kind a -> Kind a Source #

everywhereOnKindsM :: Monad m => (Kind a -> m (Kind a)) -> Kind a -> m (Kind a) Source #

everythingOnKinds :: (r -> r -> r) -> (Kind a -> r) -> Kind a -> r Source #

annForKind :: Lens' (Kind a) a Source #

getAnnForKind :: Kind a -> a Source #

setAnnForKind :: a -> Kind a -> Kind a Source #

eqKind :: Kind a -> Kind b -> Bool Source #

eqMaybeKind :: Maybe (Kind a) -> Maybe (Kind b) -> Bool Source #

compareKind :: Kind a -> Kind b -> Ordering Source #

compareMaybeKind :: Maybe (Kind a) -> Maybe (Kind b) -> Ordering Source #

data CodegenTarget Source #

Constructors

JS
JSSourceMap
CoreFn
Docs

Instances

Eq CodegenTarget Source #
Instance details Defined in Language.PureScript.Options Methods (==) :: CodegenTarget -> CodegenTarget -> Bool # (/=) :: CodegenTarget -> CodegenTarget -> Bool #
Ord CodegenTarget Source #
Instance details Defined in Language.PureScript.Options Methods compare :: CodegenTarget -> CodegenTarget -> Ordering # (<) :: CodegenTarget -> CodegenTarget -> Bool # (<=) :: CodegenTarget -> CodegenTarget -> Bool # (>) :: CodegenTarget -> CodegenTarget -> Bool # (>=) :: CodegenTarget -> CodegenTarget -> Bool # max :: CodegenTarget -> CodegenTarget -> CodegenTarget # min :: CodegenTarget -> CodegenTarget -> CodegenTarget #
Show CodegenTarget Source #
Instance details Defined in Language.PureScript.Options Methods showsPrec :: Int -> CodegenTarget -> ShowS # show :: CodegenTarget -> String # showList :: [CodegenTarget] -> ShowS #

data Options Source #

The data type of compiler options

Constructors

Options
Fields optionsVerboseErrors :: Bool Verbose error message optionsNoComments :: Bool Remove the comments from the generated js optionsCodegenTargets :: Set CodegenTarget Codegen targets (JS, CoreFn, etc.)

Instances

Show Options Source #
Instance details Defined in Language.PureScript.Options Methods showsPrec :: Int -> Options -> ShowS # show :: Options -> String # showList :: [Options] -> ShowS #
MonadReader Options Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods ask :: Make Options # local :: (Options -> Options) -> Make a -> Make a # reader :: (Options -> a) -> Make a #

defaultOptions :: Options Source #

codegenTargets :: Map String CodegenTarget Source #

prettyPrintString :: PSString -> Text Source #

Pretty print a PSString, using Haskell/PureScript escape sequences. This is identical to the Show instance except that we get a Text out instead of a String.

data Literal a Source #

Data type for literal values. Parameterised so it can be used for Exprs and Binders.

Constructors

NumericLiteral (Either Integer Double)	A numeric literal
StringLiteral PSString	A string literal
CharLiteral Char	A character literal
BooleanLiteral Bool	A boolean literal
ArrayLiteral [a]	An array literal
ObjectLiteral [(PSString, a)]	An object literal

Instances

Functor Literal Source #
Instance details Defined in Language.PureScript.AST.Literals Methods fmap :: (a -> b) -> Literal a -> Literal b # (<$) :: a -> Literal b -> Literal a #
Eq a => Eq (Literal a) Source #
Instance details Defined in Language.PureScript.AST.Literals Methods (==) :: Literal a -> Literal a -> Bool # (/=) :: Literal a -> Literal a -> Bool #
Ord a => Ord (Literal a) Source #
Instance details Defined in Language.PureScript.AST.Literals Methods compare :: Literal a -> Literal a -> Ordering # (<) :: Literal a -> Literal a -> Bool # (<=) :: Literal a -> Literal a -> Bool # (>) :: Literal a -> Literal a -> Bool # (>=) :: Literal a -> Literal a -> Bool # max :: Literal a -> Literal a -> Literal a # min :: Literal a -> Literal a -> Literal a #
Show a => Show (Literal a) Source #
Instance details Defined in Language.PureScript.AST.Literals Methods showsPrec :: Int -> Literal a -> ShowS # show :: Literal a -> String # showList :: [Literal a] -> ShowS #

data RowListItem a Source #

Constructors

RowListItem
Fields rowListAnn :: a rowListLabel :: Label rowListType :: Type a

Instances

Functor RowListItem Source #
Instance details Defined in Language.PureScript.Types Methods fmap :: (a -> b) -> RowListItem a -> RowListItem b # (<$) :: a -> RowListItem b -> RowListItem a #
Foldable RowListItem Source #
Instance details Defined in Language.PureScript.Types Methods fold :: Monoid m => RowListItem m -> m # foldMap :: Monoid m => (a -> m) -> RowListItem a -> m # foldr :: (a -> b -> b) -> b -> RowListItem a -> b # foldr' :: (a -> b -> b) -> b -> RowListItem a -> b # foldl :: (b -> a -> b) -> b -> RowListItem a -> b # foldl' :: (b -> a -> b) -> b -> RowListItem a -> b # foldr1 :: (a -> a -> a) -> RowListItem a -> a # foldl1 :: (a -> a -> a) -> RowListItem a -> a # toList :: RowListItem a -> [a] # null :: RowListItem a -> Bool # length :: RowListItem a -> Int # elem :: Eq a => a -> RowListItem a -> Bool # maximum :: Ord a => RowListItem a -> a # minimum :: Ord a => RowListItem a -> a # sum :: Num a => RowListItem a -> a # product :: Num a => RowListItem a -> a #
Traversable RowListItem Source #
Instance details Defined in Language.PureScript.Types Methods traverse :: Applicative f => (a -> f b) -> RowListItem a -> f (RowListItem b) # sequenceA :: Applicative f => RowListItem (f a) -> f (RowListItem a) # mapM :: Monad m => (a -> m b) -> RowListItem a -> m (RowListItem b) # sequence :: Monad m => RowListItem (m a) -> m (RowListItem a) #
Show a => Show (RowListItem a) Source #
Instance details Defined in Language.PureScript.Types Methods showsPrec :: Int -> RowListItem a -> ShowS # show :: RowListItem a -> String # showList :: [RowListItem a] -> ShowS #
Generic (RowListItem a) Source #
Instance details Defined in Language.PureScript.Types Associated Types type Rep (RowListItem a) :: Type -> Type # Methods from :: RowListItem a -> Rep (RowListItem a) x # to :: Rep (RowListItem a) x -> RowListItem a #
type Rep (RowListItem a) Source #
Instance details Defined in Language.PureScript.Types type Rep (RowListItem a) = D1 (MetaData "RowListItem" "Language.PureScript.Types" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "RowListItem" PrefixI True) (S1 (MetaSel (Just "rowListAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: (S1 (MetaSel (Just "rowListLabel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Label) :: S1 (MetaSel (Just "rowListType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)))))

data Constraint a Source #

A typeclass constraint

Constructors

Constraint
Fields constraintAnn :: a constraint annotation constraintClass :: Qualified (ProperName ClassName) constraint class name constraintArgs :: [Type a] type arguments constraintData :: Maybe ConstraintData additional data relevant to this constraint

Instances

Functor Constraint Source #
Instance details Defined in Language.PureScript.Types Methods fmap :: (a -> b) -> Constraint a -> Constraint b # (<$) :: a -> Constraint b -> Constraint a #
Foldable Constraint Source #
Instance details Defined in Language.PureScript.Types Methods fold :: Monoid m => Constraint m -> m # foldMap :: Monoid m => (a -> m) -> Constraint a -> m # foldr :: (a -> b -> b) -> b -> Constraint a -> b # foldr' :: (a -> b -> b) -> b -> Constraint a -> b # foldl :: (b -> a -> b) -> b -> Constraint a -> b # foldl' :: (b -> a -> b) -> b -> Constraint a -> b # foldr1 :: (a -> a -> a) -> Constraint a -> a # foldl1 :: (a -> a -> a) -> Constraint a -> a # toList :: Constraint a -> [a] # null :: Constraint a -> Bool # length :: Constraint a -> Int # elem :: Eq a => a -> Constraint a -> Bool # maximum :: Ord a => Constraint a -> a # minimum :: Ord a => Constraint a -> a # sum :: Num a => Constraint a -> a # product :: Num a => Constraint a -> a #
Traversable Constraint Source #
Instance details Defined in Language.PureScript.Types Methods traverse :: Applicative f => (a -> f b) -> Constraint a -> f (Constraint b) # sequenceA :: Applicative f => Constraint (f a) -> f (Constraint a) # mapM :: Monad m => (a -> m b) -> Constraint a -> m (Constraint b) # sequence :: Monad m => Constraint (m a) -> m (Constraint a) #
Eq (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods (==) :: Constraint a -> Constraint a -> Bool # (/=) :: Constraint a -> Constraint a -> Bool #
Ord (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods compare :: Constraint a -> Constraint a -> Ordering # (<) :: Constraint a -> Constraint a -> Bool # (<=) :: Constraint a -> Constraint a -> Bool # (>) :: Constraint a -> Constraint a -> Bool # (>=) :: Constraint a -> Constraint a -> Bool # max :: Constraint a -> Constraint a -> Constraint a # min :: Constraint a -> Constraint a -> Constraint a #
Show a => Show (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods showsPrec :: Int -> Constraint a -> ShowS # show :: Constraint a -> String # showList :: [Constraint a] -> ShowS #
Generic (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Associated Types type Rep (Constraint a) :: Type -> Type # Methods from :: Constraint a -> Rep (Constraint a) x # to :: Rep (Constraint a) x -> Constraint a #
NFData a => NFData (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods rnf :: Constraint a -> () #
ToJSON a => ToJSON (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods toJSON :: Constraint a -> Value # toEncoding :: Constraint a -> Encoding # toJSONList :: [Constraint a] -> Value # toEncodingList :: [Constraint a] -> Encoding #
FromJSON (Constraint ()) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Constraint ()) # parseJSONList :: Value -> Parser [Constraint ()] #
FromJSON a => FromJSON (Constraint a) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Constraint a) # parseJSONList :: Value -> Parser [Constraint a] #
FromJSON (Constraint SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Constraint SourceAnn) # parseJSONList :: Value -> Parser [Constraint SourceAnn] #
type Rep (Constraint a) Source #
Instance details Defined in Language.PureScript.Types type Rep (Constraint a) = D1 (MetaData "Constraint" "Language.PureScript.Types" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Constraint" PrefixI True) ((S1 (MetaSel (Just "constraintAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Just "constraintClass") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Qualified (ProperName ClassName)))) :: (S1 (MetaSel (Just "constraintArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type a]) :*: S1 (MetaSel (Just "constraintData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ConstraintData)))))

data ConstraintData Source #

Additional data relevant to type class constraints

Constructors

PartialConstraintData [[Text]] Bool

Data to accompany a Partial constraint generated by the exhaustivity checker. It contains (rendered) binder information for those binders which were not matched, and a flag indicating whether the list was truncated or not. Note: we use Text here because using Binder would introduce a cyclic dependency in the module graph.

Instances

Eq ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods (==) :: ConstraintData -> ConstraintData -> Bool # (/=) :: ConstraintData -> ConstraintData -> Bool #
Ord ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods compare :: ConstraintData -> ConstraintData -> Ordering # (<) :: ConstraintData -> ConstraintData -> Bool # (<=) :: ConstraintData -> ConstraintData -> Bool # (>) :: ConstraintData -> ConstraintData -> Bool # (>=) :: ConstraintData -> ConstraintData -> Bool # max :: ConstraintData -> ConstraintData -> ConstraintData # min :: ConstraintData -> ConstraintData -> ConstraintData #
Show ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods showsPrec :: Int -> ConstraintData -> ShowS # show :: ConstraintData -> String # showList :: [ConstraintData] -> ShowS #
Generic ConstraintData Source #
Instance details Defined in Language.PureScript.Types Associated Types type Rep ConstraintData :: Type -> Type # Methods from :: ConstraintData -> Rep ConstraintData x # to :: Rep ConstraintData x -> ConstraintData #
NFData ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods rnf :: ConstraintData -> () #
ToJSON ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods toJSON :: ConstraintData -> Value # toEncoding :: ConstraintData -> Encoding # toJSONList :: [ConstraintData] -> Value # toEncodingList :: [ConstraintData] -> Encoding #
FromJSON ConstraintData Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser ConstraintData # parseJSONList :: Value -> Parser [ConstraintData] #
type Rep ConstraintData Source #
Instance details Defined in Language.PureScript.Types type Rep ConstraintData = D1 (MetaData "ConstraintData" "Language.PureScript.Types" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "PartialConstraintData" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[Text]]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)))

data Type a Source #

The type of types

Constructors

TUnknown a Int	A unification variable of type Type
TypeVar a Text	A named type variable
TypeLevelString a PSString	A type-level string
TypeWildcard a (Maybe Text)	A type wildcard, as would appear in a partial type synonym
TypeConstructor a (Qualified (ProperName TypeName))	A type constructor
TypeOp a (Qualified (OpName TypeOpName))	A type operator. This will be desugared into a type constructor during the "operators" phase of desugaring.
TypeApp a (Type a) (Type a)	A type application
ForAll a Text (Maybe (Kind a)) (Type a) (Maybe SkolemScope)	Forall quantifier
ConstrainedType a (Constraint a) (Type a)	A type with a set of type class constraints
Skolem a Text Int SkolemScope	A skolem constant
REmpty a	An empty row
RCons a Label (Type a) (Type a)	A non-empty row
KindedType a (Type a) (Kind a)	A type with a kind annotation
BinaryNoParensType a (Type a) (Type a) (Type a)	Binary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.
ParensInType a (Type a)	Explicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed. Note: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching.

Instances

Functor Type Source #
Instance details Defined in Language.PureScript.Types Methods fmap :: (a -> b) -> Type a -> Type b # (<$) :: a -> Type b -> Type a #
Foldable Type Source #
Instance details Defined in Language.PureScript.Types Methods fold :: Monoid m => Type m -> m # foldMap :: Monoid m => (a -> m) -> Type a -> m # foldr :: (a -> b -> b) -> b -> Type a -> b # foldr' :: (a -> b -> b) -> b -> Type a -> b # foldl :: (b -> a -> b) -> b -> Type a -> b # foldl' :: (b -> a -> b) -> b -> Type a -> b # foldr1 :: (a -> a -> a) -> Type a -> a # foldl1 :: (a -> a -> a) -> Type a -> a # toList :: Type a -> [a] # null :: Type a -> Bool # length :: Type a -> Int # elem :: Eq a => a -> Type a -> Bool # maximum :: Ord a => Type a -> a # minimum :: Ord a => Type a -> a # sum :: Num a => Type a -> a # product :: Num a => Type a -> a #
Traversable Type Source #
Instance details Defined in Language.PureScript.Types Methods traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b) # sequenceA :: Applicative f => Type (f a) -> f (Type a) # mapM :: Monad m => (a -> m b) -> Type a -> m (Type b) # sequence :: Monad m => Type (m a) -> m (Type a) #
Eq (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods (==) :: Type a -> Type a -> Bool # (/=) :: Type a -> Type a -> Bool #
Ord (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods compare :: Type a -> Type a -> Ordering # (<) :: Type a -> Type a -> Bool # (<=) :: Type a -> Type a -> Bool # (>) :: Type a -> Type a -> Bool # (>=) :: Type a -> Type a -> Bool # max :: Type a -> Type a -> Type a # min :: Type a -> Type a -> Type a #
Show a => Show (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods showsPrec :: Int -> Type a -> ShowS # show :: Type a -> String # showList :: [Type a] -> ShowS #
Generic (Type a) Source #
Instance details Defined in Language.PureScript.Types Associated Types type Rep (Type a) :: Type -> Type # Methods from :: Type a -> Rep (Type a) x # to :: Rep (Type a) x -> Type a #
NFData a => NFData (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods rnf :: Type a -> () #
ToJSON a => ToJSON (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods toJSON :: Type a -> Value # toEncoding :: Type a -> Encoding # toJSONList :: [Type a] -> Value # toEncodingList :: [Type a] -> Encoding #
FromJSON (Type ()) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Type ()) # parseJSONList :: Value -> Parser [Type ()] #
FromJSON a => FromJSON (Type a) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Type a) # parseJSONList :: Value -> Parser [Type a] #
FromJSON (Type SourceAnn) Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser (Type SourceAnn) # parseJSONList :: Value -> Parser [Type SourceAnn] #
type Rep (Type a) Source #
Instance details Defined in Language.PureScript.Types type Rep (Type a) = D1 (MetaData "Type" "Language.PureScript.Types" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (((C1 (MetaCons "TUnknown" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: (C1 (MetaCons "TypeVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) :+: C1 (MetaCons "TypeLevelString" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PSString)))) :+: ((C1 (MetaCons "TypeWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text))) :+: C1 (MetaCons "TypeConstructor" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Qualified (ProperName TypeName))))) :+: (C1 (MetaCons "TypeOp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Qualified (OpName TypeOpName)))) :+: C1 (MetaCons "TypeApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a))))))) :+: (((C1 (MetaCons "ForAll" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind a))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe SkolemScope))))) :+: C1 (MetaCons "ConstrainedType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Constraint a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a))))) :+: (C1 (MetaCons "Skolem" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SkolemScope))) :+: C1 (MetaCons "REmpty" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))) :+: ((C1 (MetaCons "RCons" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Label)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)))) :+: C1 (MetaCons "KindedType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind a))))) :+: (C1 (MetaCons "BinaryNoParensType" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)))) :+: C1 (MetaCons "ParensInType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type a)))))))

newtype SkolemScope Source #

An identifier for the scope of a skolem variable

Constructors

SkolemScope
Fields runSkolemScope :: Int

Instances

Eq SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods (==) :: SkolemScope -> SkolemScope -> Bool # (/=) :: SkolemScope -> SkolemScope -> Bool #
Ord SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods compare :: SkolemScope -> SkolemScope -> Ordering # (<) :: SkolemScope -> SkolemScope -> Bool # (<=) :: SkolemScope -> SkolemScope -> Bool # (>) :: SkolemScope -> SkolemScope -> Bool # (>=) :: SkolemScope -> SkolemScope -> Bool # max :: SkolemScope -> SkolemScope -> SkolemScope # min :: SkolemScope -> SkolemScope -> SkolemScope #
Show SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods showsPrec :: Int -> SkolemScope -> ShowS # show :: SkolemScope -> String # showList :: [SkolemScope] -> ShowS #
Generic SkolemScope Source #
Instance details Defined in Language.PureScript.Types Associated Types type Rep SkolemScope :: Type -> Type # Methods from :: SkolemScope -> Rep SkolemScope x # to :: Rep SkolemScope x -> SkolemScope #
NFData SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods rnf :: SkolemScope -> () #
ToJSON SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods toJSON :: SkolemScope -> Value # toEncoding :: SkolemScope -> Encoding # toJSONList :: [SkolemScope] -> Value # toEncodingList :: [SkolemScope] -> Encoding #
FromJSON SkolemScope Source #
Instance details Defined in Language.PureScript.Types Methods parseJSON :: Value -> Parser SkolemScope # parseJSONList :: Value -> Parser [SkolemScope] #
type Rep SkolemScope Source #
Instance details Defined in Language.PureScript.Types type Rep SkolemScope = D1 (MetaData "SkolemScope" "Language.PureScript.Types" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" True) (C1 (MetaCons "SkolemScope" PrefixI True) (S1 (MetaSel (Just "runSkolemScope") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

type SourceConstraint = Constraint SourceAnn Source #

type SourceType = Type SourceAnn Source #

srcTUnknown :: Int -> SourceType Source #

srcTypeVar :: Text -> SourceType Source #

srcTypeLevelString :: PSString -> SourceType Source #

srcTypeWildcard :: SourceType Source #

srcTypeConstructor :: Qualified (ProperName TypeName) -> SourceType Source #

srcTypeOp :: Qualified (OpName TypeOpName) -> SourceType Source #

srcTypeApp :: SourceType -> SourceType -> SourceType Source #

srcForAll :: Text -> Maybe SourceKind -> SourceType -> Maybe SkolemScope -> SourceType Source #

srcConstrainedType :: SourceConstraint -> SourceType -> SourceType Source #

srcSkolem :: Text -> Int -> SkolemScope -> SourceType Source #

srcREmpty :: SourceType Source #

srcRCons :: Label -> SourceType -> SourceType -> SourceType Source #

srcKindedType :: SourceType -> SourceKind -> SourceType Source #

srcBinaryNoParensType :: SourceType -> SourceType -> SourceType -> SourceType Source #

srcParensInType :: SourceType -> SourceType Source #

srcConstraint :: Qualified (ProperName ClassName) -> [SourceType] -> Maybe ConstraintData -> SourceConstraint Source #

mapConstraintArgs :: ([Type a] -> [Type a]) -> Constraint a -> Constraint a Source #

overConstraintArgs :: Functor f => ([Type a] -> f [Type a]) -> Constraint a -> f (Constraint a) Source #

constraintDataToJSON :: ConstraintData -> Value Source #

constraintToJSON :: (a -> Value) -> Constraint a -> Value Source #

typeToJSON :: forall a. (a -> Value) -> Type a -> Value Source #

constraintDataFromJSON :: Value -> Parser ConstraintData Source #

constraintFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Constraint a) Source #

typeFromJSON :: forall a. Parser a -> (Value -> Parser a) -> Value -> Parser (Type a) Source #

srcRowListItem :: Label -> SourceType -> RowListItem SourceAnn Source #

rowToList :: Type a -> ([RowListItem a], Type a) Source #

Convert a row to a list of pairs of labels and types

rowToSortedList :: Type a -> ([RowListItem a], Type a) Source #

Convert a row to a list of pairs of labels and types, sorted by the labels.

rowFromList :: ([RowListItem a], Type a) -> Type a Source #

Convert a list of labels and types to a row

isMonoType :: Type a -> Bool Source #

Check whether a type is a monotype

mkForAll :: [(a, (Text, Maybe (Kind a)))] -> Type a -> Type a Source #

Universally quantify a type

replaceTypeVars :: Text -> Type a -> Type a -> Type a Source #

Replace a type variable, taking into account variable shadowing

replaceAllTypeVars :: [(Text, Type a)] -> Type a -> Type a Source #

Replace named type variables with types

usedTypeVariables :: Type a -> [Text] Source #

Collect all type variables appearing in a type

freeTypeVariables :: Type a -> [Text] Source #

Collect all free type variables appearing in a type

quantify :: Type a -> Type a Source #

Universally quantify over all type variables appearing free in a type

moveQuantifiersToFront :: Type a -> Type a Source #

Move all universal quantifiers to the front of a type

containsWildcards :: Type a -> Bool Source #

Check if a type contains wildcards

containsForAll :: Type a -> Bool Source #

Check if a type contains forall

everywhereOnTypes :: (Type a -> Type a) -> Type a -> Type a Source #

everywhereOnTypesTopDown :: (Type a -> Type a) -> Type a -> Type a Source #

everywhereOnTypesM :: Monad m => (Type a -> m (Type a)) -> Type a -> m (Type a) Source #

everywhereOnTypesTopDownM :: Monad m => (Type a -> m (Type a)) -> Type a -> m (Type a) Source #

everythingOnTypes :: (r -> r -> r) -> (Type a -> r) -> Type a -> r Source #

everythingWithContextOnTypes :: s -> r -> (r -> r -> r) -> (s -> Type a -> (s, r)) -> Type a -> r Source #

annForType :: Lens' (Type a) a Source #

getAnnForType :: Type a -> a Source #

setAnnForType :: a -> Type a -> Type a Source #

eqType :: Type a -> Type b -> Bool Source #

compareType :: Type a -> Type b -> Ordering Source #

eqConstraint :: Constraint a -> Constraint b -> Bool Source #

compareConstraint :: Constraint a -> Constraint b -> Ordering Source #

data DataDeclType Source #

The type ('data' or 'newtype') of a data type declaration

Constructors

Data	A standard data constructor
Newtype	A newtype constructor

Instances

Eq DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods (==) :: DataDeclType -> DataDeclType -> Bool # (/=) :: DataDeclType -> DataDeclType -> Bool #
Ord DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods compare :: DataDeclType -> DataDeclType -> Ordering # (<) :: DataDeclType -> DataDeclType -> Bool # (<=) :: DataDeclType -> DataDeclType -> Bool # (>) :: DataDeclType -> DataDeclType -> Bool # (>=) :: DataDeclType -> DataDeclType -> Bool # max :: DataDeclType -> DataDeclType -> DataDeclType # min :: DataDeclType -> DataDeclType -> DataDeclType #
Show DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> DataDeclType -> ShowS # show :: DataDeclType -> String # showList :: [DataDeclType] -> ShowS #
Generic DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep DataDeclType :: Type -> Type # Methods from :: DataDeclType -> Rep DataDeclType x # to :: Rep DataDeclType x -> DataDeclType #
NFData DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: DataDeclType -> () #
ToJSON DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods toJSON :: DataDeclType -> Value # toEncoding :: DataDeclType -> Encoding # toJSONList :: [DataDeclType] -> Value # toEncodingList :: [DataDeclType] -> Encoding #
FromJSON DataDeclType Source #
Instance details Defined in Language.PureScript.Environment Methods parseJSON :: Value -> Parser DataDeclType # parseJSONList :: Value -> Parser [DataDeclType] #
type Rep DataDeclType Source #
Instance details Defined in Language.PureScript.Environment type Rep DataDeclType = D1 (MetaData "DataDeclType" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Data" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Newtype" PrefixI False) (U1 :: Type -> Type))

data TypeKind Source #

The kinds of a type

Constructors

DataType [(Text, Maybe SourceKind)] [(ProperName ConstructorName, [SourceType])]	Data type
TypeSynonym	Type synonym
ExternData	Foreign data
LocalTypeVariable	A local type variable
ScopedTypeVar	A scoped type variable

Instances

Eq TypeKind Source #
Instance details Defined in Language.PureScript.Environment Methods (==) :: TypeKind -> TypeKind -> Bool # (/=) :: TypeKind -> TypeKind -> Bool #
Show TypeKind Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> TypeKind -> ShowS # show :: TypeKind -> String # showList :: [TypeKind] -> ShowS #
Generic TypeKind Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep TypeKind :: Type -> Type # Methods from :: TypeKind -> Rep TypeKind x # to :: Rep TypeKind x -> TypeKind #
NFData TypeKind Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: TypeKind -> () #
ToJSON TypeKind Source #
Instance details Defined in Language.PureScript.Environment Methods toJSON :: TypeKind -> Value # toEncoding :: TypeKind -> Encoding # toJSONList :: [TypeKind] -> Value # toEncodingList :: [TypeKind] -> Encoding #
FromJSON TypeKind Source #
Instance details Defined in Language.PureScript.Environment Methods parseJSON :: Value -> Parser TypeKind # parseJSONList :: Value -> Parser [TypeKind] #
type Rep TypeKind Source #
Instance details Defined in Language.PureScript.Environment type Rep TypeKind = D1 (MetaData "TypeKind" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) ((C1 (MetaCons "DataType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Text, Maybe SourceKind)]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(ProperName ConstructorName, [SourceType])])) :+: C1 (MetaCons "TypeSynonym" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "ExternData" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "LocalTypeVariable" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ScopedTypeVar" PrefixI False) (U1 :: Type -> Type))))

data NameKind Source #

A flag for whether a name is for an private or public value - only public values will be included in a generated externs file.

Constructors

Private	A private value introduced as an artifact of code generation (class instances, class member accessors, etc.)
Public	A public value for a module member or foreing import declaration
External	A name for member introduced by foreign import

Instances

Eq NameKind Source #
Instance details Defined in Language.PureScript.Environment Methods (==) :: NameKind -> NameKind -> Bool # (/=) :: NameKind -> NameKind -> Bool #
Show NameKind Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> NameKind -> ShowS # show :: NameKind -> String # showList :: [NameKind] -> ShowS #
Generic NameKind Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep NameKind :: Type -> Type # Methods from :: NameKind -> Rep NameKind x # to :: Rep NameKind x -> NameKind #
NFData NameKind Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: NameKind -> () #
type Rep NameKind Source #
Instance details Defined in Language.PureScript.Environment type Rep NameKind = D1 (MetaData "NameKind" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Private" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "Public" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "External" PrefixI False) (U1 :: Type -> Type)))

data NameVisibility Source #

The visibility of a name in scope

Constructors

Undefined	The name is defined in the current binding group, but is not visible
Defined	The name is defined in the another binding group, or has been made visible by a function binder

Instances

Eq NameVisibility Source #
Instance details Defined in Language.PureScript.Environment Methods (==) :: NameVisibility -> NameVisibility -> Bool # (/=) :: NameVisibility -> NameVisibility -> Bool #
Show NameVisibility Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> NameVisibility -> ShowS # show :: NameVisibility -> String # showList :: [NameVisibility] -> ShowS #
Generic NameVisibility Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep NameVisibility :: Type -> Type # Methods from :: NameVisibility -> Rep NameVisibility x # to :: Rep NameVisibility x -> NameVisibility #
NFData NameVisibility Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: NameVisibility -> () #
type Rep NameVisibility Source #
Instance details Defined in Language.PureScript.Environment type Rep NameVisibility = D1 (MetaData "NameVisibility" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Undefined" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Defined" PrefixI False) (U1 :: Type -> Type))

data FunctionalDependency Source #

A functional dependency indicates a relationship between two sets of type arguments in a class declaration.

Constructors

FunctionalDependency
Fields fdDeterminers :: [Int] the type arguments which determine the determined type arguments fdDetermined :: [Int] the determined type arguments

Instances

Show FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> FunctionalDependency -> ShowS # show :: FunctionalDependency -> String # showList :: [FunctionalDependency] -> ShowS #
Generic FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep FunctionalDependency :: Type -> Type # Methods from :: FunctionalDependency -> Rep FunctionalDependency x # to :: Rep FunctionalDependency x -> FunctionalDependency #
NFData FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: FunctionalDependency -> () #
ToJSON FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment Methods toJSON :: FunctionalDependency -> Value # toEncoding :: FunctionalDependency -> Encoding # toJSONList :: [FunctionalDependency] -> Value # toEncodingList :: [FunctionalDependency] -> Encoding #
FromJSON FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment Methods parseJSON :: Value -> Parser FunctionalDependency # parseJSONList :: Value -> Parser [FunctionalDependency] #
type Rep FunctionalDependency Source #
Instance details Defined in Language.PureScript.Environment type Rep FunctionalDependency = D1 (MetaData "FunctionalDependency" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "FunctionalDependency" PrefixI True) (S1 (MetaSel (Just "fdDeterminers") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Int]) :*: S1 (MetaSel (Just "fdDetermined") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Int])))

data TypeClassData Source #

Information about a type class

Constructors

TypeClassData

Fields

typeClassArguments :: [(Text, Maybe SourceKind)]
A list of type argument names, and their kinds, where kind annotations were provided.
typeClassMembers :: [(Ident, SourceType)]
A list of type class members and their types. Type arguments listed above are considered bound in these types.
typeClassSuperclasses :: [SourceConstraint]
A list of superclasses of this type class. Type arguments listed above are considered bound in the types appearing in these constraints.
typeClassDependencies :: [FunctionalDependency]
A list of functional dependencies for the type arguments of this class.
typeClassDeterminedArguments :: Set Int
A set of indexes of type argument that are fully determined by other arguments via functional dependencies. This can be computed from both typeClassArguments and typeClassDependencies.
typeClassCoveringSets :: Set (Set Int)
A sets of arguments that can be used to infer all other arguments.

Instances

Show TypeClassData Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> TypeClassData -> ShowS # show :: TypeClassData -> String # showList :: [TypeClassData] -> ShowS #
Generic TypeClassData Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep TypeClassData :: Type -> Type # Methods from :: TypeClassData -> Rep TypeClassData x # to :: Rep TypeClassData x -> TypeClassData #
NFData TypeClassData Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: TypeClassData -> () #
type Rep TypeClassData Source #
Instance details Defined in Language.PureScript.Environment type Rep TypeClassData = D1 (MetaData "TypeClassData" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "TypeClassData" PrefixI True) ((S1 (MetaSel (Just "typeClassArguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Text, Maybe SourceKind)]) :: (S1 (MetaSel (Just "typeClassMembers") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Ident, SourceType)]) :: S1 (MetaSel (Just "typeClassSuperclasses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SourceConstraint]))) :: (S1 (MetaSel (Just "typeClassDependencies") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FunctionalDependency]) :: (S1 (MetaSel (Just "typeClassDeterminedArguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set Int)) :*: S1 (MetaSel (Just "typeClassCoveringSets") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set (Set Int)))))))

data Environment Source #

The Environment defines all values and types which are currently in scope:

Constructors

Environment

Fields

names :: Map (Qualified Ident) (SourceType, NameKind, NameVisibility)
Values currently in scope
types :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind)
Type names currently in scope
dataConstructors :: Map (Qualified (ProperName ConstructorName)) (DataDeclType, ProperName TypeName, SourceType, [Ident])
Data constructors currently in scope, along with their associated type constructor name, argument types and return type.
typeSynonyms :: Map (Qualified (ProperName TypeName)) ([(Text, Maybe SourceKind)], SourceType)
Type synonyms currently in scope
typeClassDictionaries :: Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))
Available type class dictionaries. When looking up Nothing in the outer map, this returns the map of type class dictionaries in local scope (ie dictionaries brought in by a constrained type).
typeClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
Type classes
kinds :: Set (Qualified (ProperName KindName))
Kinds in scope

Instances

Show Environment Source #
Instance details Defined in Language.PureScript.Environment Methods showsPrec :: Int -> Environment -> ShowS # show :: Environment -> String # showList :: [Environment] -> ShowS #
Generic Environment Source #
Instance details Defined in Language.PureScript.Environment Associated Types type Rep Environment :: Type -> Type # Methods from :: Environment -> Rep Environment x # to :: Rep Environment x -> Environment #
NFData Environment Source #
Instance details Defined in Language.PureScript.Environment Methods rnf :: Environment -> () #
type Rep Environment Source #
Instance details Defined in Language.PureScript.Environment type Rep Environment = D1 (MetaData "Environment" "Language.PureScript.Environment" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "Environment" PrefixI True) ((S1 (MetaSel (Just "names") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Qualified Ident) (SourceType, NameKind, NameVisibility))) :: (S1 (MetaSel (Just "types") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind))) :: S1 (MetaSel (Just "dataConstructors") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Qualified (ProperName ConstructorName)) (DataDeclType, ProperName TypeName, SourceType, [Ident]))))) :: ((S1 (MetaSel (Just "typeSynonyms") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Qualified (ProperName TypeName)) ([(Text, Maybe SourceKind)], SourceType))) :: S1 (MetaSel (Just "typeClassDictionaries") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))))) :: (S1 (MetaSel (Just "typeClasses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map (Qualified (ProperName ClassName)) TypeClassData)) :: S1 (MetaSel (Just "kinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set (Qualified (ProperName KindName))))))))

initEnvironment :: Environment Source #

The initial environment with no values and only the default javascript types defined

makeTypeClassData :: [(Text, Maybe SourceKind)] -> [(Ident, SourceType)] -> [SourceConstraint] -> [FunctionalDependency] -> TypeClassData Source #

A constructor for TypeClassData that computes which type class arguments are fully determined and argument covering sets. Fully determined means that this argument cannot be used when selecting a type class instance. A covering set is a minimal collection of arguments that can be used to find an instance and therefore determine all other type arguments.

An example of the difference between determined and fully determined would be with the class: ```class C a b c | a -> b, b -> a, b -> c``` In this case, a must differ when b differs, and vice versa - each is determined by the other. Both a and b can be used in selecting a type class instance. However, c cannot - it is fully determined by a and b.

Define a graph of type class arguments with edges being fundep determiners to determined. Each argument also has a self looping edge. An argument is fully determined if doesn't appear at the start of a path of strongly connected components. An argument is not fully determined otherwise.

The way we compute this is by saying: an argument X is fully determined if there are arguments that determine X that X does not determine. This is the same thing: everything X determines includes everything in its SCC, and everything determining X is either before it in an SCC path, or in the same SCC.

showDataDeclType :: DataDeclType -> Text Source #

primName :: Text -> Qualified (ProperName a) Source #

Construct a ProperName in the Prim module

primSubName :: Text -> Text -> Qualified (ProperName a) Source #

Construct a ProperName in the Prim.NAME module.

primKind :: Text -> SourceKind Source #

primSubKind :: Text -> Text -> SourceKind Source #

kindType :: SourceKind Source #

Kind of ground types

kindConstraint :: SourceKind Source #

isKindType :: Kind a -> Bool Source #

(-:>) :: SourceKind -> SourceKind -> SourceKind infixr 4 Source #

kindSymbol :: SourceKind Source #

kindDoc :: SourceKind Source #

kindBoolean :: SourceKind Source #

kindOrdering :: SourceKind Source #

kindRowList :: SourceKind Source #

kindRow :: SourceKind -> SourceKind Source #

primTy :: Text -> SourceType Source #

Construct a type in the Prim module

tyFunction :: SourceType Source #

Type constructor for functions

tyString :: SourceType Source #

Type constructor for strings

tyChar :: SourceType Source #

Type constructor for strings

tyNumber :: SourceType Source #

Type constructor for numbers

tyInt :: SourceType Source #

Type constructor for integers

tyBoolean :: SourceType Source #

Type constructor for booleans

tyArray :: SourceType Source #

Type constructor for arrays

tyRecord :: SourceType Source #

Type constructor for records

isObject :: Type a -> Bool Source #

Check whether a type is a record

isFunction :: Type a -> Bool Source #

Check whether a type is a function

isTypeOrApplied :: Type a -> Type b -> Bool Source #

function :: SourceType -> SourceType -> SourceType Source #

Smart constructor for function types

primKinds :: Set (Qualified (ProperName KindName)) Source #

Kinds in Prim

primBooleanKinds :: Set (Qualified (ProperName KindName)) Source #

Kinds in Prim.Boolean

primOrderingKinds :: Set (Qualified (ProperName KindName)) Source #

Kinds in Prim.Ordering

primRowListKinds :: Set (Qualified (ProperName KindName)) Source #

Kinds in Prim.RowList

primTypeErrorKinds :: Set (Qualified (ProperName KindName)) Source #

Kinds in Prim.TypeError

allPrimKinds :: Set (Qualified (ProperName KindName)) Source #

All primitive kinds

primTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

The primitive types in the external javascript environment with their associated kinds. There are also pseudo Fail, Warn, and Partial types that correspond to the classes with the same names.

allPrimTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

This Map contains all of the prim types from all Prim modules.

primBooleanTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primOrderingTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primRowTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primRowListTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primSymbolTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primTypeErrorTypes :: Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) Source #

primClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

The primitive class map. This just contains the Partial class. Partial is used as a kind of magic constraint for partial functions.

allPrimClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

This contains all of the type classes from all Prim modules.

primRowClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

primRowListClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

primSymbolClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

primTypeErrorClasses :: Map (Qualified (ProperName ClassName)) TypeClassData Source #

lookupConstructor :: Environment -> Qualified (ProperName ConstructorName) -> (DataDeclType, ProperName TypeName, SourceType, [Ident]) Source #

Finds information about data constructors from the current environment.

isNewtypeConstructor :: Environment -> Qualified (ProperName ConstructorName) -> Bool Source #

Checks whether a data constructor is for a newtype.

lookupValue :: Environment -> Qualified Ident -> Maybe (SourceType, NameKind, NameVisibility) Source #

Finds information about values from the current environment.

data Binder Source #

Data type for binders

Constructors

NullBinder	Wildcard binder
LiteralBinder SourceSpan (Literal Binder)	A binder which matches a literal
VarBinder SourceSpan Ident	A binder which binds an identifier
ConstructorBinder SourceSpan (Qualified (ProperName ConstructorName)) [Binder]	A binder which matches a data constructor
OpBinder SourceSpan (Qualified (OpName ValueOpName))	A operator alias binder. During the rebracketing phase of desugaring, this data constructor will be removed.
BinaryNoParensBinder Binder Binder Binder	Binary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.
ParensInBinder Binder	Explicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed. Note: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching.
NamedBinder SourceSpan Ident Binder	A binder which binds its input to an identifier
PositionedBinder SourceSpan [Comment] Binder	A binder with source position information
TypedBinder SourceType Binder	A binder with a type annotation

Instances

Eq Binder Source #
Instance details Defined in Language.PureScript.AST.Binders Methods (==) :: Binder -> Binder -> Bool # (/=) :: Binder -> Binder -> Bool #
Ord Binder Source #
Instance details Defined in Language.PureScript.AST.Binders Methods compare :: Binder -> Binder -> Ordering # (<) :: Binder -> Binder -> Bool # (<=) :: Binder -> Binder -> Bool # (>) :: Binder -> Binder -> Bool # (>=) :: Binder -> Binder -> Bool # max :: Binder -> Binder -> Binder # min :: Binder -> Binder -> Binder #
Show Binder Source #
Instance details Defined in Language.PureScript.AST.Binders Methods showsPrec :: Int -> Binder -> ShowS # show :: Binder -> String # showList :: [Binder] -> ShowS #

binderNames :: Binder -> [Ident] Source #

Collect all names introduced in binders in an expression

isIrrefutable :: Binder -> Bool Source #

newtype AssocList k t Source #

Constructors

AssocList
Fields runAssocList :: [(k, t)]

Instances

Functor (AssocList k) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fmap :: (a -> b) -> AssocList k a -> AssocList k b # (<$) :: a -> AssocList k b -> AssocList k a #
Foldable (AssocList k) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fold :: Monoid m => AssocList k m -> m # foldMap :: Monoid m => (a -> m) -> AssocList k a -> m # foldr :: (a -> b -> b) -> b -> AssocList k a -> b # foldr' :: (a -> b -> b) -> b -> AssocList k a -> b # foldl :: (b -> a -> b) -> b -> AssocList k a -> b # foldl' :: (b -> a -> b) -> b -> AssocList k a -> b # foldr1 :: (a -> a -> a) -> AssocList k a -> a # foldl1 :: (a -> a -> a) -> AssocList k a -> a # toList :: AssocList k a -> [a] # null :: AssocList k a -> Bool # length :: AssocList k a -> Int # elem :: Eq a => a -> AssocList k a -> Bool # maximum :: Ord a => AssocList k a -> a # minimum :: Ord a => AssocList k a -> a # sum :: Num a => AssocList k a -> a # product :: Num a => AssocList k a -> a #
Traversable (AssocList k) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods traverse :: Applicative f => (a -> f b) -> AssocList k a -> f (AssocList k b) # sequenceA :: Applicative f => AssocList k (f a) -> f (AssocList k a) # mapM :: Monad m => (a -> m b) -> AssocList k a -> m (AssocList k b) # sequence :: Monad m => AssocList k (m a) -> m (AssocList k a) #
(Eq k, Eq t) => Eq (AssocList k t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: AssocList k t -> AssocList k t -> Bool # (/=) :: AssocList k t -> AssocList k t -> Bool #
(Ord k, Ord t) => Ord (AssocList k t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: AssocList k t -> AssocList k t -> Ordering # (<) :: AssocList k t -> AssocList k t -> Bool # (<=) :: AssocList k t -> AssocList k t -> Bool # (>) :: AssocList k t -> AssocList k t -> Bool # (>=) :: AssocList k t -> AssocList k t -> Bool # max :: AssocList k t -> AssocList k t -> AssocList k t # min :: AssocList k t -> AssocList k t -> AssocList k t #
(Show k, Show t) => Show (AssocList k t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> AssocList k t -> ShowS # show :: AssocList k t -> String # showList :: [AssocList k t] -> ShowS #

data PathNode t Source #

Constructors

Leaf t
Branch (PathTree t)

Instances

Functor PathNode Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fmap :: (a -> b) -> PathNode a -> PathNode b # (<$) :: a -> PathNode b -> PathNode a #
Foldable PathNode Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fold :: Monoid m => PathNode m -> m # foldMap :: Monoid m => (a -> m) -> PathNode a -> m # foldr :: (a -> b -> b) -> b -> PathNode a -> b # foldr' :: (a -> b -> b) -> b -> PathNode a -> b # foldl :: (b -> a -> b) -> b -> PathNode a -> b # foldl' :: (b -> a -> b) -> b -> PathNode a -> b # foldr1 :: (a -> a -> a) -> PathNode a -> a # foldl1 :: (a -> a -> a) -> PathNode a -> a # toList :: PathNode a -> [a] # null :: PathNode a -> Bool # length :: PathNode a -> Int # elem :: Eq a => a -> PathNode a -> Bool # maximum :: Ord a => PathNode a -> a # minimum :: Ord a => PathNode a -> a # sum :: Num a => PathNode a -> a # product :: Num a => PathNode a -> a #
Traversable PathNode Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods traverse :: Applicative f => (a -> f b) -> PathNode a -> f (PathNode b) # sequenceA :: Applicative f => PathNode (f a) -> f (PathNode a) # mapM :: Monad m => (a -> m b) -> PathNode a -> m (PathNode b) # sequence :: Monad m => PathNode (m a) -> m (PathNode a) #
Eq t => Eq (PathNode t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: PathNode t -> PathNode t -> Bool # (/=) :: PathNode t -> PathNode t -> Bool #
Ord t => Ord (PathNode t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: PathNode t -> PathNode t -> Ordering # (<) :: PathNode t -> PathNode t -> Bool # (<=) :: PathNode t -> PathNode t -> Bool # (>) :: PathNode t -> PathNode t -> Bool # (>=) :: PathNode t -> PathNode t -> Bool # max :: PathNode t -> PathNode t -> PathNode t # min :: PathNode t -> PathNode t -> PathNode t #
Show t => Show (PathNode t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> PathNode t -> ShowS # show :: PathNode t -> String # showList :: [PathNode t] -> ShowS #

newtype PathTree t Source #

Constructors

PathTree (AssocList PSString (PathNode t))

Instances

Functor PathTree Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fmap :: (a -> b) -> PathTree a -> PathTree b # (<$) :: a -> PathTree b -> PathTree a #
Foldable PathTree Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fold :: Monoid m => PathTree m -> m # foldMap :: Monoid m => (a -> m) -> PathTree a -> m # foldr :: (a -> b -> b) -> b -> PathTree a -> b # foldr' :: (a -> b -> b) -> b -> PathTree a -> b # foldl :: (b -> a -> b) -> b -> PathTree a -> b # foldl' :: (b -> a -> b) -> b -> PathTree a -> b # foldr1 :: (a -> a -> a) -> PathTree a -> a # foldl1 :: (a -> a -> a) -> PathTree a -> a # toList :: PathTree a -> [a] # null :: PathTree a -> Bool # length :: PathTree a -> Int # elem :: Eq a => a -> PathTree a -> Bool # maximum :: Ord a => PathTree a -> a # minimum :: Ord a => PathTree a -> a # sum :: Num a => PathTree a -> a # product :: Num a => PathTree a -> a #
Traversable PathTree Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods traverse :: Applicative f => (a -> f b) -> PathTree a -> f (PathTree b) # sequenceA :: Applicative f => PathTree (f a) -> f (PathTree a) # mapM :: Monad m => (a -> m b) -> PathTree a -> m (PathTree b) # sequence :: Monad m => PathTree (m a) -> m (PathTree a) #
Eq t => Eq (PathTree t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: PathTree t -> PathTree t -> Bool # (/=) :: PathTree t -> PathTree t -> Bool #
Ord t => Ord (PathTree t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: PathTree t -> PathTree t -> Ordering # (<) :: PathTree t -> PathTree t -> Bool # (<=) :: PathTree t -> PathTree t -> Bool # (>) :: PathTree t -> PathTree t -> Bool # (>=) :: PathTree t -> PathTree t -> Bool # max :: PathTree t -> PathTree t -> PathTree t # min :: PathTree t -> PathTree t -> PathTree t #
Show t => Show (PathTree t) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> PathTree t -> ShowS # show :: PathTree t -> String # showList :: [PathTree t] -> ShowS #

data DoNotationElement Source #

A statement in a do-notation block

Constructors

DoNotationValue Expr	A monadic value without a binder
DoNotationBind Binder Expr	A monadic value with a binder
DoNotationLet [Declaration]	A let statement, i.e. a pure value with a binder
PositionedDoNotationElement SourceSpan [Comment] DoNotationElement	A do notation element with source position information

Instances

Show DoNotationElement Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> DoNotationElement -> ShowS # show :: DoNotationElement -> String # showList :: [DoNotationElement] -> ShowS #

data CaseAlternative Source #

An alternative in a case statement

Constructors

CaseAlternative
Fields caseAlternativeBinders :: [Binder] A collection of binders with which to match the inputs caseAlternativeResult :: [GuardedExpr] The result expression or a collect of guarded expressions

Instances

Show CaseAlternative Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> CaseAlternative -> ShowS # show :: CaseAlternative -> String # showList :: [CaseAlternative] -> ShowS #

data WhereProvenance Source #

Metadata that tells where a let binding originated

Constructors

FromWhere	The let binding was originally a where clause
FromLet	The let binding was always a let binding

Instances

Show WhereProvenance Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> WhereProvenance -> ShowS # show :: WhereProvenance -> String # showList :: [WhereProvenance] -> ShowS #

data Expr Source #

Data type for expressions and terms

Constructors

Literal SourceSpan (Literal Expr)	A literal value
UnaryMinus SourceSpan Expr	A prefix -, will be desugared
BinaryNoParens Expr Expr Expr	Binary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.
Parens Expr	Explicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed. Note: although it seems this constructor is not used, it _is_ useful, since it prevents certain traversals from matching.
Accessor PSString Expr	An record property accessor expression (e.g. `obj.x` or `_.x`). Anonymous arguments will be removed during desugaring and expanded into a lambda that reads a property from a record.
ObjectUpdate Expr [(PSString, Expr)]	Partial record update
ObjectUpdateNested Expr (PathTree Expr)	Object updates with nested support: `x { foo { bar = e } }` Replaced during desugaring into a `Let` and nested `ObjectUpdate`s
Abs Binder Expr	Function introduction
App Expr Expr	Function application
Var SourceSpan (Qualified Ident)	Variable
Op SourceSpan (Qualified (OpName ValueOpName))	An operator. This will be desugared into a function during the "operators" phase of desugaring.
IfThenElse Expr Expr Expr	Conditional (if-then-else expression)
Constructor SourceSpan (Qualified (ProperName ConstructorName))	A data constructor
Case [Expr] [CaseAlternative]	A case expression. During the case expansion phase of desugaring, top-level binders will get desugared into case expressions, hence the need for guards and multiple binders per branch here.
TypedValue Bool Expr SourceType	A value with a type annotation
Let WhereProvenance [Declaration] Expr	A let binding
Do (Maybe ModuleName) [DoNotationElement]	A do-notation block
Ado (Maybe ModuleName) [DoNotationElement] Expr	An ado-notation block
TypeClassDictionaryConstructorApp (Qualified (ProperName ClassName)) Expr	An application of a typeclass dictionary constructor. The value should be an ObjectLiteral.
TypeClassDictionary SourceConstraint (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))) [ErrorMessageHint]	A placeholder for a type class dictionary to be inserted later. At the end of type checking, these placeholders will be replaced with actual expressions representing type classes dictionaries which can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look at superclass implementations when searching for a dictionary, the type class name and instance type, and the type class dictionaries in scope.
TypeClassDictionaryAccessor (Qualified (ProperName ClassName)) Ident	A typeclass dictionary accessor, the implementation is left unspecified until CoreFn desugaring.
DeferredDictionary (Qualified (ProperName ClassName)) [SourceType]	A placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typechecking
AnonymousArgument	A placeholder for an anonymous function argument
Hole Text	A typed hole that will be turned into a hint/error during typechecking
PositionedValue SourceSpan [Comment] Expr	A value with source position information

Instances

Show Expr Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> Expr -> ShowS # show :: Expr -> String # showList :: [Expr] -> ShowS #

data GuardedExpr Source #

The right hand side of a binder in value declarations and case expressions.

Constructors

GuardedExpr [Guard] Expr

Instances

Show GuardedExpr Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> GuardedExpr -> ShowS # show :: GuardedExpr -> String # showList :: [GuardedExpr] -> ShowS #

data Guard Source #

A guard is just a boolean-valued expression that appears alongside a set of binders

Constructors

ConditionGuard Expr
PatternGuard Binder Expr

Instances

Show Guard Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #

data TypeInstanceBody Source #

The members of a type class instance declaration

Constructors

DerivedInstance	This is a derived instance
NewtypeInstance	This is an instance derived from a newtype
NewtypeInstanceWithDictionary Expr	This is an instance derived from a newtype, desugared to include a dictionary for the type under the newtype.
ExplicitInstance [Declaration]	This is a regular (explicit) instance

Instances

Show TypeInstanceBody Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> TypeInstanceBody -> ShowS # show :: TypeInstanceBody -> String # showList :: [TypeInstanceBody] -> ShowS #

data TypeFixity Source #

Constructors

TypeFixity Fixity (Qualified (ProperName TypeName)) (OpName TypeOpName)

Instances

Eq TypeFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: TypeFixity -> TypeFixity -> Bool # (/=) :: TypeFixity -> TypeFixity -> Bool #
Ord TypeFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: TypeFixity -> TypeFixity -> Ordering # (<) :: TypeFixity -> TypeFixity -> Bool # (<=) :: TypeFixity -> TypeFixity -> Bool # (>) :: TypeFixity -> TypeFixity -> Bool # (>=) :: TypeFixity -> TypeFixity -> Bool # max :: TypeFixity -> TypeFixity -> TypeFixity # min :: TypeFixity -> TypeFixity -> TypeFixity #
Show TypeFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> TypeFixity -> ShowS # show :: TypeFixity -> String # showList :: [TypeFixity] -> ShowS #

data ValueFixity Source #

Constructors

ValueFixity Fixity (Qualified (Either Ident (ProperName ConstructorName))) (OpName ValueOpName)

Instances

Eq ValueFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: ValueFixity -> ValueFixity -> Bool # (/=) :: ValueFixity -> ValueFixity -> Bool #
Ord ValueFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: ValueFixity -> ValueFixity -> Ordering # (<) :: ValueFixity -> ValueFixity -> Bool # (<=) :: ValueFixity -> ValueFixity -> Bool # (>) :: ValueFixity -> ValueFixity -> Bool # (>=) :: ValueFixity -> ValueFixity -> Bool # max :: ValueFixity -> ValueFixity -> ValueFixity # min :: ValueFixity -> ValueFixity -> ValueFixity #
Show ValueFixity Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ValueFixity -> ShowS # show :: ValueFixity -> String # showList :: [ValueFixity] -> ShowS #

data Declaration Source #

The data type of declarations

Constructors

DataDeclaration SourceAnn DataDeclType (ProperName TypeName) [(Text, Maybe SourceKind)] [(ProperName ConstructorName, [(Ident, SourceType)])]	A data type declaration (data or newtype, name, arguments, data constructors)
DataBindingGroupDeclaration (NonEmpty Declaration)	A minimal mutually recursive set of data type declarations
TypeSynonymDeclaration SourceAnn (ProperName TypeName) [(Text, Maybe SourceKind)] SourceType	A type synonym declaration (name, arguments, type)
TypeDeclaration !TypeDeclarationData	A type declaration for a value (name, ty)
ValueDeclaration !(ValueDeclarationData [GuardedExpr])	A value declaration (name, top-level binders, optional guard, value)
BoundValueDeclaration SourceAnn Binder Expr	A declaration paired with pattern matching in let-in expression (binder, optional guard, value)
BindingGroupDeclaration (NonEmpty ((SourceAnn, Ident), NameKind, Expr))	A minimal mutually recursive set of value declarations
ExternDeclaration SourceAnn Ident SourceType	A foreign import declaration (name, type)
ExternDataDeclaration SourceAnn (ProperName TypeName) SourceKind	A data type foreign import (name, kind)
ExternKindDeclaration SourceAnn (ProperName KindName)	A foreign kind import (name)
FixityDeclaration SourceAnn (Either ValueFixity TypeFixity)	A fixity declaration
ImportDeclaration SourceAnn ModuleName ImportDeclarationType (Maybe ModuleName)	A module import (module name, qualifiedunqualifiedhiding, optional "qualified as" name)
TypeClassDeclaration SourceAnn (ProperName ClassName) [(Text, Maybe SourceKind)] [SourceConstraint] [FunctionalDependency] [Declaration]	A type class declaration (name, argument, implies, member declarations)
TypeInstanceDeclaration SourceAnn [Ident] Integer Ident [SourceConstraint] (Qualified (ProperName ClassName)) [SourceType] TypeInstanceBody	A type instance declaration (instance chain, chain index, name, dependencies, class name, instance types, member declarations)

Instances

Show Declaration Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> Declaration -> ShowS # show :: Declaration -> String # showList :: [Declaration] -> ShowS #

data ValueDeclarationData a Source #

A value declaration assigns a name and potential binders, to an expression (or multiple guarded expressions).

double x = x + x

In this example double is the identifier, x is a binder and x + x is the expression.

Constructors

ValueDeclarationData
Fields valdeclSourceAnn :: !SourceAnn valdeclIdent :: !Ident The declared value's name valdeclName :: !NameKind Whether or not this value is exported/visible valdeclBinders :: ![Binder] valdeclExpression :: !a

Instances

Functor ValueDeclarationData Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fmap :: (a -> b) -> ValueDeclarationData a -> ValueDeclarationData b # (<$) :: a -> ValueDeclarationData b -> ValueDeclarationData a #
Foldable ValueDeclarationData Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods fold :: Monoid m => ValueDeclarationData m -> m # foldMap :: Monoid m => (a -> m) -> ValueDeclarationData a -> m # foldr :: (a -> b -> b) -> b -> ValueDeclarationData a -> b # foldr' :: (a -> b -> b) -> b -> ValueDeclarationData a -> b # foldl :: (b -> a -> b) -> b -> ValueDeclarationData a -> b # foldl' :: (b -> a -> b) -> b -> ValueDeclarationData a -> b # foldr1 :: (a -> a -> a) -> ValueDeclarationData a -> a # foldl1 :: (a -> a -> a) -> ValueDeclarationData a -> a # toList :: ValueDeclarationData a -> [a] # null :: ValueDeclarationData a -> Bool # length :: ValueDeclarationData a -> Int # elem :: Eq a => a -> ValueDeclarationData a -> Bool # maximum :: Ord a => ValueDeclarationData a -> a # minimum :: Ord a => ValueDeclarationData a -> a # sum :: Num a => ValueDeclarationData a -> a # product :: Num a => ValueDeclarationData a -> a #
Traversable ValueDeclarationData Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods traverse :: Applicative f => (a -> f b) -> ValueDeclarationData a -> f (ValueDeclarationData b) # sequenceA :: Applicative f => ValueDeclarationData (f a) -> f (ValueDeclarationData a) # mapM :: Monad m => (a -> m b) -> ValueDeclarationData a -> m (ValueDeclarationData b) # sequence :: Monad m => ValueDeclarationData (m a) -> m (ValueDeclarationData a) #
Show a => Show (ValueDeclarationData a) Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ValueDeclarationData a -> ShowS # show :: ValueDeclarationData a -> String # showList :: [ValueDeclarationData a] -> ShowS #

data TypeDeclarationData Source #

A type declaration assigns a type to an identifier, eg:

identity :: forall a. a -> a

In this example identity is the identifier and forall a. a -> a the type.

Constructors

TypeDeclarationData
Fields tydeclSourceAnn :: !SourceAnn tydeclIdent :: !Ident tydeclType :: !SourceType

Instances

Eq TypeDeclarationData Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: TypeDeclarationData -> TypeDeclarationData -> Bool # (/=) :: TypeDeclarationData -> TypeDeclarationData -> Bool #
Show TypeDeclarationData Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> TypeDeclarationData -> ShowS # show :: TypeDeclarationData -> String # showList :: [TypeDeclarationData] -> ShowS #

data ImportDeclarationType Source #

The data type which specifies type of import declaration

Constructors

Implicit	An import with no explicit list: `import M`.
Explicit [DeclarationRef]	An import with an explicit list of references to import: `import M (foo)`
Hiding [DeclarationRef]	An import with a list of references to hide: `import M hiding (foo)`

Instances

Eq ImportDeclarationType Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: ImportDeclarationType -> ImportDeclarationType -> Bool # (/=) :: ImportDeclarationType -> ImportDeclarationType -> Bool #
Show ImportDeclarationType Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ImportDeclarationType -> ShowS # show :: ImportDeclarationType -> String # showList :: [ImportDeclarationType] -> ShowS #
ToJSON ImportDeclarationType Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods toJSON :: ImportDeclarationType -> Value # toEncoding :: ImportDeclarationType -> Encoding # toJSONList :: [ImportDeclarationType] -> Value # toEncodingList :: [ImportDeclarationType] -> Encoding #
FromJSON ImportDeclarationType Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods parseJSON :: Value -> Parser ImportDeclarationType # parseJSONList :: Value -> Parser [ImportDeclarationType] #

data ExportSource Source #

Constructors

ExportSource
Fields exportSourceImportedFrom :: Maybe ModuleName exportSourceDefinedIn :: ModuleName

Instances

Eq ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: ExportSource -> ExportSource -> Bool # (/=) :: ExportSource -> ExportSource -> Bool #
Ord ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods compare :: ExportSource -> ExportSource -> Ordering # (<) :: ExportSource -> ExportSource -> Bool # (<=) :: ExportSource -> ExportSource -> Bool # (>) :: ExportSource -> ExportSource -> Bool # (>=) :: ExportSource -> ExportSource -> Bool # max :: ExportSource -> ExportSource -> ExportSource # min :: ExportSource -> ExportSource -> ExportSource #
Show ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ExportSource -> ShowS # show :: ExportSource -> String # showList :: [ExportSource] -> ShowS #
Generic ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Associated Types type Rep ExportSource :: Type -> Type # Methods from :: ExportSource -> Rep ExportSource x # to :: Rep ExportSource x -> ExportSource #
NFData ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods rnf :: ExportSource -> () #
ToJSON ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods toJSON :: ExportSource -> Value # toEncoding :: ExportSource -> Encoding # toJSONList :: [ExportSource] -> Value # toEncodingList :: [ExportSource] -> Encoding #
FromJSON ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods parseJSON :: Value -> Parser ExportSource # parseJSONList :: Value -> Parser [ExportSource] #
type Rep ExportSource Source #
Instance details Defined in Language.PureScript.AST.Declarations type Rep ExportSource = D1 (MetaData "ExportSource" "Language.PureScript.AST.Declarations" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (C1 (MetaCons "ExportSource" PrefixI True) (S1 (MetaSel (Just "exportSourceImportedFrom") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ModuleName)) :*: S1 (MetaSel (Just "exportSourceDefinedIn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModuleName)))

data DeclarationRef Source #

An item in a list of explicit imports or exports

Constructors

TypeRef SourceSpan (ProperName TypeName) (Maybe [ProperName ConstructorName])	A type constructor with data constructors
TypeOpRef SourceSpan (OpName TypeOpName)	A type operator
ValueRef SourceSpan Ident	A value
ValueOpRef SourceSpan (OpName ValueOpName)	A value-level operator
TypeClassRef SourceSpan (ProperName ClassName)	A type class
TypeInstanceRef SourceSpan Ident	A type class instance, created during typeclass desugaring (name, class name, instance types)
ModuleRef SourceSpan ModuleName	A module, in its entirety
KindRef SourceSpan (ProperName KindName)	A named kind
ReExportRef SourceSpan ExportSource DeclarationRef	A value re-exported from another module. These will be inserted during elaboration in name desugaring.

Instances

Eq DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: DeclarationRef -> DeclarationRef -> Bool # (/=) :: DeclarationRef -> DeclarationRef -> Bool #
Show DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> DeclarationRef -> ShowS # show :: DeclarationRef -> String # showList :: [DeclarationRef] -> ShowS #
Generic DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Associated Types type Rep DeclarationRef :: Type -> Type # Methods from :: DeclarationRef -> Rep DeclarationRef x # to :: Rep DeclarationRef x -> DeclarationRef #
NFData DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods rnf :: DeclarationRef -> () #
ToJSON DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods toJSON :: DeclarationRef -> Value # toEncoding :: DeclarationRef -> Encoding # toJSONList :: [DeclarationRef] -> Value # toEncodingList :: [DeclarationRef] -> Encoding #
FromJSON DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods parseJSON :: Value -> Parser DeclarationRef # parseJSONList :: Value -> Parser [DeclarationRef] #
type Rep DeclarationRef Source #
Instance details Defined in Language.PureScript.AST.Declarations type Rep DeclarationRef = D1 (MetaData "DeclarationRef" "Language.PureScript.AST.Declarations" "purescript-0.13.0-1whdl2565Nb1wvlLK7uK18" False) (((C1 (MetaCons "TypeRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName TypeName)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [ProperName ConstructorName])))) :+: C1 (MetaCons "TypeOpRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (OpName TypeOpName)))) :+: (C1 (MetaCons "ValueRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) :+: C1 (MetaCons "ValueOpRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (OpName ValueOpName))))) :+: ((C1 (MetaCons "TypeClassRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName ClassName))) :+: C1 (MetaCons "TypeInstanceRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident))) :+: (C1 (MetaCons "ModuleRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ModuleName)) :+: (C1 (MetaCons "KindRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ProperName KindName))) :+: C1 (MetaCons "ReExportRef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SourceSpan) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ExportSource) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DeclarationRef)))))))

data Module Source #

A module declaration, consisting of comments about the module, a module name, a list of declarations, and a list of the declarations that are explicitly exported. If the export list is Nothing, everything is exported.

Constructors

Module SourceSpan [Comment] ModuleName [Declaration] (Maybe [DeclarationRef])

Instances

Show Module Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #

data ErrorMessage Source #

Constructors

ErrorMessage [ErrorMessageHint] SimpleErrorMessage

Instances

Show ErrorMessage Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ErrorMessage -> ShowS # show :: ErrorMessage -> String # showList :: [ErrorMessage] -> ShowS #

data HintCategory Source #

Categories of hints

Constructors

ExprHint
KindHint
CheckHint
PositionHint
SolverHint
OtherHint

Instances

Eq HintCategory Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods (==) :: HintCategory -> HintCategory -> Bool # (/=) :: HintCategory -> HintCategory -> Bool #
Show HintCategory Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> HintCategory -> ShowS # show :: HintCategory -> String # showList :: [HintCategory] -> ShowS #

data ErrorMessageHint Source #

Error message hints, providing more detailed information about failure.

Constructors

ErrorUnifyingTypes SourceType SourceType
ErrorInExpression Expr
ErrorInModule ModuleName
ErrorInInstance (Qualified (ProperName ClassName)) [SourceType]
ErrorInSubsumption SourceType SourceType
ErrorCheckingAccessor Expr PSString
ErrorCheckingType Expr SourceType
ErrorCheckingKind SourceType
ErrorCheckingGuard
ErrorInferringType Expr
ErrorInApplication Expr SourceType Expr
ErrorInDataConstructor (ProperName ConstructorName)
ErrorInTypeConstructor (ProperName TypeName)
ErrorInBindingGroup (NonEmpty Ident)
ErrorInDataBindingGroup [ProperName TypeName]
ErrorInTypeSynonym (ProperName TypeName)
ErrorInValueDeclaration Ident
ErrorInTypeDeclaration Ident
ErrorInTypeClassDeclaration (ProperName ClassName)
ErrorInForeignImport Ident
ErrorSolvingConstraint SourceConstraint
PositionedError (NonEmpty SourceSpan)

Instances

Show ErrorMessageHint Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> ErrorMessageHint -> ShowS # show :: ErrorMessageHint -> String # showList :: [ErrorMessageHint] -> ShowS #

data SimpleErrorMessage Source #

A type of error messages

Constructors

ModuleNotFound ModuleName
ErrorParsingFFIModule FilePath (Maybe ErrorMessage)
ErrorParsingModule ParseError
ErrorParsingCSTModule ParserError
MissingFFIModule ModuleName
UnnecessaryFFIModule ModuleName FilePath
MissingFFIImplementations ModuleName [Ident]
UnusedFFIImplementations ModuleName [Ident]
InvalidFFIIdentifier ModuleName Text
CannotGetFileInfo FilePath
CannotReadFile FilePath
CannotWriteFile FilePath
InfiniteType SourceType
InfiniteKind SourceKind
MultipleValueOpFixities (OpName ValueOpName)
MultipleTypeOpFixities (OpName TypeOpName)
OrphanTypeDeclaration Ident
RedefinedIdent Ident
OverlappingNamesInLet
UnknownName (Qualified Name)
UnknownImport ModuleName Name
UnknownImportDataConstructor ModuleName (ProperName TypeName) (ProperName ConstructorName)
UnknownExport Name
UnknownExportDataConstructor (ProperName TypeName) (ProperName ConstructorName)
ScopeConflict Name [ModuleName]
ScopeShadowing Name (Maybe ModuleName) [ModuleName]
DeclConflict Name Name
ExportConflict (Qualified Name) (Qualified Name)
DuplicateModule ModuleName
DuplicateTypeClass (ProperName ClassName) SourceSpan
DuplicateInstance Ident SourceSpan
DuplicateTypeArgument Text
InvalidDoBind
InvalidDoLet
CycleInDeclaration Ident
CycleInTypeSynonym (Maybe (ProperName TypeName))
CycleInTypeClassDeclaration [Qualified (ProperName ClassName)]
CycleInModules [ModuleName]
NameIsUndefined Ident
UndefinedTypeVariable (ProperName TypeName)
PartiallyAppliedSynonym (Qualified (ProperName TypeName))
EscapedSkolem Text (Maybe SourceSpan) SourceType
TypesDoNotUnify SourceType SourceType
KindsDoNotUnify SourceKind SourceKind
ConstrainedTypeUnified SourceType SourceType
OverlappingInstances (Qualified (ProperName ClassName)) [SourceType] [Qualified Ident]
NoInstanceFound SourceConstraint
AmbiguousTypeVariables SourceType SourceConstraint
UnknownClass (Qualified (ProperName ClassName))
PossiblyInfiniteInstance (Qualified (ProperName ClassName)) [SourceType]
CannotDerive (Qualified (ProperName ClassName)) [SourceType]
InvalidDerivedInstance (Qualified (ProperName ClassName)) [SourceType] Int
ExpectedTypeConstructor (Qualified (ProperName ClassName)) [SourceType] SourceType
InvalidNewtypeInstance (Qualified (ProperName ClassName)) [SourceType]
MissingNewtypeSuperclassInstance (Qualified (ProperName ClassName)) (Qualified (ProperName ClassName)) [SourceType]
UnverifiableSuperclassInstance (Qualified (ProperName ClassName)) (Qualified (ProperName ClassName)) [SourceType]
CannotFindDerivingType (ProperName TypeName)
DuplicateLabel Label (Maybe Expr)
DuplicateValueDeclaration Ident
ArgListLengthsDiffer Ident
OverlappingArgNames (Maybe Ident)
MissingClassMember (NonEmpty (Ident, SourceType))
ExtraneousClassMember Ident (Qualified (ProperName ClassName))
ExpectedType SourceType SourceKind
IncorrectConstructorArity (Qualified (ProperName ConstructorName)) Int Int	constructor name, expected argument count, actual argument count
ExprDoesNotHaveType Expr SourceType
PropertyIsMissing Label
AdditionalProperty Label
TypeSynonymInstance
OrphanInstance Ident (Qualified (ProperName ClassName)) (Set ModuleName) [SourceType]
InvalidNewtype (ProperName TypeName)
InvalidInstanceHead SourceType
TransitiveExportError DeclarationRef [DeclarationRef]
TransitiveDctorExportError DeclarationRef (ProperName ConstructorName)
ShadowedName Ident
ShadowedTypeVar Text
UnusedTypeVar Text
WildcardInferredType SourceType Context
HoleInferredType Text SourceType Context (Maybe TypeSearch)
MissingTypeDeclaration Ident SourceType
OverlappingPattern [[Binder]] Bool
IncompleteExhaustivityCheck
MisleadingEmptyTypeImport ModuleName (ProperName TypeName)
ImportHidingModule ModuleName
UnusedImport ModuleName
UnusedExplicitImport ModuleName [Name] (Maybe ModuleName) [DeclarationRef]
UnusedDctorImport ModuleName (ProperName TypeName) (Maybe ModuleName) [DeclarationRef]
UnusedDctorExplicitImport ModuleName (ProperName TypeName) [ProperName ConstructorName] (Maybe ModuleName) [DeclarationRef]
DuplicateSelectiveImport ModuleName
DuplicateImport ModuleName ImportDeclarationType (Maybe ModuleName)
DuplicateImportRef Name
DuplicateExportRef Name
IntOutOfRange Integer Text Integer Integer
ImplicitQualifiedImport ModuleName ModuleName [DeclarationRef]
ImplicitQualifiedImportReExport ModuleName ModuleName [DeclarationRef]
ImplicitImport ModuleName [DeclarationRef]
HidingImport ModuleName [DeclarationRef]
CaseBinderLengthDiffers Int [Binder]
IncorrectAnonymousArgument
InvalidOperatorInBinder (Qualified (OpName ValueOpName)) (Qualified Ident)
CannotGeneralizeRecursiveFunction Ident SourceType
CannotDeriveNewtypeForData (ProperName TypeName)
ExpectedWildcard (ProperName TypeName)
CannotUseBindWithDo Ident
ClassInstanceArityMismatch Ident (Qualified (ProperName ClassName)) Int Int	instance name, type class, expected argument count, actual argument count
UserDefinedWarning SourceType	a user-defined warning raised by using the Warn type class
UnusableDeclaration Ident [[Text]]	a declaration couldn't be used because it contained free variables
CannotDefinePrimModules ModuleName
MixedAssociativityError (NonEmpty (Qualified (OpName AnyOpName), Associativity))
NonAssociativeError (NonEmpty (Qualified (OpName AnyOpName)))

Instances

Show SimpleErrorMessage Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> SimpleErrorMessage -> ShowS # show :: SimpleErrorMessage -> String # showList :: [SimpleErrorMessage] -> ShowS #

data TypeSearch Source #

Holds the data necessary to do type directed search for typed holes

Constructors

TSBefore Environment	An Environment captured for later consumption by type directed search
TSAfter	Results of applying type directed search to the previously captured Environment
Fields tsAfterIdentifiers :: [(Qualified Text, SourceType)] The identifiers that fully satisfy the subsumption check tsAfterRecordFields :: Maybe [(Label, SourceType)] Record fields that are available on the first argument to the typed hole

Instances

Show TypeSearch Source #
Instance details Defined in Language.PureScript.AST.Declarations Methods showsPrec :: Int -> TypeSearch -> ShowS # show :: TypeSearch -> String # showList :: [TypeSearch] -> ShowS #

type Context = [(Ident, SourceType)] Source #

A map of locally-bound names in scope.

pattern MkUnguarded :: Expr -> GuardedExpr Source #

pattern TypeFixityDeclaration :: SourceAnn -> Fixity -> Qualified (ProperName TypeName) -> OpName TypeOpName -> Declaration Source #

pattern ValueFixityDeclaration :: SourceAnn -> Fixity -> Qualified (Either Ident (ProperName ConstructorName)) -> OpName ValueOpName -> Declaration Source #

pattern ValueDecl :: SourceAnn -> Ident -> NameKind -> [Binder] -> [GuardedExpr] -> Declaration Source #

onTypeSearchTypes :: (SourceType -> SourceType) -> TypeSearch -> TypeSearch Source #

onTypeSearchTypesM :: Applicative m => (SourceType -> m SourceType) -> TypeSearch -> m TypeSearch Source #

getModuleName :: Module -> ModuleName Source #

Return a module's name.

getModuleSourceSpan :: Module -> SourceSpan Source #

Return a module's source span.

getModuleDeclarations :: Module -> [Declaration] Source #

Return a module's declarations.

addDefaultImport :: Qualified ModuleName -> Module -> Module Source #

Add an import declaration for a module if it does not already explicitly import it.

Will not import an unqualified module if that module has already been imported qualified. (See #2197)

importPrim :: Module -> Module Source #

Adds import declarations to a module for an implicit Prim import and Prim | qualified as Prim, as necessary.

compDecRef :: DeclarationRef -> DeclarationRef -> Ordering Source #

declRefSourceSpan :: DeclarationRef -> SourceSpan Source #

declRefName :: DeclarationRef -> Name Source #

getTypeRef :: DeclarationRef -> Maybe (ProperName TypeName, Maybe [ProperName ConstructorName]) Source #

getTypeOpRef :: DeclarationRef -> Maybe (OpName TypeOpName) Source #

getValueRef :: DeclarationRef -> Maybe Ident Source #

getValueOpRef :: DeclarationRef -> Maybe (OpName ValueOpName) Source #

getTypeClassRef :: DeclarationRef -> Maybe (ProperName ClassName) Source #

getKindRef :: DeclarationRef -> Maybe (ProperName KindName) Source #

isModuleRef :: DeclarationRef -> Bool Source #

isImplicit :: ImportDeclarationType -> Bool Source #

isExplicit :: ImportDeclarationType -> Bool Source #

overTypeDeclaration :: (TypeDeclarationData -> TypeDeclarationData) -> Declaration -> Declaration Source #

getTypeDeclaration :: Declaration -> Maybe TypeDeclarationData Source #

unwrapTypeDeclaration :: TypeDeclarationData -> (Ident, SourceType) Source #

overValueDeclaration :: (ValueDeclarationData [GuardedExpr] -> ValueDeclarationData [GuardedExpr]) -> Declaration -> Declaration Source #

getValueDeclaration :: Declaration -> Maybe (ValueDeclarationData [GuardedExpr]) Source #

mapTypeInstanceBody :: ([Declaration] -> [Declaration]) -> TypeInstanceBody -> TypeInstanceBody Source #

traverseTypeInstanceBody :: Applicative f => ([Declaration] -> f [Declaration]) -> TypeInstanceBody -> f TypeInstanceBody Source #

A traversal for TypeInstanceBody

declSourceAnn :: Declaration -> SourceAnn Source #

declSourceSpan :: Declaration -> SourceSpan Source #

declName :: Declaration -> Maybe Name Source #

isValueDecl :: Declaration -> Bool Source #

Test if a declaration is a value declaration

isDataDecl :: Declaration -> Bool Source #

Test if a declaration is a data type or type synonym declaration

isImportDecl :: Declaration -> Bool Source #

Test if a declaration is a module import

isExternDataDecl :: Declaration -> Bool Source #

Test if a declaration is a data type foreign import

isExternKindDecl :: Declaration -> Bool Source #

Test if a declaration is a foreign kind import

isFixityDecl :: Declaration -> Bool Source #

Test if a declaration is a fixity declaration

getFixityDecl :: Declaration -> Maybe (Either ValueFixity TypeFixity) Source #

isExternDecl :: Declaration -> Bool Source #

Test if a declaration is a foreign import

isTypeClassInstanceDeclaration :: Declaration -> Bool Source #

Test if a declaration is a type class instance declaration

isTypeClassDeclaration :: Declaration -> Bool Source #

Test if a declaration is a type class declaration

flattenDecls :: [Declaration] -> [Declaration] Source #

Recursively flatten data binding groups in the list of declarations

isTrueExpr :: Expr -> Bool Source #

data ScopedIdent Source #

Constructors

LocalIdent Ident
ToplevelIdent Ident

Instances

Eq ScopedIdent Source #
Instance details Defined in Language.PureScript.AST.Traversals Methods (==) :: ScopedIdent -> ScopedIdent -> Bool # (/=) :: ScopedIdent -> ScopedIdent -> Bool #
Ord ScopedIdent Source #
Instance details Defined in Language.PureScript.AST.Traversals Methods compare :: ScopedIdent -> ScopedIdent -> Ordering # (<) :: ScopedIdent -> ScopedIdent -> Bool # (<=) :: ScopedIdent -> ScopedIdent -> Bool # (>) :: ScopedIdent -> ScopedIdent -> Bool # (>=) :: ScopedIdent -> ScopedIdent -> Bool # max :: ScopedIdent -> ScopedIdent -> ScopedIdent # min :: ScopedIdent -> ScopedIdent -> ScopedIdent #
Show ScopedIdent Source #
Instance details Defined in Language.PureScript.AST.Traversals Methods showsPrec :: Int -> ScopedIdent -> ShowS # show :: ScopedIdent -> String # showList :: [ScopedIdent] -> ShowS #

guardedExprM :: Applicative m => (Guard -> m Guard) -> (Expr -> m Expr) -> GuardedExpr -> m GuardedExpr Source #

mapGuardedExpr :: (Guard -> Guard) -> (Expr -> Expr) -> GuardedExpr -> GuardedExpr Source #

litM :: Monad m => (a -> m a) -> Literal a -> m (Literal a) Source #

everywhereOnValues :: (Declaration -> Declaration) -> (Expr -> Expr) -> (Binder -> Binder) -> (Declaration -> Declaration, Expr -> Expr, Binder -> Binder) Source #

everywhereOnValuesTopDownM :: forall m. Monad m => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder) Source #

everywhereOnValuesM :: forall m. Monad m => (Declaration -> m Declaration) -> (Expr -> m Expr) -> (Binder -> m Binder) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder) Source #

everythingOnValues :: forall r. (r -> r -> r) -> (Declaration -> r) -> (Expr -> r) -> (Binder -> r) -> (CaseAlternative -> r) -> (DoNotationElement -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r) Source #

everythingWithContextOnValues :: forall s r. s -> r -> (r -> r -> r) -> (s -> Declaration -> (s, r)) -> (s -> Expr -> (s, r)) -> (s -> Binder -> (s, r)) -> (s -> CaseAlternative -> (s, r)) -> (s -> DoNotationElement -> (s, r)) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r) Source #

everywhereWithContextOnValuesM :: forall m s. Monad m => s -> (s -> Declaration -> m (s, Declaration)) -> (s -> Expr -> m (s, Expr)) -> (s -> Binder -> m (s, Binder)) -> (s -> CaseAlternative -> m (s, CaseAlternative)) -> (s -> DoNotationElement -> m (s, DoNotationElement)) -> (Declaration -> m Declaration, Expr -> m Expr, Binder -> m Binder, CaseAlternative -> m CaseAlternative, DoNotationElement -> m DoNotationElement) Source #

inScope :: Ident -> Set ScopedIdent -> Bool Source #

everythingWithScope :: forall r. Monoid r => (Set ScopedIdent -> Declaration -> r) -> (Set ScopedIdent -> Expr -> r) -> (Set ScopedIdent -> Binder -> r) -> (Set ScopedIdent -> CaseAlternative -> r) -> (Set ScopedIdent -> DoNotationElement -> r) -> (Set ScopedIdent -> Declaration -> r, Set ScopedIdent -> Expr -> r, Set ScopedIdent -> Binder -> r, Set ScopedIdent -> CaseAlternative -> r, Set ScopedIdent -> DoNotationElement -> r) Source #

accumTypes :: Monoid r => (SourceType -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r) Source #

accumKinds :: Monoid r => (SourceKind -> r) -> (Declaration -> r, Expr -> r, Binder -> r, CaseAlternative -> r, DoNotationElement -> r) Source #

overTypes :: (SourceType -> SourceType) -> Expr -> Expr Source #

Map a function over type annotations appearing inside a value

exportedDeclarations :: Module -> [Declaration] Source #

Return a list of all declarations which are exported from a module. This function descends into data declarations to filter out unexported data constructors, and also filters out type instance declarations if they refer to classes or types which are not themselves exported.

Note that this function assumes that the module has already had its imports desugared using desugarImports. It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.

The returned declarations are in the same order as they appear in the export list, unless there is no export list, in which case they appear in the same order as they do in the source file.

isExported :: Maybe [DeclarationRef] -> Declaration -> Bool Source #

Test if a declaration is exported, given a module's export list. Note that this function does not account for type instance declarations of non-exported types, or non-exported data constructors. Therefore, you should prefer exportedDeclarations to this function, where possible.

desugarLetPatternModule :: Module -> Module Source #

Replace every BoundValueDeclaration in Let expressions with Case expressions.

prettyPrintKind :: Kind a -> Text Source #

Generate a pretty-printed string representing a Kind

type PrettyPrintConstraint = (Qualified (ProperName ClassName), [PrettyPrintType]) Source #

convertPrettyPrintType :: Int -> Type a -> PrettyPrintType Source #

typeAtomAsBox :: Int -> Type a -> Box Source #

prettyPrintTypeAtom :: Int -> Type a -> String Source #

Generate a pretty-printed string representing a Type, as it should appear inside parentheses

typeAsBox :: Int -> Type a -> Box Source #

prettyPrintType :: Int -> Type a -> String Source #

Generate a pretty-printed string representing a Type

prettyPrintTypeWithUnicode :: Int -> Type a -> String Source #

Generate a pretty-printed string representing a Type using unicode symbols where applicable

Generate a pretty-printed string representing a suggested Type

prettyPrintLabel :: Label -> Text Source #

prettyPrintObjectKey :: PSString -> Text Source #

prettyPrintValue :: Int -> Expr -> Box Source #

Pretty-print an expression

prettyPrintBinderAtom :: Binder -> Text Source #

prettyPrintBinder :: Binder -> Text Source #

Generate a pretty-printed string representing a Binder

data ExternsDeclaration Source #

A type or value declaration appearing in an externs file

Constructors

EDType	A type declaration
Fields edTypeName :: ProperName TypeName edTypeKind :: SourceKind edTypeDeclarationKind :: TypeKind
EDTypeSynonym	A type synonym
Fields edTypeSynonymName :: ProperName TypeName edTypeSynonymArguments :: [(Text, Maybe SourceKind)] edTypeSynonymType :: SourceType
EDDataConstructor	A data construtor
Fields edDataCtorName :: ProperName ConstructorName edDataCtorOrigin :: DataDeclType edDataCtorTypeCtor :: ProperName TypeName edDataCtorType :: SourceType edDataCtorFields :: [Ident]
EDValue	A value declaration
Fields edValueName :: Ident edValueType :: SourceType
EDClass	A type class declaration
Fields edClassName :: ProperName ClassName edClassTypeArguments :: [(Text, Maybe SourceKind)] edClassMembers :: [(Ident, SourceType)] edClassConstraints :: [SourceConstraint] edFunctionalDependencies :: [FunctionalDependency]
EDInstance	An instance declaration
Fields edInstanceClassName :: Qualified (ProperName ClassName) edInstanceName :: Ident edInstanceTypes :: [SourceType] edInstanceConstraints :: Maybe [SourceConstraint] edInstanceChain :: [Qualified Ident] edInstanceChainIndex :: Integer
EDKind	A kind declaration
Fields edKindName :: ProperName KindName

Instances

Show ExternsDeclaration Source #
Instance details Defined in Language.PureScript.Externs Methods showsPrec :: Int -> ExternsDeclaration -> ShowS # show :: ExternsDeclaration -> String # showList :: [ExternsDeclaration] -> ShowS #
ToJSON ExternsDeclaration Source #
Instance details Defined in Language.PureScript.Externs Methods toJSON :: ExternsDeclaration -> Value # toEncoding :: ExternsDeclaration -> Encoding # toJSONList :: [ExternsDeclaration] -> Value # toEncodingList :: [ExternsDeclaration] -> Encoding #
FromJSON ExternsDeclaration Source #
Instance details Defined in Language.PureScript.Externs Methods parseJSON :: Value -> Parser ExternsDeclaration # parseJSONList :: Value -> Parser [ExternsDeclaration] #

data ExternsTypeFixity Source #

A type fixity declaration in an externs file

Constructors

ExternsTypeFixity
Fields efTypeAssociativity :: Associativity The associativity of the operator efTypePrecedence :: Precedence The precedence level of the operator efTypeOperator :: OpName TypeOpName The operator symbol efTypeAlias :: Qualified (ProperName TypeName) The value the operator is an alias for

Instances

Show ExternsTypeFixity Source #
Instance details Defined in Language.PureScript.Externs Methods showsPrec :: Int -> ExternsTypeFixity -> ShowS # show :: ExternsTypeFixity -> String # showList :: [ExternsTypeFixity] -> ShowS #
ToJSON ExternsTypeFixity Source #
Instance details Defined in Language.PureScript.Externs Methods toJSON :: ExternsTypeFixity -> Value # toEncoding :: ExternsTypeFixity -> Encoding # toJSONList :: [ExternsTypeFixity] -> Value # toEncodingList :: [ExternsTypeFixity] -> Encoding #
FromJSON ExternsTypeFixity Source #
Instance details Defined in Language.PureScript.Externs Methods parseJSON :: Value -> Parser ExternsTypeFixity # parseJSONList :: Value -> Parser [ExternsTypeFixity] #

data ExternsFixity Source #

A fixity declaration in an externs file

Constructors

ExternsFixity
Fields efAssociativity :: Associativity The associativity of the operator efPrecedence :: Precedence The precedence level of the operator efOperator :: OpName ValueOpName The operator symbol efAlias :: Qualified (Either Ident (ProperName ConstructorName)) The value the operator is an alias for

Instances

Show ExternsFixity Source #
Instance details Defined in Language.PureScript.Externs Methods showsPrec :: Int -> ExternsFixity -> ShowS # show :: ExternsFixity -> String # showList :: [ExternsFixity] -> ShowS #
ToJSON ExternsFixity Source #
Instance details Defined in Language.PureScript.Externs Methods toJSON :: ExternsFixity -> Value # toEncoding :: ExternsFixity -> Encoding # toJSONList :: [ExternsFixity] -> Value # toEncodingList :: [ExternsFixity] -> Encoding #
FromJSON ExternsFixity Source #
Instance details Defined in Language.PureScript.Externs Methods parseJSON :: Value -> Parser ExternsFixity # parseJSONList :: Value -> Parser [ExternsFixity] #

data ExternsImport Source #

A module import in an externs file

Constructors

ExternsImport
Fields eiModule :: ModuleName The imported module eiImportType :: ImportDeclarationType The import type: regular, qualified or hiding eiImportedAs :: Maybe ModuleName The imported-as name, for qualified imports

Instances

Show ExternsImport Source #
Instance details Defined in Language.PureScript.Externs Methods showsPrec :: Int -> ExternsImport -> ShowS # show :: ExternsImport -> String # showList :: [ExternsImport] -> ShowS #
ToJSON ExternsImport Source #
Instance details Defined in Language.PureScript.Externs Methods toJSON :: ExternsImport -> Value # toEncoding :: ExternsImport -> Encoding # toJSONList :: [ExternsImport] -> Value # toEncodingList :: [ExternsImport] -> Encoding #
FromJSON ExternsImport Source #
Instance details Defined in Language.PureScript.Externs Methods parseJSON :: Value -> Parser ExternsImport # parseJSONList :: Value -> Parser [ExternsImport] #

data ExternsFile Source #

The data which will be serialized to an externs file

Constructors

ExternsFile

Fields

efVersion :: Text
The externs version
efModuleName :: ModuleName
Module name
efExports :: [DeclarationRef]
List of module exports
efImports :: [ExternsImport]
List of module imports
efFixities :: [ExternsFixity]
List of operators and their fixities
efTypeFixities :: [ExternsTypeFixity]
List of type operators and their fixities
efDeclarations :: [ExternsDeclaration]
List of type and value declaration
efSourceSpan :: SourceSpan
Source span for error reporting

Instances

Show ExternsFile Source #
Instance details Defined in Language.PureScript.Externs Methods showsPrec :: Int -> ExternsFile -> ShowS # show :: ExternsFile -> String # showList :: [ExternsFile] -> ShowS #
ToJSON ExternsFile Source #
Instance details Defined in Language.PureScript.Externs Methods toJSON :: ExternsFile -> Value # toEncoding :: ExternsFile -> Encoding # toJSONList :: [ExternsFile] -> Value # toEncodingList :: [ExternsFile] -> Encoding #
FromJSON ExternsFile Source #
Instance details Defined in Language.PureScript.Externs Methods parseJSON :: Value -> Parser ExternsFile # parseJSONList :: Value -> Parser [ExternsFile] #

applyExternsFileToEnvironment :: ExternsFile -> Environment -> Environment Source #

Convert an externs file back into a module

moduleToExternsFile :: Module -> Environment -> ExternsFile Source #

Generate an externs file for all declarations in a module

decodeExterns :: ByteString -> Maybe ExternsFile Source #

data PPEOptions Source #

prettyPrintSingleError Options

Constructors

PPEOptions
Fields ppeCodeColor :: Maybe (ColorIntensity, Color) Color code with this color... or not ppeFull :: Bool Should write a full error message? ppeLevel :: Level Should this report an error or a warning? ppeShowDocs :: Bool Should show a link to error message's doc page? ppeRelativeDirectory :: FilePath FilePath to which the errors are relative

data Level Source #

How critical the issue is

Constructors

Error
Warning

Instances

Show Level Source #
Instance details Defined in Language.PureScript.Errors Methods showsPrec :: Int -> Level -> ShowS # show :: Level -> String # showList :: [Level] -> ShowS #

data TypeMap Source #

A map from rigid type variable name/unknown variable pairs to new variables.

Constructors

TypeMap
Fields umSkolemMap :: Map Int (String, Int, Maybe SourceSpan) a map from skolems to their new names, including source and naming info umUnknownMap :: Map Int Int a map from unification variables to their new names umNextIndex :: Int unknowns and skolems share a source of names during renaming, to avoid overlaps in error messages. This is the next label for either case.

Instances

Show TypeMap Source #
Instance details Defined in Language.PureScript.Errors Methods showsPrec :: Int -> TypeMap -> ShowS # show :: TypeMap -> String # showList :: [TypeMap] -> ShowS #

newtype MultipleErrors Source #

A stack trace for an error

Constructors

MultipleErrors
Fields runMultipleErrors :: [ErrorMessage]

Instances

Show MultipleErrors Source #
Instance details Defined in Language.PureScript.Errors Methods showsPrec :: Int -> MultipleErrors -> ShowS # show :: MultipleErrors -> String # showList :: [MultipleErrors] -> ShowS #
Semigroup MultipleErrors Source #
Instance details Defined in Language.PureScript.Errors Methods (<>) :: MultipleErrors -> MultipleErrors -> MultipleErrors # sconcat :: NonEmpty MultipleErrors -> MultipleErrors # stimes :: Integral b => b -> MultipleErrors -> MultipleErrors #
Monoid MultipleErrors Source #
Instance details Defined in Language.PureScript.Errors Methods mempty :: MultipleErrors # mappend :: MultipleErrors -> MultipleErrors -> MultipleErrors # mconcat :: [MultipleErrors] -> MultipleErrors #
MonadError MultipleErrors Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods throwError :: MultipleErrors -> Make a # catchError :: Make a -> (MultipleErrors -> Make a) -> Make a #
MonadWriter MultipleErrors Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods writer :: (a, MultipleErrors) -> Make a # tell :: MultipleErrors -> Make () # listen :: Make a -> Make (a, MultipleErrors) # pass :: Make (a, MultipleErrors -> MultipleErrors) -> Make a #

newtype ErrorSuggestion Source #

Constructors

ErrorSuggestion Text

errorSpan :: ErrorMessage -> Maybe (NonEmpty SourceSpan) Source #

Get the source span for an error

errorModule :: ErrorMessage -> Maybe ModuleName Source #

Get the module name for an error

findHint :: (ErrorMessageHint -> Maybe a) -> ErrorMessage -> Maybe a Source #

stripModuleAndSpan :: ErrorMessage -> ErrorMessage Source #

Remove the module name and span hints from an error

errorCode :: ErrorMessage -> Text Source #

Get the error code for a particular error type

nonEmpty :: MultipleErrors -> Bool Source #

Check whether a collection of errors is empty or not.

errorMessage :: SimpleErrorMessage -> MultipleErrors Source #

Create an error set from a single simple error message

errorMessage' :: SourceSpan -> SimpleErrorMessage -> MultipleErrors Source #

Create an error set from a single simple error message and source annotation

errorMessage'' :: NonEmpty SourceSpan -> SimpleErrorMessage -> MultipleErrors Source #

Create an error set from a single simple error message and source annotations

errorMessage''' :: [SourceSpan] -> SimpleErrorMessage -> MultipleErrors Source #

Create an error from multiple (possibly empty) source spans, reversed sorted.

singleError :: ErrorMessage -> MultipleErrors Source #

Create an error set from a single error message

onErrorMessages :: (ErrorMessage -> ErrorMessage) -> MultipleErrors -> MultipleErrors Source #

Lift a function on ErrorMessage to a function on MultipleErrors

addHint :: ErrorMessageHint -> MultipleErrors -> MultipleErrors Source #

Add a hint to an error message

addHints :: [ErrorMessageHint] -> MultipleErrors -> MultipleErrors Source #

Add hints to an error message

defaultUnknownMap :: TypeMap Source #

unwrapErrorMessage :: ErrorMessage -> SimpleErrorMessage Source #

Extract nested error messages from wrapper errors

replaceUnknowns :: SourceType -> State TypeMap SourceType Source #

onTypesInErrorMessage :: (SourceType -> SourceType) -> ErrorMessage -> ErrorMessage Source #

onTypesInErrorMessageM :: Applicative m => (SourceType -> m SourceType) -> ErrorMessage -> m ErrorMessage Source #

errorDocUri :: ErrorMessage -> Text Source #

errorSuggestion :: SimpleErrorMessage -> Maybe ErrorSuggestion Source #

suggestionSpan :: ErrorMessage -> Maybe SourceSpan Source #

showSuggestion :: SimpleErrorMessage -> Text Source #

ansiColor :: (ColorIntensity, Color) -> String Source #

ansiColorReset :: String Source #

colorCode :: Maybe (ColorIntensity, Color) -> Text -> Text Source #

colorCodeBox :: Maybe (ColorIntensity, Color) -> Box -> Box Source #

defaultCodeColor :: (ColorIntensity, Color) Source #

Default color intesity and color for code

defaultPPEOptions :: PPEOptions Source #

Default options for PPEOptions

prettyPrintSingleError :: PPEOptions -> ErrorMessage -> Box Source #

Pretty print a single error, simplifying if necessary

prettyPrintExport :: DeclarationRef -> Text Source #

prettyPrintImport :: ModuleName -> ImportDeclarationType -> Maybe ModuleName -> Text Source #

prettyPrintRef :: DeclarationRef -> Maybe Text Source #

prettyPrintMultipleErrors :: PPEOptions -> MultipleErrors -> String Source #

Pretty print multiple errors

prettyPrintMultipleWarnings :: PPEOptions -> MultipleErrors -> String Source #

Pretty print multiple warnings

prettyPrintMultipleWarningsBox :: PPEOptions -> MultipleErrors -> [Box] Source #

Pretty print warnings as a Box

prettyPrintMultipleErrorsBox :: PPEOptions -> MultipleErrors -> [Box] Source #

Pretty print errors as a Box

prettyPrintMultipleErrorsWith :: PPEOptions -> String -> String -> MultipleErrors -> [Box] Source #

prettyPrintParseError :: ParseError -> Box Source #

Pretty print a Parsec ParseError as a Box

prettyPrintParseErrorMessages :: String -> String -> String -> String -> String -> [Message] -> Box Source #

Pretty print ParseError detail messages.

Adapted from showErrorMessages. See https://github.com/aslatter/parsec/blob/v3.1.9/Text/Parsec/Error.hs#L173.

line :: Text -> Box Source #

lineS :: String -> Box Source #

renderBox :: Box -> String Source #

toTypelevelString :: Type a -> Maybe Box Source #

rethrow :: MonadError e m => (e -> e) -> m a -> m a Source #

Rethrow an error with a more detailed error message in the case of failure

reifyErrors :: MonadError e m => m a -> m (Either e a) Source #

reflectErrors :: MonadError e m => m (Either e a) -> m a Source #

warnAndRethrow :: (MonadError e m, MonadWriter e m) => (e -> e) -> m a -> m a Source #

rethrowWithPosition :: MonadError MultipleErrors m => SourceSpan -> m a -> m a Source #

Rethrow an error with source position information

warnWithPosition :: MonadWriter MultipleErrors m => SourceSpan -> m a -> m a Source #

warnAndRethrowWithPosition :: (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => SourceSpan -> m a -> m a Source #

withPosition :: SourceSpan -> ErrorMessage -> ErrorMessage Source #

positionedError :: SourceSpan -> ErrorMessageHint Source #

filterErrors :: (ErrorMessage -> Bool) -> MultipleErrors -> MultipleErrors Source #

escalateWarningWhen :: (MonadWriter MultipleErrors m, MonadError MultipleErrors m) => (ErrorMessage -> Bool) -> m a -> m a Source #

Runs a computation listening for warnings and then escalating any warnings that match the predicate to error status.

parU :: forall m a b. MonadError MultipleErrors m => [a] -> (a -> m b) -> m [b] Source #

Collect errors in in parallel

type Unknown = Int Source #

Unification variables

data CheckState Source #

State required for type checking

Constructors

CheckState

Fields

checkEnv :: Environment
The current Environment
checkNextType :: Int
The next type unification variable
checkNextKind :: Int
The next kind unification variable
checkNextSkolem :: Int
The next skolem variable
checkNextSkolemScope :: Int
The next skolem scope constant
checkCurrentModule :: Maybe ModuleName
The current module
checkSubstitution :: Substitution
The current substitution
checkHints :: [ErrorMessageHint]
The current error message hint stack. This goes into state, rather than using rethrow, since this way, we can provide good error messages during instance resolution.

data Substitution Source #

A substitution of unification variables for types or kinds

Constructors

Substitution
Fields substType :: Map Int SourceType Type substitution substKind :: Map Int SourceKind Kind substitution

emptySubstitution :: Substitution Source #

An empty substitution

emptyCheckState :: Environment -> CheckState Source #

Create an empty CheckState

bindNames :: MonadState CheckState m => Map (Qualified Ident) (SourceType, NameKind, NameVisibility) -> m a -> m a Source #

Temporarily bind a collection of names to values

bindTypes :: MonadState CheckState m => Map (Qualified (ProperName TypeName)) (SourceKind, TypeKind) -> m a -> m a Source #

Temporarily bind a collection of names to types

withScopedTypeVars :: (MonadState CheckState m, MonadWriter MultipleErrors m) => ModuleName -> [(Text, SourceKind)] -> m a -> m a Source #

Temporarily bind a collection of names to types

withErrorMessageHint :: (MonadState CheckState m, MonadError MultipleErrors m) => ErrorMessageHint -> m a -> m a Source #

getHints :: MonadState CheckState m => m [ErrorMessageHint] Source #

These hints are added at the front, so the most nested hint occurs at the front, but the simplifier assumes the reverse order.

rethrowWithPositionTC :: (MonadState CheckState m, MonadError MultipleErrors m) => SourceSpan -> m a -> m a Source #

warnAndRethrowWithPositionTC :: (MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => SourceSpan -> m a -> m a Source #

withTypeClassDictionaries :: MonadState CheckState m => [NamedDict] -> m a -> m a Source #

Temporarily make a collection of type class dictionaries available

getTypeClassDictionaries :: MonadState CheckState m => m (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict)))) Source #

Get the currently available map of type class dictionaries

lookupTypeClassDictionaries :: MonadState CheckState m => Maybe ModuleName -> m (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) (NonEmpty NamedDict))) Source #

Lookup type class dictionaries in a module.

lookupTypeClassDictionariesForClass :: MonadState CheckState m => Maybe ModuleName -> Qualified (ProperName ClassName) -> m (Map (Qualified Ident) (NonEmpty NamedDict)) Source #

Lookup type class dictionaries in a module.

bindLocalVariables :: MonadState CheckState m => [(Ident, SourceType, NameVisibility)] -> m a -> m a Source #

Temporarily bind a collection of names to local variables

bindLocalTypeVariables :: MonadState CheckState m => ModuleName -> [(ProperName TypeName, SourceKind)] -> m a -> m a Source #

Temporarily bind a collection of names to local type variables

makeBindingGroupVisible :: MonadState CheckState m => m () Source #

Update the visibility of all names to Defined

withBindingGroupVisible :: MonadState CheckState m => m a -> m a Source #

Update the visibility of all names to Defined in the scope of the provided action

preservingNames :: MonadState CheckState m => m a -> m a Source #

Perform an action while preserving the names from the Environment.

lookupVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m SourceType Source #

Lookup the type of a value by name in the Environment

getVisibility :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m NameVisibility Source #

Lookup the visibility of a value by name in the Environment

checkVisibility :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => Qualified Ident -> m () Source #

Assert that a name is visible

lookupTypeVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => ModuleName -> Qualified (ProperName TypeName) -> m SourceKind Source #

Lookup the kind of a type by name in the Environment

getEnv :: MonadState CheckState m => m Environment Source #

Get the current Environment

getLocalContext :: MonadState CheckState m => m Context Source #

Get locally-bound names in context, to create an error message.

putEnv :: MonadState CheckState m => Environment -> m () Source #

Update the Environment

modifyEnv :: MonadState CheckState m => (Environment -> Environment) -> m () Source #

Modify the Environment

runCheck :: Functor m => StateT CheckState m a -> m (a, Environment) Source #

Run a computation in the typechecking monad, starting with an empty Environment

runCheck' :: Functor m => CheckState -> StateT CheckState m a -> m (a, Environment) Source #

Run a computation in the typechecking monad, failing with an error, or succeeding with a return value and the final Environment.

guardWith :: MonadError e m => e -> Bool -> m () Source #

Make an assertion, failing with an error message

captureSubstitution :: MonadState CheckState m => m a -> m (a, Substitution) Source #

Run a computation in the substitution monad, generating a return value and the final substitution.

capturingSubstitution :: MonadState CheckState m => (a -> Substitution -> b) -> m a -> m b Source #

withFreshSubstitution :: MonadState CheckState m => m a -> m a Source #

withoutWarnings :: MonadWriter w m => m a -> m (a, w) Source #

unsafeCheckCurrentModule :: forall m. (MonadError MultipleErrors m, MonadState CheckState m) => m ModuleName Source #

type SynonymMap = Map (Qualified (ProperName TypeName)) ([(Text, Maybe SourceKind)], SourceType) Source #

Type synonym information (arguments with kinds, aliased type), indexed by name

replaceAllTypeSynonyms :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => SourceType -> m SourceType Source #

Replace fully applied type synonyms

replaceAllTypeSynonymsM :: MonadError MultipleErrors m => SynonymMap -> SourceType -> m SourceType Source #

Replace fully applied type synonyms by explicitly providing a SynonymMap.

kindOf :: (MonadError MultipleErrors m, MonadState CheckState m) => SourceType -> m SourceKind Source #

Infer the kind of a single type

kindOfWithScopedVars :: (MonadError MultipleErrors m, MonadState CheckState m) => SourceType -> m (SourceKind, [(Text, SourceKind)]) Source #

Infer the kind of a single type, returning the kinds of any scoped type variables

kindsOf :: (MonadError MultipleErrors m, MonadState CheckState m) => Bool -> ModuleName -> ProperName TypeName -> [(Text, Maybe SourceKind)] -> [SourceType] -> m SourceKind Source #

Infer the kind of a type constructor with a collection of arguments and a collection of associated data constructors

kindsOfAll :: (MonadError MultipleErrors m, MonadState CheckState m) => ModuleName -> [(SourceAnn, ProperName TypeName, [(Text, Maybe SourceKind)], SourceType)] -> [(SourceAnn, ProperName TypeName, [(Text, Maybe SourceKind)], [SourceType])] -> m ([SourceKind], [SourceKind]) Source #

Simultaneously infer the kinds of several mutually recursive type constructors

data BindingGroupType Source #

Constructors

RecursiveBindingGroup
NonRecursiveBindingGroup

Instances

Eq BindingGroupType Source #
Instance details Defined in Language.PureScript.TypeChecker.Types Methods (==) :: BindingGroupType -> BindingGroupType -> Bool # (/=) :: BindingGroupType -> BindingGroupType -> Bool #
Ord BindingGroupType Source #
Instance details Defined in Language.PureScript.TypeChecker.Types Methods compare :: BindingGroupType -> BindingGroupType -> Ordering # (<) :: BindingGroupType -> BindingGroupType -> Bool # (<=) :: BindingGroupType -> BindingGroupType -> Bool # (>) :: BindingGroupType -> BindingGroupType -> Bool # (>=) :: BindingGroupType -> BindingGroupType -> Bool # max :: BindingGroupType -> BindingGroupType -> BindingGroupType # min :: BindingGroupType -> BindingGroupType -> BindingGroupType #
Show BindingGroupType Source #
Instance details Defined in Language.PureScript.TypeChecker.Types Methods showsPrec :: Int -> BindingGroupType -> ShowS # show :: BindingGroupType -> String # showList :: [BindingGroupType] -> ShowS #

typesOf :: (MonadSupply m, MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => BindingGroupType -> ModuleName -> [((SourceAnn, Ident), Expr)] -> m [((SourceAnn, Ident), (Expr, SourceType))] Source #

Infer the types of multiple mutually-recursive values, and return elaborated values including type class dictionaries and type annotations.

desugarTypeDeclarationsModule :: forall m. MonadError MultipleErrors m => Module -> m Module Source #

Replace all top level type declarations in a module with type annotations

desugarSignedLiterals :: Module -> Module Source #

Removes unary negation operators and replaces them with calls to negate.

rebracket :: forall m. MonadError MultipleErrors m => [ExternsFile] -> [Module] -> m [Module] Source #

Remove explicit parentheses and reorder binary operator applications.

This pass requires name desugaring and export elaboration to have run first.

rebracketFiltered :: forall m. MonadError MultipleErrors m => (Declaration -> Bool) -> [ExternsFile] -> [Module] -> m [Module] Source #

A version of rebracket which allows you to choose which declarations should be affected. This is used in docs generation, where we want to desugar type operators in instance declarations to ensure that instances are paired up with their types correctly, but we don't want to desugar type operators in value declarations.

checkFixityExports :: forall m. MonadError MultipleErrors m => Module -> m Module Source #

Checks all the fixity exports within a module to ensure that members aliased by the operators are also exported from the module.

This pass requires name desugaring and export elaboration to have run first.

desugarObjectConstructors :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module Source #

desugarDecl :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Declaration -> m Declaration Source #

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

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.

data Exports Source #

The exported declarations from a module.

Constructors

Exports

Fields

exportedTypes :: Map (ProperName TypeName) ([ProperName ConstructorName], ExportSource)
The exported types along with the module they originally came from.
exportedTypeOps :: Map (OpName TypeOpName) ExportSource
The exported type operators along with the module they originally came from.
exportedTypeClasses :: Map (ProperName ClassName) ExportSource
The exported classes along with the module they originally came from.
exportedValues :: Map Ident ExportSource
The exported values along with the module they originally came from.
exportedValueOps :: Map (OpName ValueOpName) ExportSource
The exported value operators along with the module they originally came from.
exportedKinds :: Map (ProperName KindName) ExportSource
The exported kinds along with the module they originally came from.

Instances

Show Exports Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods showsPrec :: Int -> Exports -> ShowS # show :: Exports -> String # showList :: [Exports] -> ShowS #

data Imports Source #

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

Constructors

Imports

Fields

importedTypes :: ImportMap (ProperName TypeName)
Local names for types within a module mapped to their qualified names
importedTypeOps :: ImportMap (OpName TypeOpName)
Local names for type operators within a module mapped to their qualified names
importedDataConstructors :: ImportMap (ProperName ConstructorName)
Local names for data constructors within a module mapped to their qualified names
importedTypeClasses :: ImportMap (ProperName ClassName)
Local names for classes within a module mapped to their qualified names
importedValues :: ImportMap Ident
Local names for values within a module mapped to their qualified names
importedValueOps :: ImportMap (OpName ValueOpName)
Local names for value operators within a module mapped to their qualified names
importedModules :: Set ModuleName
The name of modules that have been imported into the current scope that can be re-exported. If a module is imported with as qualification, the as name appears here, otherwise the original name.
importedQualModules :: Set ModuleName
The "as" names of modules that have been imported qualified.
importedKinds :: ImportMap (ProperName KindName)
Local names for kinds within a module mapped to their qualified names

Instances

Show Imports Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods showsPrec :: Int -> Imports -> ShowS # show :: Imports -> String # showList :: [Imports] -> ShowS #

data ImportProvenance Source #

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
Prim

Instances

Eq ImportProvenance Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods (==) :: ImportProvenance -> ImportProvenance -> Bool # (/=) :: ImportProvenance -> ImportProvenance -> Bool #
Ord ImportProvenance Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods compare :: ImportProvenance -> ImportProvenance -> Ordering # (<) :: ImportProvenance -> ImportProvenance -> Bool # (<=) :: ImportProvenance -> ImportProvenance -> Bool # (>) :: ImportProvenance -> ImportProvenance -> Bool # (>=) :: ImportProvenance -> ImportProvenance -> Bool # max :: ImportProvenance -> ImportProvenance -> ImportProvenance # min :: ImportProvenance -> ImportProvenance -> ImportProvenance #
Show ImportProvenance Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods showsPrec :: Int -> ImportProvenance -> ShowS # show :: ImportProvenance -> String # showList :: [ImportProvenance] -> ShowS #

data ImportRecord a Source #

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 importSourceSpan :: SourceSpan importProvenance :: ImportProvenance

Instances

Eq a => Eq (ImportRecord a) Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods (==) :: ImportRecord a -> ImportRecord a -> Bool # (/=) :: ImportRecord a -> ImportRecord a -> Bool #
Ord a => Ord (ImportRecord a) Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods compare :: ImportRecord a -> ImportRecord a -> Ordering # (<) :: ImportRecord a -> ImportRecord a -> Bool # (<=) :: ImportRecord a -> ImportRecord a -> Bool # (>) :: ImportRecord a -> ImportRecord a -> Bool # (>=) :: ImportRecord a -> ImportRecord a -> Bool # max :: ImportRecord a -> ImportRecord a -> ImportRecord a # min :: ImportRecord a -> ImportRecord a -> ImportRecord a #
Show a => Show (ImportRecord a) Source #
Instance details Defined in Language.PureScript.Sugar.Names.Env Methods showsPrec :: Int -> ImportRecord a -> ShowS # show :: ImportRecord a -> String # showList :: [ImportRecord a] -> ShowS #

primEnv :: Env Source #

Environment which only contains the Prim modules.

desugarDoModule :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module Source #

Replace all DoNotationBind and DoNotationValue constructors with applications of the bind function in scope, and all DoNotationLet constructors with let expressions.

desugarCasesModule :: (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module Source #

Replace all top-level binders in a module with case expressions.

desugarCaseGuards :: forall m. (MonadSupply m, MonadError MultipleErrors m) => [Declaration] -> m [Declaration] Source #

desugarCases :: forall m. (MonadSupply m, MonadError MultipleErrors m) => [Declaration] -> m [Declaration] Source #

Replace all top-level binders with case expressions.

desugarTypeClasses :: (MonadSupply m, MonadError MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module] Source #

Add type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions.

typeClassMemberName :: Declaration -> Text Source #

superClassDictionaryNames :: [Constraint a] -> [Text] Source #

createBindingGroupsModule :: MonadError MultipleErrors m => Module -> m Module Source #

Replace all sets of mutually-recursive declarations in a module with binding groups

collapseBindingGroupsModule :: [Module] -> [Module] Source #

Collapse all binding groups in a module to individual declarations

createBindingGroups :: forall m. MonadError MultipleErrors m => ModuleName -> [Declaration] -> m [Declaration] Source #

collapseBindingGroups :: [Declaration] -> [Declaration] Source #

Collapse all binding groups to individual declarations

desugarAdoModule :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module Source #

Replace all AdoNotationBind and AdoNotationValue constructors with applications of the pure and apply functions in scope, and all AdoNotationLet constructors with let expressions.

data ModuleSignature Source #

A module signature for sorting dependencies.

Constructors

ModuleSignature
Fields sigSourceSpan :: SourceSpan sigModuleName :: ModuleName sigImports :: [(ModuleName, SourceSpan)]

type ModuleGraph = [(ModuleName, [ModuleName])] Source #

A list of modules with their transitive dependencies

sortModules :: forall m a. MonadError MultipleErrors m => (a -> ModuleSignature) -> [a] -> m ([a], ModuleGraph) Source #

Sort a collection of modules based on module dependencies.

Reports an error if the module graph contains a cycle.

moduleSignature :: Module -> ModuleSignature Source #

newtype Make a Source #

A monad for running make actions

Constructors

Make
Fields unMake :: ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a

Instances

Monad Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods (>>=) :: Make a -> (a -> Make b) -> Make b # (>>) :: Make a -> Make b -> Make b # return :: a -> Make a # fail :: String -> Make a #
Functor Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods fmap :: (a -> b) -> Make a -> Make b # (<$) :: a -> Make b -> Make a #
Applicative Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods pure :: a -> Make a # (<>) :: Make (a -> b) -> Make a -> Make b # liftA2 :: (a -> b -> c) -> Make a -> Make b -> Make c # (>) :: Make a -> Make b -> Make b # (<*) :: Make a -> Make b -> Make a #
MonadIO Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods liftIO :: IO a -> Make a #
MonadError MultipleErrors Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods throwError :: MultipleErrors -> Make a # catchError :: Make a -> (MultipleErrors -> Make a) -> Make a #
MonadReader Options Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods ask :: Make Options # local :: (Options -> Options) -> Make a -> Make a # reader :: (Options -> a) -> Make a #
MonadBase IO Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods liftBase :: IO α -> Make α #
MonadBaseControl IO Make Source #
Instance details Defined in Language.PureScript.Make.Monad Associated Types type StM Make a :: Type # Methods liftBaseWith :: (RunInBase Make IO -> IO a) -> Make a # restoreM :: StM Make a -> Make a #
MonadWriter MultipleErrors Make Source #
Instance details Defined in Language.PureScript.Make.Monad Methods writer :: (a, MultipleErrors) -> Make a # tell :: MultipleErrors -> Make () # listen :: Make a -> Make (a, MultipleErrors) # pass :: Make (a, MultipleErrors -> MultipleErrors) -> Make a #
type StM Make a Source #
Instance details Defined in Language.PureScript.Make.Monad type StM Make a = Either MultipleErrors a

runMake :: Options -> Make a -> IO (Either MultipleErrors a, MultipleErrors) Source #

Execute a Make monad, returning either errors, or the result of the compile plus any warnings.

makeIO :: (IOError -> ErrorMessage) -> IO a -> Make a Source #

Run an IO action in the Make monad, by specifying how IO errors should be rendered as ErrorMessage values.

readTextFile :: FilePath -> Make ByteString Source #

Read a text file in the Make monad, capturing any errors using the MonadError instance.

type UsedImports = Map ModuleName [Qualified Name] Source #

Map of module name to list of imported names from that module which have been used.

lintImports :: forall m. MonadWriter MultipleErrors m => Module -> Env -> UsedImports -> m () Source #

Find and warn on:

Unused import statements (qualified or unqualified)
Unused references in an explicit import list
Implicit imports of modules
Implicit imports into a virtual module (unless the virtual module only has members from one module imported)
Imports using hiding (this is another form of implicit importing)

desugarImports :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module] Source #

Replaces all local names with qualified names within a list of modules. The modules should be topologically sorted beforehand.

desugarImportsWithEnv :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m (Env, [Module]) Source #

checkExhaustiveExpr :: forall m. (MonadWriter MultipleErrors m, MonadSupply m) => SourceSpan -> Environment -> ModuleName -> Expr -> m Expr Source #

Exhaustivity checking

lint :: forall m. MonadWriter MultipleErrors m => Module -> m () Source #

Lint the PureScript AST. | | Right now, this pass only performs a shadowing check.

checkNewtype :: forall m. MonadError MultipleErrors m => ProperName TypeName -> [(ProperName ConstructorName, [(Ident, SourceType)])] -> m () Source #

typeCheckModule :: forall m. (MonadSupply m, MonadState CheckState m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => Module -> m Module Source #

Type check an entire module and ensure all types and classes defined within the module that are required by exported members are also exported.

deriveInstances :: forall m. (MonadError MultipleErrors m, MonadWriter MultipleErrors m, MonadSupply m) => [ExternsFile] -> Module -> m Module Source #

Elaborates deriving instance declarations by code generation.

desugar :: (MonadSupply m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => [ExternsFile] -> [Module] -> m [Module] Source #

The desugaring pipeline proceeds as follows:

Remove signed literals in favour of negate applications
Desugar object literals with wildcards into lambdas
Desugar operator sections
Desugar do-notation
Desugar ado-notation
Desugar top-level case declarations into explicit case expressions
Desugar type declarations into value declarations with explicit type annotations
Qualify any unqualified names and types
Rebracket user-defined binary operators
Introduce type synonyms for type class dictionaries
Group mutually recursive value and data declarations into binding groups.

renameInModules :: [Module Ann] -> [Module Ann] Source #

Renames within each declaration in a module.

data MakeActions m Source #

Actions that require implementations when running in "make" mode.

This type exists to make two things abstract:

The particular backend being used (JavaScript, C++11, etc.)
The details of how files are read/written etc.

Constructors

MakeActions

Fields

getInputTimestamp :: ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))
Get the timestamp for the input file(s) for a module. If there are multiple files (.purs and foreign files, for example) the timestamp should be for the most recently modified file.
getOutputTimestamp :: ModuleName -> m (Maybe UTCTime)
Get the timestamp for the output files for a module. This should be the timestamp for the oldest modified file, or Nothing if any of the required output files are missing.
readExterns :: ModuleName -> m (FilePath, Externs)
Read the externs file for a module as a string and also return the actual path for the file.
codegen :: Module Ann -> Module -> Externs -> SupplyT m ()
Run the code generator for the module and write any required output files.
ffiCodegen :: Module Ann -> m ()
Check ffi and print it in the output directory.
progress :: ProgressMessage -> m ()
Respond to a progress update.

type Externs = ByteString Source #

Generated code for an externs file.

data ProgressMessage Source #

Progress messages from the make process

Constructors

CompilingModule ModuleName

Compilation started for the specified module

Instances

Eq ProgressMessage Source #
Instance details Defined in Language.PureScript.Make.Actions Methods (==) :: ProgressMessage -> ProgressMessage -> Bool # (/=) :: ProgressMessage -> ProgressMessage -> Bool #
Ord ProgressMessage Source #
Instance details Defined in Language.PureScript.Make.Actions Methods compare :: ProgressMessage -> ProgressMessage -> Ordering # (<) :: ProgressMessage -> ProgressMessage -> Bool # (<=) :: ProgressMessage -> ProgressMessage -> Bool # (>) :: ProgressMessage -> ProgressMessage -> Bool # (>=) :: ProgressMessage -> ProgressMessage -> Bool # max :: ProgressMessage -> ProgressMessage -> ProgressMessage # min :: ProgressMessage -> ProgressMessage -> ProgressMessage #
Show ProgressMessage Source #
Instance details Defined in Language.PureScript.Make.Actions Methods showsPrec :: Int -> ProgressMessage -> ShowS # show :: ProgressMessage -> String # showList :: [ProgressMessage] -> ShowS #

data RebuildPolicy Source #

Determines when to rebuild a module

Constructors

RebuildNever	Never rebuild this module
RebuildAlways	Always rebuild this module

Instances

Eq RebuildPolicy Source #
Instance details Defined in Language.PureScript.Make.Actions Methods (==) :: RebuildPolicy -> RebuildPolicy -> Bool # (/=) :: RebuildPolicy -> RebuildPolicy -> Bool #
Ord RebuildPolicy Source #
Instance details Defined in Language.PureScript.Make.Actions Methods compare :: RebuildPolicy -> RebuildPolicy -> Ordering # (<) :: RebuildPolicy -> RebuildPolicy -> Bool # (<=) :: RebuildPolicy -> RebuildPolicy -> Bool # (>) :: RebuildPolicy -> RebuildPolicy -> Bool # (>=) :: RebuildPolicy -> RebuildPolicy -> Bool # max :: RebuildPolicy -> RebuildPolicy -> RebuildPolicy # min :: RebuildPolicy -> RebuildPolicy -> RebuildPolicy #
Show RebuildPolicy Source #
Instance details Defined in Language.PureScript.Make.Actions Methods showsPrec :: Int -> RebuildPolicy -> ShowS # show :: RebuildPolicy -> String # showList :: [RebuildPolicy] -> ShowS #

buildMakeActions Source #

Arguments

:: FilePath	the output directory
-> Map ModuleName (Either RebuildPolicy FilePath)	a map between module names and paths to the file containing the PureScript module
-> Map ModuleName FilePath	a map between module name and the file containing the foreign javascript for the module
-> Bool	Generate a prefix comment?
-> MakeActions Make

A set of make actions that read and write modules from the given directory.

checkForeignDecls :: Module ann -> FilePath -> Make () Source #

Check that the declarations in a given PureScript module match with those in its corresponding foreign module.

rebuildModule :: forall m. (Monad m, MonadBaseControl IO m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => MakeActions m -> [ExternsFile] -> Module -> m ExternsFile Source #

Rebuild a single module.

This function is used for fast-rebuild workflows (PSCi and psc-ide are examples).

make :: forall m. (Monad m, MonadBaseControl IO m, MonadError MultipleErrors m, MonadWriter MultipleErrors m) => MakeActions m -> [PartialResult Module] -> m [ExternsFile] Source #

Compiles in "make" mode, compiling each module separately to a .js file and an externs.json file.

If timestamps have not changed, the externs file can be used to provide the module's types without having to typecheck the module again.

inferForeignModules :: forall m. MonadIO m => Map ModuleName (Either RebuildPolicy FilePath) -> m (Map ModuleName FilePath) Source #

Infer the module name for a module by looking for the same filename with a .js extension.

version :: Version Source #

IdentName Ident
ValOpName (OpName ValueOpName)
TyName (ProperName TypeName)
TyOpName (OpName TypeOpName)
DctorName (ProperName ConstructorName)
TyClassName (ProperName ClassName)
ModName ModuleName
KiName (ProperName KindName)

PPTUnknown Int
PPTypeVar Text
PPTypeLevelString PSString
PPTypeWildcard (Maybe Text)
PPTypeConstructor (Qualified (ProperName TypeName))
PPTypeOp (Qualified (OpName TypeOpName))
PPSkolem Text Int
PPTypeApp PrettyPrintType PrettyPrintType
PPConstrainedType PrettyPrintConstraint PrettyPrintType
PPKindedType PrettyPrintType (Kind ())
PPBinaryNoParensType PrettyPrintType PrettyPrintType PrettyPrintType
PPParensInType PrettyPrintType
PPForAll [(Text, Maybe (Kind ()))] PrettyPrintType
PPFunction PrettyPrintType PrettyPrintType
PPRecord [(Label, PrettyPrintType)] (Maybe PrettyPrintType)
PPRow [(Label, PrettyPrintType)] (Maybe PrettyPrintType)
PPTruncated