[Haskell-cafe] GetOpt

[Brian Hulley]

Bulat Ziganshin wrote:
> Hello Tomasz,
> [snip]
> ultimately, the main problem of all options-parsing stuff i ever seen,
> is requirement to repeat option definition many times. if i have, say,
> 40 options, then i need to maintain 3 to 5 program fragments that deal
> with each option. something like this:
>
> data Options = Options { r :: Bool,
>                         x :: Int
>                         ....
>                       }
>
> options = { "r", "description"
>            ....
>          }
>
> main = do list <- getOpts options cmdline
>          let options = Options { r = findBoolOption list "r",
>                                  x = findIntOption list "x",
>                                  ....
>                                }
>

If it is not necessary to specify a specific command letter for each option, 
then perhaps options could be composed by something like (following code 
untested):

class OptionClass a where
      setOption :: a -> String -> IO ()
      getOptionDescription :: a -> String -> String

data Option = forall a. OptionClass a => Option a
instance OptionClass Option where
      setOption (Option a) = setOption a
      getOptionDescription (Option a ) opt = getOptionDescription a opt

data ComposedOption = ComposedOption _ [Option]
instance OptionClass ComposedOption where
      setOption (ComposedOption _ os) (c:cs) = setOption (os !! (fromEnum 
c - fromEnum 'a')) cs
      getOptionDescription (ComposedOption description os) (c:cs)=
                  description ++ "." ++ getOptionDescription (os !! 
(fromEnum x - fromEnum 'a')) cs

Then each element in a module that needs an option makes its own instance of 
the existential eg

data ModOption1 = ModOption1
data ModOption2 = ModOption2

instance OptionClass ModOption1 where
     setOption ModOption1 s = case s of
                                                   [] -> do -- set default 
value
                                                   s -> do -- parse s and 
set accordingly

     getOptionDescription ModOption1 optvalue =
                -- description of this option, possibly clarified to the 
specific example of optvalue
                -- "would read from the file 'foo.txt'" if optvalue == " 
foo.txt"

moduleOptions = ComposedOption "My module" [ModOption1, ModOption2]

Then in main, do:

allOptions = ComposedOption "Name of program" [Module1.moduleOptions, 
Module2.moduleOptions, ...]

A disadvantage would be that the options would involve multiple letters in 
general eg -aaaab -aba etc when there is a lot of nesting, but an advantage 
is that it allows libraries requiring options and code using such libraries 
to be written in a modular way.

Best regards, Brian.