-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell CLI framework
--   
--   Haskell CLI framework. See <a>README.md</a> for more details.
@package iris
@version 0.1.0.0


-- | Implements a function that opens a given file in a browser.
module Iris.Browse

-- | Open a given file in a browser. The function has the following
--   algorithm:
--   
--   <ul>
--   <li>Check the <tt>BROWSER</tt> environment variable</li>
--   <li>If it's not set, try to guess browser depending on OS</li>
--   <li>If unsuccsessful, print a message</li>
--   </ul>
--   
--   <b>Throws:</b> <a>BrowseException</a> if can't find a browser.
openInBrowser :: FilePath -> IO ()

-- | Exception thrown by <a>openInBrowser</a>.
newtype BrowseException

-- | Can't find a browser application. Stores the current OS inside.
BrowserNotFoundException :: String -> BrowseException
instance GHC.Exception.Type.Exception Iris.Browse.BrowseException
instance GHC.Classes.Eq Iris.Browse.BrowseException
instance GHC.Show.Show Iris.Browse.BrowseException


-- | CLI options parsing for <tt>--browse</tt> and
--   <tt>--browse=FILE_PATH</tt>.
module Iris.Cli.Browse

-- | A CLI option parser yields a boolean value if a file needs to be open
--   in a browser.
--   
--   Use <a>openInBrowser</a> to open the file of your choice in a browser.
browseP :: String -> Parser Bool

-- | A CLI option parser for a <a>FilePath</a> that needs to be open with a
--   browser.
--   
--   Use <a>openInBrowser</a> to open the passed file in a browser.
browseFileP :: String -> Parser FilePath


-- | CLI parser for the <tt>--colour</tt> and <tt>--no-colour</tt> options.
module Iris.Cli.Colour

-- | Data type that tells whether the user wants the colouring option
--   enabled, disabled or autodetected.
--   
--   See <a>colourOptionP</a> for the parser of this option.
data ColourOption

Always :: ColourOption

Never :: ColourOption

Auto :: ColourOption

-- | A CLI option parser for the desired coloured output mode in the
--   terminal.
--   
--   It parses <tt>--colour</tt> and <tt>--no-colour</tt> flags explicitly.
--   Otherwise, it defaults to <a>Auto</a>.
colourOptionP :: Parser ColourOption
instance GHC.Enum.Bounded Iris.Cli.Colour.ColourOption
instance GHC.Enum.Enum Iris.Cli.Colour.ColourOption
instance GHC.Classes.Ord Iris.Cli.Colour.ColourOption
instance GHC.Classes.Eq Iris.Cli.Colour.ColourOption
instance GHC.Show.Show Iris.Cli.Colour.ColourOption


-- | Interactive mode datatype and CLI parser.
module Iris.Cli.Interactive

-- | Datatype for specifying if the terminal is interactive.
data InteractiveMode

Interactive :: InteractiveMode

NonInteractive :: InteractiveMode

-- | A CLI option parser for switching to non-interactive mode if the
--   <tt>--no-input</tt> flag is passed.
interactiveModeP :: Parser InteractiveMode

-- | Forces non interactive mode when the terminal is not interactive
--   
--   Use this function to check whether you can get input from the
--   terminal:
--   
--   <pre>
--   <a>handleInteractiveMode</a> requestedInteractiveMode
--   </pre>
--   
--   If the terminal is non interactive i.e. the program is run in a pipe,
--   interactive mode is set to false no matter what
handleInteractiveMode :: InteractiveMode -> IO InteractiveMode
instance GHC.Classes.Eq Iris.Cli.Interactive.InteractiveMode
instance GHC.Show.Show Iris.Cli.Interactive.InteractiveMode


-- | Wrapper around the user-defined command.
--   
--   <b>⚠️ This module is internal and doesn't follow PVP.</b>
module Iris.Cli.Internal

-- | Wrapper around <tt>cmd</tt> with additional predefined fields
data Cmd (cmd :: Type)
Cmd :: InteractiveMode -> ColourOption -> cmd -> Cmd (cmd :: Type)
[cmdInteractiveMode] :: Cmd (cmd :: Type) -> InteractiveMode
[cmdColourOption] :: Cmd (cmd :: Type) -> ColourOption
[cmdCmd] :: Cmd (cmd :: Type) -> cmd


-- | CLI options parsing for <tt>--version</tt> and
--   <tt>--numeric-version</tt>
--   
--   <b>Enabled with config</b>
module Iris.Cli.Version

data VersionSettings
VersionSettings :: Version -> (String -> String) -> VersionSettings

[versionSettingsVersion] :: VersionSettings -> Version

[versionSettingsMkDesc] :: VersionSettings -> String -> String

defaultVersionSettings :: Version -> VersionSettings

fullVersionP :: VersionSettings -> Parser (a -> a)

mkVersionParser :: Maybe VersionSettings -> Parser (a -> a)


-- | The <a>ColourMode</a> data type that allows disabling and enabling of
--   colouring.
module Iris.Colour.Mode

-- | Data type that tells whether the colouring is enabled or disabled. Its
--   value is detected automatically on application start and stored in
--   <a>CliEnv</a>.
data ColourMode

DisableColour :: ColourMode

EnableColour :: ColourMode

-- | This function performs a full check of the <a>Handle</a> colouring
--   support, env variables and user-specified settings to detect whether
--   the given handle supports colouring.
--   
--   Per CLI Guidelines, the algorithm for detecting the colouring support
--   is the following:
--   
--   __Disable color if your program is not in a terminal or the user
--   requested it. These things should disable colors:__
--   
--   <ul>
--   <li><tt>stdout</tt> or <tt>stderr</tt> is not an interactive terminal
--   (a TTY). It’s best to individually check—if you’re piping stdout to
--   another program, it’s still useful to get colors on stderr.</li>
--   <li>The <tt>NO_COLOR</tt> environment variable is set.</li>
--   <li>The <tt>TERM</tt> environment variable has the value
--   <tt>dumb</tt>.</li>
--   <li>The user passes the option <tt>--no-color</tt>.</li>
--   <li>You may also want to add a <tt>MYAPP_NO_COLOR</tt> environment
--   variable in case users want to disable color specifically for your
--   program.</li>
--   </ul>
--   
--   ℹ️ Iris performs this check on the application start automatically so
--   you don't need to call this function manually.
detectColourMode :: Handle -> ColourOption -> Maybe String -> IO ColourMode

-- | Returns <a>ColourMode</a> of a <a>Handle</a> ignoring environment and
--   CLI options. You can use this function on output <a>Handle</a>s to
--   find out whether they support colouring or not.
--   
--   Use a function like this to check whether you can print with colour to
--   terminal:
--   
--   <pre>
--   <a>handleColourMode</a> <a>stdout</a>
--   </pre>
handleColourMode :: Handle -> IO ColourMode
instance GHC.Enum.Bounded Iris.Colour.Mode.ColourMode
instance GHC.Enum.Enum Iris.Colour.Mode.ColourMode
instance GHC.Classes.Ord Iris.Colour.Mode.ColourMode
instance GHC.Classes.Eq Iris.Colour.Mode.ColourMode
instance GHC.Show.Show Iris.Colour.Mode.ColourMode


-- | Settings of a CLI app environment.
--   
--   You're encouraged to create a separate module <tt>MyApp.Settings</tt>
--   and put settings for your custom application there following the below
--   pattern:
--   
--   <pre>
--   <b>module</b> MyApp.Settings (appSettings) <b>where</b>
--   
--   -- data data for your CLI arguments and CLI parser
--   <b>import</b> MyApp.Cli (Options, optionsP)
--   
--   -- custom application environment
--   <b>import</b> MyApp.Env (Env)
--   
--   <b>import qualified</b> <a>Iris</a>
--   <b>import qualified</b> Paths_myapp <b>as</b> Autogen
--   
--   
--   appSettings :: Env -&gt; Iris.<a>CliEnvSettings</a> Options Env
--   appSettings env = Iris.defaultCliEnvSettings
--       { -- CLI parser for Options
--         Iris.<a>cliEnvSettingsCmdParser</a> = optionsP
--   
--         -- Custom app environment
--       , Iris.<a>cliEnvSettingsAppEnv</a> = env
--   
--         -- Application name
--       , Iris.<a>cliEnvSettingsAppName</a> =
--           Just "myapp"
--   
--         -- Short app description
--       , Iris.<a>cliEnvSettingsHeaderDesc</a> =
--           "myapp - short description"
--   
--         -- Long app description to appear in --help
--       , Iris.<a>cliEnvSettingsProgDesc</a> =
--           "A tool for ..."
--   
--         -- How to print app version with the --version flag
--       , Iris.<a>cliEnvSettingsVersionSettings</a> =
--           Just (Iris.<a>defaultVersionSettings</a> Autogen.version)
--               { Iris.<a>versionSettingsMkDesc</a> = v -&gt; "MyApp v" &lt;&gt; v
--               }
--       }
--   </pre>
module Iris.Settings

-- | The Iris settings type.
--   
--   Use <a>defaultCliEnvSettings</a> to specify only used fields.
data CliEnvSettings (cmd :: Type) (appEnv :: Type)
CliEnvSettings :: Parser cmd -> appEnv -> String -> String -> Maybe VersionSettings -> Maybe String -> CliEnvSettings (cmd :: Type) (appEnv :: Type)

[cliEnvSettingsCmdParser] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> Parser cmd

[cliEnvSettingsAppEnv] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> appEnv

[cliEnvSettingsHeaderDesc] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> String

[cliEnvSettingsProgDesc] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> String

[cliEnvSettingsVersionSettings] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> Maybe VersionSettings

[cliEnvSettingsAppName] :: CliEnvSettings (cmd :: Type) (appEnv :: Type) -> Maybe String

-- | Default Iris app settings.
defaultCliEnvSettings :: CliEnvSettings () ()


-- | Parser information for the default CLI parser.
module Iris.Cli.ParserInfo

cmdParserInfo :: forall cmd appEnv. CliEnvSettings cmd appEnv -> ParserInfo (Cmd cmd)


-- | Environment of a CLI app.
module Iris.Env

-- | CLI application environment. It contains default settings for every
--   CLI app and parameter
--   
--   Has the following type parameters:
--   
--   <ul>
--   <li><tt>cmd</tt>: application commands</li>
--   <li><tt>appEnv</tt>: application-specific environment; use <tt>()</tt>
--   if you don't have custom app environment</li>
--   </ul>
data CliEnv (cmd :: Type) (appEnv :: Type)
CliEnv :: cmd -> ColourMode -> ColourMode -> appEnv -> InteractiveMode -> CliEnv (cmd :: Type) (appEnv :: Type)

[cliEnvCmd] :: CliEnv (cmd :: Type) (appEnv :: Type) -> cmd

[cliEnvStdoutColourMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> ColourMode

[cliEnvStderrColourMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> ColourMode

[cliEnvAppEnv] :: CliEnv (cmd :: Type) (appEnv :: Type) -> appEnv

[cliEnvInteractiveMode] :: CliEnv (cmd :: Type) (appEnv :: Type) -> InteractiveMode

mkCliEnv :: forall cmd appEnv. CliEnvSettings cmd appEnv -> IO (CliEnv cmd appEnv)

-- | Get a field from the global environment <a>CliEnv</a>.
asksCliEnv :: MonadReader (CliEnv cmd appEnv) m => (CliEnv cmd appEnv -> field) -> m field

-- | Get a field from custom application-specific environment
--   <tt>appEnv</tt>.
asksAppEnv :: MonadReader (CliEnv cmd appEnv) m => (appEnv -> field) -> m field


-- | Helper functions to print with colouring.
module Iris.Colour.Formatting

-- | Print <a>Text</a> to <a>stdout</a> by providing a custom formatting
--   function.
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStdoutColouredLn</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStdoutColouredLn :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (Text -> Text) -> Text -> m ()

-- | Print <a>Text</a> to <a>stderr</a> by providing a custom formatting
--   function.
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStderrColouredLn</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStderrColouredLn :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (Text -> Text) -> Text -> m ()

-- | Print <a>Text</a> to <a>stdout</a> by providing a custom formatting
--   function. Doesn't breaks output line that differs from
--   <a>putStdoutColouredLn</a>
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStdoutColoured</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStdoutColoured :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (Text -> Text) -> Text -> m ()

-- | Print <a>Text</a> to <a>stderr</a> by providing a custom formatting
--   function. Doesn't breaks output line that differs from
--   <a>putStderrColouredLn</a>
--   
--   This works especially well with the <tt>colourista</tt> package:
--   
--   <pre>
--   <a>putStderrColoured</a>
--       (Colourista.formatWith [Colourista.bold, Colourista.green])
--       "my message"
--   </pre>
putStderrColoured :: (MonadReader (CliEnv cmd appEnv) m, MonadIO m) => (Text -> Text) -> Text -> m ()


-- | Functions to handle colouring of the output to terminal.
module Iris.Colour


-- | CLI options parsing.
module Iris.Cli


-- | The application monad — <a>CliApp</a>.
--   
--   Many functions in <b>Iris</b> are polymorphic over any monad that has
--   the <a>MonadReader</a> constraint.
--   
--   Implement your own application monad as a <b>newtype</b> wrapper
--   around <a>CliApp</a> in the following way.
--   
--   <pre>
--   <b>newtype</b> App a = App
--       { unApp :: Iris.<a>CliApp</a> MyOptions MyEnv a
--       } <b>deriving newtype</b>
--           ( <a>Functor</a>
--           , <a>Applicative</a>
--           , <a>Monad</a>
--           , <a>MonadIO</a>
--           , <a>MonadUnliftIO</a>
--           , <a>MonadReader</a> (Iris.<a>CliEnv</a> MyOptions MyEnv)
--           )
--   </pre>
module Iris.App

-- | Main monad for your CLI application.
--   
--   The type variables are:
--   
--   <ul>
--   <li><tt>cmd</tt>: the data type for your CLI arguments</li>
--   <li><tt>appEnv</tt>: custom environment for your application (can be
--   just <tt>()</tt> if you don't need one)</li>
--   <li><tt>a</tt>: the value inside the monadic context</li>
--   </ul>
newtype CliApp cmd appEnv a
CliApp :: (CliEnv cmd appEnv -> IO a) -> CliApp cmd appEnv a
[unCliApp] :: CliApp cmd appEnv a -> CliEnv cmd appEnv -> IO a

-- | Run application with settings.
--   
--   This function is supposed to be used in your <tt>main</tt> function:
--   
--   <pre>
--   app :: App ()
--   app = ... your main application ...
--   
--   main :: IO ()
--   main = <a>runCliApp</a> mySettings (unApp app)
--   </pre>
runCliApp :: CliEnvSettings cmd appEnv -> CliApp cmd appEnv a -> IO a

-- | Run application by constructing <a>CliEnv</a> settings manually.
runCliAppManually :: CliEnv cmd appEnv -> CliApp cmd appEnv a -> IO a
instance Control.Monad.IO.Unlift.MonadUnliftIO (Iris.App.CliApp cmd appEnv)
instance Control.Monad.Reader.Class.MonadReader (Iris.Env.CliEnv cmd appEnv) (Iris.App.CliApp cmd appEnv)
instance Control.Monad.IO.Class.MonadIO (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Monad (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Applicative (Iris.App.CliApp cmd appEnv)
instance GHC.Base.Functor (Iris.App.CliApp cmd appEnv)


-- | Utilities to check required tools and their minimal version for a CLI
--   app.
--   
--   Sometimes, your CLI application
module Iris.Tool

-- | Use this function to require specific CLI tools for your CLI
--   application.
--   
--   The function can be used in the beginning of each command in the
--   following way:
--   
--   <pre>
--   app :: App ()
--   app = Iris.<a>asksCliEnv</a> Iris.<a>cliEnvCmd</a> &gt;&gt;= <b>\case</b>
--       Download url -&gt; do
--           Iris.<a>need</a> ["curl"]
--           runDownload url
--       Evaluate hs -&gt; do
--           Iris.<a>need</a> ["ghc", "cabal"]
--           runEvaluate hs
--   </pre>
--   
--   <b>Throws:</b> <a>ToolCheckException</a> if can't find a tool or if it
--   has wrong version.
need :: MonadIO m => [Tool] -> m ()

data Tool
Tool :: Text -> Maybe ToolSelector -> Tool

[toolName] :: Tool -> Text

[toolSelector] :: Tool -> Maybe ToolSelector

data ToolSelector
ToolSelector :: (Text -> Bool) -> Maybe Text -> ToolSelector

[toolSelectorFunction] :: ToolSelector -> Text -> Bool

[toolSelectorVersionArg] :: ToolSelector -> Maybe Text

defaultToolSelector :: ToolSelector

data ToolCheckResult

ToolCheckError :: ToolCheckError -> ToolCheckResult

ToolOk :: ToolCheckResult

data ToolCheckError

ToolNotFound :: Text -> ToolCheckError

ToolWrongVersion :: Text -> ToolCheckError

-- | An exception thrown by <a>need</a> when there's an error requiring a
--   tool.
newtype ToolCheckException
ToolCheckException :: ToolCheckError -> ToolCheckException

checkTool :: Tool -> IO ToolCheckResult
instance GHC.Classes.Eq Iris.Tool.ToolCheckError
instance GHC.Show.Show Iris.Tool.ToolCheckError
instance GHC.Classes.Eq Iris.Tool.ToolCheckResult
instance GHC.Show.Show Iris.Tool.ToolCheckResult
instance GHC.Exception.Type.Exception Iris.Tool.ToolCheckException
instance GHC.Classes.Eq Iris.Tool.ToolCheckException
instance GHC.Show.Show Iris.Tool.ToolCheckException
instance Data.String.IsString Iris.Tool.Tool


-- | <b>Iris</b> is a Haskell CLI framework. It contains batteries for
--   bulding CLI applications in Haskell by following best-practices.
--   
--   The library is designed for <b>qualified</b> imports. To use it,
--   import like this:
--   
--   <pre>
--   <b>import qualified</b> <a>Iris</a>
--   </pre>
--   
--   To create an CLI application with <b>Iris</b>, you need to do the
--   following steps:
--   
--   <ol>
--   <li>Create settings for your applications by constructing a value of
--   type <a>CliEnvSettings</a>.</li>
--   <li>Define a monad for your application with the help of <a>CliApp</a>
--   by using either <b>type</b> or <b>newtype</b>.</li>
--   </ol>
--   
--   That's all! Now, you can write your CLI app by having access to all
--   capabilities provided by <b>Iris</b> 🎉
--   
--   For a detailed introduction to <b>Iris</b>, refer to the following
--   examples:
--   
--   <ul>
--   <li><a>Simple Grep Example</a></li>
--   </ul>
module Iris