design type systems

Python’s type system has matured in practice, yet its theoretical foundations remain fragmented and inadequately standardized, lacking a unified, formal characterization. Method: This paper introduces the first rigorous, type-theoretic formalization of Python’s dynamic type system, systematically modeling its core syntactic and semantic constructs—including type annotations, variance (covariance/contravariance), generics, and runtime type checking—and verifying the model’s consistency and expressive power via static analysis techniques. Contribution/Results: The framework bridges the gap between industrial practice and theoretical research by providing the first provably sound and semantically transparent account of Python’s mainstream typing features. It establishes a solid theoretical foundation for high-precision type inference, tool verification, and type system evolution, while offering an extensible, principled modeling paradigm amenable to formal reasoning and practical implementation.

To address the challenges of ensuring correctness and managing high verification overhead in lightweight operating systems (e.g., Theseus, written in Rust), this paper proposes a hybrid correctness assurance methodology integrating Rust’s type checking with Coq-based formal verification. Innovatively adopting an *intralingual* design paradigm, it leverages Rust’s type system as a trusted extension of Coq’s logical foundation, enforcing critical invariants at compile time. By deliberately relaxing certain correctness guarantees—while preserving essential safety properties—the approach achieves a novel trade-off between verification efficiency and engineering practicality. The method has been successfully applied to verify Theseus’s memory subsystem and its 10 Gb Ethernet driver. It guarantees zero runtime violations of key safety invariants while reducing overall verification effort by over 60% and scaling verification scope by a factor of three.

Existing languages typically relegate refinement types to secondary annotations or separate specifications, hindering seamless integration with core language features such as subtyping, type inference, and pattern matching, thereby limiting their practical utility. This work presents the first integration of refinement types as first-class citizens in Scala 3, leveraging dependent function types, bounded polymorphism, recursion, and union/intersection types to deeply embed logical predicates into the type system. Building upon a partial correctness semantics, we develop a fuel-bounded semantic type system, formalize a core calculus, and prove its type safety. Furthermore, we implement a prototype extension of the Scala 3 compiler that combines Rocq-based verification with a lightweight e-graph-based predicate solver, enabling practical and scalable lightweight program verification.

To address the lack of high-precision static typing in the dynamically typed functional language Elixir, this paper proposes a progressive semantic subtyping system that requires no modifications to the compiler or runtime. Methodologically, it introduces the first strong static function identification mechanism, integrating fine-grained type inference—based on guard condition modeling and pattern matching—with formalized runtime checks within semantic subtyping theory; type checking is achieved non-intrusively and with zero migration overhead. The key contribution is the first support for high-precision type inference under semantic subtyping constraints within the Elixir ecosystem: it achieves full backward compatibility while significantly improving type coverage and safety. This work establishes a reusable theoretical framework and engineering paradigm for progressive typing in dynamic languages.

This work addresses the verification of linear lambda terms under de Bruijn notation by proposing a type system that obviates the need for explicit checks of variable usage counts. Inspired by Hodas and Miller’s resource consumption model, the system embeds resource management directly into its typing rules, ensuring that well-typed terms inherently satisfy linearity constraints. Building upon de Bruijn notation and resource-sensitive type theory, we formalize a complete set of type inference rules and prove that the system enjoys subject reduction, thereby guaranteeing type safety in linear computation. This approach substantially simplifies the verification of linearity while preserving theoretical rigor.

This work addresses the susceptibility of Erlang programs to runtime errors due to its dynamic typing and the lack of static checking support in existing type annotations. We present the first complete integration of a set-theoretic type system into Erlang, which supports dynamic type tests, subtyping, recursive types, parametric polymorphism, and untagged union types, while preserving both type safety and decidability alongside Erlang’s distinctive language features. We design and implement corresponding type inference and checking algorithms, and validate their effectiveness on the Erlang standard library, third-party projects, and the checker’s own codebase. The evaluation demonstrates the approach’s practicality by successfully identifying latent type errors, confirming its feasibility and utility in real-world scenarios.

This work addresses the lack of type safety in C’s preprocessor when generating program variants, which can yield ill-typed derivatives. To remedy this, the authors propose a lightweight core calculus for C (LC) and extend it with ANSI C preprocessor directives to form Colored LC (CLC). Building on this foundation, they design the first static type system for a C subset featuring preprocessor constructs, formally guaranteeing that all programs generated within a software product line are type-safe. This contribution provides a theoretically rigorous and pedagogically accessible formal basis for ensuring type safety in C-based software product lines.