Type level Sum/Variant

[xal-0]

It would be nice to have a "map-like" Sum/Variant type to go along with Data.Type.Map. It could look something like:

data Sum (n :: [Mapping Symbol *]) where
  This :: Var k -> v -> Sum ((k ':-> v) ': m)
  That :: Sum m -> Sum ((k ':-> v) ': m)

I'm using Map right now to build up records by field name (irrespective of field order), and I want to extend it to records with more than one constructor. Sum would be perfect for this, because one could represent:

data A = B { one :: Int, two :: Bool } | C { three :: Char }

as the generic

Sum '[ "B" ':-> Map '[ "one" ':-> Int, "two" ':-> Bool ]
     , "C" ':-> Map '[ "three" ':-> Char ]
     ]

As far as I'm aware, there are packages on hackage that provide generic variant types, but none that provide a generic tagged and sorted variant that's dual to Map. Would it make sense to add this to type-level-sets?

[github-actions]

🤖 This is an automated response from Repo Assist.

The Sum/variant type you've described is the categorical dual to Map — an extensible tagged coproduct — and your proposed GADT is a solid starting sketch! Here are some thoughts on fleshing it out:

Expanded sketch

-- Safe injection (requires proof k is in the sum's domain)
class Inject (k :: Symbol) v m where
  inj :: Var k -> v -> Sum m

-- Safe elimination (dispatch/fold over a Sum)
class Dispatch m r where
  dispatch :: Sum m -> (forall k v. Var k -> v -> r) -> r

Design considerations:

1. Sorting/normalisation: To be consistent with Map, the type-level list backing Sum should be sorted and duplicate-free (using the same Cmp/Sort/Nub machinery). This ensures Sum '["A" :-> X, "B" :-> Y] and Sum '["B" :-> Y, "A" :-> X] are the same type.
2. Injection: You'd need a typeclass analogous to IsMember/Lookup to inject into the right position.
3. Projection: Safe extraction returning Maybe v or using a continuation.
4. Connection to PR Add Data.Type.Functor.Map #15: The open PR #15 proposes Data.Type.Functor.Map (a functor-based variant), but Sum is independent — product vs. coproduct.

Existing alternatives (if you need something now):

• [world-peace]((hackage.haskell.org/redacted) — OpenUnion extensible sums
• [vinyl]((hackage.haskell.org/redacted) — CoRec coproduct records

Adding Sum to type-level-sets would be a meaningful new feature — I'd suggest the maintainer weigh in on appetite for this before investing effort. Would love to see this happen though! 🙂

Generated by Repo Assist

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@040d30104520b0da5f68dc6d39592125c100bed4