    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Distribution.Verbosity
    -- Copyright   :  Ian Lynagh 2007
    -- License     :  BSD3
    --
    -- Maintainer  :  cabal-devel@haskell.org
    -- Portability :  portable
    --
    -- A 'Verbosity' type with associated utilities.
    --
    -- There are 4 standard verbosity levels from 'silent', 'normal',
    -- 'verbose' up to 'deafening'. This is used for deciding what logging
    -- messages to print.
    --
    -- Verbosity also is equipped with some internal settings which can be
    -- used to control at a fine granularity the verbosity of specific
    -- settings (e.g., so that you can trace only particular things you
    -- are interested in.)  It's important to note that the instances
    -- for 'Verbosity' assume that this does not exist.

    -- Verbosity for Cabal functions.

    module Distribution.Verbosity (
      -- * Verbosity
      Verbosity,
      silent, normal, verbose, deafening,
      moreVerbose, lessVerbose, isVerboseQuiet,
      intToVerbosity, flagToVerbosity,
      showForCabal, showForGHC,
      verboseNoFlags, verboseHasFlags,
      modifyVerbosity,

      -- * Call stacks
      verboseCallSite, verboseCallStack,
      isVerboseCallSite, isVerboseCallStack,

      -- * Output markets
      verboseMarkOutput, isVerboseMarkOutput,
      verboseUnmarkOutput,

      -- * line-wrapping
      verboseNoWrap, isVerboseNoWrap,

      -- * timestamps
      verboseTimestamp, isVerboseTimestamp,
      verboseNoTimestamp,

      -- * Stderr
      verboseStderr, isVerboseStderr,
      verboseNoStderr,
      ) where

    import Prelude ()
    import Distribution.Compat.Prelude

    import Distribution.ReadE

    import Data.List (elemIndex)
    import Distribution.Parsec
    import Distribution.Pretty
    import Distribution.Verbosity.Internal
    import Distribution.Utils.Generic (isAsciiAlpha)

    import qualified Data.Set as Set
    import qualified Distribution.Compat.CharParsing as P
    import qualified Text.PrettyPrint as PP

    data Verbosity = Verbosity {
        Verbosity -> VerbosityLevel
    vLevel :: VerbosityLevel,
        Verbosity -> Set VerbosityFlag
    vFlags :: Set VerbosityFlag,
        Verbosity -> Bool
    vQuiet :: Bool
      } deriving ((forall x. Verbosity -> Rep Verbosity x)
    -> (forall x. Rep Verbosity x -> Verbosity) -> Generic Verbosity
    forall x. Rep Verbosity x -> Verbosity
    forall x. Verbosity -> Rep Verbosity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Verbosity x -> Verbosity
    $cfrom :: forall x. Verbosity -> Rep Verbosity x
    Generic, Int -> Verbosity -> ShowS
    [Verbosity] -> ShowS
    Verbosity -> String
    (Int -> Verbosity -> ShowS)
    -> (Verbosity -> String)
    -> ([Verbosity] -> ShowS)
    -> Show Verbosity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Verbosity] -> ShowS
    $cshowList :: [Verbosity] -> ShowS
    show :: Verbosity -> String
    $cshow :: Verbosity -> String
    showsPrec :: Int -> Verbosity -> ShowS
    $cshowsPrec :: Int -> Verbosity -> ShowS
    Show, ReadPrec [Verbosity]
    ReadPrec Verbosity
    Int -> ReadS Verbosity
    ReadS [Verbosity]
    (Int -> ReadS Verbosity)
    -> ReadS [Verbosity]
    -> ReadPrec Verbosity
    -> ReadPrec [Verbosity]
    -> Read Verbosity
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Verbosity]
    $creadListPrec :: ReadPrec [Verbosity]
    readPrec :: ReadPrec Verbosity
    $creadPrec :: ReadPrec Verbosity
    readList :: ReadS [Verbosity]
    $creadList :: ReadS [Verbosity]
    readsPrec :: Int -> ReadS Verbosity
    $creadsPrec :: Int -> ReadS Verbosity
    Read, Typeable)

    mkVerbosity :: VerbosityLevel -> Verbosity
    mkVerbosity :: VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    l = Verbosity { vLevel :: VerbosityLevel
    vLevel = VerbosityLevel
    l, vFlags :: Set VerbosityFlag
    vFlags = Set VerbosityFlag
    forall a. Set a
    Set.empty, vQuiet :: Bool
    vQuiet = Bool
    False }

    instance Eq Verbosity where
        Verbosity
    x == :: Verbosity -> Verbosity -> Bool
    == Verbosity
    y = Verbosity -> VerbosityLevel
    vLevel Verbosity
    x VerbosityLevel -> VerbosityLevel -> Bool
    forall a. Eq a => a -> a -> Bool
    == Verbosity -> VerbosityLevel
    vLevel Verbosity
    y

    instance Ord Verbosity where
        compare :: Verbosity -> Verbosity -> Ordering
    compare Verbosity
    x Verbosity
    y = VerbosityLevel -> VerbosityLevel -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (Verbosity -> VerbosityLevel
    vLevel Verbosity
    x) (Verbosity -> VerbosityLevel
    vLevel Verbosity
    y)

    instance Enum Verbosity where
        toEnum :: Int -> Verbosity
    toEnum = VerbosityLevel -> Verbosity
    mkVerbosity (VerbosityLevel -> Verbosity)
    -> (Int -> VerbosityLevel) -> Int -> Verbosity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> VerbosityLevel
    forall a. Enum a => Int -> a
    toEnum
        fromEnum :: Verbosity -> Int
    fromEnum = VerbosityLevel -> Int
    forall a. Enum a => a -> Int
    fromEnum (VerbosityLevel -> Int)
    -> (Verbosity -> VerbosityLevel) -> Verbosity -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Verbosity -> VerbosityLevel
    vLevel

    instance Bounded Verbosity where
        minBound :: Verbosity
    minBound = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    forall a. Bounded a => a
    minBound
        maxBound :: Verbosity
    maxBound = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    forall a. Bounded a => a
    maxBound

    instance Binary Verbosity
    instance Structured Verbosity

    -- We shouldn't print /anything/ unless an error occurs in silent mode
    silent :: Verbosity
    silent :: Verbosity
    silent = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Silent

    -- Print stuff we want to see by default
    normal :: Verbosity
    normal :: Verbosity
    normal = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Normal

    -- Be more verbose about what's going on
    verbose :: Verbosity
    verbose :: Verbosity
    verbose = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Verbose

    -- Not only are we verbose ourselves (perhaps even noisier than when
    -- being "verbose"), but we tell everything we run to be verbose too
    deafening :: Verbosity
    deafening :: Verbosity
    deafening = VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Deafening

    moreVerbose :: Verbosity -> Verbosity
    moreVerbose :: Verbosity -> Verbosity
    moreVerbose Verbosity
    v =
        case Verbosity -> VerbosityLevel
    vLevel Verbosity
    v of
            VerbosityLevel
    Silent    -> Verbosity
    v -- silent should stay silent
            VerbosityLevel
    Normal    -> Verbosity
    v { vLevel :: VerbosityLevel
    vLevel = VerbosityLevel
    Verbose }
            VerbosityLevel
    Verbose   -> Verbosity
    v { vLevel :: VerbosityLevel
    vLevel = VerbosityLevel
    Deafening }
            VerbosityLevel
    Deafening -> Verbosity
    v

    lessVerbose :: Verbosity -> Verbosity
    lessVerbose :: Verbosity -> Verbosity
    lessVerbose Verbosity
    v =
        Verbosity -> Verbosity
    verboseQuiet (Verbosity -> Verbosity) -> Verbosity -> Verbosity
    forall a b. (a -> b) -> a -> b
    $
        case Verbosity -> VerbosityLevel
    vLevel Verbosity
    v of
            VerbosityLevel
    Deafening -> Verbosity
    v -- deafening stays deafening
            VerbosityLevel
    Verbose   -> Verbosity
    v { vLevel :: VerbosityLevel
    vLevel = VerbosityLevel
    Normal }
            VerbosityLevel
    Normal    -> Verbosity
    v { vLevel :: VerbosityLevel
    vLevel = VerbosityLevel
    Silent }
            VerbosityLevel
    Silent    -> Verbosity
    v

    -- | Combinator for transforming verbosity level while retaining the
    -- original hidden state.
    --
    -- For instance, the following property holds
    --
    -- prop> isVerboseNoWrap (modifyVerbosity (max verbose) v) == isVerboseNoWrap v
    --
    -- __Note__: you can use @modifyVerbosity (const v1) v0@ to overwrite
    -- @v1@'s flags with @v0@'s flags.
    --
    -- @since 2.0.1.0
    modifyVerbosity :: (Verbosity -> Verbosity) -> Verbosity -> Verbosity
    modifyVerbosity :: (Verbosity -> Verbosity) -> Verbosity -> Verbosity
    modifyVerbosity Verbosity -> Verbosity
    f Verbosity
    v = Verbosity
    v { vLevel :: VerbosityLevel
    vLevel = Verbosity -> VerbosityLevel
    vLevel (Verbosity -> Verbosity
    f Verbosity
    v) }

    intToVerbosity :: Int -> Maybe Verbosity
    intToVerbosity :: Int -> Maybe Verbosity
    intToVerbosity Int
    0 = Verbosity -> Maybe Verbosity
    forall a. a -> Maybe a
    Just (VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Silent)
    intToVerbosity Int
    1 = Verbosity -> Maybe Verbosity
    forall a. a -> Maybe a
    Just (VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Normal)
    intToVerbosity Int
    2 = Verbosity -> Maybe Verbosity
    forall a. a -> Maybe a
    Just (VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Verbose)
    intToVerbosity Int
    3 = Verbosity -> Maybe Verbosity
    forall a. a -> Maybe a
    Just (VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    Deafening)
    intToVerbosity Int
    _ = Maybe Verbosity
    forall a. Maybe a
    Nothing

    -- | Parser verbosity
    --
    -- >>> explicitEitherParsec parsecVerbosity "normal"
    -- Right (Verbosity {vLevel = Normal, vFlags = fromList [], vQuiet = False})
    --
    -- >>> explicitEitherParsec parsecVerbosity "normal+nowrap  "
    -- Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap], vQuiet = False})
    --
    -- >>> explicitEitherParsec parsecVerbosity "normal+nowrap +markoutput"
    -- Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})
    --
    -- >>> explicitEitherParsec parsecVerbosity "normal +nowrap +markoutput"
    -- Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})
    --
    -- >>> explicitEitherParsec parsecVerbosity "normal+nowrap+markoutput"
    -- Right (Verbosity {vLevel = Normal, vFlags = fromList [VNoWrap,VMarkOutput], vQuiet = False})
    --
    -- >>> explicitEitherParsec parsecVerbosity "deafening+nowrap+stdout+stderr+callsite+callstack"
    -- Right (Verbosity {vLevel = Deafening, vFlags = fromList [VCallStack,VCallSite,VNoWrap,VStderr], vQuiet = False})
    --
    -- /Note:/ this parser will eat trailing spaces.
    --
    instance Parsec Verbosity where
        parsec :: forall (m :: * -> *). CabalParsing m => m Verbosity
    parsec = m Verbosity
    forall (m :: * -> *). CabalParsing m => m Verbosity
    parsecVerbosity

    instance Pretty Verbosity where
        pretty :: Verbosity -> Doc
    pretty = String -> Doc
    PP.text (String -> Doc) -> (Verbosity -> String) -> Verbosity -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Verbosity -> String
    showForCabal

    parsecVerbosity :: CabalParsing m => m Verbosity
    parsecVerbosity :: forall (m :: * -> *). CabalParsing m => m Verbosity
    parsecVerbosity = m Verbosity
    parseIntVerbosity m Verbosity -> m Verbosity -> m Verbosity
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> m Verbosity
    parseStringVerbosity
      where
        parseIntVerbosity :: m Verbosity
    parseIntVerbosity = do
            Int
    i <- m Int
    forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
    P.integral
            case Int -> Maybe Verbosity
    intToVerbosity Int
    i of
                Just Verbosity
    v  -> Verbosity -> m Verbosity
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity
    v
                Maybe Verbosity
    Nothing -> String -> m Verbosity
    forall (m :: * -> *) a. Parsing m => String -> m a
    P.unexpected (String -> m Verbosity) -> String -> m Verbosity
    forall a b. (a -> b) -> a -> b
    $ String
    "Bad integral verbosity: " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    i String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ". Valid values are 0..3"

        parseStringVerbosity :: m Verbosity
    parseStringVerbosity = do
            VerbosityLevel
    level <- m VerbosityLevel
    parseVerbosityLevel
            ()
    _ <- m ()
    forall (m :: * -> *). CharParsing m => m ()
    P.spaces
            [Verbosity -> Verbosity]
    flags <- m (Verbosity -> Verbosity) -> m [Verbosity -> Verbosity]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many (m (Verbosity -> Verbosity)
    parseFlag m (Verbosity -> Verbosity) -> m () -> m (Verbosity -> Verbosity)
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* m ()
    forall (m :: * -> *). CharParsing m => m ()
    P.spaces)
            Verbosity -> m Verbosity
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Verbosity -> m Verbosity) -> Verbosity -> m Verbosity
    forall a b. (a -> b) -> a -> b
    $ (Verbosity -> (Verbosity -> Verbosity) -> Verbosity)
    -> Verbosity -> [Verbosity -> Verbosity] -> Verbosity
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl' (((Verbosity -> Verbosity) -> Verbosity -> Verbosity)
    -> Verbosity -> (Verbosity -> Verbosity) -> Verbosity
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (Verbosity -> Verbosity) -> Verbosity -> Verbosity
    forall a b. (a -> b) -> a -> b
    ($)) (VerbosityLevel -> Verbosity
    mkVerbosity VerbosityLevel
    level) [Verbosity -> Verbosity]
    flags

        parseVerbosityLevel :: m VerbosityLevel
    parseVerbosityLevel = do
            String
    token <- (Char -> Bool) -> m String
    forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
    P.munch1 Char -> Bool
    isAsciiAlpha
            case String
    token of
                String
    "silent"    -> VerbosityLevel -> m VerbosityLevel
    forall (m :: * -> *) a. Monad m => a -> m a
    return VerbosityLevel
    Silent
                String
    "normal"    -> VerbosityLevel -> m VerbosityLevel
    forall (m :: * -> *) a. Monad m => a -> m a
    return VerbosityLevel
    Normal
                String
    "verbose"   -> VerbosityLevel -> m VerbosityLevel
    forall (m :: * -> *) a. Monad m => a -> m a
    return VerbosityLevel
    Verbose
                String
    "debug"     -> VerbosityLevel -> m VerbosityLevel
    forall (m :: * -> *) a. Monad m => a -> m a
    return VerbosityLevel
    Deafening
                String
    "deafening" -> VerbosityLevel -> m VerbosityLevel
    forall (m :: * -> *) a. Monad m => a -> m a
    return VerbosityLevel
    Deafening
                String
    _           -> String -> m VerbosityLevel
    forall (m :: * -> *) a. Parsing m => String -> m a
    P.unexpected (String -> m VerbosityLevel) -> String -> m VerbosityLevel
    forall a b. (a -> b) -> a -> b
    $ String
    "Bad verbosity level: " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    token
        parseFlag :: m (Verbosity -> Verbosity)
    parseFlag = do
            Char
    _ <- Char -> m Char
    forall (m :: * -> *). CharParsing m => Char -> m Char
    P.char Char
    '+'
            String
    token <- (Char -> Bool) -> m String
    forall (m :: * -> *). CharParsing m => (Char -> Bool) -> m String
    P.munch1 Char -> Bool
    isAsciiAlpha
            case String
    token of
                String
    "callsite"   -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseCallSite
                String
    "callstack"  -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseCallStack
                String
    "nowrap"     -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseNoWrap
                String
    "markoutput" -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseMarkOutput
                String
    "timestamp"  -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseTimestamp
                String
    "stderr"     -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseStderr
                String
    "stdout"     -> (Verbosity -> Verbosity) -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Verbosity -> Verbosity
    verboseNoStderr
                String
    _            -> String -> m (Verbosity -> Verbosity)
    forall (m :: * -> *) a. Parsing m => String -> m a
    P.unexpected (String -> m (Verbosity -> Verbosity))
    -> String -> m (Verbosity -> Verbosity)
    forall a b. (a -> b) -> a -> b
    $ String
    "Bad verbosity flag: " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    token

    flagToVerbosity :: ReadE Verbosity
    flagToVerbosity :: ReadE Verbosity
    flagToVerbosity = ShowS -> ParsecParser Verbosity -> ReadE Verbosity
    forall a. ShowS -> ParsecParser a -> ReadE a
    parsecToReadE ShowS
    forall a. a -> a
    id ParsecParser Verbosity
    forall (m :: * -> *). CabalParsing m => m Verbosity
    parsecVerbosity

    showForCabal :: Verbosity -> String
    showForCabal :: Verbosity -> String
    showForCabal Verbosity
    v
        | Set VerbosityFlag -> Bool
    forall a. Set a -> Bool
    Set.null (Verbosity -> Set VerbosityFlag
    vFlags Verbosity
    v)
        = String -> (Int -> String) -> Maybe Int -> String
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (ShowS
    forall a. HasCallStack => String -> a
    error String
    "unknown verbosity") Int -> String
    forall a. Show a => a -> String
    show (Maybe Int -> String) -> Maybe Int -> String
    forall a b. (a -> b) -> a -> b
    $
            Verbosity -> [Verbosity] -> Maybe Int
    forall a. Eq a => a -> [a] -> Maybe Int
    elemIndex Verbosity
    v [Verbosity
    silent,Verbosity
    normal,Verbosity
    verbose,Verbosity
    deafening]
        | Bool
    otherwise
        = [String] -> String
    unwords
            ([String] -> String) -> [String] -> String
    forall a b. (a -> b) -> a -> b
    $ VerbosityLevel -> String
    showLevel (Verbosity -> VerbosityLevel
    vLevel Verbosity
    v)
            String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : (VerbosityFlag -> [String]) -> [VerbosityFlag] -> [String]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap VerbosityFlag -> [String]
    showFlag (Set VerbosityFlag -> [VerbosityFlag]
    forall a. Set a -> [a]
    Set.toList (Verbosity -> Set VerbosityFlag
    vFlags Verbosity
    v))
      where
        showLevel :: VerbosityLevel -> String
    showLevel VerbosityLevel
    Silent    = String
    "silent"
        showLevel VerbosityLevel
    Normal    = String
    "normal"
        showLevel VerbosityLevel
    Verbose   = String
    "verbose"
        showLevel VerbosityLevel
    Deafening = String
    "debug"

        showFlag :: VerbosityFlag -> [String]
    showFlag VerbosityFlag
    VCallSite   = [String
    "+callsite"]
        showFlag VerbosityFlag
    VCallStack  = [String
    "+callstack"]
        showFlag VerbosityFlag
    VNoWrap     = [String
    "+nowrap"]
        showFlag VerbosityFlag
    VMarkOutput = [String
    "+markoutput"]
        showFlag VerbosityFlag
    VTimestamp  = [String
    "+timestamp"]
        showFlag VerbosityFlag
    VStderr     = [String
    "+stderr"]

    showForGHC :: Verbosity -> String
    showForGHC :: Verbosity -> String
    showForGHC   Verbosity
    v = String -> (Int -> String) -> Maybe Int -> String
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (ShowS
    forall a. HasCallStack => String -> a
    error String
    "unknown verbosity") Int -> String
    forall a. Show a => a -> String
    show (Maybe Int -> String) -> Maybe Int -> String
    forall a b. (a -> b) -> a -> b
    $
        Verbosity -> [Verbosity] -> Maybe Int
    forall a. Eq a => a -> [a] -> Maybe Int
    elemIndex Verbosity
    v [Verbosity
    silent,Verbosity
    normal,Verbosity
    __,Verbosity
    verbose,Verbosity
    deafening]
            where __ :: Verbosity
    __ = Verbosity
    silent -- this will be always ignored by elemIndex

    -- | Turn on verbose call-site printing when we log.
    verboseCallSite :: Verbosity -> Verbosity
    verboseCallSite :: Verbosity -> Verbosity
    verboseCallSite = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VCallSite

    -- | Turn on verbose call-stack printing when we log.
    verboseCallStack :: Verbosity -> Verbosity
    verboseCallStack :: Verbosity -> Verbosity
    verboseCallStack = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VCallStack

    -- | Turn on @-----BEGIN CABAL OUTPUT-----@ markers for output
    -- from Cabal (as opposed to GHC, or system dependent).
    verboseMarkOutput :: Verbosity -> Verbosity
    verboseMarkOutput :: Verbosity -> Verbosity
    verboseMarkOutput = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VMarkOutput

    -- | Turn off marking; useful for suppressing nondeterministic output.
    verboseUnmarkOutput :: Verbosity -> Verbosity
    verboseUnmarkOutput :: Verbosity -> Verbosity
    verboseUnmarkOutput = VerbosityFlag -> Verbosity -> Verbosity
    verboseNoFlag VerbosityFlag
    VMarkOutput

    -- | Disable line-wrapping for log messages.
    verboseNoWrap :: Verbosity -> Verbosity
    verboseNoWrap :: Verbosity -> Verbosity
    verboseNoWrap = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VNoWrap

    -- | Mark the verbosity as quiet
    verboseQuiet :: Verbosity -> Verbosity
    verboseQuiet :: Verbosity -> Verbosity
    verboseQuiet Verbosity
    v = Verbosity
    v { vQuiet :: Bool
    vQuiet = Bool
    True }

    -- | Turn on timestamps for log messages.
    verboseTimestamp :: Verbosity -> Verbosity
    verboseTimestamp :: Verbosity -> Verbosity
    verboseTimestamp = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VTimestamp

    -- | Turn off timestamps for log messages.
    verboseNoTimestamp :: Verbosity -> Verbosity
    verboseNoTimestamp :: Verbosity -> Verbosity
    verboseNoTimestamp = VerbosityFlag -> Verbosity -> Verbosity
    verboseNoFlag VerbosityFlag
    VTimestamp

    -- | Turn on timestamps for log messages.
    --
    -- @since 3.4.0.0
    verboseStderr :: Verbosity -> Verbosity
    verboseStderr :: Verbosity -> Verbosity
    verboseStderr = VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    VStderr

    -- | Turn off timestamps for log messages.
    --
    -- @since 3.4.0.0
    verboseNoStderr :: Verbosity -> Verbosity
    verboseNoStderr :: Verbosity -> Verbosity
    verboseNoStderr = VerbosityFlag -> Verbosity -> Verbosity
    verboseNoFlag VerbosityFlag
    VStderr

    -- | Helper function for flag enabling functions
    verboseFlag :: VerbosityFlag -> (Verbosity -> Verbosity)
    verboseFlag :: VerbosityFlag -> Verbosity -> Verbosity
    verboseFlag VerbosityFlag
    flag Verbosity
    v = Verbosity
    v { vFlags :: Set VerbosityFlag
    vFlags = VerbosityFlag -> Set VerbosityFlag -> Set VerbosityFlag
    forall a. Ord a => a -> Set a -> Set a
    Set.insert VerbosityFlag
    flag (Verbosity -> Set VerbosityFlag
    vFlags Verbosity
    v) }

    -- | Helper function for flag disabling functions
    verboseNoFlag :: VerbosityFlag -> (Verbosity -> Verbosity)
    verboseNoFlag :: VerbosityFlag -> Verbosity -> Verbosity
    verboseNoFlag VerbosityFlag
    flag Verbosity
    v = Verbosity
    v { vFlags :: Set VerbosityFlag
    vFlags = VerbosityFlag -> Set VerbosityFlag -> Set VerbosityFlag
    forall a. Ord a => a -> Set a -> Set a
    Set.delete VerbosityFlag
    flag (Verbosity -> Set VerbosityFlag
    vFlags Verbosity
    v) }

    -- | Turn off all flags
    verboseNoFlags :: Verbosity -> Verbosity
    verboseNoFlags :: Verbosity -> Verbosity
    verboseNoFlags Verbosity
    v = Verbosity
    v { vFlags :: Set VerbosityFlag
    vFlags = Set VerbosityFlag
    forall a. Set a
    Set.empty }

    verboseHasFlags :: Verbosity -> Bool
    verboseHasFlags :: Verbosity -> Bool
    verboseHasFlags = Bool -> Bool
    not (Bool -> Bool) -> (Verbosity -> Bool) -> Verbosity -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set VerbosityFlag -> Bool
    forall a. Set a -> Bool
    Set.null (Set VerbosityFlag -> Bool)
    -> (Verbosity -> Set VerbosityFlag) -> Verbosity -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Verbosity -> Set VerbosityFlag
    vFlags

    -- | Test if we should output call sites when we log.
    isVerboseCallSite :: Verbosity -> Bool
    isVerboseCallSite :: Verbosity -> Bool
    isVerboseCallSite = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VCallSite

    -- | Test if we should output call stacks when we log.
    isVerboseCallStack :: Verbosity -> Bool
    isVerboseCallStack :: Verbosity -> Bool
    isVerboseCallStack = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VCallStack

    -- | Test if we should output markets.
    isVerboseMarkOutput :: Verbosity -> Bool
    isVerboseMarkOutput :: Verbosity -> Bool
    isVerboseMarkOutput = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VMarkOutput

    -- | Test if line-wrapping is disabled for log messages.
    isVerboseNoWrap :: Verbosity -> Bool
    isVerboseNoWrap :: Verbosity -> Bool
    isVerboseNoWrap = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VNoWrap

    -- | Test if we had called 'lessVerbose' on the verbosity
    isVerboseQuiet :: Verbosity -> Bool
    isVerboseQuiet :: Verbosity -> Bool
    isVerboseQuiet = Verbosity -> Bool
    vQuiet

    -- | Test if we should output timestamps when we log.
    isVerboseTimestamp :: Verbosity -> Bool
    isVerboseTimestamp :: Verbosity -> Bool
    isVerboseTimestamp = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VTimestamp

    -- | Test if we should output to stderr when we log.
    --
    -- @since 3.4.0.0
    isVerboseStderr :: Verbosity -> Bool
    isVerboseStderr :: Verbosity -> Bool
    isVerboseStderr = VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    VStderr

    -- | Helper function for flag testing functions.
    isVerboseFlag :: VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag :: VerbosityFlag -> Verbosity -> Bool
    isVerboseFlag VerbosityFlag
    flag = (VerbosityFlag -> Set VerbosityFlag -> Bool
    forall a. Ord a => a -> Set a -> Bool
    Set.member VerbosityFlag
    flag) (Set VerbosityFlag -> Bool)
    -> (Verbosity -> Set VerbosityFlag) -> Verbosity -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Verbosity -> Set VerbosityFlag
    vFlags

    -- $setup
    -- >>> import Test.QuickCheck (Arbitrary (..), arbitraryBoundedEnum)
    -- >>> instance Arbitrary VerbosityLevel where arbitrary = arbitraryBoundedEnum
    -- >>> instance Arbitrary Verbosity where arbitrary = fmap mkVerbosity arbitrary