Haskell: Defining a proper interface for data types with many fields

Question

For the representation of a DSL syntax tree I have data types that represent this tree. At several places, within this tree I get quite a number of subelements that are optional and/or have a "*" multiplicity. So one data type might look something like

data SpecialDslExpression = MyExpression String [Int] Double [String] (Maybe Bool)

What I am looking for is a possibility to construct such a type without having to specify all of the parameters, assuming I have a valid default for each of them. The usage scenario is such that I need to create many instances of the type with all kinds of combinations of its parameters given or omitted (most of the time two or three), but very rarely all of them. Grouping the parameters into subtypes won't get me far as the parameter combinations don't follow a pattern that would have segmentation improve matters.

I could define functions with different parameter combinations to create the type using defaults for the rest, but I might end up with quite a number of them that would become hard to name properly, as there might be no possibility to give a proper name to the idea of createWithFirstAndThirdParameter in a given context.

So in the end the question boils down to: Is it possible to create such a data type or an abstraction over it that would give me something like optional parameters that I can specify or omit at wish?

Records + a default instance

daniel gratzer
– daniel gratzer

2013-09-05 03:30:35 +00:00
Commented Sep 5, 2013 at 3:30 — daniel gratzer
– daniel gratzer, Commented Sep 5, 2013 at 3:30
Maybe your DSL-Expression could be made a monoid?

bennofs
– bennofs

2013-09-05 05:59:08 +00:00
Commented Sep 5, 2013 at 5:59 — bennofs
– bennofs, Commented Sep 5, 2013 at 5:59

kqr · Accepted Answer · 2013-09-05 04:53:59Z

I would suggest a combinations of lenses and a default instance. If you are not already importing Control.Lens in half of your modules, now is the time to start! What the heck are lenses, anyway? A lens is a getter and a setter mashed into one function. And they are very composable. Any time you need to access or modify parts of a data structure but you think record syntax is unwieldy, lenses are there for you.

So, the first thing you need to do – enable TH and import Control.Lens.

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens

The modification you need to do to your data type is adding names for all the fields, like so:

data SpecialDslExpression = MyExpression { _exprType :: String
                                         , _exprParams :: [Int]
                                         , _exprCost :: Double
                                         , _exprComment :: [String]
                                         , _exprLog :: Maybe Bool
                                         } deriving Show

The underscores in the beginning of the field names are important, for the following step. Because now we want to generate lenses for the fields. We can ask GHC to do that for us with Template Haskell.

$(makeLenses ''SpecialDslExpression)

Then the final thing that needs to be done is constructing an "empty" instance. Beware that nobody will check statically that you actually fill all the required fields, so you should preferably add an error to those fields so you at least get a run-time error. Something like this:

emptyExpression = MyExpression (error "Type field is required!") [] 0.0 [] Nothing

Now you are ready to roll! You cannot use an emptyExpression, and it will fail at run-time:

> emptyExpression
MyExpression {_exprType = "*** Exception: Type field is required!

But! As long as you populate the type field, you will be golden:

> emptyExpression & exprType .~ "Test expression"

MyExpression { _exprType = "Test expression"
             , _exprParams = []
             , _exprCost = 0.0
             , _exprComment = []
             , _exprLog = Nothing
             }

You can also fill several fields at once, if you want to.

> emptyExpression & exprType .~ "Test expression"
|                 & exprLog .~ Just False
|                 & exprComment .~ ["Test comment"]

MyExpression { _exprType = "Test expression"
             , _exprParams = []
             , _exprCost = 0.0
             , _exprComment = ["Test comment"]
             , _exprLog = Just False
             }

You can also use lenses to apply a function to a field, or look inside a field of a field, or modify any other existing expression and so on. I definitely recommend taking a look at what you can do!

daniel gratzer · Accepted Answer · 2013-09-05 04:31:36Z

11

Alright I'll actually expand upon my comment. Firstly, define your data type as a record (and throw in a few type synonyms).

data Example = E {
    one   :: Int,
    two   :: String,
    three :: Bool,
    four  :: Double
}

next you create a default instance

defaultExample = Example 1 "foo" False 1.4

and then when a user wants to tweak a field in the default to make their own data they can do this:

 myData = defaultExample{four=2.8}

Finally, when they want to pattern match just one item, they can use

  foo MyData{four=a} = a

answered Sep 5, 2013 at 4:31

daniel gratzer

54k11 gold badges100 silver badges137 bronze badges

1 Comment

Levi Pearson Over a year ago

There is a typeclass, Data.Default, that defines the 'def' method that returns the 'default' record of your type. You can then generally do def { field = value } for all your record types.

Collectives™ on Stack Overflow

Haskell: Defining a proper interface for data types with many fields

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related