[Paper Review] Close Encounters of the Higher Kind Emulating Constructor Classes in Standard ML

Yutaka Nagashima, Liam O’Connor|arXiv (Cornell University)|Aug 11, 2016

Logic, programming, and type systems4 references3 citations

TL;DR

This paper presents a technique to emulate constructor classes—such as Monad, Applicative, and Functor—in Standard ML using only the language's module system, without language extensions. By leveraging ML functors to automatically derive functions and instantiate superclasses from minimal definitions (e.g., return and bind), the approach enables full abstraction instantiation with zero code duplication, supporting over 20 derived functions from just two user-defined operations.

ABSTRACT

We implement a library for encoding constructor classes in Standard ML, including elaboration from minimal definitions, and automatic instantiation of superclasses.

Motivation & Objective

• To enable constructor classes like Monad and Applicative in Standard ML without modifying the language.
• To eliminate code duplication by automatically deriving standard functions (e.g., join, liftM) from minimal definitions.
• To support automatic superclass instantiation, such as deriving Applicative and Functor instances from a Monad definition.
• To provide a transferable, extensible framework compatible with all ML dialects that support modules.
• To handle complex cases like monad transformers and multiple inheritance (e.g., diamond problem) using static, mathematically sound module composition.

Proposed method

• Using ML functors to transform minimal definitions (e.g., return and bind) into full constructor class instances.
• Defining elaboration functors like mk_Monad that generate complete signatures from minimal ones.
• Employing reverse subtyping via functors such as Mona_Min_To_App_Min to derive superclass instances from minimal definitions.
• Formalizing monad transformers as parameterized functors that compose base monads with state or other types.
• Using flat module structures to avoid nested qualifiers and reduce verbosity in client code.
• Resolving the diamond problem via mathematical equivalence of superclass methods, ensuring consistent behavior regardless of inheritance path.

Experimental results

Research questions

• RQ1 Can constructor classes such as Monad and Applicative be fully emulated in Standard ML using only the module system?
• RQ2 How can minimal definitions (e.g., return and bind) be automatically expanded into full class instances with all standard functions?
• RQ3 Can superclass instances (e.g., Applicative and Functor) be automatically generated from a minimal Monad definition?
• RQ4 How can monad transformers and multiple class constraints be modeled in a type-safe, extensible way without language extensions?
• RQ5 Can the approach support multiple valid instances for the same type (e.g., two Applicative instances for lists) without requiring newtype wrappers?

Key findings

• The library automatically derives more than twenty standard functions—such as join, liftM, and forever—from just two user-defined functions: return and bind.
• The approach successfully supports automatic instantiation of superclasses, so that a list monad is simultaneously recognized as a Functor, Applicative, and Monad.
• The method avoids the diamond problem by relying on mathematical equivalence of superclass methods, ensuring consistent behavior regardless of inheritance path.
• The library supports multiple valid instances for the same type, such as two Applicative instances for lists (cartesian vs. pairwise), without requiring newtype wrappers.
• The approach is transferable to other ML dialects and avoids language extensions, maintaining compatibility with all Standard ML implementations.
• The technique enables full support for monad transformers and recursive class constraints via parameterized functors, such as mk_ConsProd for composing monads.