🥮 mooncakes.io

    marianoguerra/pure-py/types does not have a README file

    ClassTable

    source

    The class table Σ: every class declared so far, by qualified name.

    A port of the reference's classes.py. A class has type parameters, and its base is a class type applied to arguments in terms of them.

    ClassTableEntry

    source
    pub(all) struct ClassTableEntry {
      type_params : Array[String]
      own_fields : Array[(String, Type)]
      base : (String, Array[Type])?
    } derive(Eq, 
    Debug    )

    FieldMapFailure

    source
    pub(all) enum FieldMapFailure {
      ArityMismatch(expected~ : Int, given~ : Int)
      UnknownKeywordArgs(Array[String])
    }

    Why field_map is undefined.

    FieldScheme

    source
    pub(all) struct FieldScheme {
      type_params : Array[String]
      fields : Array[(String, Type)]
    } derive(Eq, 
    Debug    )

    A class's fields, generic in its type parameters.
    pub(all) enum Head {
      HLit(Lit)
      HClass(String)
      HLen(Int)
    } derive(Compare, Eq, 
    Debug    )

    A head: a literal, a class, or a length n standing for the head list_n.

    Instance

    source
    pub(all) enum Instance {
      Found(String, Array[Type])
      Undetermined
      NoInstance
    }

    The instance of a class a type determines: at a class type above it or below it, the class at the arguments that make the two agree.

    Lit

    source
    pub(all) enum Lit {
      NoneLit
      Bool(Bool)
      Int(
    BigInt    )
      Float(Double)
      Str(String)
    } derive(Compare, Eq, 
    Debug    )

    The value of a literal type.

    Equality compares the value's Python type as well as the value, as LiteralType.__eq__ does, since True == 1 and 1 == 1.0 hold between values of different types and Literal[True] is not Literal[1]. Separate arms give that for free.

    Lit::repr

    source
    fn Lit::repr(self : Lit) -> String

    Python's repr of the value, which is what Literal[...] prints.

    Member

    source
    pub(all) enum Member {
      Typed(Type)
      AnnotationOnly
      ClassOf(String)
    } derive(Eq, 
    Debug    )

    What a predefined member is to the checker.

    Primitive

    source
    pub(all) enum Primitive {
      Object
      Never
      NoneType
      Bool
      Int
      Float
      Str
      Sized
    } derive(Compare, Eq, 
    Debug    )

    The types of PurePy, and the annotations that spell them.

    A port of the reference's type_syntax.py. Two layers, as there: a TypeExpr is what an annotation SAYS, with class names unresolved, and a Type is what it MEANS once every name has been looked up in the module's context. The checker resolves one into the other (resolve_type in lib/check), because only it has the context.

    Primitive::name

    source
    fn Primitive::name(self : Primitive) -> String

    The name an annotation spells a primitive with, and the one render prints.

    Resolved

    source
    pub(all) struct Resolved {
      params : Array[Type]
      result : Type
    } derive(Eq, 
    Debug    )

    The overloads of the operators: a port of the reference's operators.py.

    An overload resolves to the parameter types it was chosen at and its result. The candidates of an operator are tried at the operand types and again at their base types (so Literal[1] + Literal[2] finds int + int), duplicates are dropped keeping the first, and the least of what is left wins (minimum).

    Shape

    source
    pub(all) enum Shape {
      Rest(Type, Array[Head])
      Constr(Type, Array[Shape], Array[Head])
      Tuple(Array[Shape])
      List(Type, Array[Shape])
      Dict(Type, Array[(String, Shape)], Array[String])
    } derive(Eq, 
    Debug    )

    Type

    source
    pub(all) enum Type {
      Prim(Primitive)
      List(Type)
      Tuple(Array[Type])
      Dict(Type)
      Callable(Array[Type], Type)
      Literal(Lit)
      TypeVar(String)
      Class(String, Array[Type])
      Union(Type, Type)
      Defaulted(Array[Type], Int, Type)
      Builtin(String)
    } derive(Compare, Eq, 
    Debug    )

    A type. A class is named by its qualified name, which is what identifies it in the class table: two classes of one name in two modules are two classes.

    TypeExpr

    source
    pub(all) enum TypeExpr {
      PrimE(Primitive)
      ListE(TypeExpr)
      TupleE(Array[TypeExpr])
      DictE(TypeExpr)
      CallableE(Array[TypeExpr], TypeExpr)
      LitE(Lit)
      TypeName(Array[String], Array[TypeExpr])
      UnionE(TypeExpr, TypeExpr)
    } derive(Eq, 
    Debug    )

    What an annotation says, before its class names are resolved.

    all_pairs

    source
    fn[A, B] all_pairs(xs : Array[A], ys : Array[B], f : (A, B) -> Bool) -> Bool

    Whether f holds of every pair zip(xs, ys) makes: Python's zip, which stops at the shorter.

    ancestors

    source
    fn ancestors(sigma : 
    SortedMap    [String, ClassTableEntry], c : String) -> Array[String]

    The class and every class it inherits from, nearest first.

    base_of

    source
    fn base_of(sigma : 
    SortedMap    [String, ClassTableEntry], c : String) -> (String, Array[Type])?

    base_type

    source
    fn base_type(tau : Type) -> Type

    The type a literal's value belongs to; any other type is its own base.

    below_excluded

    source
    fn below_excluded(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, hs : Array[Head]) -> Bool

    binary_overloads

    source

    The binary operators by the name a message prints.

    comparable

    source
    fn comparable(sigma : 
    SortedMap    [String, ClassTableEntry], s : Type, t : Type) -> Bool

    declared_type

    source
    fn declared_type(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, args : Array[Type], x : String) -> Type

    disjuncts

    source
    fn disjuncts(tau : Type) -> Array[Type]

    The parts of a union, left to right.

    dotted_name

    source
    fn dotted_name(e : 
    Expr    ) -> Array[String]?

    a, a.b, a.b.c as its parts; None for anything else.

    empty_class_table

    source

    equality_type

    source
    fn equality_type(sigma : 
    SortedMap    [String, ClassTableEntry], t : Type) -> Bool

    Whether values of a type can be compared with ==: anything but a function, and anything that holds no function.

    equivalent

    source
    fn equivalent(sigma : 
    SortedMap    [String, ClassTableEntry], s : Type, t : Type) -> Bool

    field_map

    source
    fn[T] field_map(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, positional : Array[T], kwd_names : Array[String], kwd_values : Array[T]) -> Array[(String, T)]?

    Match a constructor's or a pattern's arguments to the class's fields, as pairs in the order the dict the reference builds iterates: the positional ones first, then the keywords as written.

    None when the count is wrong, or the keywords are not exactly the fields the positional arguments left over.

    field_names

    source
    fn field_names(sigma : 
    SortedMap    [String, ClassTableEntry], c : String) -> Array[String]

    field_type

    source
    fn field_type(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, args : Array[Type], x : String) -> Type?

    A field's type at a class type's arguments.

    fields

    source

    Every field, inherited first, generic in the class's type parameters.
    fn fv(tau : Type) -> Array[String]

    The type variables a type mentions.

    head_typed

    source
    fn head_typed(sigma : 
    SortedMap    [String, ClassTableEntry], h : Head, tau : Type) -> Bool

    heads_add

    source
    fn heads_add(hs : Array[Head], h : Head) -> Array[Head]

    A set of heads, as a sorted array with no repeats.

    instance

    source
    fn instance(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, tau : Type) -> Instance

    instance_above

    source
    fn instance_above(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, tau : Type) -> Instance

    instance_below

    source
    fn instance_below(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, tau : Type) -> Instance

    instantiate

    source
    fn instantiate(pi : FieldScheme, taus : Array[Type]) -> Array[(String, Type)]

    The fields at the type arguments taus.

    instantiated_ancestor

    source
    fn instantiated_ancestor(sigma : 
    SortedMap    [String, ClassTableEntry], tau : Type, d : String) -> (String, Array[Type])

    The instantiation of ancestor d of a class type, reached along the base classes.

    join

    source

    join_seq

    source

    The join of a sequence, folded from the right as the reference does: join(t0, join(t1, ... join(tn, Never))).

    keys_add

    source
    fn keys_add(ks : Array[String], k : String) -> Array[String]

    lit_base

    source
    fn lit_base(v : Lit) -> Type

    lit_of_constant

    source

    The literal a constant is, if it is one a literal type can hold.

    literal_type

    source
    fn literal_type(e : 
    Expr    ) -> Lit?

    The literal an expression spells: a constant, or a negated number.

    lookup

    source
    fn[T] lookup(pairs : Array[(String, T)], x : String) -> T

    The value field_map paired with field x.

    meet

    source

    minimum

    source

    The first candidate whose parameters are below every other candidate's, position by position.

    no_field_map

    source
    fn no_field_map(sigma : 
    SortedMap    [String, ClassTableEntry], c : String, n : Int, kwd_names : Array[String]) -> FieldMapFailure

    overloads_binary

    source
    fn overloads_binary(sigma : 
    SortedMap    [String, ClassTableEntry], op : String, s : Type, t : Type) -> Array[Resolved]

    overloads_unary

    source
    fn overloads_unary(sigma : 
    SortedMap    [String, ClassTableEntry], op : String, s : Type) -> Array[Resolved]

    parse_annotation

    source
    fn parse_annotation(e : 
    Expr    ) -> TypeExpr?

    What an annotation says, or None when it is not one PurePy has.

    predefined_classes

    source

    The class table every program starts with: range, with its start and its stop.

    predefined_members

    source
    fn predefined_members(q : String) -> Array[(String, Member)]?

    The predefined modules of Figure 2.7 and what each member is: the reference's PREDEFINED_MEMBERS. The table lives here, below both the checker and the evaluator, because both have to agree on it: a name the checker accepts and the evaluator has no value for would type-check and then fail to run.

    predefined_modules

    source
    let predefined_modules : Array[String]

    The modules the specification predefines.

    primitives

    source
    let primitives : Array[Primitive]

    Every primitive, in the reference's declaration order.

    product

    source
    fn[T] product(lists : ArrayView[Array[T]]) -> Array[Array[T]]

    itertools.product: the last list varies fastest.

    range_class

    source
    let range_class : String

    builtins.range, the one class the specification predefines.

    render

    source
    fn render(tau : Type) -> String

    A type as a message prints it.

    shape_type

    source
    fn shape_type(k : Shape) -> Type

    shapes

    source

    The shapes of the values of tau that no head in hs excludes.

    shapes_seq

    source

    Every combination of one shape per type: itertools.product of the shapes of each, last component varying fastest.

    short_name

    source
    fn short_name(c : String) -> String

    The last segment of a class's qualified name: what a message prints.

    subscript_args

    source

    substitute

    source
    fn substitute(taus : ArrayView[Type], alphas : ArrayView[String], sigma : Type) -> Type

    The types taus put for the parameters alphas in sigma.

    subtype

    source

    t_bool

    source
    let t_bool : Type

    t_float

    source
    let t_float : Type

    t_int

    source
    let t_int : Type

    t_never

    source
    let t_never : Type

    t_none

    source
    let t_none : Type

    t_object

    source
    let t_object : Type

    t_sized

    source
    let t_sized : Type

    t_str

    source
    let t_str : Type

    type_args

    source
    fn type_args(sigma : 
    SortedMap    [String, ClassTableEntry], alphas : Array[String], s : Type, t : Type) -> Array[(String, Type)]

    The type arguments for alphas a generic s takes when a value of type t is given for it: a map from type parameter to type. A type variable not among alphas is a type, not a parameter to solve for.

    type_args_seq

    source
    fn type_args_seq(sigma : 
    SortedMap    [String, ClassTableEntry], alphas : Array[String], ss : Array[Type], ts : Array[Type]) -> Array[(String, Type)]

    type_params_of

    source
    fn type_params_of(sigma : 
    SortedMap    [String, ClassTableEntry], c : String) -> Array[String]

    typed_heads

    source

    unary_overloads

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io