:: String -> Maybe Int -package:vty-windows

readPositiveInt :: String -> Maybe Int
http-client Network.HTTP.Client.Internal
Read a positive Int, accounting for overflow
parseSeed :: String -> Maybe Int
doctest-parallel Test.DocTest.Internal.Options
Parse seed argument 
>>> parseSeed "--seed=6"
Just 6

>>> parseSeed "--seeeed=6"
Nothing
parseThreads :: String -> Maybe Int
doctest-parallel Test.DocTest.Internal.Options
Parse number of threads argument 
>>> parseThreads "-j6"
Just 6

>>> parseThreads "-j-2"
Nothing

>>> parseThreads "-jA"
Nothing
outernmostPrec :: String -> Maybe Int
express Data.Express.Utils.String
Returns the operator precedence of an infix string. 
> outernmostPrec "1 + 2"
Just 6
numVar :: String -> Maybe Int
RefSerialize Data.RefSerialize.Serialize
readIntegral :: Num a => String -> Maybe a
yesod-core Yesod.Core, hledger-web Hledger.Web.Import
fromEnum :: Enum a => a -> Maybe Int
prelude-safeenum Prelude.SafeEnum
Convert to an Int.
parseTime :: Fractional time => String -> Maybe time
audacity Sound.Audacity.LabelTrack
mkFailMessage :: (FilterMonad Response m, WebMonad Response m) => String -> m b
happstack-server Happstack.Server.Internal.Monads
unexpected :: (MonadBaseControl IO m, HasCallStack) => String -> m a
webdriver Test.WebDriver.Commands.Wait
throws ExpectFailed. This is nice for writing your own abstractions.
throwString :: (MonadIO m, HasCallStack) => String -> m a
unliftio UnliftIO.Exception
A convenience function for throwing a user error. This is useful for cases where it would be too high a burden to define your own exception type. This throws an exception of type StringException. When GHC supports it (base 4.9 and GHC 8.0 and onward), it includes a call stack.
throwErrno :: MonadIO m => String -> m a
unliftio UnliftIO.Foreign
Lifted throwErrno.
die :: MonadIO m => String -> m a
relude Relude.Lifted.Exit
Lifted version of die. 
>>> die "Goodbye!"
Goodbye!
*** Exception: ExitFailure 1
die :: MonadIO m => String -> m a
universum Universum.Lifted.Env
Lifted version of die. die is available since base-4.8, but it's more convenient to redefine it instead of using CPP.
fatalError :: MonadIO m => String -> m a
hdaemonize System.Posix.Daemonize
When you encounter an error where the only sane way to handle it is to write an error to the log and die messily, use fatalError. This is a good candidate for things like not being able to find configuration files on startup.
expectationFailure :: (HasCallStack, MonadIO m) => String -> m a
sandwich Test.Sandwich.Expectations
General-purpose function to throw a test exception with a String.
pendingWith :: (HasCallStack, MonadIO m) => String -> m a
sandwich Test.Sandwich.Expectations
Throws a Pending exception with a message to add additional details.
assertFailure :: (HasCallStack, MonadIO m) => String -> m a
ImpSpec Test.ImpSpec Test.ImpSpec.Expectations.Lifted
Just like expectationFailure, but does not force the return type to unit. Lifted version of assertFailure
assertColorFailure :: (HasCallStack, MonadIO m) => String -> m a
ImpSpec Test.ImpSpec Test.ImpSpec.Expectations.Lifted
toMaybeScalar :: C a v => v -> Maybe a
numeric-prelude Algebra.OccasionallyScalar
fail :: Monad m => String -> m a
basic-prelude CorePrelude, prelude-compat Prelude2010
Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression. As part of the MonadFail proposal (MFP), this function is moved to its own class MonadFail (see Control.Monad.Fail for more details). The definition here will be removed in a future release.
cast :: (Typeable a, Typeable b) => a -> Maybe b
base Data.Typeable, protolude Protolude, base-prelude BasePrelude, ihaskell IHaskellPrelude, ghc-internal GHC.Internal.Data.Typeable, rebase Rebase.Prelude, essence-of-live-coding LiveCoding, massiv-test Test.Massiv.Utils
The type-safe cast operation
cast :: forall (a :: *) (b :: *) . (Typeable a, Typeable b) => a -> Maybe b
open-witness Data.OpenWitness.Typeable
castValue :: (Typeable v1, Typeable v2) => v1 -> Maybe v2
haskey-btree Data.BTree.Impure.Internal.Structures
Cast a value to a different type. Essentially this is just a drop-in replacement for cast.
throwError :: forall e (sig :: (Type -> Type) -> Type -> Type) m a . Has (Throw e) sig m => e -> m a
fused-effects Control.Effect.Throw
Throw an error, escaping the current computation up to the nearest catchError (if any). 
runThrow (throwError e >>= k) = runThrow (throwError e)