Safe Haskell	Safe
Language	Haskell2010

Network.LXD.Client.Internal.Prelude

Contents

Re-exports
Monads
Monad Transformers
Foldable
Monoid
Strings

Description

Internal prelude.

Synopsis

Re-exports

module Prelude

Monads

module Control.Monad

Monad Transformers

class Monad m => MonadError e (m :: * -> *) | m -> e where #

The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.

Is parameterized over the type of error information and the monad type constructor. It is common to use Either String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the MonadError class. You can also define your own error type and/or use a monad type constructor other than Either String or Either IOError. In these cases you will have to explicitly define instances of the Error and/or MonadError classes.

Minimal complete definition

throwError, catchError

Methods

throwError :: e -> m a #

Is used within a monadic computation to begin exception processing.

Instances

MonadError IOException IO
Methods throwError :: IOException -> IO a # catchError :: IO a -> (IOException -> IO a) -> IO a #
MonadError ServantError ClientM
Methods throwError :: ServantError -> ClientM a # catchError :: ClientM a -> (ServantError -> ClientM a) -> ClientM a #
MonadError e m => MonadError e (MaybeT m)
Methods throwError :: e -> MaybeT m a # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadError e m => MonadError e (ListT m)
Methods throwError :: e -> ListT m a # catchError :: ListT m a -> (e -> ListT m a) -> ListT m a #
MonadError e (Either e)
Methods throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a #
(Monoid w, MonadError e m) => MonadError e (WriterT w m)
Methods throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(Monoid w, MonadError e m) => MonadError e (WriterT w m)
Methods throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
MonadError e m => MonadError e (StateT s m)
Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadError e m => MonadError e (StateT s m)
Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadError e m => MonadError e (IdentityT * m)
Methods throwError :: e -> IdentityT * m a # catchError :: IdentityT * m a -> (e -> IdentityT * m a) -> IdentityT * m a #
Monad m => MonadError e (ExceptT e m)
Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
(Monad m, Error e) => MonadError e (ErrorT e m)
Methods throwError :: e -> ErrorT e m a # catchError :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a #
MonadError e m => MonadError e (ReaderT * r m)
Methods throwError :: e -> ReaderT * r m a # catchError :: ReaderT * r m a -> (e -> ReaderT * r m a) -> ReaderT * r m a #
(Monoid w, MonadError e m) => MonadError e (RWST r w s m)
Methods throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(Monoid w, MonadError e m) => MonadError e (RWST r w s m)
Methods throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #

data ExceptT e (m :: * -> *) a :: * -> (* -> *) -> * -> * #

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

e - The exception type.
m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Instances

MonadBaseControl b m => MonadBaseControl b (ExceptT e m)
Associated Types type StM (ExceptT e m :: * -> ) a :: # Methods liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a # restoreM :: StM (ExceptT e m) a -> ExceptT e m a #
MonadState s m => MonadState s (ExceptT e m)
Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
MonadReader r m => MonadReader r (ExceptT e m)
Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
Monad m => MonadError e (ExceptT e m)
Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
MonadTrans (ExceptT e)
Methods lift :: Monad m => m a -> ExceptT e m a #
MonadTransControl (ExceptT e)
Associated Types type StT (ExceptT e :: (* -> ) -> -> ) a :: # Methods liftWith :: Monad m => (Run (ExceptT e) -> m a) -> ExceptT e m a # restoreT :: Monad m => m (StT (ExceptT e) a) -> ExceptT e m a #
Monad m => Monad (ExceptT e m)
Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a # fail :: String -> ExceptT e m a #
Functor m => Functor (ExceptT e m)
Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
MonadFix m => MonadFix (ExceptT e m)
Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a #
MonadFail m => MonadFail (ExceptT e m)
Methods fail :: String -> ExceptT e m a #
(Functor m, Monad m) => Applicative (ExceptT e m)
Methods pure :: a -> ExceptT e m a # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Foldable f => Foldable (ExceptT e f)
Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # sum :: Num a => ExceptT e f a -> a # product :: Num a => ExceptT e f a -> a #
Traversable f => Traversable (ExceptT e f)
Methods traverse :: Applicative f => (a -> f b) -> ExceptT e f a -> f (ExceptT e f b) # sequenceA :: Applicative f => ExceptT e f (f a) -> f (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)
Methods empty :: ExceptT e m a # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Eq e, Eq1 m) => Eq1 (ExceptT e m)
Methods liftEq :: (a -> b -> Bool) -> ExceptT e m a -> ExceptT e m b -> Bool #
(Ord e, Ord1 m) => Ord1 (ExceptT e m)
Methods liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering #
(Read e, Read1 m) => Read1 (ExceptT e m)
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT e m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ExceptT e m a] #
(Show e, Show1 m) => Show1 (ExceptT e m)
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS #
MonadZip m => MonadZip (ExceptT e m)
Methods mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b) # mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # munzip :: ExceptT e m (a, b) -> (ExceptT e m a, ExceptT e m b) #
MonadIO m => MonadIO (ExceptT e m)
Methods liftIO :: IO a -> ExceptT e m a #
MonadThrow m => MonadThrow (ExceptT e m)	Throws exceptions into the base monad.
Methods throwM :: Exception e => e -> ExceptT e m a #
MonadCatch m => MonadCatch (ExceptT e m)	Catches exceptions from the base monad.
Methods catch :: Exception e => ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
PrimMonad m => PrimMonad (ExceptT e m)
Associated Types type PrimState (ExceptT e m :: * -> ) :: # Methods primitive :: (State# (PrimState (ExceptT e m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (ExceptT e m)), a#)) -> ExceptT e m a #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)
Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Read e, Read1 m, Read a) => Read (ExceptT e m a)
Methods readsPrec :: Int -> ReadS (ExceptT e m a) # readList :: ReadS [ExceptT e m a] # readPrec :: ReadPrec (ExceptT e m a) # readListPrec :: ReadPrec [ExceptT e m a] #
(Show e, Show1 m, Show a) => Show (ExceptT e m a)
Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
type StT (ExceptT e) a
type StT (ExceptT e) a = Either e a
type PrimState (ExceptT e m)
type PrimState (ExceptT e m) = PrimState m
type StM (ExceptT e m) a
type StM (ExceptT e m) a = ComposeSt (ExceptT e) m a

runExceptT :: ExceptT e m a -> m (Either e a) #

The inverse of ExceptT.

throwError :: MonadError e m => forall a. e -> m a #

Is used within a monadic computation to begin exception processing.

class Monad m => MonadIO (m :: * -> *) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: 4.9.0.0
Methods liftIO :: IO a -> IO a #
MonadIO ClientM
Methods liftIO :: IO a -> ClientM a #
MonadIO WithRemoteHost #
Methods liftIO :: IO a -> WithRemoteHost a #
MonadIO WithLocalHost #
Methods liftIO :: IO a -> WithLocalHost a #
MonadIO m => MonadIO (ListT m)
Methods liftIO :: IO a -> ListT m a #
MonadIO m => MonadIO (MaybeT m)
Methods liftIO :: IO a -> MaybeT m a #
MonadIO m => MonadIO (IdentityT * m)
Methods liftIO :: IO a -> IdentityT * m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (ExceptT e m)
Methods liftIO :: IO a -> ExceptT e m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ReaderT * r m)
Methods liftIO :: IO a -> ReaderT * r m a #
MonadIO m => MonadIO (ContT * r m)
Methods liftIO :: IO a -> ContT * r m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #

liftIO :: MonadIO m => forall a. IO a -> m a #

Lift a computation from the IO monad.

class Monad m => MonadState s (m :: * -> *) | m -> s where #

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get, put

Methods

get :: m s #

Return the state from the internals of the monad.

put :: s -> m () #

Replace the state inside the monad.

Instances

MonadState s m => MonadState s (MaybeT m)
Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
MonadState s m => MonadState s (ListT m)
Methods get :: ListT m s # put :: s -> ListT m () # state :: (s -> (a, s)) -> ListT m a #
Monad m => MonadState s (StateT s m)
Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m)
Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m)
Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
Monad m => MonadState s (StateT s m)
Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
MonadState s m => MonadState s (IdentityT * m)
Methods get :: IdentityT * m s # put :: s -> IdentityT * m () # state :: (s -> (a, s)) -> IdentityT * m a #
MonadState s m => MonadState s (ExceptT e m)
Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
(Error e, MonadState s m) => MonadState s (ErrorT e m)
Methods get :: ErrorT e m s # put :: s -> ErrorT e m () # state :: (s -> (a, s)) -> ErrorT e m a #
MonadState s m => MonadState s (ReaderT * r m)
Methods get :: ReaderT * r m s # put :: s -> ReaderT * r m () # state :: (s -> (a, s)) -> ReaderT * r m a #
MonadState s m => MonadState s (ContT * r m)
Methods get :: ContT * r m s # put :: s -> ContT * r m () # state :: (s -> (a, s)) -> ContT * r m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m)
Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m)
Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #

newtype StateT s (m :: * -> *) a :: * -> (* -> *) -> * -> * #

A state transformer monad parameterized by:

s - The state.
m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Constructors

StateT
Fields runStateT :: s -> m (a, s)

Instances

MonadBaseControl b m => MonadBaseControl b (StateT s m)
Associated Types type StM (StateT s m :: * -> ) a :: # Methods liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a # restoreM :: StM (StateT s m) a -> StateT s m a #
Monad m => MonadState s (StateT s m)
Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadError e m => MonadError e (StateT s m)
Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadTrans (StateT s)
Methods lift :: Monad m => m a -> StateT s m a #
MonadTransControl (StateT s)
Associated Types type StT (StateT s :: (* -> ) -> -> ) a :: # Methods liftWith :: Monad m => (Run (StateT s) -> m a) -> StateT s m a # restoreT :: Monad m => m (StT (StateT s) a) -> StateT s m a #
Monad m => Monad (StateT s m)
Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a # fail :: String -> StateT s m a #
Functor m => Functor (StateT s m)
Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
MonadFix m => MonadFix (StateT s m)
Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Methods fail :: String -> StateT s m a #
(Functor m, Monad m) => Applicative (StateT s m)
Methods pure :: a -> StateT s m a # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
MonadPlus m => MonadPlus (StateT s m)
Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
MonadThrow m => MonadThrow (StateT s m)
Methods throwM :: Exception e => e -> StateT s m a #
MonadCatch m => MonadCatch (StateT s m)
Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadMask m => MonadMask (StateT s m)
Methods mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #
PrimMonad m => PrimMonad (StateT s m)
Associated Types type PrimState (StateT s m :: * -> ) :: # Methods primitive :: (State# (PrimState (StateT s m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (StateT s m)), a#)) -> StateT s m a #
type StT (StateT s) a
type StT (StateT s) a = (a, s)
type PrimState (StateT s m)
type PrimState (StateT s m) = PrimState m
type StM (StateT s m) a
type StM (StateT s m) a = ComposeSt (StateT s) m a

modify :: MonadState s m => (s -> s) -> m () #

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

get :: MonadState s m => m s #

Return the state from the internals of the monad.

put :: MonadState s m => s -> m () #

Replace the state inside the monad.

class MonadTrans (t :: (* -> *) -> * -> *) where #

The class of monad transformers. Instances should satisfy the following laws, which state that lift is a monad transformation:

```
lift . return = return
```
```
lift (m >>= f) = lift m >>= (lift . f)
```

Minimal complete definition

lift

Methods

lift :: Monad m => m a -> t m a #

Lift a computation from the argument monad to the constructed monad.

Instances

MonadTrans ListT
Methods lift :: Monad m => m a -> ListT m a #
MonadTrans MaybeT
Methods lift :: Monad m => m a -> MaybeT m a #
MonadTrans (IdentityT *)
Methods lift :: Monad m => m a -> IdentityT * m a #
Monoid w => MonadTrans (WriterT w)
Methods lift :: Monad m => m a -> WriterT w m a #
MonadTrans (StateT s)
Methods lift :: Monad m => m a -> StateT s m a #
MonadTrans (ExceptT e)
Methods lift :: Monad m => m a -> ExceptT e m a #
MonadTrans (ErrorT e)
Methods lift :: Monad m => m a -> ErrorT e m a #
MonadTrans (StateT s)
Methods lift :: Monad m => m a -> StateT s m a #
Monoid w => MonadTrans (WriterT w)
Methods lift :: Monad m => m a -> WriterT w m a #
MonadTrans (ReaderT * r)
Methods lift :: Monad m => m a -> ReaderT * r m a #
MonadTrans (ContT * r)
Methods lift :: Monad m => m a -> ContT * r m a #
Monoid w => MonadTrans (RWST r w s)
Methods lift :: Monad m => m a -> RWST r w s m a #
Monoid w => MonadTrans (RWST r w s)
Methods lift :: Monad m => m a -> RWST r w s m a #

lift :: MonadTrans t => forall (m :: * -> *) a. Monad m => m a -> t m a #

Lift a computation from the argument monad to the constructed monad.

Foldable

foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

Monoid

module Data.Monoid

Strings

class IsString a where #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Minimal complete definition

fromString

Methods

fromString :: String -> a #

Instances

IsString ByteString
Methods fromString :: String -> ByteString #
IsString ByteString
Methods fromString :: String -> ByteString #
IsString Value
Methods fromString :: String -> Value #
IsString String
Methods fromString :: String -> String #
IsString AsciiString
Methods fromString :: String -> AsciiString #
IsString RequestBody	Since 0.4.12
Methods fromString :: String -> RequestBody #
IsString MediaType
Methods fromString :: String -> MediaType #
IsString Doc
Methods fromString :: String -> Doc #
IsString OperationId #
Methods fromString :: String -> OperationId #
IsString PoolName #
Methods fromString :: String -> PoolName #
IsString ProfileName #
Methods fromString :: String -> ProfileName #
IsString NetworkName #
Methods fromString :: String -> NetworkName #
IsString ImageAliasName #
Methods fromString :: String -> ImageAliasName #
IsString LocalContainer #
Methods fromString :: String -> LocalContainer #
IsString FileType #
Methods fromString :: String -> FileType #
IsString FileMode #
Methods fromString :: String -> FileMode #
IsString LocalImageByAlias #
Methods fromString :: String -> LocalImageByAlias #
IsString ContainerName #
Methods fromString :: String -> ContainerName #
(~) * a Char => IsString [a]	`(a ~ Char)` context was introduced in `4.9.0.0` Since: 2.1
Methods fromString :: String -> [a] #
IsString a => IsString (Identity a)
Methods fromString :: String -> Identity a #
(IsString s, FoldCase s) => IsString (CI s)
Methods fromString :: String -> CI s #
IsString (Seq Char)
Methods fromString :: String -> Seq Char #
(~) * a Char => IsString (DList a)
Methods fromString :: String -> DList a #
(IsString a, Hashable a) => IsString (Hashed a)
Methods fromString :: String -> Hashed a #
IsString (Doc a)
Methods fromString :: String -> Doc a #
IsString a => IsString (Const * a b)	Since: 4.9.0.0
Methods fromString :: String -> Const * a b #
IsString a => IsString (Tagged k s a)
Methods fromString :: String -> Tagged k s a #