JSON to Elm Type Generator

Example Input

{
  "id": 1,
  "name": "Priya Singh",
  "email": "priya@learnhubly.com",
  "isActive": true,
  "tags": ["developer", "admin"],
  "profile": {
    "bio": "Principal Software Engineer",
    "skills": ["Go", "React", "TypeScript"]
  }
}

Example Output

module Data.User exposing (User, Profile, userDecoder, profileDecoder)

import Json.Decode as Decode exposing (Decoder)
import Json.Decode.Pipeline as Pipeline


type alias Profile =
    { bio : String
    , skills : List String
    }


type alias User =
    { id : Int
    , name : String
    , email : String
    , isActive : Bool
    , tags : List String
    , profile : Profile
    }


profileDecoder : Decoder Profile
profileDecoder =
    Decode.succeed Profile
        |> Pipeline.required "bio" Decode.string
        |> Pipeline.required "skills" (Decode.list Decode.string)


userDecoder : Decoder User
userDecoder =
    Decode.succeed User
        |> Pipeline.required "id" Decode.int
        |> Pipeline.required "name" Decode.string
        |> Pipeline.required "email" Decode.string
        |> Pipeline.required "isActive" Decode.bool
        |> Pipeline.required "tags" (Decode.list Decode.string)
        |> Pipeline.required "profile" profileDecoder

Does it support Elm 0.19?

Yes. The generated code is fully compatible with Elm 0.19 and uses the elm/json package (version 1.1.3) which is the standard JSON library in the current Elm ecosystem. The Pipeline decoder syntax uses NoRedInk/elm-json-decode-pipeline which is the community-standard package for decoding record types in Elm 0.19. Elm 0.19 is the current stable version of Elm and has been since August 2019. All new Elm projects should use 0.19.

What is a JSON decoder in Elm?

A JSON decoder in Elm is a value of type Decoder a that describes how to convert a raw JSON value into an Elm value of type a. Unlike JavaScript where JSON.parse() returns a loosely-typed object that can fail at runtime when you access fields that do not exist, Elm's JSON decoders are explicit and handle failure as a value — decoding either succeeds and returns Ok value or fails and returns Err String describing what went wrong. This explicit failure handling is what allows Elm to guarantee no runtime exceptions even when consuming external JSON data from APIs that might change their response structure.

What is the difference between Pipeline.required and Pipeline.optional?

Pipeline.required decodes a field that must be present in the JSON and must not be null — if the field is absent or null, the entire decoder fails with an error. Pipeline.optional decodes a field that may be absent or null — if the field is missing or null, it uses the provided default value instead of failing. The tool generates Pipeline.required for fields that have a non-null value in your JSON sample, and Pipeline.optional for fields that appear as null. Review these carefully against the actual API contract — a field that was non-null in your sample but is sometimes null in real responses should use Pipeline.optional with an appropriate default or Maybe.

How do I decode a JSON array of objects at the top level?

If the API returns a top-level JSON array rather than a single object, use Decode.list applied to the generated decoder: Decode.list userDecoder. This tells Elm to expect a JSON array and decode each element using userDecoder, producing a List User on success. In an Http.get call: Http.get { url = apiUrl, expect = Http.expectJson GotUsers (Decode.list userDecoder) }. The generated decoder from this tool is for a single item — wrapping it in Decode.list handles the array case.

What packages do I need to install?

The generated code requires two packages: elm/json which is a core Elm package included in all Elm projects by default, and NoRedInk/elm-json-decode-pipeline for the Pipeline syntax. Install the pipeline package with: elm install NoRedInk/elm-json-decode-pipeline. This adds it to your elm.json dependencies automatically. If you prefer not to use a third-party package, you can replace the Pipeline syntax with manual Decode.map2, Decode.map3 etc. calls, though this becomes verbose for records with more than about four fields.

Why does Elm require explicit JSON decoders when other languages don't?

Most languages with automatic JSON serialization — Python, JavaScript, C# with System.Text.Json — use reflection or runtime type information to map JSON fields to object properties automatically. Elm does not have runtime reflection, and its type system operates entirely at compile time. The trade-off is that JSON parsing failures are handled explicitly and caught by the type system rather than causing runtime exceptions. In JavaScript, accessing a JSON field that does not exist returns undefined which then propagates through your code causing errors far from the source. In Elm, the decoder fails at the boundary where JSON enters your application, the failure is a typed value you must handle, and errors never propagate silently.

Can I use the generated decoder with Elm's Http module?

Yes. The generated decoder works directly with Elm's Http.get, Http.post, and Http.request. Pass it to Http.expectJson: Http.get { url = 'https://api.example.com/users/1', expect = Http.expectJson GotUser userDecoder }. The Http module applies the decoder to the response body and delivers the result to your update function as a Msg containing Result Http.Error User. Http.Error covers both network failures and JSON decode failures, so a single case expression in your update function handles all failure scenarios.

How do I handle union types (custom types) from JSON?

The tool generates type aliases (record types) from JSON objects. If your API uses a discriminated union pattern — a JSON field that indicates which variant of a type the object represents, like a type field with values 'admin' or 'user' — the generated code will represent it as a String field. To properly model this as an Elm custom type, you need to write a custom decoder: Decode.field 'type' Decode.string |> Decode.andThen (\typeStr -> case typeStr of 'admin' -> Decode.succeed Admin 'user' -> Decode.succeed RegularUser _ -> Decode.fail ('Unknown user type: ' ++ typeStr)). The andThen combinator is what enables this pattern in the elm/json decoder API.