sum-type-boilerplate: Library for reducing the boilerplate involved with sum types

[ library, mit, th, types ] [ Propose Tags ]

Library for reducing the boilerplate involved in creating and manipulating sum types

[Skip to Readme]




Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS] 0.1.0, 0.1.1
Change log
Dependencies base (>=4.9 && <5), template-haskell [details]
License MIT
Author David Reaver
Maintainer David Reaver
Category Types, TH
Home page
Bug tracker
Source repo head: git clone
Uploaded by jdreaver at 2017-07-31T15:45:18Z
Reverse Dependencies 1 direct, 7 indirect [details]
Downloads 2109 total (14 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2017-07-31 [all 1 reports]

Readme for sum-type-boilerplate-0.1.1

[back to package description]

sum-type-boilerplate: A Haskell sum type library


This library allows users to easily construct and manipulate sum types via Template Haskell It was born out of the author's desire to reduce the boilerplate associated with lots of large sum types while keeping the type safety they provide.

Sum Types

A sum type (also called a tagged union) looks like this in Haskell:

data MySum
  = MySumTypeA TypeA
  | MySumTypeB TypeB
  | MySumTypeC TypeC

Constructing this when you have a large number of types can be error-prone if you intend to have a uniform naming scheme, and if you intend to only have each type present once.

If you have many sum types with overlapping sets of types, then functions to convert between them can be full of boilerplate.

data OtherSum
  = OtherSumTypeA TypeA
  | OtherSumTypeB TypeB

otherSumToMySum :: OtherSum -> MySum
otherSumToMySum (OtherSumTypeA typeA) = MySumTypeA typeA
otherSumToMySum (OtherSumTypeB typeB) = MySumTypeB typeB

mySumToOtherSum :: MySum -> Maybe OtherSum
mySumToOtherSum (MySumTypeA typeA) = Just $ OtherSumTypeA typeA
mySumToOtherSum (MySumTypeB typeB) = Just $ OtherSumTypeB typeB
mySumToOtherSum other = Nothing

The boilerplate in examples isn't too bad, but consider writing this when your sum type has dozens of types in it!

Where does this library come in?

Using sum-type-boilerplate, you can reduce all of the previous code into the following:

constructSumType "MySum" defaultSumTypeOptions [''TypeA, ''TypeB, ''TypeC]
constructSumType "OtherSum" defaultSumTypeOptions [''TypeA, ''TypeB]
sumTypeConverter "otherSumToMySum" ''OtherSum ''MySum
partialSumTypeConverter "mySumToOtherSum" ''MySum ''OtherSum

More features

  • This library has an extremely simple implementation. (In fact, it is useful as an example if you are learning template-haskell for the first time.)
  • The only dependency is on template-haskell. That means adding it as a dependency probably doesn't introduce transitive dependencies.
  • The template haskell used here just produces vanilla Haskell data types. No crazy type-level magic is going on. That means if you want to ditch this library later on, just copy the generated code into your project.


While working on my event sourcing library I found it is super common for me to have to construct fairly large sum types of events. In the system I was working on, each event handler has their own event sum type that represents what events that handler can listen to. I also had a sum type that holds all the events in the system for the purpose of serialization and interacting with the database.

Converting between all of these event types became a huge pain, and I was writing a ton of boilerplate. I didn't want to lose type safety or encapsulation by just using the "big sum type" everywhere, but I also didn't want to keep writing new sum types and conversion functions. Thus, I created the Template Haskell functions that are now in sum-type-boilerplate to ease the burden of writing this mechanical code.

I thought this might be useful not only for users of eventful, but also for anyone that needs to deal with large sum types.