module Sound.Sox.Private.Option where

import qualified Sound.Sox.Private.Arguments as Args
import qualified Data.Map as Map
import Data.Monoid (Monoid(mappend, mempty), )
import Data.Semigroup (Semigroup((<>)), )

{- |
You can combine options using the 'Monoid' functions 'mappend' and 'mconcat'.
When the same option is given multiple times,
only the first occurence is respected.
-}
newtype T = Cons {T -> Map String [String]
decons :: Map.Map String [String]}

instance Semigroup T where
   Cons Map String [String]
x <> :: T -> T -> T
<> Cons Map String [String]
y = Map String [String] -> T
Cons (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map String [String]
x Map String [String]
y)

instance Monoid T where
   mempty :: T
mempty = Map String [String] -> T
Cons forall a. Monoid a => a
mempty
   mappend :: T -> T -> T
mappend = forall a. Semigroup a => a -> a -> a
(<>)

toArguments :: T -> Args.T
toArguments :: T -> T
toArguments =
   [String] -> T
Args.Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\(String
name,[String]
values) -> String
nameforall a. a -> [a] -> [a]
:[String]
values) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   T -> Map String [String]
decons

single :: String -> [String] -> T
single :: String -> [String] -> T
single String
name [String]
values =
   Map String [String] -> T
Cons (forall k a. k -> a -> Map k a
Map.singleton String
name [String]
values)