diff --git a/NEWS b/NEWS
--- a/NEWS
+++ b/NEWS
@@ -30,3 +30,10 @@
   complicated.
 
 * Reworked included combinators in Combinator module.
+
+Release 0.6.0.0, September 28, 2012
+Changes since release 0.4.0.0:
+
+* Add Functor instances for OptSpec, ArgSpec
+
+* Add ThreeArg and ChoiceArg ArgSpecs
diff --git a/System/Console/MultiArg.hs b/System/Console/MultiArg.hs
--- a/System/Console/MultiArg.hs
+++ b/System/Console/MultiArg.hs
@@ -19,7 +19,7 @@
   -- vocabularies, from simple to complex.
 
   -- * Terminology
-  
+
   -- | Some terms are used throughout multiarg:
   --
   -- [@word@] When you run your program from the Unix shell prompt,
@@ -96,7 +96,7 @@
   -- can parse @l@ as a short option. This would result in a
   -- \"pending\" of @20@. Then, the next parser can treat @20@ as an
   -- option argument. After that parse there will be no pendings.
-  
+
   -- * Getting started
 
   -- |If your needs are simple to moderately complicated just look at the
@@ -145,6 +145,17 @@
   --
   -- multiarg can be complicated, although I'd like to believe this is
   -- because it addresses a complicated problem in a flexible way.
+
+  -- * Projects usings multiarg
+
+  -- | * Penny, an extensible double-entry accounting
+  -- system. <http://hackage.haskell.org/package/penny-lib> The code
+  -- using multiarg is woven throughout the system; for example, see
+  -- the Penny.Liberty module.
+  --
+  -- * multiarg was originally written for Pantry, which I have yet to
+  -- polish for release, but which is available on Github at
+  -- <https://github.com/massysett/Pantry>.
 
   module System.Console.MultiArg.SimpleParser ) where
 
diff --git a/System/Console/MultiArg/Combinator.hs b/System/Console/MultiArg/Combinator.hs
--- a/System/Console/MultiArg/Combinator.hs
+++ b/System/Console/MultiArg/Combinator.hs
@@ -6,19 +6,21 @@
   -- * Parser combinators
   notFollowedBy,
   (<?>),
-  
+
   -- * Combined long and short option parser
   OptSpec(OptSpec, longOpts, shortOpts, argSpec),
-  ArgSpec(NoArg, OptionalArg, OneArg, TwoArg, VariableArg),
+  ArgSpec(NoArg, OptionalArg, OneArg, TwoArg,
+          ThreeArg, VariableArg, ChoiceArg),
   parseOption,
-  
+
   -- * Other words
   matchApproxWord ) where
-  
-import Data.List (isPrefixOf, intersperse)
+
+import Data.List (isPrefixOf, intersperse, nubBy, intercalate)
 import Data.Set ( Set )
 import qualified Data.Set as Set
-import Control.Applicative ((<*>), optional, (<$))
+import Control.Applicative
+       ((<$>), (<*>), optional, (<$), (*>), (<|>), many)
 
 import System.Console.MultiArg.Prim
   ( Parser, throw, try, approxLongOpt,
@@ -28,9 +30,9 @@
 import System.Console.MultiArg.Option
   ( LongOpt, ShortOpt, unLongOpt,
     makeLongOpt, makeShortOpt, unShortOpt )
-import Control.Applicative ((<|>), many)
 import qualified Data.Map as M
 import Data.Map ((!))
+import Data.Maybe (fromMaybe)
 import Data.Monoid ( mconcat )
 
 
@@ -51,7 +53,7 @@
 -- all previous errors, replacing them with a single error of type
 -- Replaced containing the string given.
 (<?>) :: Parser a -> String -> Parser a
-(<?>) l e = l <??> (const [Replaced e])
+(<?>) l e = l <??> const [Replaced e]
 
 infix 0 <?>
 
@@ -66,7 +68,7 @@
       matches = Set.filter p s
       err = throw $ Expected
             ("word matching one of: "
-             ++ (concat . intersperse ", " $ Set.toList s))
+             ++ (intercalate ", " $ Set.toList s))
   case Set.toList matches of
     [] -> err
     (x:[]) -> return (a, x)
@@ -74,14 +76,14 @@
 
 
 unsafeShortOpt :: Char -> ShortOpt
-unsafeShortOpt c = case makeShortOpt c of
-  Nothing -> error $ "invalid short option: " ++ [c]
-  Just o -> o
+unsafeShortOpt c =
+  fromMaybe (error $ "invalid short option: " ++ [c])
+            (makeShortOpt c)
 
 unsafeLongOpt :: String -> LongOpt
-unsafeLongOpt c = case makeLongOpt c of
-  Nothing -> error $ "invalid long option: " ++ c
-  Just o -> o
+unsafeLongOpt c =
+  fromMaybe (error $ "invalid long option: " ++ c)
+            (makeLongOpt c)
 
 
 -- |Specifies options for the 'parseOption' function. Each OptSpec
@@ -97,16 +99,19 @@
   -- your long option does not meet these conditions, a runtime error
   -- will occur.
 
-          
+
   , shortOpts :: [Char]
     -- ^ Each Char is a single short option, such as @v@. The
     -- character cannot be a dash; if it is, a runtime error will occur.
-    
+
   , argSpec :: ArgSpec a
     -- ^ What to do each time one of the given long options or
     -- short options appears on the command line.
   }
 
+instance Functor OptSpec where
+  fmap f (OptSpec ls ss as) = OptSpec ls ss (fmap f as)
+
 -- | Specifies how many arguments each option takes. As with
 -- 'System.Console.GetOpt.ArgDescr', there are (at least) two ways to
 -- use this type. You can simply represent each possible option using
@@ -137,10 +142,15 @@
     -- argument, @-a -b@ will be parsed with @-b@ being an argument to
     -- option @a@, even though @-b@ starts with a hyphen and therefore
     -- \"looks like\" an option.
-    
+
   | TwoArg (String -> String -> a)
-    -- ^ This option takes two arguments. Parsed similarly to 'OneArg'.
+    -- ^ This option takes two arguments. Parsed similarly to
+    -- 'OneArg'.
 
+  | ThreeArg (String -> String -> String -> a)
+    -- ^ This option takes three arguments. Parsed similarly to
+    -- 'OneArg'.
+
   | VariableArg ([String] -> a)
     -- ^ This option takes a variable number of arguments--zero or
     -- more. Option arguments continue until the command line contains
@@ -151,8 +161,34 @@
     -- @-a@ as the last option on the command line, then the only way
     -- to indicate the end of arguments for @a@ and the beginning of
     -- positional argments is with a stopper.
-    
 
+  | ChoiceArg [(String, a)]
+    -- ^ This option takes a single argument, which must match one of
+    -- the strings given in the list. The user may supply the shortest
+    -- unambiguous string. If the argument list to ChoiceArg has
+    -- duplicate strings, only the first string is used. For instance,
+    -- ChoiceArg could be useful if you were parsing the @--color@
+    -- option to GNU grep, which requires the user to supply one of
+    -- three arguments: @always@, @never@, or @auto@.
+
+
+instance Functor ArgSpec where
+  fmap f a = case a of
+    NoArg i -> NoArg $ f i
+    OptionalArg g ->
+      OptionalArg $ \ms -> f (g ms)
+    OneArg g ->
+      OneArg $ \s1 -> f (g s1)
+    TwoArg g ->
+      TwoArg $ \s1 s2 -> f (g s1 s2)
+    ThreeArg g ->
+      ThreeArg $ \s1 s2 s3 -> f (g s1 s2 s3)
+    VariableArg g ->
+      VariableArg $ \ls -> f (g ls)
+    ChoiceArg gs ->
+      ChoiceArg . map (\(s, r) -> (s, f r)) $ gs
+
+
 -- | Parses a single command line option. Examines all the options
 -- specified using multiple OptSpec and parses one option on the
 -- command line accordingly. Fails without consuming any input if the
@@ -161,6 +197,14 @@
 -- options; for example, the user could type @--verb@ for @--verbose@
 -- and @--vers@ for @--version@.
 --
+-- This function is applied to a list of OptSpec, rather than to a
+-- single OptSpec, because in order to correctly handle the parsing of
+-- shortened long options (e.g. @--verb@ rather than @--verbose@) it
+-- is necessary for one function to have access to all of the
+-- OptSpec. Applying this function multiple times to different lists
+-- of OptSpec and then using the @<|>@ function to combine them will
+-- break the proper parsing of shortened long options.
+--
 -- For an example that uses this function, see
 -- "System.Console.MultiArg.SimpleParser".
 parseOption :: [OptSpec a] -> Parser a
@@ -169,11 +213,11 @@
   in case mconcat ([shortOpt] <*> os) of
     Nothing -> longs
     Just shorts -> longs <|> shorts
-  
+
 longOptParser :: [OptSpec a] -> Parser a
 longOptParser os = longOpt (longOptSet os) (longOptMap os)
-      
 
+
 longOptSet :: [OptSpec a] -> Set LongOpt
 longOptSet = Set.fromList . concatMap toOpts where
   toOpts = map unsafeLongOpt . longOpts
@@ -190,43 +234,42 @@
 longOpt set mp = do
   (_, lo, maybeArg) <- approxLongOpt set
   let spec = mp ! lo
+      maybeNextArg = maybe nextArg return maybeArg
   case spec of
     NoArg a -> case maybeArg of
       Nothing -> return a
       Just _ -> fail $ "option " ++ unLongOpt lo
                   ++ " does not take argument"
     OptionalArg f -> return (f maybeArg)
-    OneArg f -> case maybeArg of
-      Nothing -> do
-        a1 <- nextArg
-        return $ f a1
-      Just a -> return $ f a
-    TwoArg f -> case maybeArg of
-      Nothing -> do
-        a1 <- nextArg
-        a2 <- nextArg
-        return $ f a1 a2
-      Just a1 -> do
-        a2 <- nextArg
-        return $ f a1 a2
+    OneArg f -> f <$> maybeNextArg
+    TwoArg f -> f <$> maybeNextArg <*> nextArg
+    ThreeArg f -> f <$> maybeNextArg <*> nextArg <*> nextArg
     VariableArg f -> do
       as <- many nonOptionPosArg
       return . f $ case maybeArg of
         Nothing -> as
         Just a1 -> a1 : as
-
+    ChoiceArg ls -> do
+      s <- maybeNextArg
+      case matchAbbrev ls s of
+        Nothing -> fail $ "option " ++ unLongOpt lo
+                   ++ " requires an argument: "
+                   ++ (concat . intersperse ", " . map fst $ ls)
+        Just g -> return g
 
 shortOpt :: OptSpec a -> Maybe (Parser a)
 shortOpt o = mconcat parsers where
   parsers = map mkParser . shortOpts $ o
   mkParser c =
     let opt = unsafeShortOpt c
-    in Just $ case argSpec o of
-      NoArg a -> a <$ nextShort opt
-      OptionalArg f -> shortOptionalArg opt f
-      OneArg f -> shortOneArg opt f
-      TwoArg f -> shortTwoArg opt f
-      VariableArg f -> shortVariableArg opt f
+    in Just $ nextShort opt *> case argSpec o of
+      NoArg a -> return a
+      OptionalArg f -> shortOptionalArg f
+      OneArg f -> shortOneArg f
+      TwoArg f -> shortTwoArg f
+      ThreeArg f -> shortThreeArg f
+      VariableArg f -> shortVariableArg f
+      ChoiceArg ls -> shortChoiceArg opt ls
 
 -- | Parses a short option without an argument, either pending or
 -- non-pending. Fails with a single error message rather than two.
@@ -236,44 +279,43 @@
   err = Expected ("short option: " ++ [unShortOpt o])
   e ls = err : (drop 2 ls)
 
-shortVariableArg :: ShortOpt -> ([String] -> a) -> Parser a
-shortVariableArg opt f = do
-  nextShort opt
+shortVariableArg :: ([String] -> a) -> Parser a
+shortVariableArg f = do
   maybeSameWordArg <- optional pendingShortOptArg
   args <- many nonOptionPosArg
   case maybeSameWordArg of
     Nothing -> return (f args)
     Just arg1 -> return (f (arg1:args))
-  
 
-shortTwoArg :: ShortOpt -> (String -> String -> a) -> Parser a
-shortTwoArg opt f = do
-  nextShort opt
-  maybeSameWordArg <- optional pendingShortOptArg
-  case maybeSameWordArg of
-    Nothing -> do
-      arg1 <- nextArg
-      arg2 <- nextArg
-      return (f arg1 arg2)
-    Just arg1 -> do 
-      arg2 <- nextArg
-      return (f arg1 arg2)
-  
 
-shortOneArg :: ShortOpt -> (String -> a) -> Parser a
-shortOneArg opt f = do
-  nextShort opt
-  maybeSameWordArg <- optional pendingShortOptArg
-  case maybeSameWordArg of
-    Nothing -> do
-      arg <- nextArg
-      return (f arg)
-    Just a -> return (f a)
+shortOneArg :: (String -> a) -> Parser a
+shortOneArg f = f <$> firstShortArg
 
 
-shortOptionalArg :: ShortOpt -> (Maybe String -> a) -> Parser a
-shortOptionalArg opt f = do
-  nextShort opt
+firstShortArg :: Parser String
+firstShortArg =
+  optional pendingShortOptArg >>= maybe nextArg return
+
+
+shortChoiceArg :: ShortOpt -> [(String, a)] -> Parser a
+shortChoiceArg opt ls =
+  firstShortArg
+  >>= maybe err return . matchAbbrev ls
+  where
+    err = fail $ "option " ++ [unShortOpt opt] ++ " requires "
+          ++ "one argument: "
+          ++ (concat . intersperse " " . map fst $ ls)
+
+
+
+shortTwoArg :: (String -> String -> a) -> Parser a
+shortTwoArg f = f <$> firstShortArg <*> nextArg
+
+shortThreeArg :: (String -> String -> String -> a) -> Parser a
+shortThreeArg f = f <$> firstShortArg <*> nextArg <*> nextArg
+
+shortOptionalArg :: (Maybe String -> a) -> Parser a
+shortOptionalArg f = do
   maybeSameWordArg <- optional pendingShortOptArg
   case maybeSameWordArg of
     Nothing -> do
@@ -282,3 +324,19 @@
         Nothing -> return (f Nothing)
         Just a -> return (f (Just a))
     Just a -> return (f (Just a))
+
+-- | Finds the unambiguous short match for a string, if there is
+-- one. Returns a string describing the error condition if there is
+-- one, or the matching result if successful.
+matchAbbrev :: [(String, a)] -> String -> Maybe a
+matchAbbrev ls s =
+  let ls' = nubBy (\x y -> fst x == fst y) ls
+  in case lookup s ls' of
+    Just a -> return a
+    Nothing ->
+      let pdct (t, _) = s `isPrefixOf` t
+      in case filter pdct ls of
+        (_, a):[] -> return a
+        _ -> Nothing
+
+
diff --git a/System/Console/MultiArg/Option.hs b/System/Console/MultiArg/Option.hs
--- a/System/Console/MultiArg/Option.hs
+++ b/System/Console/MultiArg/Option.hs
@@ -11,6 +11,7 @@
   where
 
 import Data.List (find)
+import Data.Maybe (isNothing)
 
 -- | Short options. Options that are preceded with a single dash on
 -- the command line and consist of a single letter. That single letter
@@ -38,19 +39,19 @@
 -- | Makes a long option. Returns Nothing if the string is not a valid
 -- long option.
 makeLongOpt :: String -> Maybe LongOpt
-makeLongOpt t = case isValidLongOptText t of
-  True -> Just $ LongOpt t
-  False -> Nothing
+makeLongOpt t =
+  if isValidLongOptText t then Just $ LongOpt t else Nothing
 
+
 isValidLongOptText :: String -> Bool
 isValidLongOptText s = case s of
   [] -> False
   x:xs ->
-    if x == '-' || x == '='
+    if x `elem` ['-', '=']
     then False
     else case xs of
       [] -> True
       y:_ ->
-        if y == '-' || y == '='
+        if y `elem` ['-', '=']
         then False
-        else maybe True (const False) (find (== '=') xs)
+        else isNothing . find (== '=') $ xs
diff --git a/System/Console/MultiArg/Prim.hs b/System/Console/MultiArg/Prim.hs
--- a/System/Console/MultiArg/Prim.hs
+++ b/System/Console/MultiArg/Prim.hs
@@ -7,13 +7,13 @@
 module System.Console.MultiArg.Prim (
     -- * Parser types
   Parser,
-  
+
   -- * Running a parser
-  
+
   -- | Each parser runner is applied to a list of Strings, which are the
-  -- command line arguments to parse. 
+  -- command line arguments to parse.
   parse,
-  
+
   -- * Higher-level parser combinators
   parserMap,
   good,
@@ -21,7 +21,7 @@
   choice,
   combine,
   lookAhead,
-  
+
   -- ** Running parsers multiple times
   several,
   manyTill,
@@ -32,13 +32,13 @@
   genericThrow,
   (<??>),
   try,
-  
+
   -- * Parsers
   -- ** Short options and arguments
   pendingShortOpt,
   nonPendingShortOpt,
-  pendingShortOptArg,  
-  
+  pendingShortOptArg,
+
   -- ** Long options and arguments
   exactLongOpt,
   approxLongOpt,
@@ -46,14 +46,14 @@
   -- ** Stoppers
   stopper,
   resetStopper,
-  
+
   -- ** Positional (non-option) arguments
   nextArg,
   nonOptionPosArg,
-  
+
   -- ** Miscellaneous
   end,
-  
+
   -- * Errors
   Message(Expected, StrMsg, Replaced, UnknownError),
   Error(Error),
@@ -66,7 +66,7 @@
   (ShortOpt,
     unShortOpt,
     LongOpt,
-    unLongOpt, 
+    unLongOpt,
     makeLongOpt )
 import Control.Applicative ( Applicative, Alternative )
 import qualified Control.Applicative
@@ -77,7 +77,7 @@
 import Control.Monad ( when, MonadPlus(mzero, mplus), guard )
 import Data.Monoid ( Monoid ( mempty, mappend ) )
 import qualified Data.List as L
-import Data.List (isPrefixOf)
+import Data.List (isPrefixOf, intercalate)
 
 type Location = String
 
@@ -104,10 +104,10 @@
   -- something else. The string indicates what was expected.
   | StrMsg String
     -- ^ The 'fromString' function was applied.
-    
+
   | Replaced String
     -- ^ A previous list of error messages was replaced with this error message.
-    
+
   | UnknownError
     -- ^ Any other error; used by 'genericThrow'.
 
@@ -182,10 +182,10 @@
   -- Unicode strings, see the documentation in
   -- "System.Console.MultiArg.GetArgs" before you use
   -- 'System.Environment.getArgs'.
-  
+
   -> Parser a
   -- ^ Parser to run
-  
+
   -> Exceptional Error a
   -- ^ Success or failure. Any parser might fail; for example, the
   -- command line might not have any values left to parse. Use of the
@@ -355,7 +355,7 @@
 
 pendingShortOpt :: ShortOpt -> Parser ()
 pendingShortOpt so = Parser $ \s ->
-  let err = Expected ("pending short option: " ++ [(unShortOpt so)])
+  let err = Expected ("pending short option: " ++ [unShortOpt so])
       es = (Bad, s { errors = err : errors s })
       gd newSt = (Good (), newSt)
   in maybe es gd $ do
@@ -480,8 +480,8 @@
   let (pre, word, afterEq) = splitLongWord str
   guard (pre == "--")
   return (word, afterEq)
-  
 
+
 nextWord :: ParseSt -> Maybe (String, ParseSt)
 nextWord st = case remaining st of
   [] -> Nothing
@@ -496,7 +496,7 @@
 approxLongOptError set st = st { errors = newE : errors st } where
   newE = Expected ex
   ex = "a long option: " ++ longs
-  longs = concat . L.intersperse ", " $ opts
+  longs = intercalate ", " opts
   opts = fmap unLongOpt . Set.toList $ set
 
 -- | Examines the next word. If it matches a Text in the set
@@ -517,7 +517,7 @@
     if Set.member opt ts
       then return ((word, opt, afterEq), s')
       else do
-      let p t = word `isPrefixOf` (unLongOpt t)
+      let p t = word `isPrefixOf` unLongOpt t
           matches = Set.filter p ts
       case Set.toList matches of
         [] -> Nothing
@@ -584,8 +584,8 @@
     Good g -> (Good g, s')
     Bad -> (Bad, s'') where
       s'' = s { errors = errors s' }
-      
 
+
 -- | Returns the next string on the command line as long as there are
 -- no pendings. Be careful - this will return the next string even if
 -- it looks like an option (that is, it starts with a dash.) Consider
@@ -726,7 +726,7 @@
         let (ls, finalGoodSt, finalBadSt) = parseRepeat st' f
         in (a : ls, finalGoodSt, finalBadSt)
     (Bad, st') -> ([], st1, st')
-    
+
 
 -- | Succeeds if there is no more input left.
 end :: Parser ()
diff --git a/System/Console/MultiArg/SimpleParser.hs b/System/Console/MultiArg/SimpleParser.hs
--- a/System/Console/MultiArg/SimpleParser.hs
+++ b/System/Console/MultiArg/SimpleParser.hs
@@ -5,19 +5,19 @@
 module System.Console.MultiArg.SimpleParser (
   -- * Interspersion control
   Intersperse (Intersperse, StopOptions)
-  
+
   -- * Option specifications
   , C.OptSpec (OptSpec, longOpts, shortOpts, argSpec)
   , C.ArgSpec (NoArg, OptionalArg, OneArg, TwoArg, VariableArg)
-    
+
     -- * Exceptions
   , Ex.Exceptional (Exception, Success)
   , P.Error (Error)
   , P.Message (Expected, StrMsg, Replaced, UnknownError)
-    
+
     -- * Get command line arguments
   , G.getArgs
-  
+
     -- * The parser
   , parse
   ) where
@@ -26,8 +26,8 @@
 import qualified System.Console.MultiArg.GetArgs as G
 import qualified System.Console.MultiArg.Combinator as C
 import qualified Control.Monad.Exception.Synchronous as Ex
-import Control.Applicative ( many, (<|>), optional, (*>),
-                             (<$))
+import Control.Applicative ( many, (<|>), optional,
+                             (<$), (<*>), (<*), (<$>))
 import Data.Maybe (catMaybes)
 
 -- | What to do after encountering the first non-option,
@@ -42,21 +42,21 @@
   -- command line is entered, then @-b@ will result in an error
   -- because @-b@ starts with a hyphen and therefore \"looks like\" an
   -- option.
-  
+
   | StopOptions
     -- ^ No additional options will be parsed after encountering the
     -- first positional argument. For example, if @a@ and @b@ are
     -- options, in the command line @-a posarg -b@, @b@ will be parsed
     -- as a positional argument rather than as an option.
 
--- | Parse a command line. 
+-- | Parse a command line.
 parse ::
   Intersperse
   -- ^ What to do after encountering the first positional argument
-  
+
   -> [C.OptSpec a]
   -- ^ All possible options
-  
+
   -> (String -> a)
   -- ^ How to handle positional arguments. This function is applied to
   -- the appropriate string every time the parser encounters a
@@ -82,15 +82,15 @@
 parseOptsNoIntersperse p = P.manyTill p e where
   e = P.end <|> nonOpt
   nonOpt = P.lookAhead next
-  next = ((() <$ P.nonOptionPosArg) <|> P.stopper)
+  next = (() <$ P.nonOptionPosArg) <|> P.stopper
 
 
 parseStopOpts :: P.Parser a -> (String -> a) -> P.Parser [a]
-parseStopOpts optParser p = do
-  opts <- parseOptsNoIntersperse optParser
-  _ <- optional P.stopper
-  args <- many P.nextArg
-  return $ opts ++ (map p args)
+parseStopOpts optParser p =
+  (\opts args -> opts ++ map p args)
+  <$> parseOptsNoIntersperse optParser
+  <* optional P.stopper
+  <*> many P.nextArg
 
 
 -- | @parseIntersperse o p@ parses options and positional arguments,
@@ -98,8 +98,8 @@
 -- when applied to a string, returns the appropriate type.
 parseIntersperse :: P.Parser a -> (String -> a) -> P.Parser [a]
 parseIntersperse optParser p =
-  let pa = P.nonOptionPosArg >>= return . Just . p
-      po = optParser >>= return . Just
-      ps = P.stopper *> return Nothing
+  let pa = (Just . p) <$> P.nonOptionPosArg
+      po = Just <$> optParser
+      ps = Nothing <$ P.stopper
       parser = po <|> ps <|> pa
-  in P.manyTill parser P.end >>= return . catMaybes
+  in catMaybes <$> P.manyTill parser P.end
diff --git a/multiarg.cabal b/multiarg.cabal
--- a/multiarg.cabal
+++ b/multiarg.cabal
@@ -1,5 +1,5 @@
 Name: multiarg
-Version: 0.4.0.0
+Version: 0.6.0.0
 Cabal-version: >=1.8
 Build-Type: Simple
 License: MIT
@@ -41,7 +41,7 @@
         base ==4.*,
         explicit-exception ==0.1.*,
         containers ==0.4.*
-        
+
     -- See documentation in System.Console.MultiArg.GetArgs for details
     if flag(newbase)
         Build-depends: