curry.typecheck.sigtable module

The signature table: the type schemes of Curry symbols, read from the FlatCurry interfaces that the front end writes.

The front end writes the interface M.fint of every module M it compiles. The interface holds the type of every function and constructor, after the dictionary translation of the type classes, and the translation to ICurry drops it. This module reads the interface on demand. It never parses a whole file. Interface indexes the text once, with one regular expression that skips quoted names, and records the offset of every Func, Type, TypeSyn, TypeNew, Cons and NewCons entry. An entry is decoded with the FlatCurry reader the first time a symbol asks for it.

A Scheme is the type of one symbol. The class context comes from the leading dictionary parameters of the FlatCurry type: a constraint C a is a parameter of type () -> _Dict#C a. The scheme of a constructor comes from its Type entry. show_scheme() prints a scheme in Curry syntax, for example Num a => a -> a -> a.

The instances come from the names _inst#Class#Type of the loaded modules; the context of an instance comes from its type. The naming convention is the one of curry-frontend 2.0.0, the front end of PAKCS 3.4.1. The table checks for _inst#Prelude.Num#Prelude.Int when it reads the interface of the Prelude.

One SignatureTable belongs to one interpreter, as interp.sigtable. Interpreter.reset clears it. A symbol without a scheme is an error only when the caller asks for one with required=True; an untyped use of a symbol never reads the table.

class curry.typecheck.sigtable.Instance(classname, typename, modulename, name, scheme)

Bases: object

A class instance, from the function _inst#Class#Type of the module that declares it.

Variables:

• classname – The qualified class name, e.g., Prelude.Show.

• typename – The type constructor as the name spells it: qualified, e.g., Prelude.Maybe, or one of the special constructors [], (), (,) and so on, and (->).

• modulename – The module that declares the instance.

• name – The name of the instance function in that module.

• scheme – The scheme of the instance function. Its context is the instance context; its type is () -> _Dict#Class head.

classname

property context

property fullname

property head

The instance head, e.g., TCons ("Prelude","Maybe") [TVar 0].

modulename

name

scheme

typename

class curry.typecheck.sigtable.Interface(path, data=None)

Bases: object

One FlatCurry interface, indexed by the offsets of its entries.

Variables:

• path – The file.

• data – Its text, as bytes.

• name – The module name the interface declares.

• imports – The imported modules.

constructor(name)

The constructor name: a pair of its type declaration and its Cons or NewCons entry, or None.

constructor_names()

function(name)

The Func entry of name, or None.

function_names()

instance_names()

The names of the instance functions, _inst#Class#Type.

classmethod load(path)

Reads an interface. Files are cached by name, size, and time.

classmethod purge()

Forgets the cached interfaces whose files are gone.

scheme(name, is_constructor=False)

The scheme of a function or constructor of this module, or None.

type_decl(name)

The Type, TypeSyn or TypeNew entry of name, or None.

type_names()

exception curry.typecheck.sigtable.InterfaceError

Bases: CurryTypeError

An interface is missing or unreadable, a needed entry is absent, or a name does not follow the convention of the pinned front end.

class curry.typecheck.sigtable.Predicate(*args)

Bases: Predicate

A class constraint C t. classname is the qualified name of the class, e.g., Prelude.Num; typeexpr is the constrained type.

class curry.typecheck.sigtable.Scheme(modulename, name, typevars, context, typeexpr, arity, ndicts, flat_typeexpr=None, is_constructor=False)

Bases: object

The type scheme of one symbol.

Variables:

• modulename – The module of the symbol.

• name – The name of the symbol in its module.

• typevars – The quantified type variables as pairs (index, kind), the top quantifier first, then the own quantifier of a class method.

• context – The class constraints, a tuple of Predicate, recovered from the leading dictionary parameters in their order.

• typeexpr – The type without the dictionary parameters and the quantifiers.

• arity – The FlatCurry arity. The leading dictionary parameters count.

• ndicts – The number of dictionary parameters, in the order the symbol takes them. A class method with its own constraints, such as round, takes the dictionaries of those constraints after its FlatCurry parameters.

• flat_typeexpr – The type as the interface writes it, dictionaries and quantifiers included. None for a built-in scheme.

• is_constructor – Whether the symbol is a data constructor.

arity

context

flat_typeexpr

property fullname

is_constructor

modulename

name

ndicts

property source_arity

the arity less the dictionaries, at least zero.

Type:

The number of value parameters among the FlatCurry parameters

typeexpr

typevars

class curry.typecheck.sigtable.SignatureTable(interp)

Bases: object

The type schemes of the symbols of one interpreter.

The table finds the interface of a module from the module’s source file (interface_candidates()), indexes it once, and decodes one entry per symbol on first use. It memoizes per module object, so the modules of compile(mode='expr') are served while they live. clear() forgets everything; Interpreter.reset calls it.

static check_frontend(iface)

Checks that an interface of the Prelude names its instances as curry-frontend 2.0.0 does. Raises InterfaceError otherwise.

clear()

Forgets every interface, scheme and instance.

instance(classname, typename)

The Instance of a class at a type constructor, or None. The class is qualified, e.g., Prelude.Show; the type constructor is qualified or special, e.g., Prelude.Maybe or [].

instances()

The instance map over the loaded modules: a dict from the pair of the qualified class name and the type constructor name to the Instance. Every loaded module is scanned for its _inst#Class#Type functions. Two modules that declare the same instance are an error.

instances_of(classname)

The instances of one class, by type constructor name.

interface(module)

The Interface of a module, given as a module object or as the name of a loaded module, or None when no interface file exists.

interface_filename(module)

The interface file of a module, or None.

property interp

lookup(symbol, required=False)

The Scheme of a symbol, or None when the symbol has none.

Parameters:

• symbol – A CurryNodeInfo or the fully-qualified name of a symbol of a loaded module.

• required – Whether a missing scheme is an error. The typed path asks for a scheme that way; an untyped use never asks.

Raises:

InterfaceError – required is set and the symbol has no scheme.

modules()

The names of the modules whose interface the table has found.

type_decl(typename)

The Type, TypeSyn or TypeNew entry of a type, given by its fully-qualified name, e.g., Prelude.IO, or None.

curry.typecheck.sigtable.find_interface(filename, modulename)

The interface file of a module, or None.

curry.typecheck.sigtable.interface_candidates(filename, modulename)

The places where the interface of a module may lie, in the order of the search. filename is the Curry source. The copy beside the module’s ICurry file is read, under the directory of the source and under the root of the module; the step that writes the ICurry file writes it (see cache.INTERFACE_SUFFIXES). The front end’s own copy under .curry/<frontend_subdir>/ is never read: after a hit of the ICurry cache it can belong to another version of the source.

curry.typecheck.sigtable.module_root(dirname, modulename)

The root of the module modulename whose source lies in dirname: the directory without the package path. The root of A.B at <root>/A/B.curry is <root>.

curry.typecheck.sigtable.show_predicate(pred, names=None, module=None)

Prints a class constraint, e.g., Show (Maybe a).

curry.typecheck.sigtable.show_scheme(scheme, module=None, qualify=None)

Prints a scheme in Curry syntax with the context folded back, e.g., Num a => a -> a -> a. The variables are named in the order of their first occurrence in the type; a variable of the context alone comes last. Names of the Prelude and of the scheme’s own module are unqualified; module names another module whose names stay unqualified, and qualify=True qualifies every name outside the Prelude.

curry.typecheck.sigtable.show_type(typeexpr, names=None, module=None)

Prints a type in Curry syntax. Variables are named a, b, c, … in the order of their first occurrence; names may be a mapping from variable index to name. Names of the Prelude and of module are unqualified.

curry.typecheck.sigtable.typevar_name(i)

The name of the i-th type variable: a to z, then a1 to z1, and so on.