diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Kadzuya Okamoto https://arow.info
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,28 @@
+# tonaparser
+
+Integrated parser library created for tonatona meta application framework.
+
+It can construct system configuration from environment variables, command line arguments, and any IO values depends on them.
+See details for `example/Main.hs`.
+
+## Build example app
+
+```
+$ stack build --pedantic --flag tonaparser:buildexample tonaparser
+```
+
+Then check how it works with various command line options and environment variables.
+
+```
+$ stack exec tonaparser-example -- --new-foo 3 --bar-baz foo
+Foo {foo = 3, bar = Bar {baz = "foo"}}
+
+$ stack exec tonaparser-example -- --new-foo 3
+Foo {foo = 3, bar = Bar {baz = "baz"}}
+
+$ stack exec tonaparser-example -- --foo 3 --bar-baz foo
+tonaparser-example: No required configuration for "Configuration for Foo.foo"
+
+$ FOO=5 stack exec tonaparser-example -- --bar-baz foo
+Foo {foo = 5, bar = Bar {baz = "foo"}}
+```
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/example/Main.hs b/example/Main.hs
new file mode 100644
--- /dev/null
+++ b/example/Main.hs
@@ -0,0 +1,70 @@
+module Main where
+
+import RIO
+
+import Say (sayShow)
+import TonaParser
+  ( Parser
+  , ParserMods(..)
+  , (.||)
+  , argLong
+  , defParserMods
+  , envVar
+  , modify
+  , optionalVal
+  , requiredVal
+  , withConfig
+  )
+
+data Bar = Bar
+  { baz :: String
+  } deriving Show
+
+data Foo = Foo
+  { foo :: Int
+  , bar :: Bar
+  } deriving Show
+
+-- If environment variable "BAZ" exist, use the value
+-- else if command line argument "--baz" exist, use the value
+-- else use default value "baz"
+barParser :: Parser Bar
+barParser =
+  Bar <$>
+    optionalVal
+      "Configuration for Bar.baz"
+      (argLong "baz" .|| envVar "BAZ")
+      "baz"
+
+setPrefixBar :: Parser Bar -> Parser Bar
+setPrefixBar =
+  modify
+    defParserMods
+      { cmdLineLongMods = ("bar-" <>)
+      , envVarMods = ("BAR_" <>)
+      }
+
+fooParser :: Parser Foo
+fooParser = Foo
+  <$> requiredVal
+    "Configuration for Foo.foo"
+    (argLong "foo" .|| envVar "FOO")
+  <*> setPrefixBar barParser
+
+modifyFoo :: Parser Foo -> Parser Foo
+modifyFoo =
+  modify
+    defParserMods
+      { cmdLineLongMods = longMods
+      , envVarMods = envMods
+      }
+  where
+    longMods "foo" = "new-foo"
+    longMods a = a
+    envMods "BAR_BAZ" = "NEW_BAR_BAZ"
+    envMods a = a
+
+main :: IO ()
+main =
+  withConfig (modifyFoo fooParser) $ \config ->
+    sayShow $ config
diff --git a/src/TonaParser.hs b/src/TonaParser.hs
new file mode 100644
--- /dev/null
+++ b/src/TonaParser.hs
@@ -0,0 +1,357 @@
+{-| Integrated parser library created for tonatona meta application framework.
+  It can construct system configuration from environment variables, command line arguments, and any IO values depends on them.
+  See details for @example/Main.hs@.
+-}
+
+module TonaParser
+  (
+  -- * Run parser
+    Parser
+  , withConfig
+  -- * Construct primitive parsers
+  , optionalVal
+  , requiredVal
+  , optionalEnum
+  , requiredEnum
+  , liftWith
+  , Source
+  , module System.Envy
+  , Description
+  , (.||)
+  , envVar
+  , argLong
+  -- * Modify parsers
+  , modify
+  , defParserMods
+  , ParserMods
+  , cmdLineLongMods
+  , envVarMods
+  ) where
+
+import RIO
+import qualified RIO.List as List
+import qualified RIO.Map as Map
+
+import Control.Monad (ap)
+import Data.Typeable (Proxy(..), typeOf, typeRep)
+import Say (sayString)
+import System.Environment (getArgs, getEnvironment)
+import System.Envy (Var(fromVar, toVar))
+
+
+
+-- Types
+
+{-| Main type representing how to construct system configuration.
+ -}
+newtype Parser a = Parser
+  { runParser :: Bool -> Config -> (Bool -> a -> IO ()) -> IO () }
+
+instance Functor Parser where
+  fmap :: (a -> b) -> Parser a -> Parser b
+  fmap f p = Parser $ \b conf action ->
+    runParser p b conf (\b' -> action b' . f)
+
+instance Applicative Parser where
+  pure :: a -> Parser a
+  pure a = Parser $ \b _ action -> action b a
+
+  (<*>) = ap
+
+instance Monad Parser where
+  (>>=) :: Parser a -> (a -> Parser b) -> Parser b
+  p >>= k = Parser $ \b conf action ->
+    runParser p b conf $ \b' x ->
+      runParser (k x) b' conf action
+
+instance MonadIO Parser where
+  liftIO :: forall a. IO a -> Parser a
+  liftIO ma = Parser $ \b _ action -> action b =<< ma
+
+
+-- Operators
+
+
+modify :: ParserMods -> Parser a -> Parser a
+modify mods (Parser parserFunc) =
+  Parser $ \b oldConfig ->
+    let newConfig =
+          oldConfig
+            { confParserMods = confParserMods oldConfig <> mods
+            }
+    in parserFunc b newConfig
+
+withConfig :: Parser a -> (a -> IO ()) -> IO ()
+withConfig parser action = do
+  envVars <- getEnvVars
+  cmdLineArgs <- getCmdLineArgs
+  args <- getArgs
+  let isHelp = length (filter (`elem` ["--help", "-h"]) args) > 0
+  parse parser isHelp envVars cmdLineArgs action
+
+parse ::
+     Parser a
+  -> Bool
+  -> Map String String -- ^ Environment variables.
+  -> [(String, String)] -- ^ Command line arguments and values.
+  -> (a -> IO ())
+  -> IO ()
+parse (Parser parserFunc) isHelp envVars cmdLineArgs action =
+  parserFunc isHelp conf $ \b a ->
+    if b
+      then do
+        sayString $ unlines
+          [ "Display this help and exit"
+          , "    Default: False"
+          , "    Type: Bool"
+          , "    Command line option: -h"
+          , "    Command line option: --help"
+          ]
+      else action a
+  where
+    conf =
+        Config
+          { confCmdLineArgs = cmdLineArgs
+          , confEnvVars = envVars
+          , confParserMods = defParserMods
+          }
+
+
+getEnvVars :: IO (Map String String)
+getEnvVars = do
+  environment <- getEnvironment
+  pure $ Map.fromList environment
+
+-- TODO: Handle short-hands options.
+getCmdLineArgs :: IO [(String, String)]
+getCmdLineArgs = do
+  args <- getArgs
+  pure $ parseArgs args
+
+{-|
+  >>> parseArgs ["--bool", "--foo", "bar", "-v"]
+  [("bool",""),("foo","bar")]
+-}
+parseArgs :: [String] -> [(String, String)]
+parseArgs [] = []
+parseArgs [('-':'-':key)] = [(key, "")]
+parseArgs (('-':'-':key):ls@(('-':_):_)) = (key, "") : parseArgs ls
+parseArgs (('-':'-':key):val:ls) = (key, val) : parseArgs ls
+parseArgs (('-':_):ls) = parseArgs ls
+parseArgs (_:ls) = parseArgs ls
+
+{-| A 'Parser' constructor for required values.
+-}
+requiredVal :: Var a => Description -> Source -> Parser a
+requiredVal desc srcs = do
+  ma <- fieldMaybe Nothing desc srcs
+  handleRequired desc ma
+
+{-| A 'Parser' constructor for optional values.
+-}
+optionalVal :: Var a => Description -> Source -> a -> Parser a
+optionalVal desc srcs df = do
+  ma <- fieldMaybe (Just df) desc srcs
+  maybe (pure df) pure ma
+
+{-| A 'Parser' constructor for required values.
+-}
+requiredEnum :: (Var a, Enum a, Bounded a) => Description -> Source -> Parser a
+requiredEnum desc srcs = do
+  ma <- fieldMaybeEnum Nothing desc srcs
+  handleRequired desc ma
+
+{-| A 'Parser' constructor for optional values.
+-}
+optionalEnum :: (Var a, Enum a, Bounded a) => Description -> Source -> a -> Parser a
+optionalEnum desc srcs df = do
+  ma <- fieldMaybeEnum (Just df) desc srcs
+  maybe (pure df) pure ma
+
+handleRequired :: Description -> Maybe a -> Parser a
+handleRequired _ (Just a) = pure a
+handleRequired desc Nothing =
+  Parser $ \isHelp _ action ->
+    if isHelp
+      then action isHelp $ error "unreachable"
+      else error $
+           "No required configuration for \"" <> unDescription desc <> "\"\n" <>
+           "Try with '--help' option for more information."
+
+{-| A `Parser` constructor from @cont@.
+-}
+liftWith :: ((a -> IO ()) -> IO ()) -> Parser a
+liftWith cont = Parser $ \b _ action -> cont (action b)
+
+fieldMaybe :: forall a. (Var a) => Maybe a -> Description -> Source -> Parser (Maybe a)
+fieldMaybe mdef desc source =
+  Parser $ \isHelp conf action -> do
+    when isHelp $
+      sayString $ helpLine mdef (confParserMods conf) desc source
+    action isHelp $ fieldMaybeVal isHelp conf desc source
+
+
+fieldMaybeVal ::
+     forall a. (Var a)
+  => Bool
+  -> Config
+  -> Description
+  -> Source
+  -> Maybe a
+fieldMaybeVal isHelp conf desc (Source srcs) = do
+  val <- findValInSrc conf srcs
+  let v =
+        case (show (typeRep (Proxy :: Proxy a)), val) of
+          ("Bool", "") -> "True"
+          ("Bool", "true") -> "True"
+          ("Bool", "false") -> "False"
+          _ -> val
+  case fromVar v of
+    Nothing ->
+      if isHelp
+        then Nothing
+        else error $
+             "Invalid type of value for \"" <> unDescription desc <> "\".\n" <>
+             "Try with '--help' option for more information."
+    a -> a
+
+helpLine :: forall a. (Var a) => Maybe a -> ParserMods -> Description -> Source -> String
+helpLine mdef mods (Description desc) (Source srcs) =
+  unlines $
+    desc : map (indent 4)
+      (helpDefault mdef : helpType (Proxy :: Proxy a) : map (helpSource mods) srcs)
+
+indent :: Int -> String -> String
+indent n str =
+  replicate n ' ' <> str
+
+helpType :: forall a. Typeable a => Proxy a -> String
+helpType p = "Type: " <> case show (typeRep p) of
+  "[Char]" -> "String"
+  "ByteString" -> "String"
+  "Text" -> "String"
+  a -> a
+
+helpDefault :: Var a => Maybe a -> String
+helpDefault a@Nothing = case show (typeOf a) of
+  "Bool" -> "Default: False"
+  _ -> "Required"
+helpDefault (Just def) = "Default: " <> toVar def
+
+helpSource :: ParserMods -> InnerSource -> String
+helpSource ParserMods {envVarMods} (EnvVar str) =
+  "Environment variable: " <> envVarMods str
+helpSource ParserMods {cmdLineLongMods} (ArgLong str) =
+  "Command line option: --" <> cmdLineLongMods str
+helpSource ParserMods {cmdLineShortMods} (ArgShort c) =
+  "Command line option: -" <> [cmdLineShortMods c]
+
+fieldMaybeEnum :: (Var a, Enum a, Bounded a) => Maybe a -> Description -> Source -> Parser (Maybe a)
+fieldMaybeEnum mdef desc source =
+  Parser $ \isHelp conf action -> do
+    when isHelp $
+      sayString $ helpLineEnum mdef (confParserMods conf) desc source
+    action isHelp $ fieldMaybeVal isHelp conf desc source
+
+helpLineEnum :: forall a. (Var a, Enum a, Bounded a) => Maybe a -> ParserMods -> Description -> Source -> String
+helpLineEnum mdef mods (Description desc) (Source srcs) =
+  unlines $
+    desc : map (indent 4)
+      (helpDefault mdef : helpType (Proxy :: Proxy a) <> helpEnum (Proxy :: Proxy a) : map (helpSource mods) srcs)
+
+helpEnum :: forall a. (Var a, Enum a, Bounded a) => Proxy a -> String
+helpEnum _ = if (length enums <= 8)
+  then " (" <> (List.intercalate "|" . map toVar) enums <> ")"
+  else ""
+  where
+    enums = [(minBound :: a)..maxBound]
+
+findValInSrc :: Config -> [InnerSource] -> Maybe String
+findValInSrc conf srcs = listToMaybe $ mapMaybe (findValInSrcs conf) srcs
+
+findValInSrcs :: Config -> InnerSource -> Maybe String
+findValInSrcs conf innerSource =
+  let cmdLineArgs = confCmdLineArgs conf
+      envVars = confEnvVars conf
+      mods = confParserMods conf
+      longMods = cmdLineLongMods mods
+      shortMods = cmdLineShortMods mods
+      envMods = envVarMods mods
+  in
+  case innerSource of
+    ArgLong str -> findValInCmdLineLong cmdLineArgs longMods str
+    ArgShort ch -> findValInCmdLineShort cmdLineArgs shortMods ch
+    EnvVar var -> findValInEnvVar envVars envMods var
+
+findValInCmdLineLong
+  :: [(String, String)]
+  -> (String -> String)
+  -> String
+  -> Maybe String
+findValInCmdLineLong args modFunc str =
+  let modifiedVal = modFunc str
+  in lookup modifiedVal args
+
+findValInCmdLineShort
+  :: [(String, String)]
+  -> (Char -> Char)
+  -> Char
+  -> Maybe String
+findValInCmdLineShort args modFunc ch =
+  let modifiedVal = modFunc ch
+  in lookup [modifiedVal] args
+
+findValInEnvVar
+  :: Map String String
+  -> (String -> String)
+  -> String
+  -> Maybe String
+findValInEnvVar args modFunc var =
+  let modifiedVal = modFunc var
+  in Map.lookup modifiedVal args
+
+data Config = Config
+  { confCmdLineArgs :: [(String, String)]
+  , confEnvVars :: Map String String
+  , confParserMods :: ParserMods
+  }
+
+data ParserMods = ParserMods
+  { cmdLineLongMods :: String -> String
+  , cmdLineShortMods :: Char -> Char
+  , envVarMods :: String -> String
+  }
+
+instance Semigroup ParserMods where
+  ParserMods a b c <> ParserMods a' b' c' =
+    ParserMods (a' . a) (b' . b) (c' . c)
+
+instance Monoid ParserMods where
+  mappend = (<>)
+  mempty = ParserMods id id id
+
+defParserMods :: ParserMods
+defParserMods = mempty
+
+data InnerSource
+  = EnvVar String
+  | ArgLong String
+  | ArgShort Char
+
+newtype Source = Source { _unSource :: [InnerSource] }
+
+(.||) :: Source -> Source -> Source
+(.||) (Source a) (Source b) = Source (a ++ b)
+
+newtype Description = Description { unDescription :: String }
+  deriving (Show, Eq, Read, IsString)
+
+envVar :: String -> Source
+envVar name =
+  Source [EnvVar name]
+
+argLong :: String -> Source
+argLong name = Source [ArgLong name]
+
+-- argShort :: Char -> Source
+-- argShort name = Source [ArgShort name]
diff --git a/test/DocTest.hs b/test/DocTest.hs
new file mode 100644
--- /dev/null
+++ b/test/DocTest.hs
@@ -0,0 +1,58 @@
+module Main (main) where
+
+import RIO
+
+import System.FilePath.Glob (glob)
+import Test.DocTest (doctest)
+
+main :: IO ()
+main = glob "src/**/*.hs" >>= doDocTest
+
+doDocTest :: [String] -> IO ()
+doDocTest options =
+  doctest $
+    options <>
+    ghcExtensions
+
+ghcExtensions :: [String]
+ghcExtensions =
+    [ "-XAutoDeriveTypeable"
+    , "-XBangPatterns"
+    , "-XBinaryLiterals"
+    , "-XConstraintKinds"
+    , "-XDataKinds"
+    , "-XDefaultSignatures"
+    , "-XDeriveDataTypeable"
+    , "-XDeriveFoldable"
+    , "-XDeriveFunctor"
+    , "-XDeriveGeneric"
+    , "-XDeriveTraversable"
+    , "-XDoAndIfThenElse"
+    , "-XEmptyDataDecls"
+    , "-XExistentialQuantification"
+    , "-XFlexibleContexts"
+    , "-XFlexibleInstances"
+    , "-XFunctionalDependencies"
+    , "-XGADTs"
+    , "-XGeneralizedNewtypeDeriving"
+    , "-XInstanceSigs"
+    , "-XKindSignatures"
+    , "-XLambdaCase"
+    , "-XMonadFailDesugaring"
+    , "-XMultiParamTypeClasses"
+    , "-XMultiWayIf"
+    , "-XNamedFieldPuns"
+    , "-XNoImplicitPrelude"
+    , "-XOverloadedStrings"
+    , "-XPartialTypeSignatures"
+    , "-XPatternGuards"
+    , "-XPolyKinds"
+    , "-XRankNTypes"
+    , "-XRecordWildCards"
+    , "-XScopedTypeVariables"
+    , "-XStandaloneDeriving"
+    , "-XTupleSections"
+    , "-XTypeFamilies"
+    , "-XTypeSynonymInstances"
+    , "-XViewPatterns"
+    ]
diff --git a/test/Spec.hs b/test/Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/Spec.hs
@@ -0,0 +1,8 @@
+{-# LANGUAGE QuasiQuotes #-}
+
+module Main where
+
+import RIO
+
+main :: IO ()
+main = pure ()
diff --git a/tonaparser.cabal b/tonaparser.cabal
new file mode 100644
--- /dev/null
+++ b/tonaparser.cabal
@@ -0,0 +1,98 @@
+-- This file has been generated from package.yaml by hpack version 0.28.2.
+--
+-- see: https://github.com/sol/hpack
+--
+-- hash: 30075f27701989cb778813963b65cd8243a94fedf74e41f83d3a32bfbd100386
+
+name:           tonaparser
+version:        0.1.0.0
+synopsis:       Scalable way to pass runtime configurations for tonatona
+description:    Tonaparser provides a way to pass runtime configurations. This library is supposed to be used with @tonatona@.
+category:       Library, System, Tonatona
+homepage:       https://github.com/tonatona-project/tonatona#readme
+bug-reports:    https://github.com/tonatona-project/tonatona/issues
+author:         Kadzuya Okamoto, Dennis Gosnell
+maintainer:     arow.okamoto+github@gmail.com
+copyright:      2018 Kadzuya Okamoto
+license:        MIT
+license-file:   LICENSE
+build-type:     Simple
+cabal-version:  >= 1.10
+extra-source-files:
+    README.md
+
+source-repository head
+  type: git
+  location: https://github.com/tonatona-project/tonatona
+
+flag buildexample
+  description: Build a small example program
+  manual: False
+  default: False
+
+library
+  exposed-modules:
+      TonaParser
+  other-modules:
+      Paths_tonaparser
+  hs-source-dirs:
+      src
+  default-extensions: AutoDeriveTypeable BangPatterns BinaryLiterals ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DoAndIfThenElse EmptyDataDecls ExistentialQuantification FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MonadFailDesugaring MultiParamTypeClasses MultiWayIf NamedFieldPuns NoImplicitPrelude OverloadedStrings PartialTypeSignatures PatternGuards PolyKinds RankNTypes RecordWildCards ScopedTypeVariables StandaloneDeriving TupleSections TypeFamilies TypeSynonymInstances ViewPatterns
+  ghc-options: -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns -Wredundant-constraints
+  build-depends:
+      base >=4.7 && <5
+    , envy >=1.5
+    , rio >=0.1
+    , say >=0.1
+  default-language: Haskell2010
+
+executable tonaparser-example
+  main-is: Main.hs
+  other-modules:
+      Paths_tonaparser
+  hs-source-dirs:
+      example
+  default-extensions: AutoDeriveTypeable BangPatterns BinaryLiterals ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DoAndIfThenElse EmptyDataDecls ExistentialQuantification FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MonadFailDesugaring MultiParamTypeClasses MultiWayIf NamedFieldPuns NoImplicitPrelude OverloadedStrings PartialTypeSignatures PatternGuards PolyKinds RankNTypes RecordWildCards ScopedTypeVariables StandaloneDeriving TupleSections TypeFamilies TypeSynonymInstances ViewPatterns
+  ghc-options: -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns -Wredundant-constraints
+  build-depends:
+      base >=4.7 && <5
+    , envy >=1.5
+    , rio >=0.1
+    , say
+    , tonaparser
+  if flag(buildexample)
+    buildable: True
+  else
+    buildable: False
+  default-language: Haskell2010
+
+test-suite doctest
+  type: exitcode-stdio-1.0
+  main-is: DocTest.hs
+  hs-source-dirs:
+      test
+  default-extensions: AutoDeriveTypeable BangPatterns BinaryLiterals ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DoAndIfThenElse EmptyDataDecls ExistentialQuantification FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MonadFailDesugaring MultiParamTypeClasses MultiWayIf NamedFieldPuns NoImplicitPrelude OverloadedStrings PartialTypeSignatures PatternGuards PolyKinds RankNTypes RecordWildCards ScopedTypeVariables StandaloneDeriving TupleSections TypeFamilies TypeSynonymInstances ViewPatterns
+  ghc-options: -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns -Wredundant-constraints
+  build-depends:
+      Glob
+    , base >=4.7 && <5
+    , doctest
+    , envy >=1.5
+    , rio >=0.1
+    , say >=0.1
+  default-language: Haskell2010
+
+test-suite spec
+  type: exitcode-stdio-1.0
+  main-is: Spec.hs
+  hs-source-dirs:
+      test
+  default-extensions: AutoDeriveTypeable BangPatterns BinaryLiterals ConstraintKinds DataKinds DefaultSignatures DeriveDataTypeable DeriveFoldable DeriveFunctor DeriveGeneric DeriveTraversable DoAndIfThenElse EmptyDataDecls ExistentialQuantification FlexibleContexts FlexibleInstances FunctionalDependencies GADTs GeneralizedNewtypeDeriving InstanceSigs KindSignatures LambdaCase MonadFailDesugaring MultiParamTypeClasses MultiWayIf NamedFieldPuns NoImplicitPrelude OverloadedStrings PartialTypeSignatures PatternGuards PolyKinds RankNTypes RecordWildCards ScopedTypeVariables StandaloneDeriving TupleSections TypeFamilies TypeSynonymInstances ViewPatterns
+  ghc-options: -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns -Wredundant-constraints
+  build-depends:
+      base >=4.7 && <5
+    , envy >=1.5
+    , rio >=0.1
+    , say >=0.1
+    , tonatona
+  default-language: Haskell2010