Parsing with Data.Yaml.Combinators, part 3

In the last part I tried my best to explain the operators used to combine and apply the field parsers to build up an object parser. We also created a parser for one of our own simple types. In this part we will make the inclusion of a gender in a person record optional and we will also address one of the problems I encountered, how to create an inner object based on some of the fields in a record.

Here is the new input.yaml:

We’ll start with making the gender field optional. This is fine in YAML; you just leave the field out, but our Person type requires a Gender field to be constructed, so we will need to provide a default. We’ll start by importing Data.Maybe (fromMaybe) as the optField function will return a FieldParser (Maybe Gender) and the <*> operator expects a FieldParser Gender. fromMaybe takes a default value of type a and a Maybe a and returns an a.

fromMaybe :: a -> Maybe a -> a

But fromMaybe can’t operate directly on the FieldParser (Maybe Gender). Luckily Maybe is an instance of Functor, so we’ll use our trusty fmap again (this time in it’s <$> operator form).

That should do it. Now onto the address. As you can see in the input.yaml, the address information has been split up into two parts. Let’s assume we don’t have the clout to effect a better structuring of this data in our input, but we still want to be able to use a better structure in our program. We want an Address type object that is constructed from the street and house_number fields of each record.

We’ll stick an addressParser in each of the functions personParser and organizationParser.

Now, this adressParser must have the type FieldParser Address and it must gobble up the street field and the house_number field.

There it is. The Address constructor takes a Text and an Int and produces an Address.

Address :: Text -> Int -> Address

This is mapped onto a FieldParser that want’s the two fields street and street-number. The result is a FieldParser Address. The process can be followed in ghci:

> :t  field “street” string

field “street” string :: FieldParser Text

> :t Address <$> field “street” string

Address <$> field “street” string :: FieldParser (Int -> Address)

> :t Address <$> field “street” string <*> field “street_number” integer

Address <$> field “street” string <*> field “street_number” integer

  :: FieldParser Address

> :t (object (Address <$> field “street” string <*> field “street_number” integer))

(object (Address <$> field “street” string <*> field “street_number” integer))

  :: Parser Address

> parse (object (Address <$> field “street” string <*> field “street_number” integer)) “{street: ‘North La Brea Avenue’, street_number: 709}”

Right (Address “North La Brea Avenue” 709)

We can now build and run our finished parser:

> contacts-parser input.yaml

Contacts [Person “Coco Lenoix” (Address “Havenhurst Drive” 1612) Unassigned,Person “Diane Selwyn” (Address “Griffith Park Boulevard” 2900) Female,Person “Adam Kersher” (Address “Spring Street” 634) Male] [Organization “StudioCanal” (Address “Place du Spectacle” 1),Organization “ABC Studios” (Address “West 66th Street” 77)]

For now, this concludes this short series of posts on Data.Yaml.Combinators. I hope they will prove useful to some of my fellow Haskellers. I know it was useful for me to write them as it forced me to understand how the different parts work together.

If you have suggestions for how to follow this up, and if I have the skills necessary to implement those same suggestions, I may consider more installments in the series.

Series Navigation

<< Parsing with Data.Yaml.Combinators, part 2