converting list to tuple

Question

I have few command-line options (5 for example) and I want to convert them to tuple. The problem is that I expect them to appear in correct order, so tuple can be easily built from list using pattern-match, but in real life options can be provided in random order, so I don't know if head of the list contain Verbose option or log file name?

I tried to think how to do that using continuation-passing style, however nothing useful comes into my mind.

Is that ever possible?

I think that I can "sort" the list to have it in predicted order, but it does not look good.

Also I could get rid of the tuple and create data record - however that will still lead up to checking the type of attribute and set the correct field of the record. Still a lot of typing.

Have you considered using one of the numerous command line parsing packages on hackage? — Nathan Howell, Jul 07 '12 at 07:34
Packages such as `cmdargs` and `optparse-applicative` fill in records fields.. ignoring the order of arguments on the command line. You might try one or both of these out as an alternative to GetOpt. — Nathan Howell, Jul 07 '12 at 07:43
@jdevelop And what goes wrong with GetOpt? I've used that several times before with great success for just such a use case. — Daniel Wagner, Jul 07 '12 at 07:54
@DanielWagner nothing is wrong with GetOpt, it returns options as it finds them in command line. But I need to convert the list of options to tuple. Perhaps tuple isn't good choice. — jdevelop, Jul 07 '12 at 08:13
@jdevelop You're right. I think you're better of with a custom options record and record syntax. — fuz, Jul 07 '12 at 13:16

score 1 · Accepted Answer · answered Jul 07 '12 at 14:25

Given what you describe, I think you have two options. Of the two, I would say that converting to a dictionary would be easiest, but converting to a Tuple would work and only be a little clumsy

So, take this definition:

options :: [OptDescr (String, String)]
options = [Option ['a'] ["alpha"] (ReqArg (\a -> ("alpha", a)) "empty") "",
           Option ['b'] ["beta"] (ReqArg (\a -> ("beta", a)) "empty") "",
           Option ['g'] ["gamma"] (ReqArg (\a -> ("gamma", a)) "empty") ""]

main = do
    args <- getArgs
    let (opts, nonopts, errs) = getOpt Permute options args
    putStrLn $ show opts

From this, a couple of my example outputs are:

[("beta","b"),("alpha","a")]
[("alpha","a"),("gamma","g"),("beta","b")]

and so on. Same order as on the command line. But, because of the way I set it up above, I basically have an association list, so... if I in particular want a Tuple that has the values (alpha, beta, gamma), then my best option is...

(lookup "alpha" opts, lookup "beta" opts, lookup "gamma" opts)

You resulting data type would be (Maybe String, Maybe String, Maybe String), in the order of "alpha", "beta", and "gamma".

converting list to tuple

1 Answers1