) where

import Control.Monad.Trans.Class (lift)

import Control.Monad.Trans.Writer

import Data.Monoid

import Data.Version

-> Maybe (ParserFailure ParserHelp -> [String] -> IO (a,(b,a)))

-- ^ optional handler for parser failure; 'handleParseResult' is called by

-- default

-- ^ commands (use 'addCommand')

-> IO (a,b)

complicatedOptions numericVersion versionString numericHpackVersion h pd footerStr commonParser mOnFailure commandParser =

-> (a -> b) -- ^ constructor to wrap up command in common data type

-> Parser c -- ^ common parser

-> Parser a -- ^ command parser

addCommand cmd title footerStr constr =

addCommand' cmd title footerStr (\a c -> (constr a,c))

-- ^ footer of command help

-> Parser c

-- ^ common parser

-- ^ sub-commands (use 'addCommand')

addSubCommands cmd title footerStr commonParser commandParser =

addCommand' cmd

title

-> (a -> c -> (b,c)) -- ^ constructor to wrap up command in common data type

-> Parser c -- ^ common parser

-> Parser a -- ^ command parser

addCommand' cmd title footerStr constr commonParser inner =

lift (tell (command cmd

(info (constr <$> inner <*> commonParser)

-- ^ metavar for the sub-command

-> Parser a

-- ^ common settings

-- ^ commands (use 'addCommand')

-> Parser (a,(b,a))

complicatedParser commandMetavar commonParser commandParser =

(,) <$>

commonParser <*>

(Right (),d) -> hsubparser' commandMetavar d

(Left b,_) -> pure (b,mempty)

module Stack.Options.ConfigParser where

import Data.Char

import Data.Monoid.Extra

import qualified Data.Set as Set

import Options.Applicative

import Stack.Options.GhcVariantParser

import Stack.Options.NixParser

import Stack.Options.Utils

import Stack.Types.Config

import qualified System.FilePath as FilePath

import Control.Arrow ((&&&))

import Control.Monad (liftM, liftM2, (<=<), when, forM, forM_)

import Control.Monad.Logger

import Control.Monad.Reader (MonadReader,runReaderT,ask,asks)

import qualified Data.ByteString as BS

import Path.Extra

import Path.Find

import Path.IO hiding (findFiles)

import Stack.Build.Installed

import Stack.Constants

import Stack.Constants.Config

import Stack.PrettyPrint

import Stack.Types.Build

import Stack.Types.Compiler

mapMaybe (D.simpleParse . T.unpack . decodeUtf8) $

C8.words $

C8.concat $

thDeps =

-- The dependent file path is surrounded by quotes but is not escaped.

-- It can be an absolute or relative path.

import Control.Applicative

import Control.Concurrent.Async (Concurrently(..))

import Control.Monad (liftM, when, join, unless, guard)

import Control.Monad.Logger

import Control.Monad.Reader (MonadReader, ReaderT (..))

import Control.Monad.State (get, put, modify)

import Path.IO hiding (findExecutable)

import qualified Paths_stack as Meta

import Prelude hiding (concat, elem, any) -- Fix AMP warning

import Stack.Build (build)

import Stack.Config (loadConfig)

import Stack.Constants (stackProgName)

import Stack.Constants.Config (distRelativeDir)

import Stack.Exec (defaultEnvSettings)

import Stack.Fetch

import Stack.GhcPkg (createDatabase, getCabalPkgVer, getGlobalDB, mkGhcPackagePath)

import Stack.PrettyPrint

import Stack.Setup.Installed

import Stack.Snapshot (loadSnapshot)

eldconfigOut <- tryProcessStdout Nothing sbinEnv "ldconfig" ["-p"]

egccErrOut <- tryProcessStderrStdout Nothing menv "gcc" ["-v"]

let firstWords = case eldconfigOut of

T.lines $ T.decodeUtf8With T.lenientDecode ldconfigOut

Left _ -> []

checkLib lib

eres <- tryProcessStdout Nothing menv exeName ["--info"]

let minfo = do

Right bs <- Just eres

version <- lookup "Project version" pairs_ >>= parseVersionFromString

arch <- lookup "Target platform" pairs_ >>= simpleParse . takeWhile (/= '-')

return (version, arch)

import Control.Applicative

import Control.DeepSeq (NFData)

import Data.Aeson.Extended

(ToJSON, toJSON, FromJSON, parseJSON,

withObject, (.:), withText)

import qualified Options.Applicative.Types as OA

import Path

import Prelude

import Stack.Types.Compiler

import qualified System.FilePath as FP

return $ LTS x y

nightly = do

t1 <- T.stripPrefix "nightly-" t0

-- | Most recent Nightly and newest LTS version per major release.

data Snapshots = Snapshots

import Control.Applicative

import Control.Monad

import Control.Monad.IO.Unlift

import Control.Monad.Logger

import Control.Monad.Reader hiding (lift)

StackT {unStackT :: ReaderT (Env config) m a}

deriving (Functor,Applicative,Monad,MonadIO,MonadReader (Env config),MonadThrow,MonadTrans)

-- | Takes the configured log level into account.

instance MonadIO m => MonadLogger (StackT config m) where

monadLoggerLog = stickyLoggerFunc

module Stack.Types.TemplateName where

import Control.Applicative

import Data.Aeson.Extended (FromJSON, withText, parseJSON)

import Data.Aeson.Types (typeMismatch)

Nothing -> parseValidFile (T.pack fname) (fname <> ".hsfiles") fname

Just prefix -> parseValidFile prefix fname fname

where

$ asum (validParses prefix hsf orig)

validParses prefix hsf orig =

-- NOTE: order is important

import Control.Monad.IO.Unlift

import Control.Monad.Logger

import Control.Monad.Reader (local)

import Control.Monad.Writer.Lazy (Writer)

import Data.Attoparsec.Args (parseArgs, EscapingMode (Escaping))

import Data.Attoparsec.Interpreter (getInterpreterArgs)

globalFooter = "Run 'stack --help' for global options that apply to all subcommands."

type AddCommand =

-- | fall-through to external executables in `git` style if they exist