Safe Haskell	None
Language	Haskell2010

Type.Check.HM.Type

Contents

Monomorphic types.
Typed values
Polymorphic types.

Description

This module contains the abstract syntax of Hindley-Milner types.

Synopsis

class (Show v, Ord v) => IsVar v where
- prettyLetters :: [v]
class HasLoc f where
- type Loc f :: *
- getLoc :: f -> Loc f
class DefLoc f where
- defLoc :: f
data TypeF loc var r
- = VarT loc var
- | ConT loc var [r]
- | ArrowT loc r r
- | TupleT loc [r]
- | ListT loc r
newtype Type loc var = Type {
- unType :: Fix (TypeF loc var)
}
varT :: loc -> var -> Type loc var
conT :: loc -> var -> [Type loc var] -> Type loc var
arrowT :: loc -> Type loc v -> Type loc v -> Type loc v
tupleT :: loc -> [Type loc var] -> Type loc var
listT :: loc -> Type loc var -> Type loc var
data Typed loc v a = Typed {
- typed'type :: Type loc v
- typed'value :: a
}
data SignatureF loc var r
- = ForAllT loc var r
- | MonoT (Type loc var)
newtype Signature loc var = Signature {
- unSignature :: Fix (SignatureF loc var)
}
forAllT :: loc -> v -> Signature loc v -> Signature loc v
monoT :: Type loc src -> Signature loc src
stripSignature :: Signature src var -> Type src var
splitSignature :: Signature loc var -> ([var], Type loc var)
typeToSignature :: (Eq loc, Ord v) => Type loc v -> Signature loc v
getTypeVars :: (Ord var, HasTypeVars f) => f src var -> [(src, var)]
newtype VarSet src var = VarSet {
- unVarSet :: Map var src
}
differenceVarSet :: Ord var => VarSet src var -> VarSet src var -> VarSet src var
varSetToList :: VarSet src var -> [(src, var)]
memberVarSet :: Ord var => var -> VarSet src var -> Bool
class HasTypeVars f where
- tyVars :: Ord var => f src var -> VarSet src var
- tyVarsInOrder :: (Eq src, Ord var) => f src var -> [(var, src)]
class LocFunctor f where
- mapLoc :: (locA -> locB) -> f locA var -> f locB var
setLoc :: LocFunctor f => loc -> f locA v -> f loc v
class TypeFunctor f where
- mapType :: (Type loc var -> Type loc var) -> f loc var -> f loc var
extractFunType :: Type loc var -> ([Type loc var], Type loc var)
extractArrow :: Type loc var -> Maybe (Type loc var, Type loc var)
isMono :: Type loc var -> Bool
isPoly :: Type loc var -> Bool

Documentation

class (Show v, Ord v) => IsVar v where Source #

Functions we need for variables to do type-inference.

Methods

prettyLetters :: [v] Source #

Canonical leters for pretty output

Instances

Instances details

IsVar Int Source #
Instance details Defined in Type.Check.HM.Type Methods prettyLetters :: [Int] Source #
IsVar String Source #
Instance details Defined in Type.Check.HM.Type Methods prettyLetters :: [String] Source #
IsVar Text Source #
Instance details Defined in Type.Check.HM.Type Methods prettyLetters :: [Text] Source #

class HasLoc f where Source #

Class to get source code location.

Associated Types

type Loc f :: * Source #

Type for source code location

Methods

getLoc :: f -> Loc f Source #

Get the source code location.

Instances

Instances details

HasLoc (Type loc v) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Loc (Type loc v) Source # Methods getLoc :: Type loc v -> Loc (Type loc v) Source #
HasLoc (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Loc (Signature loc var) Source # Methods getLoc :: Signature loc var -> Loc (Signature loc var) Source #
HasLoc (Term prim loc v) Source #
Instance details Defined in Type.Check.HM.Term Associated Types type Loc (Term prim loc v) Source # Methods getLoc :: Term prim loc v -> Loc (Term prim loc v) Source #

class DefLoc f where Source #

Type class for default location

Methods

defLoc :: f Source #

Instances

Instances details

DefLoc () Source #
Instance details Defined in Type.Check.HM.Type Methods defLoc :: () Source #

Monomorphic types.

data TypeF loc var r Source #

Type functor. Arguments are

loc - source code locations
var - variable name
r - recursion

There are only two requried constructors: VarT and ConT other constructors are used for convenience of pretty-printing the type.

Constructors

VarT loc var	Variables
ConT loc var [r]	type constant with list of arguments
ArrowT loc r r	Special case of ConT that is rendered as ->
TupleT loc [r]	Special case of ConT that is rendered as (,,,)
ListT loc r	Special case of ConT that is rendered as [a]

Instances

Instances details

Functor (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods fmap :: (a -> b) -> TypeF loc var a -> TypeF loc var b # (<$) :: a -> TypeF loc var b -> TypeF loc var a #
Foldable (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods fold :: Monoid m => TypeF loc var m -> m # foldMap :: Monoid m => (a -> m) -> TypeF loc var a -> m # foldMap' :: Monoid m => (a -> m) -> TypeF loc var a -> m # foldr :: (a -> b -> b) -> b -> TypeF loc var a -> b # foldr' :: (a -> b -> b) -> b -> TypeF loc var a -> b # foldl :: (b -> a -> b) -> b -> TypeF loc var a -> b # foldl' :: (b -> a -> b) -> b -> TypeF loc var a -> b # foldr1 :: (a -> a -> a) -> TypeF loc var a -> a # foldl1 :: (a -> a -> a) -> TypeF loc var a -> a # toList :: TypeF loc var a -> [a] # null :: TypeF loc var a -> Bool # length :: TypeF loc var a -> Int # elem :: Eq a => a -> TypeF loc var a -> Bool # maximum :: Ord a => TypeF loc var a -> a # minimum :: Ord a => TypeF loc var a -> a # sum :: Num a => TypeF loc var a -> a # product :: Num a => TypeF loc var a -> a #
Traversable (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods traverse :: Applicative f => (a -> f b) -> TypeF loc var a -> f (TypeF loc var b) # sequenceA :: Applicative f => TypeF loc var (f a) -> f (TypeF loc var a) # mapM :: Monad m => (a -> m b) -> TypeF loc var a -> m (TypeF loc var b) # sequence :: Monad m => TypeF loc var (m a) -> m (TypeF loc var a) #
(Eq loc, Eq var) => Eq1 (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftEq :: (a -> b -> Bool) -> TypeF loc var a -> TypeF loc var b -> Bool #
(Ord loc, Ord var) => Ord1 (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftCompare :: (a -> b -> Ordering) -> TypeF loc var a -> TypeF loc var b -> Ordering #
(Show loc, Show var) => Show1 (TypeF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> TypeF loc var a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [TypeF loc var a] -> ShowS #
(Eq loc, Eq var, Eq r) => Eq (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods (==) :: TypeF loc var r -> TypeF loc var r -> Bool # (/=) :: TypeF loc var r -> TypeF loc var r -> Bool #
(Data loc, Data var, Data r) => Data (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeF loc var r -> c (TypeF loc var r) # gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (TypeF loc var r) # toConstr :: TypeF loc var r -> Constr # dataTypeOf :: TypeF loc var r -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TypeF loc var r)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeF loc var r)) # gmapT :: (forall b. Data b => b -> b) -> TypeF loc var r -> TypeF loc var r # gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> TypeF loc var r -> r0 # gmapQr :: forall r0 r'. (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> TypeF loc var r -> r0 # gmapQ :: (forall d. Data d => d -> u) -> TypeF loc var r -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeF loc var r -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeF loc var r -> m (TypeF loc var r) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeF loc var r -> m (TypeF loc var r) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeF loc var r -> m (TypeF loc var r) #
(Ord loc, Ord var, Ord r) => Ord (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods compare :: TypeF loc var r -> TypeF loc var r -> Ordering # (<) :: TypeF loc var r -> TypeF loc var r -> Bool # (<=) :: TypeF loc var r -> TypeF loc var r -> Bool # (>) :: TypeF loc var r -> TypeF loc var r -> Bool # (>=) :: TypeF loc var r -> TypeF loc var r -> Bool # max :: TypeF loc var r -> TypeF loc var r -> TypeF loc var r # min :: TypeF loc var r -> TypeF loc var r -> TypeF loc var r #
(Show loc, Show var, Show r) => Show (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods showsPrec :: Int -> TypeF loc var r -> ShowS # show :: TypeF loc var r -> String # showList :: [TypeF loc var r] -> ShowS #
Generic (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Rep (TypeF loc var r) :: Type -> Type # Methods from :: TypeF loc var r -> Rep (TypeF loc var r) x # to :: Rep (TypeF loc var r) x -> TypeF loc var r #
type Rep (TypeF loc var r) Source #
Instance details Defined in Type.Check.HM.Type type Rep (TypeF loc var r) = D1 ('MetaData "TypeF" "Type.Check.HM.Type" "hindley-milner-type-check-0.1.1.0-9nmtzC9RFBTLXwkiC1uZyJ" 'False) ((C1 ('MetaCons "VarT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 loc) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 var)) :+: C1 ('MetaCons "ConT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 loc) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 var) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [r])))) :+: (C1 ('MetaCons "ArrowT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 loc) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 r) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 r))) :+: (C1 ('MetaCons "TupleT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 loc) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [r])) :+: C1 ('MetaCons "ListT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 loc) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 r)))))

newtype Type loc var Source #

Monomorphic types.

Constructors

Type
Fields unType :: Fix (TypeF loc var)

Instances

Instances details

HasTypeVars Type Source #
Instance details Defined in Type.Check.HM.Type Methods tyVars :: Ord var => Type src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => Type src var -> [(var, src)] Source #
TypeFunctor Type Source #
Instance details Defined in Type.Check.HM.Type Methods mapType :: (Type loc var -> Type loc var) -> Type loc var -> Type loc var Source #
LocFunctor Type Source #
Instance details Defined in Type.Check.HM.Type Methods mapLoc :: (locA -> locB) -> Type locA var -> Type locB var Source #
CanApply Type Source #
Instance details Defined in Type.Check.HM.Subst Methods apply :: Ord v => Subst loc v -> Type loc v -> Type loc v Source #
Functor (Type a) Source #
Instance details Defined in Type.Check.HM.Type Methods fmap :: (a0 -> b) -> Type a a0 -> Type a b # (<$) :: a0 -> Type a b -> Type a a0 #
(Eq loc, Eq var) => Eq (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods (==) :: Type loc var -> Type loc var -> Bool # (/=) :: Type loc var -> Type loc var -> Bool #
(Data loc, Data var) => Data (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type loc var -> c (Type loc var) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type loc var) # toConstr :: Type loc var -> Constr # dataTypeOf :: Type loc var -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type loc var)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type loc var)) # gmapT :: (forall b. Data b => b -> b) -> Type loc var -> Type loc var # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type loc var -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type loc var -> r # gmapQ :: (forall d. Data d => d -> u) -> Type loc var -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type loc var -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type loc var -> m (Type loc var) #
(Ord loc, Ord var) => Ord (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods compare :: Type loc var -> Type loc var -> Ordering # (<) :: Type loc var -> Type loc var -> Bool # (<=) :: Type loc var -> Type loc var -> Bool # (>) :: Type loc var -> Type loc var -> Bool # (>=) :: Type loc var -> Type loc var -> Bool # max :: Type loc var -> Type loc var -> Type loc var # min :: Type loc var -> Type loc var -> Type loc var #
(Show loc, Show var) => Show (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods showsPrec :: Int -> Type loc var -> ShowS # show :: Type loc var -> String # showList :: [Type loc var] -> ShowS #
Generic (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Rep (Type loc var) :: Type -> Type # Methods from :: Type loc var -> Rep (Type loc var) x # to :: Rep (Type loc var) x -> Type loc var #
(NFData loc, NFData var) => NFData (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods rnf :: Type loc var -> () #
PrettyVar v => Pretty (Type loc v) Source #
Instance details Defined in Type.Check.HM.Pretty Methods pretty :: Type loc v -> Doc ann # prettyList :: [Type loc v] -> Doc ann #
PrettyVar v => Pretty (FixityCtx v (Type loc v)) Source #
Instance details Defined in Type.Check.HM.Pretty Methods pretty :: FixityCtx v (Type loc v) -> Doc ann # prettyList :: [FixityCtx v (Type loc v)] -> Doc ann #
HasLoc (Type loc v) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Loc (Type loc v) Source # Methods getLoc :: Type loc v -> Loc (Type loc v) Source #
type Rep (Type loc var) Source #
Instance details Defined in Type.Check.HM.Type type Rep (Type loc var) = D1 ('MetaData "Type" "Type.Check.HM.Type" "hindley-milner-type-check-0.1.1.0-9nmtzC9RFBTLXwkiC1uZyJ" 'True) (C1 ('MetaCons "Type" 'PrefixI 'True) (S1 ('MetaSel ('Just "unType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Fix (TypeF loc var)))))
type Loc (Type loc v) Source #
Instance details Defined in Type.Check.HM.Type type Loc (Type loc v) = loc

varT :: loc -> var -> Type loc var Source #

varT loc x constructs a type variable named x with source code at loc.

conT :: loc -> var -> [Type loc var] -> Type loc var Source #

conT loc x constructs a type constant named x with source code at loc.

arrowT :: loc -> Type loc v -> Type loc v -> Type loc v Source #

arrowT loc t0 t1 constructs an arrow type from t0 to t1 with source code at loc.

tupleT :: loc -> [Type loc var] -> Type loc var Source #

tupleT loc ts constructs tuple of types ts with source code at loc.

listT :: loc -> Type loc var -> Type loc var Source #

listT loc t constructs list of t with source code at loc.

Typed values

data Typed loc v a Source #

Values that are tagged explicitly with their type.

Constructors

Typed
Fields typed'type :: Type loc v typed'value :: a

Instances

Instances details

Functor (Typed loc v) Source #
Instance details Defined in Type.Check.HM.Type Methods fmap :: (a -> b) -> Typed loc v a -> Typed loc v b # (<$) :: a -> Typed loc v b -> Typed loc v a #
Foldable (Typed loc v) Source #
Instance details Defined in Type.Check.HM.Type Methods fold :: Monoid m => Typed loc v m -> m # foldMap :: Monoid m => (a -> m) -> Typed loc v a -> m # foldMap' :: Monoid m => (a -> m) -> Typed loc v a -> m # foldr :: (a -> b -> b) -> b -> Typed loc v a -> b # foldr' :: (a -> b -> b) -> b -> Typed loc v a -> b # foldl :: (b -> a -> b) -> b -> Typed loc v a -> b # foldl' :: (b -> a -> b) -> b -> Typed loc v a -> b # foldr1 :: (a -> a -> a) -> Typed loc v a -> a # foldl1 :: (a -> a -> a) -> Typed loc v a -> a # toList :: Typed loc v a -> [a] # null :: Typed loc v a -> Bool # length :: Typed loc v a -> Int # elem :: Eq a => a -> Typed loc v a -> Bool # maximum :: Ord a => Typed loc v a -> a # minimum :: Ord a => Typed loc v a -> a # sum :: Num a => Typed loc v a -> a # product :: Num a => Typed loc v a -> a #
Traversable (Typed loc v) Source #
Instance details Defined in Type.Check.HM.Type Methods traverse :: Applicative f => (a -> f b) -> Typed loc v a -> f (Typed loc v b) # sequenceA :: Applicative f => Typed loc v (f a) -> f (Typed loc v a) # mapM :: Monad m => (a -> m b) -> Typed loc v a -> m (Typed loc v b) # sequence :: Monad m => Typed loc v (m a) -> m (Typed loc v a) #
(Eq loc, Eq v, Eq a) => Eq (Typed loc v a) Source #
Instance details Defined in Type.Check.HM.Type Methods (==) :: Typed loc v a -> Typed loc v a -> Bool # (/=) :: Typed loc v a -> Typed loc v a -> Bool #
(Data loc, Data v, Data a) => Data (Typed loc v a) Source #
Instance details Defined in Type.Check.HM.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Typed loc v a -> c (Typed loc v a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Typed loc v a) # toConstr :: Typed loc v a -> Constr # dataTypeOf :: Typed loc v a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Typed loc v a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Typed loc v a)) # gmapT :: (forall b. Data b => b -> b) -> Typed loc v a -> Typed loc v a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typed loc v a -> r # gmapQ :: (forall d. Data d => d -> u) -> Typed loc v a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Typed loc v a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Typed loc v a -> m (Typed loc v a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Typed loc v a -> m (Typed loc v a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Typed loc v a -> m (Typed loc v a) #
(Ord loc, Ord v, Ord a) => Ord (Typed loc v a) Source #
Instance details Defined in Type.Check.HM.Type Methods compare :: Typed loc v a -> Typed loc v a -> Ordering # (<) :: Typed loc v a -> Typed loc v a -> Bool # (<=) :: Typed loc v a -> Typed loc v a -> Bool # (>) :: Typed loc v a -> Typed loc v a -> Bool # (>=) :: Typed loc v a -> Typed loc v a -> Bool # max :: Typed loc v a -> Typed loc v a -> Typed loc v a # min :: Typed loc v a -> Typed loc v a -> Typed loc v a #
(Show loc, Show v, Show a) => Show (Typed loc v a) Source #
Instance details Defined in Type.Check.HM.Type Methods showsPrec :: Int -> Typed loc v a -> ShowS # show :: Typed loc v a -> String # showList :: [Typed loc v a] -> ShowS #

Polymorphic types.

data SignatureF loc var r Source #

Functor for signature is a special type that we need for type inference algorithm. We specify which variables in the type are schematic (non-free).

Constructors

ForAllT loc var r	specify schematic variable
MonoT (Type loc var)	contains the type

Instances

Instances details

Functor (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods fmap :: (a -> b) -> SignatureF loc var a -> SignatureF loc var b # (<$) :: a -> SignatureF loc var b -> SignatureF loc var a #
Foldable (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods fold :: Monoid m => SignatureF loc var m -> m # foldMap :: Monoid m => (a -> m) -> SignatureF loc var a -> m # foldMap' :: Monoid m => (a -> m) -> SignatureF loc var a -> m # foldr :: (a -> b -> b) -> b -> SignatureF loc var a -> b # foldr' :: (a -> b -> b) -> b -> SignatureF loc var a -> b # foldl :: (b -> a -> b) -> b -> SignatureF loc var a -> b # foldl' :: (b -> a -> b) -> b -> SignatureF loc var a -> b # foldr1 :: (a -> a -> a) -> SignatureF loc var a -> a # foldl1 :: (a -> a -> a) -> SignatureF loc var a -> a # toList :: SignatureF loc var a -> [a] # null :: SignatureF loc var a -> Bool # length :: SignatureF loc var a -> Int # elem :: Eq a => a -> SignatureF loc var a -> Bool # maximum :: Ord a => SignatureF loc var a -> a # minimum :: Ord a => SignatureF loc var a -> a # sum :: Num a => SignatureF loc var a -> a # product :: Num a => SignatureF loc var a -> a #
Traversable (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods traverse :: Applicative f => (a -> f b) -> SignatureF loc var a -> f (SignatureF loc var b) # sequenceA :: Applicative f => SignatureF loc var (f a) -> f (SignatureF loc var a) # mapM :: Monad m => (a -> m b) -> SignatureF loc var a -> m (SignatureF loc var b) # sequence :: Monad m => SignatureF loc var (m a) -> m (SignatureF loc var a) #
(Eq loc, Eq var) => Eq1 (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftEq :: (a -> b -> Bool) -> SignatureF loc var a -> SignatureF loc var b -> Bool #
(Ord loc, Ord var) => Ord1 (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftCompare :: (a -> b -> Ordering) -> SignatureF loc var a -> SignatureF loc var b -> Ordering #
(Show loc, Show var) => Show1 (SignatureF loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SignatureF loc var a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [SignatureF loc var a] -> ShowS #
(Eq loc, Eq var, Eq r) => Eq (SignatureF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods (==) :: SignatureF loc var r -> SignatureF loc var r -> Bool # (/=) :: SignatureF loc var r -> SignatureF loc var r -> Bool #
(Data loc, Data var, Data r) => Data (SignatureF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SignatureF loc var r -> c (SignatureF loc var r) # gunfold :: (forall b r0. Data b => c (b -> r0) -> c r0) -> (forall r1. r1 -> c r1) -> Constr -> c (SignatureF loc var r) # toConstr :: SignatureF loc var r -> Constr # dataTypeOf :: SignatureF loc var r -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SignatureF loc var r)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SignatureF loc var r)) # gmapT :: (forall b. Data b => b -> b) -> SignatureF loc var r -> SignatureF loc var r # gmapQl :: (r0 -> r' -> r0) -> r0 -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r0 # gmapQr :: forall r0 r'. (r' -> r0 -> r0) -> r0 -> (forall d. Data d => d -> r') -> SignatureF loc var r -> r0 # gmapQ :: (forall d. Data d => d -> u) -> SignatureF loc var r -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SignatureF loc var r -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SignatureF loc var r -> m (SignatureF loc var r) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SignatureF loc var r -> m (SignatureF loc var r) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SignatureF loc var r -> m (SignatureF loc var r) #
(Ord loc, Ord var, Ord r) => Ord (SignatureF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods compare :: SignatureF loc var r -> SignatureF loc var r -> Ordering # (<) :: SignatureF loc var r -> SignatureF loc var r -> Bool # (<=) :: SignatureF loc var r -> SignatureF loc var r -> Bool # (>) :: SignatureF loc var r -> SignatureF loc var r -> Bool # (>=) :: SignatureF loc var r -> SignatureF loc var r -> Bool # max :: SignatureF loc var r -> SignatureF loc var r -> SignatureF loc var r # min :: SignatureF loc var r -> SignatureF loc var r -> SignatureF loc var r #
(Show loc, Show var, Show r) => Show (SignatureF loc var r) Source #
Instance details Defined in Type.Check.HM.Type Methods showsPrec :: Int -> SignatureF loc var r -> ShowS # show :: SignatureF loc var r -> String # showList :: [SignatureF loc var r] -> ShowS #

newtype Signature loc var Source #

Signaure is a special type that we need for type inference algorithm. We specify which variables in the type are schematic (non-free).

Constructors

Signature
Fields unSignature :: Fix (SignatureF loc var)

Instances

Instances details

HasTypeVars Signature Source #
Instance details Defined in Type.Check.HM.Type Methods tyVars :: Ord var => Signature src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => Signature src var -> [(var, src)] Source #
LocFunctor Signature Source #
Instance details Defined in Type.Check.HM.Type Methods mapLoc :: (locA -> locB) -> Signature locA var -> Signature locB var Source #
CanApply Signature Source #
Instance details Defined in Type.Check.HM.Subst Methods apply :: Ord v => Subst loc v -> Signature loc v -> Signature loc v Source #
Functor (Signature loc) Source #
Instance details Defined in Type.Check.HM.Type Methods fmap :: (a -> b) -> Signature loc a -> Signature loc b # (<$) :: a -> Signature loc b -> Signature loc a #
(Eq loc, Eq var) => Eq (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods (==) :: Signature loc var -> Signature loc var -> Bool # (/=) :: Signature loc var -> Signature loc var -> Bool #
(Data loc, Data var) => Data (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Signature loc var -> c (Signature loc var) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Signature loc var) # toConstr :: Signature loc var -> Constr # dataTypeOf :: Signature loc var -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Signature loc var)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Signature loc var)) # gmapT :: (forall b. Data b => b -> b) -> Signature loc var -> Signature loc var # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Signature loc var -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Signature loc var -> r # gmapQ :: (forall d. Data d => d -> u) -> Signature loc var -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Signature loc var -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Signature loc var -> m (Signature loc var) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature loc var -> m (Signature loc var) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature loc var -> m (Signature loc var) #
(Ord loc, Ord var) => Ord (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods compare :: Signature loc var -> Signature loc var -> Ordering # (<) :: Signature loc var -> Signature loc var -> Bool # (<=) :: Signature loc var -> Signature loc var -> Bool # (>) :: Signature loc var -> Signature loc var -> Bool # (>=) :: Signature loc var -> Signature loc var -> Bool # max :: Signature loc var -> Signature loc var -> Signature loc var # min :: Signature loc var -> Signature loc var -> Signature loc var #
(Show loc, Show var) => Show (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Methods showsPrec :: Int -> Signature loc var -> ShowS # show :: Signature loc var -> String # showList :: [Signature loc var] -> ShowS #
PrettyVar v => Pretty (Signature loc v) Source #
Instance details Defined in Type.Check.HM.Pretty Methods pretty :: Signature loc v -> Doc ann # prettyList :: [Signature loc v] -> Doc ann #
PrettyVar v => Pretty (FixityCtx v (Signature loc v)) Source #
Instance details Defined in Type.Check.HM.Pretty Methods pretty :: FixityCtx v (Signature loc v) -> Doc ann # prettyList :: [FixityCtx v (Signature loc v)] -> Doc ann #
HasLoc (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type Associated Types type Loc (Signature loc var) Source # Methods getLoc :: Signature loc var -> Loc (Signature loc var) Source #
type Loc (Signature loc var) Source #
Instance details Defined in Type.Check.HM.Type type Loc (Signature loc var) = loc

forAllT :: loc -> v -> Signature loc v -> Signature loc v Source #

forAllT x t universally quantifies x in t.

monoT :: Type loc src -> Signature loc src Source #

monoT t lifts a monomorophic type t to a polymorphic one.

stripSignature :: Signature src var -> Type src var Source #

Removes all information on variables in the type. it gets the thing that we store in constructor MonoT.

splitSignature :: Signature loc var -> ([var], Type loc var) Source #

Separates type variables from type definition.

typeToSignature :: (Eq loc, Ord v) => Type loc v -> Signature loc v Source #

Converts simple type to signature with all free variables set to schematic.

getTypeVars :: (Ord var, HasTypeVars f) => f src var -> [(src, var)] Source #

Reads all type-variables.

newtype VarSet src var Source #

Set with information on source code locations. We use it to keep the source code locations for variables.

Constructors

VarSet
Fields unVarSet :: Map var src

Instances

Instances details

Ord var => Semigroup (VarSet src var) Source #
Instance details Defined in Type.Check.HM.Type Methods (<>) :: VarSet src var -> VarSet src var -> VarSet src var # sconcat :: NonEmpty (VarSet src var) -> VarSet src var # stimes :: Integral b => b -> VarSet src var -> VarSet src var #
Ord var => Monoid (VarSet src var) Source #
Instance details Defined in Type.Check.HM.Type Methods mempty :: VarSet src var # mappend :: VarSet src var -> VarSet src var -> VarSet src var # mconcat :: [VarSet src var] -> VarSet src var #

differenceVarSet :: Ord var => VarSet src var -> VarSet src var -> VarSet src var Source #

difference for VarSet's

varSetToList :: VarSet src var -> [(src, var)] Source #

Converts varset to list.

memberVarSet :: Ord var => var -> VarSet src var -> Bool Source #

Checks membership of the item in the varset.

class HasTypeVars f where Source #

The class of types which have free type variables.

Methods

tyVars :: Ord var => f src var -> VarSet src var Source #

tyVars t calculates the set of free type variables in t.

tyVarsInOrder :: (Eq src, Ord var) => f src var -> [(var, src)] Source #

tyVarsInOrder t is like tyVars t, except that the type variables are returned in the order in which they are encountered.

Instances

Instances details

HasTypeVars Type Source #
Instance details Defined in Type.Check.HM.Type Methods tyVars :: Ord var => Type src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => Type src var -> [(var, src)] Source #
HasTypeVars Signature Source #
Instance details Defined in Type.Check.HM.Type Methods tyVars :: Ord var => Signature src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => Signature src var -> [(var, src)] Source #
HasTypeVars TypeError Source #
Instance details Defined in Type.Check.HM.TypeError Methods tyVars :: Ord var => TypeError src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => TypeError src var -> [(var, src)] Source #
HasTypeVars (TyTerm prim) Source #
Instance details Defined in Type.Check.HM.TyTerm Methods tyVars :: Ord var => TyTerm prim src var -> VarSet src var Source # tyVarsInOrder :: (Eq src, Ord var) => TyTerm prim src var -> [(var, src)] Source #

class LocFunctor f where Source #

Mapping over source code locations. It's like functor but for source code locations.

Methods

mapLoc :: (locA -> locB) -> f locA var -> f locB var Source #

Instances

Instances details

LocFunctor Type Source #
Instance details Defined in Type.Check.HM.Type Methods mapLoc :: (locA -> locB) -> Type locA var -> Type locB var Source #
LocFunctor Signature Source #
Instance details Defined in Type.Check.HM.Type Methods mapLoc :: (locA -> locB) -> Signature locA var -> Signature locB var Source #
LocFunctor TypeError Source #
Instance details Defined in Type.Check.HM.TypeError Methods mapLoc :: (locA -> locB) -> TypeError locA var -> TypeError locB var Source #
LocFunctor (Term prim) Source #
Instance details Defined in Type.Check.HM.Term Methods mapLoc :: (locA -> locB) -> Term prim locA var -> Term prim locB var Source #
LocFunctor (TyTerm prim) Source #
Instance details Defined in Type.Check.HM.TyTerm Methods mapLoc :: (locA -> locB) -> TyTerm prim locA var -> TyTerm prim locB var Source #

setLoc :: LocFunctor f => loc -> f locA v -> f loc v Source #

Sets the source code location to given value for all expressions in the functor.

class TypeFunctor f where Source #

Mapps over all types that are contained in the value

Methods

mapType :: (Type loc var -> Type loc var) -> f loc var -> f loc var Source #

Instances

Instances details

TypeFunctor Type Source #
Instance details Defined in Type.Check.HM.Type Methods mapType :: (Type loc var -> Type loc var) -> Type loc var -> Type loc var Source #
TypeFunctor (Term prim) Source #
Instance details Defined in Type.Check.HM.Term Methods mapType :: (Type loc var -> Type loc var) -> Term prim loc var -> Term prim loc var Source #
TypeFunctor (TyTerm prim) Source #
Instance details Defined in Type.Check.HM.TyTerm Methods mapType :: (Type loc var -> Type loc var) -> TyTerm prim loc var -> TyTerm prim loc var Source #

extractFunType :: Type loc var -> ([Type loc var], Type loc var) Source #

If underlying type is a function with several arguments it extracts its list of arguments and result type.

extractArrow :: Type loc var -> Maybe (Type loc var, Type loc var) Source #

If underlying type is an arrow it extracts its single argument and result type.

isMono :: Type loc var -> Bool Source #

Checks that type is monomorphic.

isPoly :: Type loc var -> Bool Source #

Checks that type is polymorphic.