Derive Elm types and Json code from Haskell types, using aeson's options


Version on this page:0.6.1
LTS Haskell 22.29:0.8.3
Stackage Nightly 2023-12-26:0.8.2
Latest on Hackage:0.8.3

See all snapshots elm-bridge appears in

BSD-3-Clause licensed by Alexander Thiemann, Simon Marechal
Maintained by Alexander Thiemann
This version can be pinned in stack with:elm-bridge-0.6.1@sha256:108b3306bc18eac2e82d092606665cb78f2195ccccecf7c8de5b44127329219f,2458

Module documentation for 0.6.1

Used by 1 package in lts-18.28(full list with versions):

Elm Bridge

Build Status

Hackage Deps


Hackage: elm-bridge

Building the bridge from Haskell to Elm and back. Define types once, use on both sides and enjoy easy (de)serialisation. Cheers!

This version of the package only supports Elm 0.19. Version 0.5.2 supports Elm 0.18, and Version supports Elm 0.16 and Elm 0.17.

Note that the bartavelle/json-helpers package, with version >= 1.2.0, is expected by the generated Elm modules.


{-# LANGUAGE TemplateHaskell #-}
import Elm.Derive
import Elm.Module

import Data.Proxy

data Foo
   = Foo
   { f_name :: String
   , f_blablub :: Int
   } deriving (Show, Eq)

deriveBoth defaultOptions ''Foo

main :: IO ()
main =
    putStrLn $ makeElmModule "Foo"
    [ DefineElm (Proxy :: Proxy Foo)

Output will be:

module Foo where

import Json.Decode
import Json.Decode exposing ((:=))
import Json.Encode
import Json.Helpers exposing (..)

type alias Foo  =
   { f_name: String
   , f_blablub: Int

jsonDecFoo : Json.Decode.Decoder ( Foo )
jsonDecFoo =
   ("f_name" := Json.Decode.string) `Json.Decode.andThen` \pf_name ->
   ("f_blablub" := Json.Decode.int) `Json.Decode.andThen` \pf_blablub ->
   Json.Decode.succeed {f_name = pf_name, f_blablub = pf_blablub}

jsonEncFoo : Foo -> Value
jsonEncFoo  val =
   [ ("f_name", Json.Encode.string val.f_name)
   , ("f_blablub", Json.Encode.int val.f_blablub)

Also, there are functions Elm.Json.stringSerForSimpleAdt and Elm.Json.stringParserForSimpleAdt to generate functions for your non-JSON ADT types.

For more usage examples check the tests or the examples dir.



  • Using cabal: cabal install elm-bridge
  • From Source: git clone https://github.com/agrafix/elm-bridge.git && cd elm-bridge && cabal install


  • elm package install bartavelle/json-helpers

or, for Elm 0.19:

  • elm install bartavelle/json-helpers


Pull requests are welcome! Please consider creating an issue beforehand, so we can discuss what you would like to do. Code should be written in a consistent style throughout the project. Avoid whitespace that is sensible to conflicts. (E.g. alignment of = signs in functions definitions) Note that by sending a pull request you agree that your contribution can be released under the BSD3 License as part of the elm-bridge package or related packages.



  • Support for Elm 0.19


  • Fix a bug about tuples.


  • Large change for sum types that used constructorTagModifier. The generated types are now unaffected! This is a breaking change for those who used this feature.


Drop support for aeson < 1. Add support for aeson == 1.2.*



  • Fixed support for Elm 0.18 (see issue #17)


New features

  • Support for Elm 0.18
  • Dropped support for Elm 0.17 and Elm 0.16


New features

  • Support for Elm 0.17


New features

  • The Elm JSON encoders and decoders now match aeson more closely. In partlicular, single constructor sum types are now encoded without the constructor. Also, the aeson 0.11 option unwrapUnaryRecords is now supported.


  • Fixed Elm type error in encoders for types like [Map String v] (


New features

  • The template Haskell derivation functions now take aeson Option type instead of a custom type. This change makes it easier to synchronize the Haskell and Elm code.
  • The generated Elm code can be personalized. Helpers functions assist in converting type names, and defining which type will be newtyped.