.:

Retrieve the value associated with the given key of an Object. The result is empty if the key is not present or the value cannot be converted to the desired type. This accessor is appropriate if the key and value must be present in an object for it to be valid. If the key and value are optional, use .:? instead.

Retrieve the value associated with the given key of an Object. The result is empty if the key is not present or the value cannot be converted to the desired type. This accessor is appropriate if the key and value must be present in an object for it to be valid. If the key and value are optional, use .:? instead.

Alias for lookup.

Operator equivalent of cons.

> toList $ 1 .: 2 .: 3 .: nil
[1,2,3]

Compose two functions. f .: g is similar to f . g except that g will be fed two arguments instead of one before handing its result to f. This function is defined as

(f .: g) x y = f (g x y)

Example usage:

concatMap :: (a -> [b]) -> [a] -> [b]
concatMap = concat .: map

Notice how two arguments (the function and the list) will be given to map before the result is passed to concat. This is equivalent to:

concatMap f xs = concat (map f xs)

Operator equivalent of cons.

> toList $ 1 .: 2 .: 3 .: nil
[1,2,3]

Retrieve value in Mapping indexed by a !!str Text key. This parser fails if the key doesn't exist.

Prepend an element, the traditional cons.

>>> 1 .: 2 .: 3 .: [4, 5, 6 :: SInteger]
[1,2,3,4,5,6] :: [SInteger]

Multivariable composition.

f .: g ≡ (f .) . g ≡ \c d -> f (g c d)

Like Aeson's .:, but for FromGraphSON.

Given a field ID and a Value TStruct, get the value stored in the struct under that field ID. The lookup fails if the field is absent or if it's not the same type as expected by this call's context.

Cons a key/value pair.

Get the given key from the Value, erroring if it doesn't exist.

Synonym for objectWithKey. The .: operators can be chained.

>>> let json = "{\"key1\": {\"nested-key\": 3}}"

>>> parseByteString ("key1" .: "nested-key" .: integer) json :: [Int]
> [3]

It works both as a standalone parser and as a part of objectOf parser

>>> let test = "[{\"name\": \"test1\", \"value\": 1}, {\"name\": \"test2\", \"value\": null}, {\"name\": \"test3\"}]"

>>> let person = objectOf $ (,) <$> "name" .: string <*> "value" .: integer .| (-1)

>>> let people = arrayOf person

>>> parseByteString people test :: [(T.Text, Int)]
[("test1",1),("test2",-1),("test3",-1)]

Property by a key grammar. Infix version of key.

Extends the .: warning to include the field name that failed to parse.

Binary composition: pass two args to the right argument before composing.

(f .: g) x y = f (g x y)

or,

f .: g = curry (f . uncurry g)

This is the same as the common idiom (f .) . g but more easily extended to multiple uses, due to the fixity declaration.

Retrieve the value associated with the given key of an Object. The result is Nothing if the key is not present or empty if the value cannot be converted to the desired type. This differs from .:? by attempting to parse Null the same as any other JSON value, instead of interpreting it as Nothing.