A double-encoded JSON value.

>>> encode (JSONString True)
"\"true\""

>>> decode "\"true\"" :: Maybe (JSONString Bool)
Just (JSONString {jsonString = True})

Works like aeson's (.:), but assumes the value being parsed is double-encoded. Mnemonic: $ sorta looks like an S (for String).

Works like aeson's (.=), but double-encodes the value being serialized.

Bools rendered 0 or 1

>>> oneOrZero <$> decode "1"
Just True

>>> oneOrZero <$> decode "0"
Just False

Bools rendered "yes" or "no"

>>> yesOrNo <$> decode "\"yes\""
Just True

>>> yesOrNo <$> decode "\"no\""
Just False

Bools rendered "on" or "off"

>>> onOrOff <$> decode "\"on\""
Just True

>>> onOrOff <$> decode "\"off\""
Just False

Bools rendered as more-or-less anything.

>>> let Just bs = decode "[1, \"1\", \"true\", \"yes\", \"on\", true]"
>>> and $ map anyBool bs
True

Sometimes an empty string in a JSON object actually means Nothing

>>> emptyAsNothing <$> decode "\"\"" :: Maybe (Maybe Text)
Just Nothing

>>> emptyAsNothing <$> decode "\"something\"" :: Maybe (Maybe Text)
Just (Just "something")

Some systems attempt to treat keys in JSON objects case-insensitively(ish). Golang's JSON marshalling is a prominent example: https://golang.org/pkg/encoding/json/#Marshal. The (.:~) combinator works like (.:), but if it fails to match, attempts to find a case-insensitive variant of the key being sought. If there is an exact match, (.:~) will take that; if there are multiple non-exact matches, the choice of selected value is unspecified. Mnemonic: ~ swaps case in vi.

>>> data Foo = Foo Int deriving (Read, Show)
>>> instance FromJSON Foo where parseJSON (Object o) = Foo <$> o .:~ "foo"
>>> decode "{\"FOO\": 12}" :: Maybe Foo
Just (Foo 12)
>>> decode "{\"foo\": 17, \"FOO\": 12}" :: Maybe Foo
Just (Foo 17)