Data.Object

The core of this package is the Object data type, which is used for handling scalars, sequences and mappings in a nested manner. This is the same structure used in JSON or Yaml data.

The Object data type is polymorphic in its keys and values. Submodules within this package provide more concrete datatypes, such as a String Object and a specialized scalar type.

Besides the Object data type, there are utility functions and type classes for converting objects around. Care has been taken to avoid any overloaded instances for these type classes.

Object data type

data Object key val

Can represent nested values as scalars, sequences and mappings. A sequence is synonymous with a list, while a mapping is synonymous with a list of pairs.

Note that instances of standard library type classes for this data type leave the key untouched while altering the value. For example, the Functor instance defines fmap to be synonymous with mapValues.

Constructors

Mapping [(key, Object key val)]

Sequence [Object key val]

Scalar val

Instances

Typeable2 Object

Monad (Object key)

Functor (Object key)

Applicative (Object key)

Foldable (Object key)

Traversable (Object key)

(Eq key, Eq val) => Eq (Object key val)

(Data key, Data val) => Data (Object key val)

(Show key, Show val) => Show (Object key val)

Convenient type synonyms

type StringObject = Object String String

type TextObject = Object Text Text

Objects with keys and values of strict Text.

Scalar data type

data Scalar

Constructors

Numeric Rational

Text Text

Binary ByteString

Bool Bool

Timestamp UTCTime

Null

type ScalarObject = Object String Scalar

Basic mapping of keys and values

mapKeys :: (keyIn -> keyOut) -> Object keyIn val -> Object keyOut val

Apply some conversion to the keys of an Object, leaving the values unchanged.

mapValues :: (valIn -> valOut) -> Object key valIn -> Object key valOut

Apply some conversion to the values of an Object, leaving the keys unchanged. This is equivalent to fmap.

mapKeysValues :: (keyIn -> keyOut) -> (valIn -> valOut) -> Object keyIn valIn -> Object keyOut valOut

Apply a conversion to both the keys and values of an Object.

mapKeysValuesA :: Applicative f => (keyIn -> f keyOut) -> (valIn -> f valOut) -> Object keyIn valIn -> f (Object keyOut valOut)

Apply an Applicative conversion to both the keys and values of an Object.

mapKeysValuesM :: Monad m => (keyIn -> m keyOut) -> (valIn -> m valOut) -> Object keyIn valIn -> m (Object keyOut valOut)

The same as mapKeysValuesA, but using a Monad since some people are more comfortable with Monads and not all Monads are Applicative.

Extracting underlying values

data ObjectExtractError

An error value returned when an unexpected node is encountered, eg you were expecting a Scalar and found a Mapping.

Constructors

ExpectedScalar

ExpectedSequence

ExpectedMapping

MissingKey String

Instances

Show ObjectExtractError

Typeable ObjectExtractError

Exception ObjectExtractError

fromScalar :: Failure ObjectExtractError m => Object k v -> m v

Extract a scalar from the input, failing if the input is a sequence or mapping.

fromSequence :: Failure ObjectExtractError m => Object k v -> m [Object k v]

Extract a sequence from the input, failing if the input is a scalar or mapping.

fromMapping :: Failure ObjectExtractError m => Object k v -> m [(k, Object k v)]

Extract a mapping from the input, failing if the input is a scalar or sequence.

Lookups

lookupObject :: (Show k, Eq k, Failure ObjectExtractError m) => k -> [(k, Object k v)] -> m (Object k v)

lookupScalar :: (Show k, Eq k, Failure ObjectExtractError m) => k -> [(k, Object k v)] -> m v

lookupSequence :: (Show k, Eq k, Failure ObjectExtractError m) => k -> [(k, Object k v)] -> m [Object k v]

lookupMapping :: (Show k, Eq k, Failure ObjectExtractError m) => k -> [(k, Object k v)] -> m [(k, Object k v)]