Safe Haskell	Safe-Inferred
Language	Haskell98

Options.Applicative.Internal

Documentation

data P a Source

Instances

Alternative P
Monad P
Functor P
MonadPlus P
Applicative P
MonadP P

data Context Source

Constructors

forall a . Context [String] (ParserInfo a)
NullContext

Instances

Monoid Context

class (Alternative m, MonadPlus m) => MonadP m where Source

Methods

setContext :: Maybe String -> ParserInfo a -> m () Source

getPrefs :: m ParserPrefs Source

missingArgP :: ParseError -> Completer -> m a Source

tryP :: m a -> m (Either ParseError a) Source

errorP :: ParseError -> m a Source

exitP :: Parser b -> Either ParseError a -> m a Source

Instances

MonadP Completion
MonadP P

data ParseError Source

Constructors

ErrorMsg String
InfoMsg String
ShowHelpText
UnknownError
MissingError (OptTree (Chunk Doc))

Instances

Show ParseError
Monoid ParseError

uncons :: [a] -> Maybe (a, [a]) Source

hoistMaybe :: MonadPlus m => Maybe a -> m a Source

hoistEither :: MonadP m => Either ParseError a -> m a Source

runReadM :: MonadP m => ReadM a -> String -> m a Source

withReadM :: (String -> String) -> ReadM a -> ReadM a Source

runP :: P a -> ParserPrefs -> (Either ParseError a, Context) Source

data Completion a Source

Instances

Alternative Completion
Monad Completion
Functor Completion
MonadPlus Completion
Applicative Completion
MonadP Completion

runCompletion :: Completion r -> ParserPrefs -> Maybe (Either SomeParser Completer) Source

data SomeParser Source

Constructors

forall a . SomeParser (Parser a)

data ComplError Source

Constructors

ComplParseError String
ComplExit

data ListT m a Source

Instances

MonadTrans ListT
Monad m => Alternative (ListT m)
Monad m => Monad (ListT m)
Monad m => Functor (ListT m)
Monad m => MonadPlus (ListT m)
Monad m => Applicative (ListT m)

takeListT :: Monad m => Int -> ListT m a -> ListT m a Source

runListT :: Monad m => ListT m a -> m [a] Source

data NondetT m a Source

Instances

MonadTrans NondetT
Monad m => Alternative (NondetT m)
Monad m => Monad (NondetT m)
Monad m => Functor (NondetT m)
Monad m => MonadPlus (NondetT m)
Monad m => Applicative (NondetT m)

cut :: Monad m => NondetT m () Source

(<!>) :: Monad m => NondetT m a -> NondetT m a -> NondetT m a Source

disamb :: Monad m => Bool -> NondetT m a -> m (Maybe a) Source