On Tue, Jul 16, 2013 at 04:57:59PM -0400, Michael Orlitzky wrote:

This all works great, except that when there's 20 or so options, I duplicate a ton of code in the definition of OptionalCfg. Is there some pre-existing solution that will let me take a Cfg and create a new type with Cfg's fields wrapped in Maybe?

You can always try data Cfg f = Cfg { verbose :: f Bool } and set f to Maybe or Identity depending on what you use it for. It will be slightly notationally cumbersome to extract values from the Identity functor though. Tom

On 07/16/2013 09:57 PM, Michael Orlitzky wrote:

I have a common pattern in my command-line programs; I start out with a configuration data type, which over-simplified looks like:

data Cfg = Cfg { verbose :: Bool }

Now, there's usually a default configuration,

default :: Cfg default = Cfg False

The user can override the defaults one of two ways, either via a config file, or from the command-line. If both are specified, the command-line takes precedence. The way I do this is with,

data OptionalCfg = OptionalCfg { verbose :: Maybe Bool }

And then I define I Monoid instance for OptionalCfg which lets me merge two ofthem. Once the two OptionalCfgs are merged, I merge *that* with the default Cfg.

This all works great, except that when there's 20 or so options, I duplicate a ton of code in the definition of OptionalCfg. Is there some pre-existing solution that will let me take a Cfg and create a new type with Cfg's fields wrapped in Maybe?

One option is to combine OptionalCfg with Cfg, by parameterizing Cfg. If you make data Cfg a = Cfg { cfgVerbose :: a Bool } Then you can choose between Cfg Identity and Cfg Maybe. Furthermore, these are different types, so you can still have a monoid over Cfg Maybe. There might be some lens magic that makes working with this easier too. For example, verbose :: Lens' (Cfg a) Bool verbose = cfgVerbose.traverse Or something to that effect (that actually compiles). - ollie

On 07/16/2013 04:57 PM, Michael Orlitzky wrote:

This all works great, except that when there's 20 or so options, I duplicate a ton of code in the definition of OptionalCfg. Is there some pre-existing solution that will let me take a Cfg and create a new type with Cfg's fields wrapped in Maybe?

For posterity, I report failure =) If I parameterize the Configuration type by a functor, it breaks the DeriveDataTypeable magic in cmdargs. The resulting manual definitions along with the lenses to look inside the Identity functor well exceed the duplicated code from OptionalCfg. Combining the option parsing and config file parsing increases the amount of code in the command-line parser by roughly an equal amount, but in my opinion a worse consequence is that it conflates two unrelated procedures. I very much like this: rc_cfg <- from_rc cmd_cfg <- apply_args let opt_config = rc_cfg <> cmd_cfg ... All things considered the duplicated data structure seems like the least of three evils.