Construct a JSON key/value Pair. Infix alias for \k v -> (k, toJSON v).

object [ "name" .= ("Alice" :: MisoString), "age" .= (30 :: Int) ]

Create a Value from a list of name/value Pairs.

The empty JSON Array (i.e. []).

The empty JSON Object (i.e. {}).

Look up a required key in a JSON Object. Fails with a parse error if the key is absent.

Look up an optional key in a JSON Object. Returns Nothing if the key is absent; delegates to parseJSON if present.

Like .:? but always wraps a present value in Just, so a key with a null JSON value decodes to Just Null rather than Nothing. Useful when you need to distinguish a missing key from an explicit null.

Provide a default when a Parser produces Nothing. Typically chained after .:?:

o .:? "count" .!= 0

Encode a value as a JSON MisoString.

On the client (WASM / GHC JS backend) calls JSON.stringify() via FFI for maximum performance. On the server (1) falls back to encodePure.

Relies on the pure implementation of JSON parsing / serialization.

This can be used on the server or the client, it is more efficient to use encode on the client (since it relies on JSON.stringify()).

Decode a JSON MisoString into a Haskell value, returning Nothing on failure.

On the client calls JSON.parse() via FFI. On the server uses the pure Haskell parser. For a human-readable error message on failure use eitherDecode.

Succeed only when the Value is a JSON object; fail with typeMismatch otherwise. The inner parser receives the Object map for key lookups with .: etc.

Succeed only when the Value is a JSON string (MisoString); fail with typeMismatch otherwise.

Succeed only when the Value is a JSON array; fail with typeMismatch otherwise. The inner parser receives the list of elements.

Succeed only when the Value is a JSON number; fail with typeMismatch otherwise. The inner parser receives the underlying Double.

Succeed only when the Value is a Bool; fail with typeMismatch otherwise.

A type that can be deserialised from a JSON Value.

Instances for the most common Haskell types are provided. Derive via Generics for product/sum types, or write instances by hand:

-- Generic derivation:
data Point = Point { x :: Double, y :: Double }
  deriving (Generic, Show, Eq)
instance FromJSON Point

-- Manual instance:
instance FromJSON Point where
  parseJSON = withObject "Point" $ \o ->
    Point <$> o .: "x" <*> o .: "y"

A lightweight JSON parse monad. Wraps Either MisoString a so that parse failures carry a human-readable error message.

Parser is a Functor, Applicative, Monad, MonadFail, and Alternative. The Alternative instance tries the right branch only when the left branch fails — useful for decoding sum types with multiple valid shapes.

Combine with parseJSON and the accessor operators (.: etc.) to build composite decoders:

data Point = Point Double Double

instance FromJSON Point where
  parseJSON = withArray "Point" $ \xs ->
    Point <$> parseJSON (xs !! 0)
          <*> parseJSON (xs !! 1)

Run a parser function, returning Nothing on failure instead of an error string.

A type that can be serialised to a JSON Value.

Instances for the most common Haskell types are provided. Derive via Generics for product/sum types, or write instances by hand for full control:

-- Generic derivation (mirrors aeson defaults):
data Point = Point { x :: Double, y :: Double }
  deriving (Generic, Show, Eq)
instance ToJSON Point

-- Manual instance:
instance ToJSON Point where
  toJSON (Point x y) = object ["x" .= x, "y" .= y]

Convert a JSON Value to a Haskell type, returning a Result. Useful when a Value is already in hand; use decode to parse from a string.

Run a parser function, returning Left errMsg on failure.

Decode a JSON MisoString, returning Left errMsg on failure. Prefer decode when the error message is not needed.

Produce a parse failure describing a type mismatch. Used by the with* combinators and useful in hand-written FromJSON instances.

Encode a value as indented (pretty-printed) JSON using defConfig (4-space indentation). Not available in the 1 build.

Like encodePretty but with a custom Config. Not available in the 1 build.

Default pretty-print config: 4-space indentation.

Pretty-printing configuration for encodePretty and encodePretty'.

Convert a Miso JSON Value to a raw JavaScript value via FFI.

Convert a raw JavaScript value to a Miso JSON Value via FFI. Returns Nothing if the JS value cannot be represented as a JSON Value.

Call JSON.stringify() on a JavaScript value, returning a JSON string.

Call JSON.parse() on a JSON string, returning a raw JavaScript value.

Configuration for generic JSON encoding and decoding via genericToJSON and genericParseJSON. Mirrors the subset of aeson's Options that is relevant to miso's Generic machinery.

Construct with defaultOptions and override only the fields you need:

myOpts :: Options
myOpts = defaultOptions { fieldLabelModifier = camelTo2 '_' }

Default encoding/decoding options, matching aeson's defaults: no field or constructor name transformation, allNullaryToStringTag enabled, omitNothingFields disabled.

Top-level generic encoding class.

Encoding rules match aeson's defaults:

• All-nullary sum + allNullaryToStringTag: "C"
• Single-constructor record: {"field1": v1, ...}
• Single-constructor positional: v (1 field), [v1,v2,...] (n>1), [] (0)
• Sum record constructor: {"tag": "C", "field1": v1, ...}
• Sum nullary constructor: {"tag": "C"}
• Sum positional constructor: {"tag": "C", "contents": v} or [...]

Collect a constructor's fields into Fields.

Encode sum constructors with a "tag" key.

Determine at the type level whether every constructor of a sum type is nullary (has no fields). Used to implement allNullaryToStringTag.

Intermediate representation of a constructor's fields after encoding.

RecordFields is produced when every selector has a name (record syntax); PositionalFields is produced for all other constructors.

Top-level generic decoding class. Symmetric with GToJSON.

Decoding rules match aeson's defaults (see Options and defaultOptions).

Field-level decoder. Knows whether the constructor is a record and how many fields it has; can decode from a JSON Object (record mode) or a positional '[Value]' list.

Parse sum constructors, trying each branch left-to-right.

Derive toJSON via Generics with custom Options. Called by the default ToJSON implementation using defaultOptions.

Derive parseJSON via Generics with custom Options. Called by the default FromJSON implementation using defaultOptions.

Convert a camelCase identifier to a separated form using the given delimiter.

camelTo2 '_' "camelCaseField" == "camel_case_field"

Commonly used as fieldLabelModifier in a custom Options.