module-system - SKILL.md Agent Skill

name: module-system description: "Implement module systems for organizing code, encapsulation, and namespace management." version: "1.0.0" tags: [runtime, modules, pldi, design] difficulty: intermediate languages: [ocaml, haskell, rust] dependencies: [type-checker-generator]

Module System

Module systems provide mechanisms for organizing code, encapsulating implementation details, and managing namespaces. They are essential for building large-scale software systems.

When to Use This Skill

Designing language module systems
Building large codebases
Implementing encapsulation
Managing dependencies
Teaching programming language design

What This Skill Does

Namespace Management: Organize names into hierarchical namespaces
Encapsulation: Hide implementation details
Interface/Implementation Separation: Define signatures and structures
Functors/Parameterized Modules: Create module-level functions
Dependency Management: Handle module dependencies

Key Concepts

Concept	Description
Module	Collection of related definitions
Signature	Module interface specification
Structure	Module implementation
Functor	Module-level function
Sealing	Hide implementation behind signature
Import	Use definitions from another module

Tips

Use signatures for abstraction
Seal modules to hide implementation
Use functors for generic libraries
Consider cyclic dependencies carefully
Separate interface from implementation

Common Use Cases

Large-scale software organization
Library design
Namespace management
Information hiding
Dependency injection via functors

Related Skills

type-class-implementer - Alternative abstraction mechanism
ffi-designer - Foreign function interface
type-checker-generator - Type checking for modules

Canonical References

Reference	Why It Matters
MacQueen "Modules for Standard ML"	Original ML modules
Leroy "Manifest types, modules, and separate compilation"	OCaml modules
Dreyer "Understanding and Evolving ML Modules"	Modern treatment

Tradeoffs and Limitations

Approach Tradeoffs

Approach	Pros	Cons
Simple modules	Easy to implement	Limited abstraction
ML-style	Powerful abstraction	Complex
Mixins/Traits	Composable	No sealing

When NOT to Use This Skill

Small single-file programs
When simple imports suffice
Prototype/experimental code

Limitations

Cyclic dependencies are tricky
Higher-order modules are complex
Type abstraction can be limited

Assessment Criteria

A high-quality implementation should have:

Criterion	What to Look For
Encapsulation	Hides implementation
Namespace	Manages names properly
Dependencies	Handles imports correctly
Abstraction	Supports signatures

Quality Indicators

✅ Good: Full encapsulation, proper namespacing, functor support ⚠️ Warning: Leaky abstraction, complex dependency handling ❌ Bad: No encapsulation, namespace pollution

Research Tools & Artifacts

Real-world module systems:

Tool	Why It Matters
OCaml modules	Full-featured modules
ML signatures	ML module system
Rust modules	Simple module system
Java modules (JDK 9)	Java module system

Key Systems

GHC Haskell: Type-based modules
Dune: OCaml build system

Research Frontiers

Current module research:

Direction	Key Papers	Challenge
Hierarchical	"Hierarchical Modules"	Scale
Mixins	"Mixins"	Composition
Types	"Modules as Types"	Type-based

Hot Topics

Wasm modules: WebAssembly modules
ES modules: JavaScript modules

Implementation Pitfalls

Common module bugs:

Pitfall	Real Example	Prevention
Cyclic deps	Circular imports	Detect cycles
Name collision	Name conflicts	Namespaces