Adaptation-Based Programming in Haskell

We present an embedded DSL to support adaptation-based programming (ABP) in Haskell. ABP is an abstract model for defining adaptive values, called adaptives, which adapt in response to some associated feedback. We show how our design choices in Haskell motivate higher-level combinators and constructs and help us derive more complicated compositional adaptives. We also show an important specialization of ABP is in support of reinforcement learning constructs, which optimize adaptive values based on a programmer-specified objective function. This permits ABP users to easily define adaptive values that express uncertainty anywhere in their programs. Over repeated executions, these adaptive values adjust to more efficient ones and enable the user’s programs to self optimize. The design of our DSL depends significantly on the use of type classes. We will illustrate, along with presenting our DSL, how the use of type classes can support the gradual evolution of DSLs.

💡 Research Summary

The paper introduces an embedded domain‑specific language (DSL) for adaptation‑based programming (ABP) built on Haskell. ABP is a programming model in which programmers can declare “adaptive values” that automatically adjust in response to feedback, thereby allowing programs to self‑optimize without the programmer having to enumerate all possible decision rules. The authors leverage Haskell’s powerful type system—particularly type classes and associated type families—to define a minimal yet expressive interface for adaptive values.

The core of the DSL is the Adaptive type class:

class Adaptive a where
  type Value a
  type Feedback a
  value :: a -> Value a          -- extract the current concrete value
  adapt :: Feedback a -> a -> a  -- produce a new adaptive from feedback

Value a denotes the concrete result that the adaptive supplies to the rest of the program, while Feedback a describes the shape of external information used to improve the adaptive. By separating these concerns, the DSL can represent simple adaptives (e.g., a scalar learning rate) as well as rich structures that store statistics, histories, or even entire learning models.

Two canonical examples illustrate the approach.

1. Incremental Linear Regression – The adaptive is a Line consisting of a slope and intercept. Each data point (x, y) is supplied as feedback; the adapt function updates the parameters using a fixed learning rate η. The value function simply returns the current line, making the adaptive behave like a mutable model that improves as more points are observed.

2. Multi‑Armed Bandit with Upper Confidence Bound (UCB) – The adaptive is a Bandit a that maintains, for each arm a, the number of pulls and the accumulated reward. adapt incorporates a new reward for the arm that was just pulled. value implements the UCB selection rule r_i / n_i + sqrt(log N / n_i), automatically balancing exploration and exploitation. Helper functions such as zeroPulls (to ensure each arm is tried at least once) and sortDesc (to pick the arm with the highest bound) are provided as reusable DSL components.

Beyond these base adaptives, the paper shows how derived instances enable compositional adaptives. For example, a pair (a, b) becomes an adaptive whenever both components are adaptives, allowing parallel adaptation of two independent strategies. Function‑type adaptives (a -> b) give rise to contextual adaptives where the adaptation depends on the input argument. This compositionality lets programmers build sophisticated adaptive systems from simple building blocks without writing boilerplate code.

A significant contribution is the theoretical convergence analysis. For the bandit adaptive, the authors prove that under the standard assumption that rewards lie in `