15312 Foundations Of Programming Languages ((better)) -

Feature: Type Inference with Parametric Polymorphism

Language: We'll implement this feature in a fictional language called "PolyLambda".

Description: PolyLambda is a statically typed, functional programming language that supports parametric polymorphism. Our feature, "Type Inference with Parametric Polymorphism," allows the compiler to automatically infer the types of polymorphic functions, making it easier for developers to write generic code. 15312 foundations of programming languages

Motivation: Parametric polymorphism enables developers to write reusable code that works with multiple data types. However, manually specifying type parameters can be cumbersome and error-prone. By adding type inference, we can alleviate this burden and make PolyLambda more expressive and user-friendly.

Implementation:

3. Analyzing Language Trade-Offs

• Evaluating the trade-offs between different language design choices.

4. Type Safety Theorem

Theorem (Safety): If ( \cdot \vdash e : \tau ) and ( e \Downarrow v ), then ( \cdot \vdash v : \tau ).

This follows from:

• Progress: If ( \cdot \vdash e : \tau ), then either ( e ) is a value or exists ( e' ) such that ( e \rightarrow e' ).
• Preservation: If ( \cdot \vdash e : \tau ) and ( e \rightarrow e' ), then ( \cdot \vdash e' : \tau ).

Parametric Polymorphism and Abstraction

The essay on 15-312 would be incomplete without addressing Parametric Polymorphism (generics). Most students encounter generics as a way to write "reusable code." 15-312 redefines this through the lens of Abstraction.

The course utilizes a modularity theorem that shows how abstract types hide implementation details. It teaches that a polymorphic function (one that works for any type $\alpha$) is constrained by its ignorance. If you write a function that takes a list of items of type $\alpha$, you cannot know what $\alpha$ is. Therefore, you cannot perform operations specific to integers or strings. "Type Inference with Parametric Polymorphism

This constraint is a feature, not a bug. It guarantees that the function is purely algebraic and detached from specific implementation details. This instills a deep appreciation for abstraction barriers—a concept that is crucial in large-scale software architecture, yet often lost in the weeds of object-oriented inheritance hierarchies.