Let Functions Speak: Lightweight Parametric Polymorphism via Domain and Range Types

2026-03-24

AI Summary

This work addresses the erosion of TypeScript’s static guarantees caused by the pervasive use of the `any` type in function decorators within dynamic languages. We propose the F<:DR calculus, which introduces domain (Dom(T)) and range (Range(T)) projection types to enable precise type checking for arbitrary function calls while preserving compatibility with System F<:. The approach supports lightweight parametric polymorphism, allowing safe expression of higher-order function patterns without resorting to unsafe `any` types. Leveraging logical relations and a path-selection mechanism, we formalize and prove the semantic type safety of F<:DR in Rocq. Moreover, the design naturally extends to other projection scenarios, such as product types.

Technology Category

• Reasoning under Uncertainty: Other Foundations of Reasoning under Uncertainty
• Knowledge Representation and Reasoning: Description Logics
• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Systems and Infrastructure for Web, Mobile and WoT: Experiences and lessons learnt from Web-based algorithms and system deployments
• Security and Privacy: Data transparency and provenance

Abstract

Dynamic languages such as Python and JavaScript widely use function decorators to extend behavior. In TypeScript, a common way to type such patterns uses Parameters<T> and ReturnType<T>. In practice, this idiom relies on a function-type bound for T that is expressed using the unsafe type any, which weakens static guarantees. At the core is a standard typing principle: application is justified only when the callee is exposed as an arrow type. We present F<:DR, a calculus that adds domain and range projection types, Dom(T) and Range(T), for arbitrary types T. These projections permit typing applications through abstract function types: an argument of type Dom(T) witnesses callability, and the result is typed as Range(T). This design complements, rather than replaces, standard arrow-based application, which remains admissible via subtyping in System F<:. We mechanize F<:DR in Rocq and prove semantic type soundness using logical relations with path selection, which delays projection interpretation until function structure is resolved. The same technique extends to additional projection types, illustrated for primitive pairs, i.e., product types.

Problem

• parametric polymorphism
• function types
• type safety
• domain and range types
• static typing

Innovation

• domain and range types
• parametric polymorphism
• type soundness
• function decorators
• projection types