infernu-0.0.0.1: Type inference and checker for JavaScript (experimental)

Safe HaskellNone
LanguageHaskell2010

Infernu.Types

Synopsis

Documentation

data GenInfo Source

Constructors

GenInfo 

Fields

isGen :: Bool
 
declName :: Maybe String
 

Instances

newtype Source Source

Constructors

Source (GenInfo, SourcePos) 

Instances

emptySource :: Source Source

data Exp a Source

Constructors

EVar a EVarName 
EApp a (Exp a) [Exp a] 
EAbs a [EVarName] (Exp a) 
ELet a EVarName (Exp a) (Exp a) 
ELit a LitVal 
EAssign a EVarName (Exp a) (Exp a) 
EPropAssign a (Exp a) EPropName (Exp a) (Exp a) 
EIndexAssign a (Exp a) (Exp a) (Exp a) (Exp a) 
EArray a [Exp a] 
ETuple a [Exp a] 
ERow a Bool [(EPropName, Exp a)] 
EStringMap a [(String, Exp a)] 
ECase a (Exp a) [(LitVal, Exp a)] 
EProp a (Exp a) EPropName 
EIndex a (Exp a) (Exp a) 
ENew a (Exp a) [Exp a] 

Instances

Functor Exp 
Foldable Exp 
Eq a => Eq (Exp a) 
Ord a => Ord (Exp a) 
Show a => Show (Exp a) 
VarNames t => VarNames (Exp (a, t)) 
Pretty (Exp a) 

data LitVal Source

Constructors

LitNumber Double 
LitBoolean Bool 
LitString String 
LitRegex String Bool Bool 
LitUndefined 
LitNull 

Instances

type EVarName = String Source

type TVarName = Int Source

data TBody Source

Constructors

TVar TVarName 
TNumber 
TBoolean 
TString 
TRegex 
TUndefined 
TNull 

Instances

data TConsName Source

Constructors

TArray 
TTuple 
TName TypeId 
TStringMap 

Instances

newtype TypeId Source

Constructors

TypeId TVarName 

Instances

type Type = Fix FType Source

newtype Fix f Source

Constructors

Fix 

Fields

unFix :: f (Fix f)
 

Instances

Substable Type

applySubst for Types >>> applySubst (Map.fromList [(0, Fix $ TBody TNumber)]) (Fix $ TBody $ TVar 0) Fix (TBody TNumber) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TBody $ TVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowEnd $ Just $ RowTVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowProp "bla" (schemeEmpty $ Fix $ TBody TString) (TRowEnd $ Just $ RowTVar 0)) Fix (TRow (TRowProp "bla" (TScheme {schemeVars = [], schemeType = TQual {qualPred = [], qualType = Fix (TBody TString)}}) (TRowEnd Nothing)))

VarNames Type

VarNames instance for Type t

>>> freeTypeVars (Fix $ TBody TNumber)
fromList []
>>> freeTypeVars (Fix $ TBody $ TVar 0)
fromList [0]
>>> freeTypeVars (Fix $ TFunc [Fix $ TBody $ TVar 0] (Fix $ TBody $ TVar 1))
fromList [0,1]
>>> freeTypeVars (Fix $ TFunc [] (Fix $ TBody $ TVar 1))
fromList [1]
>>> freeTypeVars $ (Fix $ (TRow (TRowEnd (Just $ RowTVar 3))) :: Type)
fromList [3]
Pretty Type 
Eq (f (Fix f)) => Eq (Fix f) 
Ord (f (Fix f)) => Ord (Fix f) 
Show (f (Fix f)) => Show (Fix f) 
Substable (TRowList Type) 
VarNames (FType (Fix FType)) 
Pretty [Type] 
Pretty (FType Type) 

replaceFix :: (Functor f, Eq (f (Fix f))) => f (Fix f) -> f (Fix f) -> Fix f -> Fix f Source

data FType t Source

Constructors

TBody TBody 
TCons TConsName [t] 
TFunc [t] t

TFunc (functions) are Profunctor-types. Arguments could have been a single t and always wrapped in a Tuple - but are expanded to a list here for convenience

TRow (TRowList t) 

Instances

Functor FType 
Foldable FType 
Traversable FType 
Substable Type

applySubst for Types >>> applySubst (Map.fromList [(0, Fix $ TBody TNumber)]) (Fix $ TBody $ TVar 0) Fix (TBody TNumber) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TBody $ TVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowEnd $ Just $ RowTVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowProp "bla" (schemeEmpty $ Fix $ TBody TString) (TRowEnd $ Just $ RowTVar 0)) Fix (TRow (TRowProp "bla" (TScheme {schemeVars = [], schemeType = TQual {qualPred = [], qualType = Fix (TBody TString)}}) (TRowEnd Nothing)))

VarNames Type

VarNames instance for Type t

>>> freeTypeVars (Fix $ TBody TNumber)
fromList []
>>> freeTypeVars (Fix $ TBody $ TVar 0)
fromList [0]
>>> freeTypeVars (Fix $ TFunc [Fix $ TBody $ TVar 0] (Fix $ TBody $ TVar 1))
fromList [0,1]
>>> freeTypeVars (Fix $ TFunc [] (Fix $ TBody $ TVar 1))
fromList [1]
>>> freeTypeVars $ (Fix $ (TRow (TRowEnd (Just $ RowTVar 3))) :: Type)
fromList [3]
Pretty Type 
Eq t => Eq (FType t) 
Ord t => Ord (FType t) 
Show t => Show (FType t) 
Substable (TRowList Type) 
VarNames (FType (Fix FType)) 
Pretty [Type] 
Pretty (FType Type) 

data TypeError Source

Constructors

TypeError 

Fields

source :: Source
 
message :: String
 

Instances

data InferState Source

Constructors

InferState 

Fields

nameSource :: NameSource
 
mainSubst :: TSubst
 
varSchemes :: Map VarId TypeScheme
 
varInstances :: Gr QualType ()
 
namedTypes :: Map TypeId (Type, TypeScheme)
 
classes :: Map ClassName (Class Type)
 
pendingUni :: Set (Source, Type, (ClassName, Set TypeScheme))
 

Instances

Eq InferState 
Show InferState 
Substable InferState 
VarNames InferState

VarNames instance for InferState >>> :{ varInstances $ mapVarNames (k -> k + 1) $ emptyInferState { varInstances = Map.fromList [ (0, Set.fromList [ qualEmpty $ Fix $ TBody $ TVar 0, qualEmpty $ Fix $ TBody $ TVar 1]) , (1, Set.fromList [ qualEmpty $ Fix $ TBody $ TVar 0 , TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 3)] (Fix $ TBody $ TVar 1) ]) ]} :} fromList [(1,fromList [TQual {qualPred = [], qualType = Fix (TBody (TVar 1))},TQual {qualPred = [], qualType = Fix (TBody (TVar 2))}]),(2,fromList [TQual {qualPred = [], qualType = Fix (TBody (TVar 1))},TQual {qualPred = [TPredIsIn {predClass = ClassName Bla, predType = Fix (TBody (TVar 4))}], qualType = Fix (TBody (TVar 2))}])]

Pretty InferState 

newtype RowTVar Source

Constructors

RowTVar TVarName 

Instances

getRowTVar :: RowTVar -> TVarName Source

liftRowTVar :: (TVarName -> TVarName) -> RowTVar -> RowTVar Source

data FlatRowEnd t Source

Constructors

FlatRowEndTVar (Maybe RowTVar) 
FlatRowEndRec TypeId [t] 

data TRowList t Source

Row type.

Constructors

TRowProp EPropName (TScheme t) (TRowList t) 
TRowEnd (Maybe RowTVar) 
TRowRec TypeId [t] 

Instances

Functor TRowList 
Foldable TRowList 
Traversable TRowList 
Eq t => Eq (TRowList t) 
Ord t => Ord (TRowList t) 
Show t => Show (TRowList t) 
Substable (TRowList Type) 
VarNames t => VarNames (TRowList t)

VarNames instance for TRowList

>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody TNumber) (TRowEnd $ Just $ RowTVar 1))
fromList [1]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowEnd Nothing))
fromList [2]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowEnd $ Just $ RowTVar 1))
fromList [1,2]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowProp "y" (schemeEmpty $ Fix $ TBody $ TVar 3) (TRowEnd $ Just $ RowTVar 1)))
fromList [1,2,3]

newtype ClassName Source

Constructors

ClassName String 

Instances

data Class t Source

Constructors

Class 

Fields

classInstances :: [TScheme t]
 

Instances

Functor Class 
Foldable Class 
Traversable Class 
Eq t => Eq (Class t) 
Ord t => Ord (Class t) 
Show t => Show (Class t) 
(Ord t, VarNames t, Pretty t) => Pretty (Class t) 

data TPred t Source

Constructors

TPredIsIn 

Fields

predClass :: ClassName
 
predType :: t
 

Instances

data TQual t Source

Constructors

TQual 

Fields

qualPred :: [TPred t]
 
qualType :: t
 

Instances

Functor TQual 
Foldable TQual 
Traversable TQual 
Eq t => Eq (TQual t) 
Ord t => Ord (TQual t) 
Show t => Show (TQual t) 
(Substable t, VarNames t) => Substable (TQual t)

Substable instance for TQual >>> let qt = TQual [TPredIsIn (ClassName Bla) (Fix $ TBody (TVar 0))] (Fix $ TBody (TVar 0)) >>> let s = singletonSubst 0 (Fix $ TBody TNumber) >>> applySubst s qt TQual {qualPred = [TPredIsIn {predClass = ClassName Bla, predType = Fix (TBody TNumber)}], qualType = Fix (TBody TNumber)}

VarNames t => VarNames (TQual t) 
(VarNames t, Pretty t) => Pretty (TQual t) 

qualEmpty :: t -> TQual t Source

type QualType = TQual Type Source

data TScheme t Source

Constructors

TScheme 

Fields

schemeVars :: [TVarName]
 
schemeType :: TQual t
 

Instances

Functor TScheme 
Foldable TScheme 
Traversable TScheme 
Eq t => Eq (TScheme t) 
Ord t => Ord (TScheme t) 
Show t => Show (TScheme t) 
(VarNames t, Substable t) => Substable (TScheme t) 
VarNames t => VarNames (TScheme t)

VarNames instance for TScheme >>> let sc v t = TScheme v (qualEmpty t) >>> freeTypeVars $ sc [0, 1] (Fix $ TBody $ TVar 2) fromList [2] >>> freeTypeVars $ sc [0, 1] (Fix $ TBody $ TVar 1) fromList [] >>> freeTypeVars $ sc [0] (Fix $ TBody $ TVar 1) fromList [1] >>> freeTypeVars $ sc [0] (Fix $ TBody $ TVar 0) fromList [] >>> freeTypeVars $ schemeEmpty (Fix $ TBody $ TVar 1) fromList [1] >>> freeTypeVars $ schemeEmpty (Fix $ TBody $ TNumber) fromList [] >>> freeTypeVars $ sc [1] (Fix $ TBody $ TNumber) fromList [] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 0)] (Fix $ TBody $ TVar 0)) fromList [] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 0)] (Fix $ TBody $ TVar 2)) fromList [2] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 2)] (Fix $ TBody $ TVar 2)) fromList [2] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 2)] (Fix $ TBody $ TVar 0)) fromList [2]

(Ord t, VarNames t, Pretty t) => Pretty (TScheme t) 

schemeEmpty :: t -> TScheme t Source

schemeFromQual :: TQual t -> TScheme t Source

type TypeScheme = TScheme Type Source

type TypeEnv = Map EVarName VarId Source

Type environment: maps AST variables (not type variables!) to quantified type schemes.

Note: instance of Substable

class Substable a where Source

Minimal complete definition

applySubst

Methods

applySubst :: TSubst -> a -> a Source

applySubst' :: (Functor f, Substable a) => TSubst -> f a -> f a Source

Instances

Substable InferState 
Substable Type

applySubst for Types >>> applySubst (Map.fromList [(0, Fix $ TBody TNumber)]) (Fix $ TBody $ TVar 0) Fix (TBody TNumber) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TBody $ TVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowEnd $ Just $ RowTVar 0) Fix (TRow (TRowEnd Nothing)) >>> applySubst (Map.fromList [(0, Fix $ TRow $ TRowEnd Nothing)]) (Fix $ TRow $ TRowProp "bla" (schemeEmpty $ Fix $ TBody TString) (TRowEnd $ Just $ RowTVar 0)) Fix (TRow (TRowProp "bla" (TScheme {schemeVars = [], schemeType = TQual {qualPred = [], qualType = Fix (TBody TString)}}) (TRowEnd Nothing)))

Substable a => Substable [a] 
Substable a => Substable (Maybe a) 
(Ord a, Substable a) => Substable (Set a) 
(VarNames t, Substable t) => Substable (TScheme t) 
(Substable t, VarNames t) => Substable (TQual t)

Substable instance for TQual >>> let qt = TQual [TPredIsIn (ClassName Bla) (Fix $ TBody (TVar 0))] (Fix $ TBody (TVar 0)) >>> let s = singletonSubst 0 (Fix $ TBody TNumber) >>> applySubst s qt TQual {qualPred = [TPredIsIn {predClass = ClassName Bla, predType = Fix (TBody TNumber)}], qualType = Fix (TBody TNumber)}

Substable t => Substable (TPred t) 
Substable (TRowList Type) 
Substable b => Substable (a, b) 
Substable a => Substable (Map b a) 

flattenRow :: TRowList t -> (Map EPropName (TScheme t), FlatRowEnd t) Source

unflattenRow :: Map EPropName (TScheme t) -> FlatRowEnd t -> (EPropName -> Bool) -> TRowList t Source

type TSubst = Map TVarName Type Source

nullSubst :: TSubst Source

composeSubst :: TSubst -> TSubst -> TSubst Source

composeSubst should obey the law: applySubst (composeSubst new old) t = applySubst new (applySubst old t) >>> composeSubst (Map.fromList []) (Map.fromList []) fromList [] >>> composeSubst (Map.fromList [(0,Fix (TBody (TVar 1)))]) (Map.fromList []) fromList [(0,Fix (TBody (TVar 1)))] >>> composeSubst (Map.fromList []) (Map.fromList [(0,Fix (TBody (TVar 1)))]) fromList [(0,Fix (TBody (TVar 1)))] >>> composeSubst (Map.fromList [(1,Fix (TBody (TVar 2)))]) (Map.fromList [(0,Fix (TBody (TVar 1)))]) fromList [(0,Fix (TBody (TVar 2))),(1,Fix (TBody (TVar 2)))] >>> composeSubst (Map.fromList [(0,Fix (TBody (TVar 1)))]) (Map.fromList [(1,Fix (TBody (TVar 2)))]) fromList [(0,Fix (TBody (TVar 2))),(1,Fix (TBody (TVar 2)))]

singletonSubst :: TVarName -> Type -> TSubst Source

newtype VarId Source

Constructors

VarId Int 

Instances

data NameSource Source

Constructors

NameSource 

Fields

lastName :: TVarName
 

Instances

addEquivalence :: TVarName -> TVarName -> Gr QualType () -> Gr QualType () Source

Adds a pair of equivalent items to an equivalence map. >>> import Infernu.Pretty >>> let m1 = addEquivalence 1 2 Map.empty >>> pretty m1 "Map (b => Set {b, c}, c => Set {b, c})" >>> pretty $ addEquivalence 1 3 m1 "Map (b => Set {b, c, d}, c => Set {b, c, d}, d => Set {b, c, d})" >>> pretty $ addEquivalence 3 1 m1 "Map (b => Set {b, c, d}, c => Set {b, c, d}, d => Set {b, c, d})" >>> pretty $ addEquivalence 4 5 m1 "Map (b => Set {b, c}, c => Set {b, c}, e => Set {e, f}, f => Set {e, f})" >>> pretty $ addEquivalence 1 4 $ addEquivalence 4 5 m1 "Map (b => Set {b, c, e, f}, c => Set {b, c, e, f}, e => Set {b, c, e, f}, f => Set {b, c, e, f})"

class VarNames a where Source

Methods

freeTypeVars :: a -> Set TVarName Source

mapVarNames :: (TVarName -> TVarName) -> a -> a Source

Instances

VarNames InferState

VarNames instance for InferState >>> :{ varInstances $ mapVarNames (k -> k + 1) $ emptyInferState { varInstances = Map.fromList [ (0, Set.fromList [ qualEmpty $ Fix $ TBody $ TVar 0, qualEmpty $ Fix $ TBody $ TVar 1]) , (1, Set.fromList [ qualEmpty $ Fix $ TBody $ TVar 0 , TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 3)] (Fix $ TBody $ TVar 1) ]) ]} :} fromList [(1,fromList [TQual {qualPred = [], qualType = Fix (TBody (TVar 1))},TQual {qualPred = [], qualType = Fix (TBody (TVar 2))}]),(2,fromList [TQual {qualPred = [], qualType = Fix (TBody (TVar 1))},TQual {qualPred = [TPredIsIn {predClass = ClassName Bla, predType = Fix (TBody (TVar 4))}], qualType = Fix (TBody (TVar 2))}])]

VarNames Type

VarNames instance for Type t

>>> freeTypeVars (Fix $ TBody TNumber)
fromList []
>>> freeTypeVars (Fix $ TBody $ TVar 0)
fromList [0]
>>> freeTypeVars (Fix $ TFunc [Fix $ TBody $ TVar 0] (Fix $ TBody $ TVar 1))
fromList [0,1]
>>> freeTypeVars (Fix $ TFunc [] (Fix $ TBody $ TVar 1))
fromList [1]
>>> freeTypeVars $ (Fix $ (TRow (TRowEnd (Just $ RowTVar 3))) :: Type)
fromList [3]
VarNames TBody 
VarNames TVarName 
VarNames t => VarNames [t] 
VarNames t => VarNames (TScheme t)

VarNames instance for TScheme >>> let sc v t = TScheme v (qualEmpty t) >>> freeTypeVars $ sc [0, 1] (Fix $ TBody $ TVar 2) fromList [2] >>> freeTypeVars $ sc [0, 1] (Fix $ TBody $ TVar 1) fromList [] >>> freeTypeVars $ sc [0] (Fix $ TBody $ TVar 1) fromList [1] >>> freeTypeVars $ sc [0] (Fix $ TBody $ TVar 0) fromList [] >>> freeTypeVars $ schemeEmpty (Fix $ TBody $ TVar 1) fromList [1] >>> freeTypeVars $ schemeEmpty (Fix $ TBody $ TNumber) fromList [] >>> freeTypeVars $ sc [1] (Fix $ TBody $ TNumber) fromList [] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 0)] (Fix $ TBody $ TVar 0)) fromList [] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 0)] (Fix $ TBody $ TVar 2)) fromList [2] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 2)] (Fix $ TBody $ TVar 2)) fromList [2] >>> freeTypeVars $ TScheme [0, 1] (TQual [TPredIsIn (ClassName Bla) (Fix $ TBody $ TVar 2)] (Fix $ TBody $ TVar 0)) fromList [2]

VarNames t => VarNames (TQual t) 
VarNames t => VarNames (TPred t) 
VarNames (FType (Fix FType)) 
VarNames t => VarNames (TRowList t)

VarNames instance for TRowList

>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody TNumber) (TRowEnd $ Just $ RowTVar 1))
fromList [1]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowEnd Nothing))
fromList [2]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowEnd $ Just $ RowTVar 1))
fromList [1,2]
>>> freeTypeVars (TRowProp "x" (schemeEmpty $ Fix $ TBody $ TVar 2) (TRowProp "y" (schemeEmpty $ Fix $ TBody $ TVar 3) (TRowEnd $ Just $ RowTVar 1)))
fromList [1,2,3]
VarNames t => VarNames (Exp (a, t)) 
VarNames t => VarNames (a, t) 
VarNames t => VarNames (Map a t) 

type EPropName = String Source

mapTopAnnotation :: (a -> a) -> Exp a -> Exp a Source