Do be do be do (1611.09259v2)

Abstract: We explore the design and implementation of Frank, a strict functional programming language with a bidirectional effect type system designed from the ground up around a novel variant of Plotkin and Pretnar's effect handler abstraction. Effect handlers provide an abstraction for modular effectful programming: a handler acts as an interpreter for a collection of commands whose interfaces are statically tracked by the type system. However, Frank eliminates the need for an additional effect handling construct by generalising the basic mechanism of functional abstraction itself. A function is simply the special case of a Frank operator that interprets no commands. Moreover, Frank's operators can be multihandlers which simultaneously interpret commands from several sources at once, without disturbing the direct style of functional programming with values. Effect typing in Frank employs a novel form of effect polymorphism which avoid mentioning effect variables in source code. This is achieved by propagating an ambient ability inwards, rather than accumulating unions of potential effects outwards. We introduce Frank by example, and then give a formal account of the Frank type system and its semantics. We introduce Core Frank by elaborating Frank operators into functions, case expressions, and unary handlers, and then give a sound small-step operational semantics for Core Frank. Programming with effects and handlers is in its infancy. We contribute an exploration of future possibilities, particularly in combination with other forms of rich type system.

• The paper presents Frank's main contribution in integrating effect handling directly into functional abstraction, eliminating separate effect constructs.
• It develops a bidirectional effect type system that enables operators to act as multihandlers while supporting effect polymorphism without explicit effect variables.
• The work outlines a clear small-step operational semantics for Core Frank, paving the way for future enhancements in effectful programming languages.

Overview of the Frank Programming Language

The paper presents Frank, a strict functional programming language designed around a novel variant of Plotkin and Pretnar's effect handler abstraction. It introduces several innovative concepts in effectful programming, notably the elimination of distinct effect handling constructs by generalizing functional abstraction. In Frank, functions are merely a special case of operators that interpret no commands. Frank operators, potentially multihandlers, can interpret commands from multiple sources while preserving direct style functional programming.

Key Concepts

• Effect Handlers: Frank leverages effect handlers as an abstraction for modular effectful programming. Operators act as interpreters for a defined set of commands, with interfaces tracked by the type system. Frank's innovation is in integrating these handlers directly into the underlying mechanism of functional abstraction without additional constructs.
• Effect Polymorphism: The language introduces a distinctive form of effect polymorphism that avoids explicitly mentioning effect variables in source code. This is achieved through the propagation of an ambient ability inward, rather than accumulating unions of possible effects outward.
• Bidirectional Effect Typing: This new system underpins the design of Frank, contributing to managing effects and ensuring the operations remain in the direct style of functional programming.

Detailed Contribution

The contributions of the paper include:

1. Language Design: Frank is introduced with a strict functional syntax and a bidirectional effect type system.
2. Operators as Multihandlers: Operators can handle multiple computations over distinct effect sets simultaneously, facilitating more robust effect management.
3. Novel Effect Polymorphism: This approach negates the need for explicit effect variables in the code by relying on the environment's ambient ability to instantiate the effects of operators being applied.
4. Pattern Matching Compilation: In Frank, pattern matching is compiled into a call-by-value language, allowing for unary effect handlers.
5. Operational Semantics: A straightforward small-step operational semantics for Core Frank is provided, proving the soundness of the type system.
6. Future Possibilities: The paper explores future directions, including combining effect handling with features like substructural typing, dependent types, and totality.

Numerical Results and Claims

The authors do not heavily focus on empirical results; instead, they put forward theoretical advancements in handling effects within a programming language. Frank's primary contribution lies in its conceptual approach to effect handling and polymorphism, with emphasis on practical syntax and semantics improvements.

Implications and Future Directions

Frank's design points towards future developments in combining effect handlers with a sophisticated type system for higher-level programming constructs. The paper suggests enhancements such as incorporating session types for communication protocols, integrating dependent types, and exploring substructural typing systems for formal verification and efficiency.

Efforts to expand Frank's capabilities could include handling more complex patterns like dynamic effects, enhanced error handling mechanisms, and better tooling for multi-threaded or asynchronous computation models. The integration of negative adjustments or controlled snooping might offer flexibility in managing computational effects.

Conclusion

Frank presents a significant shift in the way effectful computations are integrated within functional programming languages. By treating effect handling seamlessly within the language's core abstraction mechanisms, Frank simplifies the programming model and enhances modularity. While practical applications and real-world implications remain an ongoing exploration, the groundwork laid by Frank promises advancements in language design for effectful computation.