refactor: Builder and ConfigBuilder are structurally identical monads — unify via StateT #28

New issue

Closed

opened 2026-06-10 14:48:48 +02:00 by yorunikakeru · 0 comments

yorunikakeru commented

2026-06-10 14:48:48 +02:00

Owner

Problem

DSL.Builder contains two nearly identical monad implementations:

newtype Builder scope a = Builder
    { runBuilder :: SectionState -> Either DomainError (a, SectionState) }

newtype ConfigBuilder a = ConfigBuilder
    { runConfigBuilder :: ConfigState -> Either DomainError (a, ConfigState) }

Both have hand-written Functor, Applicative, and Monad instances that are structurally identical. The only difference is the state type (SectionState vs ConfigState).

Consequence

Any new combinator (rollback, local scope, inspection) must be written twice. The instances are copy-paste boilerplate that can silently drift if one is modified.

Options

Option A — Use StateT s (Either DomainError)

type Builder scope = StateT SectionState (Either DomainError)
type ConfigBuilder  = StateT ConfigState  (Either DomainError)

Eliminates both hand-written monad implementations. runBuilder becomes runStateT. Requires transformers or mtl dependency.

Option B — Single polymorphic newtype

newtype GenBuilder s a = GenBuilder
    { runGenBuilder :: s -> Either DomainError (a, s) }

Derive all instances once. Builder scope and ConfigBuilder become type aliases. No new dependency.

Option C — Keep as-is but add a HasField-based abstraction

Low-risk, no new dependency, but does not remove the duplication.

## Problem `DSL.Builder` contains two nearly identical monad implementations: ```haskell newtype Builder scope a = Builder { runBuilder :: SectionState -> Either DomainError (a, SectionState) } newtype ConfigBuilder a = ConfigBuilder { runConfigBuilder :: ConfigState -> Either DomainError (a, ConfigState) } ``` Both have hand-written `Functor`, `Applicative`, and `Monad` instances that are structurally identical. The only difference is the state type (`SectionState` vs `ConfigState`). ## Consequence Any new combinator (rollback, local scope, inspection) must be written twice. The instances are copy-paste boilerplate that can silently drift if one is modified. ## Options **Option A — Use `StateT s (Either DomainError)`** ```haskell type Builder scope = StateT SectionState (Either DomainError) type ConfigBuilder = StateT ConfigState (Either DomainError) ``` Eliminates both hand-written monad implementations. `runBuilder` becomes `runStateT`. Requires `transformers` or `mtl` dependency. **Option B — Single polymorphic newtype** ```haskell newtype GenBuilder s a = GenBuilder { runGenBuilder :: s -> Either DomainError (a, s) } ``` Derive all instances once. `Builder scope` and `ConfigBuilder` become type aliases. No new dependency. **Option C — Keep as-is but add a `HasField`-based abstraction** Low-risk, no new dependency, but does not remove the duplication.

~~yorunikakeru referenced this issue 2026-06-11 15:42:48 +02:00~~

refactor(builder): unify builders with StateT #33

yorunikakeru referenced this issue from a pull request that will close it,

2026-06-11 15:42:54 +02:00

refactor(builder): unify builders with StateT #33

yorunikakeru closed this issue

2026-06-11 15:42:58 +02:00