Safe Haskell	None
Language	Haskell2010

Bio.Streaming

Synopsis

class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
class MonadCatch m => MonadMask (m :: Type -> Type)
data ByteStream m r
streamFile :: (MonadIO m, MonadMask m) => FilePath -> (ByteStream m () -> m r) -> m r
streamHandle :: MonadIO m => Handle -> ByteStream m ()
streamInput :: (MonadIO m, MonadMask m) => FilePath -> (ByteStream m () -> m r) -> m r
streamInputs :: MonadIO m => [FilePath] -> (Stream (ByteStream m) m () -> r) -> r
withOutputFile :: (MonadIO m, MonadMask m) => FilePath -> (Handle -> m a) -> m a
protectTerm :: (Functor f, MonadIO m) => Stream f m r -> Stream f m r
psequence :: MonadIO m => Int -> Stream (Of (IO a)) m b -> Stream (Of a) m b
progressGen :: MonadIO m => (Int -> a -> String) -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r
progressNum :: MonadIO m => String -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r
progressPos :: MonadIO m => (a -> (Refseq, Int)) -> String -> Refs -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r
mergeStreams :: (Monad m, Ord a) => Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s)
mergeStreamsBy :: Monad m => (a -> a -> Ordering) -> Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s)
mergeStreamsOn :: (Monad m, Ord b) => (a -> b) -> Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s)
join :: Monad m => m (m a) -> m a
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) :: forall k k1. (k -> Type) -> (k1 -> k) -> k1 -> Type = Compose {
- getCompose :: f (g a)
}
data Sum (f :: k -> Type) (g :: k -> Type) (a :: k) :: forall k. (k -> Type) -> (k -> Type) -> k -> Type
- = InL (f a)
- | InR (g a)
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
- first :: (a -> b) -> p a c -> p b c
- second :: (b -> c) -> p a b -> p a c
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
newtype Identity a = Identity {
- runIdentity :: a
}
void :: Functor f => f a -> f ()
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
class Applicative f => Alternative (f :: Type -> Type) where
- (<|>) :: f a -> f a -> f a
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: Monad m => m a -> t m a
chunksOf :: (Monad m, Functor f) => Int -> Stream f m r -> Stream (Stream f m) m r
concats :: (Monad m, Functor f) => Stream (Stream f m) m r -> Stream f m r
cutoff :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Maybe r)
decompose :: (Monad m, Functor f) => Stream (Compose m f) m r -> Stream f m r
delays :: (MonadIO m, Applicative f) => Double -> Stream f m r
destroy :: (Functor f, Monad m) => Stream f m r -> (f b -> b) -> (m b -> b) -> (r -> b) -> b
distribute :: (Monad m, Functor f, MonadTrans t, MFunctor t, Monad (t (Stream f m))) => Stream f (t m) r -> t (Stream f m) r
effect :: (Monad m, Functor f) => m (Stream f m r) -> Stream f m r
expand :: (Monad m, Functor f) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r
expandPost :: (Monad m, Functor g) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r
groups :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream (Sum (Stream f m) (Stream g m)) m r
hoistUnexposed :: (Monad m, Functor f) => (forall a. m a -> n a) -> Stream f m r -> Stream f n r
inspect :: Monad m => Stream f m r -> m (Either r (f (Stream f m r)))
intercalates :: (Monad m, Monad (t m), MonadTrans t) => t m x -> Stream (t m) m r -> t m r
interleaves :: (Monad m, Applicative h) => Stream h m r -> Stream h m r -> Stream h m r
iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> Stream f m a -> m a
iterTM :: (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> Stream f m a -> t m a
maps :: (Monad m, Functor f) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r
mapsM :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
mapsMPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
mapsM_ :: (Functor f, Monad m) => (forall x. f x -> m x) -> Stream f m r -> m r
mapsPost :: (Monad m, Functor g) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r
never :: (Monad m, Applicative f) => Stream f m r
repeats :: (Monad m, Functor f) => f () -> Stream f m r
repeatsM :: (Monad m, Functor f) => m (f ()) -> Stream f m r
replicates :: (Monad m, Functor f) => Int -> f () -> Stream f m ()
run :: Monad m => Stream m m r -> m r
separate :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream f (Stream g m) r
splitsAt :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Stream f m r)
streamBuild :: (forall b. (r -> b) -> (m b -> b) -> (f b -> b) -> b) -> Stream f m r
streamFold :: (Functor f, Monad m) => (r -> b) -> (m b -> b) -> (f b -> b) -> Stream f m r -> b
takes :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m ()
unfold :: (Monad m, Functor f) => (s -> m (Either r (f s))) -> s -> Stream f m r
unseparate :: (Monad m, Functor f, Functor g) => Stream f (Stream g m) r -> Stream (Sum f g) m r
untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
unzips :: (Monad m, Functor f, Functor g) => Stream (Compose f g) m r -> Stream f (Stream g m) r
wrap :: (Monad m, Functor f) => f (Stream f m r) -> Stream f m r
yields :: (Monad m, Functor f) => f r -> Stream f m r
zips :: (Monad m, Functor f, Functor g) => Stream f m r -> Stream g m r -> Stream (Compose f g) m r
zipsWith :: (Monad m, Functor h) => (forall x y. f x -> g y -> h (x, y)) -> Stream f m r -> Stream g m r -> Stream h m r
zipsWith' :: Monad m => (forall x y p. (x -> y -> p) -> f x -> g y -> h p) -> Stream f m r -> Stream g m r -> Stream h m r
lazily :: Of a b -> (a, b)
mapped :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
mappedPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r
strictly :: (a, b) -> Of a b
class MFunctor (t :: (Type -> Type) -> k -> Type) where
- hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b
class (MFunctor t, MonadTrans t) => MMonad (t :: (Type -> Type) -> Type -> Type) where
- embed :: Monad n => (forall a. m a -> t n a) -> t m b -> t n b
data Of a b = !a :> b
data Stream (f :: Type -> Type) (m :: Type -> Type) r
each :: (Monad m, Foldable f) => f a -> Stream (Of a) m ()

Documentation

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

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)

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a Source #
MonadIO m => MonadIO (ListT m)
Instance details Defined in Control.Monad.Trans.List Methods liftIO :: IO a -> ListT m a Source #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a Source #
MonadIO m => MonadIO (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods liftIO :: IO a -> ByteStream m a Source #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a Source #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a Source #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods liftIO :: IO a -> AccumT w m a Source #
MonadIO m => MonadIO (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods liftIO :: IO a -> SelectT r m a Source #
(MonadIO m, Functor f) => MonadIO (Stream f m)
Instance details Defined in Streaming.Internal Methods liftIO :: IO a -> Stream f m a Source #
MonadIO m => MonadIO (Parser r m) Source #
Instance details Defined in Bio.Streaming.Parse Methods liftIO :: IO a -> Parser r m a Source #
MonadIO m => MonadIO (Furrow a m) Source #
Instance details Defined in Bio.Streaming.Furrow Methods liftIO :: IO a0 -> Furrow a m a0 Source #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a Source #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a Source #

class MonadCatch m => MonadMask (m :: Type -> Type) #

Minimal complete definition

mask, uninterruptibleMask, generalBracket

Instances

MonadMask IO
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c)
e ~ SomeException => MonadMask (Either e)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c)
MonadMask m => MonadMask (MaybeT m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c)
MonadMask m => MonadMask (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c)
(Error e, MonadMask m) => MonadMask (ErrorT e m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b generalBracket :: ErrorT e m a -> (a -> ExitCase b -> ErrorT e m c) -> (a -> ErrorT e m b) -> ErrorT e m (b, c)
MonadMask m => MonadMask (ExceptT e m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c)
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch 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 generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch 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 generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)
MonadMask m => MonadMask (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c)
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)

data ByteStream m r Source #

A space-efficient representation of a succession of Word8 vectors, supporting many efficient operations.

An effectful ByteStream contains 8-bit bytes, or by using certain operations can be interpreted as containing 8-bit characters. It also contains an offset, which will be needed to track the virtual offsets in the BGZF decode.

Instances

MonadTrans ByteStream Source #
Instance details Defined in Bio.Streaming.Bytes Methods lift :: Monad m => m a -> ByteStream m a Source #
Monad m => Monad (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods (>>=) :: ByteStream m a -> (a -> ByteStream m b) -> ByteStream m b Source # (>>) :: ByteStream m a -> ByteStream m b -> ByteStream m b Source # return :: a -> ByteStream m a Source # fail :: String -> ByteStream m a Source #
Monad m => Functor (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods fmap :: (a -> b) -> ByteStream m a -> ByteStream m b Source # (<$) :: a -> ByteStream m b -> ByteStream m a Source #
Monad m => Applicative (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods pure :: a -> ByteStream m a Source # (<>) :: ByteStream m (a -> b) -> ByteStream m a -> ByteStream m b Source # liftA2 :: (a -> b -> c) -> ByteStream m a -> ByteStream m b -> ByteStream m c Source # (>) :: ByteStream m a -> ByteStream m b -> ByteStream m b Source # (<*) :: ByteStream m a -> ByteStream m b -> ByteStream m a Source #
MonadIO m => MonadIO (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods liftIO :: IO a -> ByteStream m a Source #
(m ~ Identity, Show r) => Show (ByteStream m r) Source #
Instance details Defined in Bio.Streaming.Bytes Methods showsPrec :: Int -> ByteStream m r -> ShowS Source # show :: ByteStream m r -> String Source # showList :: [ByteStream m r] -> ShowS Source #
r ~ () => IsString (ByteStream m r) Source #
Instance details Defined in Bio.Streaming.Bytes Methods fromString :: String -> ByteStream m r Source #
(Semigroup r, Monad m) => Semigroup (ByteStream m r) Source #
Instance details Defined in Bio.Streaming.Bytes Methods (<>) :: ByteStream m r -> ByteStream m r -> ByteStream m r Source # sconcat :: NonEmpty (ByteStream m r) -> ByteStream m r Source # stimes :: Integral b => b -> ByteStream m r -> ByteStream m r Source #
(Semigroup r, Monoid r, Monad m) => Monoid (ByteStream m r) Source #
Instance details Defined in Bio.Streaming.Bytes Methods mempty :: ByteStream m r Source # mappend :: ByteStream m r -> ByteStream m r -> ByteStream m r Source # mconcat :: [ByteStream m r] -> ByteStream m r Source #

streamFile :: (MonadIO m, MonadMask m) => FilePath -> (ByteStream m () -> m r) -> m r Source #

streamHandle :: MonadIO m => Handle -> ByteStream m () Source #

streamInput :: (MonadIO m, MonadMask m) => FilePath -> (ByteStream m () -> m r) -> m r Source #

Reads stdin if the filename is "-", else reads the named file.

streamInputs :: MonadIO m => [FilePath] -> (Stream (ByteStream m) m () -> r) -> r Source #

Reads multiple inputs in sequence.

Only one file is opened at a time, so they must also be consumed in sequence. The filename "-" refers to stdin, if no filenames are given, stdin is read.

withOutputFile :: (MonadIO m, MonadMask m) => FilePath -> (Handle -> m a) -> m a Source #

protectTerm :: (Functor f, MonadIO m) => Stream f m r -> Stream f m r Source #

Protects the terminal from binary junk.

If s is a Stream, then protectTerm s throws an error if stdout is a terminal device, followed by the same Stream. This is most usefully composed with functions that might otherwise write binary data to an interactive terminal.

psequence :: MonadIO m => Int -> Stream (Of (IO a)) m b -> Stream (Of a) m b Source #

progressGen :: MonadIO m => (Int -> a -> String) -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r Source #

A general progress indicator that prints some message after a set number of records have passed through.

progressNum :: MonadIO m => String -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r Source #

A simple progress indicator that prints the number of records.

progressPos :: MonadIO m => (a -> (Refseq, Int)) -> String -> Refs -> Int -> (String -> IO ()) -> Stream (Of a) m r -> Stream (Of a) m r Source #

A simple progress indicator that prints a position every set number of passed records.

mergeStreams :: (Monad m, Ord a) => Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s) Source #

mergeStreamsBy :: Monad m => (a -> a -> Ordering) -> Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s) Source #

mergeStreamsOn :: (Monad m, Ord b) => (a -> b) -> Stream (Of a) m r -> Stream (Of a) m s -> Stream (Of a) m (r, s) Source #

join :: Monad m => m (m a) -> m a Source #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

Examples

Expand

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c Source #

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) :: forall k k1. (k -> Type) -> (k1 -> k) -> k1 -> Type infixr 9 Source #

Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.

Constructors

Compose infixr 9
Fields getCompose :: f (g a)

Instances

Functor f => Generic1 (Compose f g :: k -> Type)
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 (Compose f g) :: k -> Type Source # Methods from1 :: Compose f g a -> Rep1 (Compose f g) a Source # to1 :: Rep1 (Compose f g) a -> Compose f g a Source #
Functor f => MFunctor (Compose f :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> Compose f m b -> Compose f n b #
(Functor f, Functor g) => Functor (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b Source # (<$) :: a -> Compose f g b -> Compose f g a Source #
(Applicative f, Applicative g) => Applicative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a Source # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source # (>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<*) :: Compose f g a -> Compose f g b -> Compose f g a Source #
(Foldable f, Foldable g) => Foldable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m Source # foldr :: (a -> b -> b) -> b -> Compose f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b Source # foldl :: (b -> a -> b) -> b -> Compose f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b Source # foldr1 :: (a -> a -> a) -> Compose f g a -> a Source # foldl1 :: (a -> a -> a) -> Compose f g a -> a Source # toList :: Compose f g a -> [a] Source # null :: Compose f g a -> Bool Source # length :: Compose f g a -> Int Source # elem :: Eq a => a -> Compose f g a -> Bool Source # maximum :: Ord a => Compose f g a -> a Source # minimum :: Ord a => Compose f g a -> a Source # sum :: Num a => Compose f g a -> a Source # product :: Num a => Compose f g a -> a Source #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) Source # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) Source # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) Source # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) Source #
(Eq1 f, Eq1 g) => Eq1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftEq :: (a -> b -> Bool) -> Compose f g a -> Compose f g b -> Bool Source #
(Ord1 f, Ord1 g) => Ord1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftCompare :: (a -> b -> Ordering) -> Compose f g a -> Compose f g b -> Ordering Source #
(Read1 f, Read1 g) => Read1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose f g a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose f g a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose f g a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose f g a] Source #
(Show1 f, Show1 g) => Show1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose f g a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose f g a] -> ShowS Source #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a Source # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a Source # some :: Compose f g a -> Compose f g [a] Source # many :: Compose f g a -> Compose f g [a] Source #
(Hashable1 f, Hashable1 g) => Hashable1 (Compose f g)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Compose f g a -> Int #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool Source # (/=) :: Compose f g a -> Compose f g a -> Bool Source #
(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Compose f g a -> c (Compose f g a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose f g a) Source # toConstr :: Compose f g a -> Constr Source # dataTypeOf :: Compose f g a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a)) Source # gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Compose f g a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) Source #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering Source # (<) :: Compose f g a -> Compose f g a -> Bool Source # (<=) :: Compose f g a -> Compose f g a -> Bool Source # (>) :: Compose f g a -> Compose f g a -> Bool Source # (>=) :: Compose f g a -> Compose f g a -> Bool Source # max :: Compose f g a -> Compose f g a -> Compose f g a Source # min :: Compose f g a -> Compose f g a -> Compose f g a Source #
(Read1 f, Read1 g, Read a) => Read (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods readsPrec :: Int -> ReadS (Compose f g a) Source # readList :: ReadS [Compose f g a] Source # readPrec :: ReadPrec (Compose f g a) Source # readListPrec :: ReadPrec [Compose f g a] Source #
(Show1 f, Show1 g, Show a) => Show (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS Source # show :: Compose f g a -> String Source # showList :: [Compose f g a] -> ShowS Source #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type Source # Methods from :: Compose f g a -> Rep (Compose f g a) x Source # to :: Rep (Compose f g a) x -> Compose f g a Source #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Compose f g a -> Int # hash :: Compose f g a -> Int #
type Rep1 (Compose f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep1 (Compose f g :: k -> Type) = D1 (MetaData "Compose" "Data.Functor.Compose" "base" True) (C1 (MetaCons "Compose" PrefixI True) (S1 (MetaSel (Just "getCompose") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (f :.: Rec1 g)))
type Rep (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep (Compose f g a) = D1 (MetaData "Compose" "Data.Functor.Compose" "base" True) (C1 (MetaCons "Compose" PrefixI True) (S1 (MetaSel (Just "getCompose") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f (g a)))))

data Sum (f :: k -> Type) (g :: k -> Type) (a :: k) :: forall k. (k -> Type) -> (k -> Type) -> k -> Type Source #

Lifted sum of functors.

Constructors

InL (f a)
InR (g a)

Instances

Generic1 (Sum f g :: k -> Type)
Instance details Defined in Data.Functor.Sum Associated Types type Rep1 (Sum f g) :: k -> Type Source # Methods from1 :: Sum f g a -> Rep1 (Sum f g) a Source # to1 :: Rep1 (Sum f g) a -> Sum f g a Source #
(Functor f, Functor g) => Functor (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b Source # (<$) :: a -> Sum f g b -> Sum f g a Source #
(Foldable f, Foldable g) => Foldable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m Source # foldr :: (a -> b -> b) -> b -> Sum f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b Source # foldl :: (b -> a -> b) -> b -> Sum f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b Source # foldr1 :: (a -> a -> a) -> Sum f g a -> a Source # foldl1 :: (a -> a -> a) -> Sum f g a -> a Source # toList :: Sum f g a -> [a] Source # null :: Sum f g a -> Bool Source # length :: Sum f g a -> Int Source # elem :: Eq a => a -> Sum f g a -> Bool Source # maximum :: Ord a => Sum f g a -> a Source # minimum :: Ord a => Sum f g a -> a Source # sum :: Num a => Sum f g a -> a Source # product :: Num a => Sum f g a -> a Source #
(Traversable f, Traversable g) => Traversable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) Source # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) Source # mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) Source # sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) Source #
(Eq1 f, Eq1 g) => Eq1 (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods liftEq :: (a -> b -> Bool) -> Sum f g a -> Sum f g b -> Bool Source #
(Ord1 f, Ord1 g) => Ord1 (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods liftCompare :: (a -> b -> Ordering) -> Sum f g a -> Sum f g b -> Ordering Source #
(Read1 f, Read1 g) => Read1 (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Sum f g a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Sum f g a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Sum f g a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Sum f g a] Source #
(Show1 f, Show1 g) => Show1 (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Sum f g a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Sum f g a] -> ShowS Source #
(Hashable1 f, Hashable1 g) => Hashable1 (Sum f g)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Sum f g a -> Int #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods (==) :: Sum f g a -> Sum f g a -> Bool Source # (/=) :: Sum f g a -> Sum f g a -> Bool Source #
(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Sum f g a -> c (Sum f g a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum f g a) Source # toConstr :: Sum f g a -> Constr Source # dataTypeOf :: Sum f g a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum f g a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum f g a)) Source # gmapT :: (forall b. Data b => b -> b) -> Sum f g a -> Sum f g a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Sum f g a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum f g a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) Source #
(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods compare :: Sum f g a -> Sum f g a -> Ordering Source # (<) :: Sum f g a -> Sum f g a -> Bool Source # (<=) :: Sum f g a -> Sum f g a -> Bool Source # (>) :: Sum f g a -> Sum f g a -> Bool Source # (>=) :: Sum f g a -> Sum f g a -> Bool Source # max :: Sum f g a -> Sum f g a -> Sum f g a Source # min :: Sum f g a -> Sum f g a -> Sum f g a Source #
(Read1 f, Read1 g, Read a) => Read (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods readsPrec :: Int -> ReadS (Sum f g a) Source # readList :: ReadS [Sum f g a] Source # readPrec :: ReadPrec (Sum f g a) Source # readListPrec :: ReadPrec [Sum f g a] Source #
(Show1 f, Show1 g, Show a) => Show (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods showsPrec :: Int -> Sum f g a -> ShowS Source # show :: Sum f g a -> String Source # showList :: [Sum f g a] -> ShowS Source #
Generic (Sum f g a)
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type Source # Methods from :: Sum f g a -> Rep (Sum f g a) x Source # to :: Rep (Sum f g a) x -> Sum f g a Source #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Sum f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Sum f g a -> Int # hash :: Sum f g a -> Int #
type Rep1 (Sum f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum type Rep1 (Sum f g :: k -> Type) = D1 (MetaData "Sum" "Data.Functor.Sum" "base" False) (C1 (MetaCons "InL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)) :+: C1 (MetaCons "InR" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g)))
type Rep (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum type Rep (Sum f g a) = D1 (MetaData "Sum" "Data.Functor.Sum" "base" False) (C1 (MetaCons "InL" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))) :+: C1 (MetaCons "InR" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g a))))

class Bifunctor (p :: Type -> Type -> Type) where Source #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d Source #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

first :: (a -> b) -> p a c -> p b c Source #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand

>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

second :: (b -> c) -> p a b -> p a c Source #

Map covariantly over the second argument.

second ≡ bimap id

Examples

Expand

>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

Instances

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) Source # first :: (a -> b) -> (a, c) -> (b, c) Source # second :: (b -> c) -> (a, b) -> (a, c) Source #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d Source # first :: (a -> b) -> Arg a c -> Arg b c Source # second :: (b -> c) -> Arg a b -> Arg a c Source #
Bifunctor Of
Instance details Defined in Data.Functor.Of Methods bimap :: (a -> b) -> (c -> d) -> Of a c -> Of b d Source # first :: (a -> b) -> Of a c -> Of b c Source # second :: (b -> c) -> Of a b -> Of a c Source #
Bifunctor ((,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) Source # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) Source # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) Source #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source # first :: (a -> b) -> Const a c -> Const b c Source # second :: (b -> c) -> Const a b -> Const a c Source #
Bifunctor (K1 i :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source # first :: (a -> b) -> K1 i a c -> K1 i b c Source # second :: (b -> c) -> K1 i a b -> K1 i a c Source #
Bifunctor ((,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) Source # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) Source # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) Source #
Bifunctor ((,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) Source # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) Source # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) Source #
Bifunctor ((,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) Source #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) Source #

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

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)

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad.

Instances

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a Source #
MonadIO m => MonadIO (ListT m)
Instance details Defined in Control.Monad.Trans.List Methods liftIO :: IO a -> ListT m a Source #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a Source #
MonadIO m => MonadIO (ByteStream m) Source #
Instance details Defined in Bio.Streaming.Bytes Methods liftIO :: IO a -> ByteStream m a Source #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a Source #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a Source #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods liftIO :: IO a -> AccumT w m a Source #
MonadIO m => MonadIO (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods liftIO :: IO a -> SelectT r m a Source #
(MonadIO m, Functor f) => MonadIO (Stream f m)
Instance details Defined in Streaming.Internal Methods liftIO :: IO a -> Stream f m a Source #
MonadIO m => MonadIO (Parser r m) Source #
Instance details Defined in Bio.Streaming.Parse Methods liftIO :: IO a -> Parser r m a Source #
MonadIO m => MonadIO (Furrow a m) Source #
Instance details Defined in Bio.Streaming.Furrow Methods liftIO :: IO a0 -> Furrow a m a0 Source #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a Source #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a Source #

newtype Identity a Source #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b Source # (>>) :: Identity a -> Identity b -> Identity b Source # return :: a -> Identity a Source # fail :: String -> Identity a Source #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b Source # (<$) :: a -> Identity b -> Identity a Source #
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a Source #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a Source # (<>) :: Identity (a -> b) -> Identity a -> Identity b Source # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source # (>) :: Identity a -> Identity b -> Identity b Source # (<*) :: Identity a -> Identity b -> Identity a Source #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m Source # foldMap :: Monoid m => (a -> m) -> Identity a -> m Source # foldr :: (a -> b -> b) -> b -> Identity a -> b Source # foldr' :: (a -> b -> b) -> b -> Identity a -> b Source # foldl :: (b -> a -> b) -> b -> Identity a -> b Source # foldl' :: (b -> a -> b) -> b -> Identity a -> b Source # foldr1 :: (a -> a -> a) -> Identity a -> a Source # foldl1 :: (a -> a -> a) -> Identity a -> a Source # toList :: Identity a -> [a] Source # null :: Identity a -> Bool Source # length :: Identity a -> Int Source # elem :: Eq a => a -> Identity a -> Bool Source # maximum :: Ord a => Identity a -> a Source # minimum :: Ord a => Identity a -> a Source # sum :: Num a => Identity a -> a Source # product :: Num a => Identity a -> a Source #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) Source # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) Source # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) Source # sequence :: Monad m => Identity (m a) -> m (Identity a) Source #
Eq1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool Source #
Ord1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering Source #
Read1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] Source #
Show1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS Source #
Hashable1 Identity
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Identity a -> Int #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a Source # maxBound :: Identity a Source #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a Source # pred :: Identity a -> Identity a Source # toEnum :: Int -> Identity a Source # fromEnum :: Identity a -> Int Source # enumFrom :: Identity a -> [Identity a] Source # enumFromThen :: Identity a -> Identity a -> [Identity a] Source # enumFromTo :: Identity a -> Identity a -> [Identity a] Source # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] Source #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool Source # (/=) :: Identity a -> Identity a -> Bool Source #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a Source # exp :: Identity a -> Identity a Source # log :: Identity a -> Identity a Source # sqrt :: Identity a -> Identity a Source # (**) :: Identity a -> Identity a -> Identity a Source # logBase :: Identity a -> Identity a -> Identity a Source # sin :: Identity a -> Identity a Source # cos :: Identity a -> Identity a Source # tan :: Identity a -> Identity a Source # asin :: Identity a -> Identity a Source # acos :: Identity a -> Identity a Source # atan :: Identity a -> Identity a Source # sinh :: Identity a -> Identity a Source # cosh :: Identity a -> Identity a Source # tanh :: Identity a -> Identity a Source # asinh :: Identity a -> Identity a Source # acosh :: Identity a -> Identity a Source # atanh :: Identity a -> Identity a Source # log1p :: Identity a -> Identity a Source # expm1 :: Identity a -> Identity a Source # log1pexp :: Identity a -> Identity a Source # log1mexp :: Identity a -> Identity a Source #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a Source # recip :: Identity a -> Identity a Source # fromRational :: Rational -> Identity a Source #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a Source # rem :: Identity a -> Identity a -> Identity a Source # div :: Identity a -> Identity a -> Identity a Source # mod :: Identity a -> Identity a -> Identity a Source # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) Source # divMod :: Identity a -> Identity a -> (Identity a, Identity a) Source # toInteger :: Identity a -> Integer Source #
Data a => Data (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) Source # toConstr :: Identity a -> Constr Source # dataTypeOf :: Identity a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) Source # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a Source # (-) :: Identity a -> Identity a -> Identity a Source # (*) :: Identity a -> Identity a -> Identity a Source # negate :: Identity a -> Identity a Source # abs :: Identity a -> Identity a Source # signum :: Identity a -> Identity a Source # fromInteger :: Integer -> Identity a Source #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering Source # (<) :: Identity a -> Identity a -> Bool Source # (<=) :: Identity a -> Identity a -> Bool Source # (>) :: Identity a -> Identity a -> Bool Source # (>=) :: Identity a -> Identity a -> Bool Source # max :: Identity a -> Identity a -> Identity a Source # min :: Identity a -> Identity a -> Identity a Source #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) Source # readList :: ReadS [Identity a] Source # readPrec :: ReadPrec (Identity a) Source # readListPrec :: ReadPrec [Identity a] Source #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational Source #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer Source # floatDigits :: Identity a -> Int Source # floatRange :: Identity a -> (Int, Int) Source # decodeFloat :: Identity a -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Identity a Source # exponent :: Identity a -> Int Source # significand :: Identity a -> Identity a Source # scaleFloat :: Int -> Identity a -> Identity a Source # isNaN :: Identity a -> Bool Source # isInfinite :: Identity a -> Bool Source # isDenormalized :: Identity a -> Bool Source # isNegativeZero :: Identity a -> Bool Source # isIEEE :: Identity a -> Bool Source # atan2 :: Identity a -> Identity a -> Identity a Source #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) Source # truncate :: Integral b => Identity a -> b Source # round :: Integral b => Identity a -> b Source # ceiling :: Integral b => Identity a -> b Source # floor :: Integral b => Identity a -> b Source #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS Source # show :: Identity a -> String Source # showList :: [Identity a] -> ShowS Source #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] Source # index :: (Identity a, Identity a) -> Identity a -> Int Source # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool Source # rangeSize :: (Identity a, Identity a) -> Int Source # unsafeRangeSize :: (Identity a, Identity a) -> Int
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a Source #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep (Identity a) x Source # to :: Rep (Identity a) x -> Identity a Source #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a Source # sconcat :: NonEmpty (Identity a) -> Identity a Source # stimes :: Integral b => b -> Identity a -> Identity a Source #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a Source # mappend :: Identity a -> Identity a -> Identity a Source # mconcat :: [Identity a] -> Identity a Source #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int Source # alignment :: Identity a -> Int Source # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) Source # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (Identity a) Source # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () Source # peek :: Ptr (Identity a) -> IO (Identity a) Source # poke :: Ptr (Identity a) -> Identity a -> IO () Source #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a Source # (.\|.) :: Identity a -> Identity a -> Identity a Source # xor :: Identity a -> Identity a -> Identity a Source # complement :: Identity a -> Identity a Source # shift :: Identity a -> Int -> Identity a Source # rotate :: Identity a -> Int -> Identity a Source # zeroBits :: Identity a Source # bit :: Int -> Identity a Source # setBit :: Identity a -> Int -> Identity a Source # clearBit :: Identity a -> Int -> Identity a Source # complementBit :: Identity a -> Int -> Identity a Source # testBit :: Identity a -> Int -> Bool Source # bitSizeMaybe :: Identity a -> Maybe Int Source # bitSize :: Identity a -> Int Source # isSigned :: Identity a -> Bool Source # shiftL :: Identity a -> Int -> Identity a Source # unsafeShiftL :: Identity a -> Int -> Identity a Source # shiftR :: Identity a -> Int -> Identity a Source # unsafeShiftR :: Identity a -> Int -> Identity a Source # rotateL :: Identity a -> Int -> Identity a Source # rotateR :: Identity a -> Int -> Identity a Source # popCount :: Identity a -> Int Source #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int Source # countLeadingZeros :: Identity a -> Int Source # countTrailingZeros :: Identity a -> Int Source #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type Source # Methods from1 :: Identity a -> Rep1 Identity a Source # to1 :: Rep1 Identity a -> Identity a Source #
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

void :: Functor f => f a -> f () Source #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Expand

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int '()':

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

liftM2 (+) [0,1] [0,2] = [0,2,1,3]
liftM2 (+) (Just 1) Nothing = Nothing

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad.

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #

Lift a ternary function to actions.

class Applicative f => Alternative (f :: Type -> Type) where Source #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Minimal complete definition

empty, (<|>)

Methods

(<|>) :: f a -> f a -> f a infixl 3 Source #

An associative binary operation

Instances

Alternative []	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] Source # (<\|>) :: [a] -> [a] -> [a] Source # some :: [a] -> [[a]] Source # many :: [a] -> [[a]] Source #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a Source # (<\|>) :: Maybe a -> Maybe a -> Maybe a Source # some :: Maybe a -> Maybe [a] Source # many :: Maybe a -> Maybe [a] Source #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a Source # (<\|>) :: IO a -> IO a -> IO a Source # some :: IO a -> IO [a] Source # many :: IO a -> IO [a] Source #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a Source # (<\|>) :: Option a -> Option a -> Option a Source # some :: Option a -> Option [a] Source # many :: Option a -> Option [a] Source #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a Source # (<\|>) :: ZipList a -> ZipList a -> ZipList a Source # some :: ZipList a -> ZipList [a] Source # many :: ZipList a -> ZipList [a] Source #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a Source # (<\|>) :: STM a -> STM a -> STM a Source # some :: STM a -> STM [a] Source # many :: STM a -> STM [a] Source #
Alternative ReadPrec	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadPrec Methods empty :: ReadPrec a Source # (<\|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a Source # some :: ReadPrec a -> ReadPrec [a] Source # many :: ReadPrec a -> ReadPrec [a] Source #
Alternative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: ReadP a Source # (<\|>) :: ReadP a -> ReadP a -> ReadP a Source # some :: ReadP a -> ReadP [a] Source # many :: ReadP a -> ReadP [a] Source #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a Source # (<\|>) :: Seq a -> Seq a -> Seq a Source # some :: Seq a -> Seq [a] Source # many :: Seq a -> Seq [a] Source #
Alternative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: P a Source # (<\|>) :: P a -> P a -> P a Source # some :: P a -> P [a] Source # many :: P a -> P [a] Source #
Alternative Array
Instance details Defined in Data.Primitive.Array Methods empty :: Array a Source # (<\|>) :: Array a -> Array a -> Array a Source # some :: Array a -> Array [a] Source # many :: Array a -> Array [a] Source #
Alternative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods empty :: SmallArray a Source # (<\|>) :: SmallArray a -> SmallArray a -> SmallArray a Source # some :: SmallArray a -> SmallArray [a] Source # many :: SmallArray a -> SmallArray [a] Source #
Alternative Vector
Instance details Defined in Data.Vector Methods empty :: Vector a Source # (<\|>) :: Vector a -> Vector a -> Vector a Source # some :: Vector a -> Vector [a] Source # many :: Vector a -> Vector [a] Source #
Alternative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a Source # (<\|>) :: U1 a -> U1 a -> U1 a Source # some :: U1 a -> U1 [a] Source # many :: U1 a -> U1 [a] Source #
MonadPlus m => Alternative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a Source # (<\|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source # some :: WrappedMonad m a -> WrappedMonad m [a] Source # many :: WrappedMonad m a -> WrappedMonad m [a] Source #
ArrowPlus a => Alternative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 Source # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source # some :: ArrowMonad a a0 -> ArrowMonad a [a0] Source # many :: ArrowMonad a a0 -> ArrowMonad a [a0] Source #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a Source # (<\|>) :: Proxy a -> Proxy a -> Proxy a Source # some :: Proxy a -> Proxy [a] Source # many :: Proxy a -> Proxy [a] Source #
Applicative m => Alternative (ListT m)
Instance details Defined in Control.Monad.Trans.List Methods empty :: ListT m a Source # (<\|>) :: ListT m a -> ListT m a -> ListT m a Source # some :: ListT m a -> ListT m [a] Source # many :: ListT m a -> ListT m [a] Source #
(Functor m, Monad m) => Alternative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a Source # (<\|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a Source # some :: MaybeT m a -> MaybeT m [a] Source # many :: MaybeT m a -> MaybeT m [a] Source #
Alternative (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods empty :: Parser i a Source # (<\|>) :: Parser i a -> Parser i a -> Parser i a Source # some :: Parser i a -> Parser i [a] Source # many :: Parser i a -> Parser i [a] Source #
Alternative f => Alternative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: Rec1 f a Source # (<\|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a Source # some :: Rec1 f a -> Rec1 f [a] Source # many :: Rec1 f a -> Rec1 f [a] Source #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 Source # (<\|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 Source # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] Source #
Alternative f => Alternative (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a Source # (<\|>) :: Ap f a -> Ap f a -> Ap f a Source # some :: Ap f a -> Ap f [a] Source # many :: Ap f a -> Ap f [a] Source #
Alternative f => Alternative (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods empty :: Alt f a Source # (<\|>) :: Alt f a -> Alt f a -> Alt f a Source # some :: Alt f a -> Alt f [a] Source # many :: Alt f a -> Alt f [a] Source #
Alternative m => Alternative (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a Source # (<\|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a Source # some :: IdentityT m a -> IdentityT m [a] Source # many :: IdentityT m a -> IdentityT m [a] Source #
(Functor m, Monad m, Error e) => Alternative (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods empty :: ErrorT e m a Source # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source # some :: ErrorT e m a -> ErrorT e m [a] Source # many :: ErrorT e m a -> ErrorT e m [a] Source #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a Source # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source # some :: ExceptT e m a -> ExceptT e m [a] Source # many :: ExceptT e m a -> ExceptT e m [a] Source #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a Source # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a Source # some :: StateT s m a -> StateT s m [a] Source # many :: StateT s m a -> StateT s m [a] Source #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a Source # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a Source # some :: StateT s m a -> StateT s m [a] Source # many :: StateT s m a -> StateT s m [a] Source #
(Monoid w, Alternative m) => Alternative (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods empty :: WriterT w m a Source # (<\|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # some :: WriterT w m a -> WriterT w m [a] Source # many :: WriterT w m a -> WriterT w m [a] Source #
(Monoid w, Alternative m) => Alternative (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods empty :: WriterT w m a Source # (<\|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a Source # some :: WriterT w m a -> WriterT w m [a] Source # many :: WriterT w m a -> WriterT w m [a] Source #
(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods empty :: AccumT w m a Source # (<\|>) :: AccumT w m a -> AccumT w m a -> AccumT w m a Source # some :: AccumT w m a -> AccumT w m [a] Source # many :: AccumT w m a -> AccumT w m [a] Source #
(Functor m, MonadPlus m) => Alternative (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods empty :: SelectT r m a Source # (<\|>) :: SelectT r m a -> SelectT r m a -> SelectT r m a Source # some :: SelectT r m a -> SelectT r m [a] Source # many :: SelectT r m a -> SelectT r m [a] Source #
(Applicative f, Monad m) => Alternative (Stream f m)
Instance details Defined in Streaming.Internal Methods empty :: Stream f m a Source # (<\|>) :: Stream f m a -> Stream f m a -> Stream f m a Source # some :: Stream f m a -> Stream f m [a] Source # many :: Stream f m a -> Stream f m [a] Source #
(Alternative f, Alternative g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :: g) a Source # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a Source # some :: (f :: g) a -> (f :: g) [a] Source # many :: (f :: g) a -> (f :: g) [a] Source #
(Alternative f, Alternative g) => Alternative (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a Source # (<\|>) :: Product f g a -> Product f g a -> Product f g a Source # some :: Product f g a -> Product f g [a] Source # many :: Product f g a -> Product f g [a] Source #
Alternative m => Alternative (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a Source # (<\|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source # some :: ReaderT r m a -> ReaderT r m [a] Source # many :: ReaderT r m a -> ReaderT r m [a] Source #
Alternative f => Alternative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: M1 i c f a Source # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a Source # some :: M1 i c f a -> M1 i c f [a] Source # many :: M1 i c f a -> M1 i c f [a] Source #
(Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :.: g) a Source # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a Source # some :: (f :.: g) a -> (f :.: g) [a] Source # many :: (f :.: g) a -> (f :.: g) [a] Source #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a Source # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a Source # some :: Compose f g a -> Compose f g [a] Source # many :: Compose f g a -> Compose f g [a] Source #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods empty :: RWST r w s m a Source # (<\|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source # some :: RWST r w s m a -> RWST r w s m [a] Source # many :: RWST r w s m a -> RWST r w s m [a] Source #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods empty :: RWST r w s m a Source # (<\|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source # some :: RWST r w s m a -> RWST r w s m [a] Source # many :: RWST r w s m a -> RWST r w s m [a] Source #

class MonadTrans (t :: (Type -> Type) -> Type -> Type) where Source #

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)
```

Methods

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

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

Instances

MonadTrans ListT
Instance details Defined in Control.Monad.Trans.List Methods lift :: Monad m => m a -> ListT m a Source #
MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a Source #
MonadTrans ByteStream Source #
Instance details Defined in Bio.Streaming.Bytes Methods lift :: Monad m => m a -> ByteStream m a Source #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a Source #
MonadTrans (ErrorT e)
Instance details Defined in Control.Monad.Trans.Error Methods lift :: Monad m => m a -> ErrorT e m a Source #
MonadTrans (ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a Source #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a Source #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a Source #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods lift :: Monad m => m a -> WriterT w m a Source #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods lift :: Monad m => m a -> WriterT w m a Source #
Monoid w => MonadTrans (AccumT w)
Instance details Defined in Control.Monad.Trans.Accum Methods lift :: Monad m => m a -> AccumT w m a Source #
MonadTrans (SelectT r)
Instance details Defined in Control.Monad.Trans.Select Methods lift :: Monad m => m a -> SelectT r m a Source #
Functor f => MonadTrans (Stream f)
Instance details Defined in Streaming.Internal Methods lift :: Monad m => m a -> Stream f m a Source #
MonadTrans (Parser r) Source #
Instance details Defined in Bio.Streaming.Parse Methods lift :: Monad m => m a -> Parser r m a Source #
MonadTrans (Furrow a) Source #
Instance details Defined in Bio.Streaming.Furrow Methods lift :: Monad m => m a0 -> Furrow a m a0 Source #
MonadTrans (ContT r)
Instance details Defined in Control.Monad.Trans.Cont Methods lift :: Monad m => m a -> ContT r m a Source #
MonadTrans (ReaderT r :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a Source #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods lift :: Monad m => m a -> RWST r w s m a Source #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods lift :: Monad m => m a -> RWST r w s m a Source #

chunksOf :: (Monad m, Functor f) => Int -> Stream f m r -> Stream (Stream f m) m r #

concats :: (Monad m, Functor f) => Stream (Stream f m) m r -> Stream f m r #

cutoff :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Maybe r) #

decompose :: (Monad m, Functor f) => Stream (Compose m f) m r -> Stream f m r #

delays :: (MonadIO m, Applicative f) => Double -> Stream f m r #

destroy :: (Functor f, Monad m) => Stream f m r -> (f b -> b) -> (m b -> b) -> (r -> b) -> b #

distribute :: (Monad m, Functor f, MonadTrans t, MFunctor t, Monad (t (Stream f m))) => Stream f (t m) r -> t (Stream f m) r #

effect :: (Monad m, Functor f) => m (Stream f m r) -> Stream f m r #

expand :: (Monad m, Functor f) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r #

expandPost :: (Monad m, Functor g) => (forall a b. (g a -> b) -> f a -> h b) -> Stream f m r -> Stream g (Stream h m) r #

groups :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream (Sum (Stream f m) (Stream g m)) m r #

hoistUnexposed :: (Monad m, Functor f) => (forall a. m a -> n a) -> Stream f m r -> Stream f n r #

inspect :: Monad m => Stream f m r -> m (Either r (f (Stream f m r))) #

intercalates :: (Monad m, Monad (t m), MonadTrans t) => t m x -> Stream (t m) m r -> t m r #

interleaves :: (Monad m, Applicative h) => Stream h m r -> Stream h m r -> Stream h m r #

iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> Stream f m a -> m a #

iterTM :: (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> Stream f m a -> t m a #

maps :: (Monad m, Functor f) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r #

mapsM :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r #

mapsMPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r #

mapsM_ :: (Functor f, Monad m) => (forall x. f x -> m x) -> Stream f m r -> m r #

mapsPost :: (Monad m, Functor g) => (forall x. f x -> g x) -> Stream f m r -> Stream g m r #

never :: (Monad m, Applicative f) => Stream f m r #

repeats :: (Monad m, Functor f) => f () -> Stream f m r #

repeatsM :: (Monad m, Functor f) => m (f ()) -> Stream f m r #

replicates :: (Monad m, Functor f) => Int -> f () -> Stream f m () #

run :: Monad m => Stream m m r -> m r #

separate :: (Monad m, Functor f, Functor g) => Stream (Sum f g) m r -> Stream f (Stream g m) r #

splitsAt :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Stream f m r) #

streamBuild :: (forall b. (r -> b) -> (m b -> b) -> (f b -> b) -> b) -> Stream f m r #

streamFold :: (Functor f, Monad m) => (r -> b) -> (m b -> b) -> (f b -> b) -> Stream f m r -> b #

takes :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m () #

unfold :: (Monad m, Functor f) => (s -> m (Either r (f s))) -> s -> Stream f m r #

unseparate :: (Monad m, Functor f, Functor g) => Stream f (Stream g m) r -> Stream (Sum f g) m r #

untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r #

unzips :: (Monad m, Functor f, Functor g) => Stream (Compose f g) m r -> Stream f (Stream g m) r #

wrap :: (Monad m, Functor f) => f (Stream f m r) -> Stream f m r #

yields :: (Monad m, Functor f) => f r -> Stream f m r #

zips :: (Monad m, Functor f, Functor g) => Stream f m r -> Stream g m r -> Stream (Compose f g) m r #

zipsWith :: (Monad m, Functor h) => (forall x y. f x -> g y -> h (x, y)) -> Stream f m r -> Stream g m r -> Stream h m r #

zipsWith' :: Monad m => (forall x y p. (x -> y -> p) -> f x -> g y -> h p) -> Stream f m r -> Stream g m r -> Stream h m r #

lazily :: Of a b -> (a, b) #

mapped :: (Monad m, Functor f) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r #

mappedPost :: (Monad m, Functor g) => (forall x. f x -> m (g x)) -> Stream f m r -> Stream g m r #

strictly :: (a, b) -> Of a b #

class MFunctor (t :: (Type -> Type) -> k -> Type) where #

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b #

Instances

MFunctor ListT
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> ListT m b -> ListT n b #
MFunctor Lift
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> Lift m b -> Lift n b #
MFunctor MaybeT
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> MaybeT m b -> MaybeT n b #
MFunctor (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> IdentityT m b -> IdentityT n b #
MFunctor (ErrorT e :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> ErrorT e m b -> ErrorT e n b #
MFunctor (ExceptT e :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> ExceptT e m b -> ExceptT e n b #
MFunctor (StateT s :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> StateT s m b -> StateT s n b #
MFunctor (StateT s :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> StateT s m b -> StateT s n b #
MFunctor (WriterT w :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> WriterT w m b -> WriterT w n b #
MFunctor (WriterT w :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> WriterT w m b -> WriterT w n b #
MFunctor (Backwards :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> Backwards m b -> Backwards n b #
Functor f => MFunctor (Stream f :: (Type -> Type) -> Type -> Type)
Instance details Defined in Streaming.Internal Methods hoist :: Monad m => (forall a. m a -> n a) -> Stream f m b -> Stream f n b #
MFunctor (Furrow a :: (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Bio.Streaming.Furrow Methods hoist :: Monad m => (forall a0. m a0 -> n a0) -> Furrow a m b -> Furrow a n b #
MFunctor (Product f :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> Product f m b -> Product f n b #
MFunctor (ReaderT r :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> ReaderT r m b -> ReaderT r n b #
Functor f => MFunctor (Compose f :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> Compose f m b -> Compose f n b #
MFunctor (RWST r w s :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> RWST r w s m b -> RWST r w s n b #
MFunctor (RWST r w s :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: Monad m => (forall a. m a -> n a) -> RWST r w s m b -> RWST r w s n b #

class (MFunctor t, MonadTrans t) => MMonad (t :: (Type -> Type) -> Type -> Type) where #

Methods

embed :: Monad n => (forall a. m a -> t n a) -> t m b -> t n b #

Instances

MMonad ListT
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> ListT n a) -> ListT m b -> ListT n b #
MMonad MaybeT
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> MaybeT n a) -> MaybeT m b -> MaybeT n b #
MMonad (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> IdentityT n a) -> IdentityT m b -> IdentityT n b #
Error e => MMonad (ErrorT e)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> ErrorT e n a) -> ErrorT e m b -> ErrorT e n b #
MMonad (ExceptT e)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> ExceptT e n a) -> ExceptT e m b -> ExceptT e n b #
Monoid w => MMonad (WriterT w)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> WriterT w n a) -> WriterT w m b -> WriterT w n b #
Monoid w => MMonad (WriterT w)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> WriterT w n a) -> WriterT w m b -> WriterT w n b #
Functor f => MMonad (Stream f)
Instance details Defined in Streaming.Internal Methods embed :: Monad n => (forall a. m a -> Stream f n a) -> Stream f m b -> Stream f n b #
MMonad (Furrow a) Source #
Instance details Defined in Bio.Streaming.Furrow Methods embed :: Monad n => (forall a0. m a0 -> Furrow a n a0) -> Furrow a m b -> Furrow a n b #
MMonad (ReaderT r :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods embed :: Monad n => (forall a. m a -> ReaderT r n a) -> ReaderT r m b -> ReaderT r n b #

data Of a b #

Constructors

!a :> b

Instances

Bifunctor Of
Instance details Defined in Data.Functor.Of Methods bimap :: (a -> b) -> (c -> d) -> Of a c -> Of b d Source # first :: (a -> b) -> Of a c -> Of b c Source # second :: (b -> c) -> Of a b -> Of a c Source #
Eq2 Of
Instance details Defined in Data.Functor.Of Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Of a c -> Of b d -> Bool Source #
Ord2 Of
Instance details Defined in Data.Functor.Of Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Of a c -> Of b d -> Ordering Source #
Show2 Of
Instance details Defined in Data.Functor.Of Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Of a b -> ShowS Source # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Of a b] -> ShowS Source #
Monoid a => Monad (Of a)
Instance details Defined in Data.Functor.Of Methods (>>=) :: Of a a0 -> (a0 -> Of a b) -> Of a b Source # (>>) :: Of a a0 -> Of a b -> Of a b Source # return :: a0 -> Of a a0 Source # fail :: String -> Of a a0 Source #
Functor (Of a)
Instance details Defined in Data.Functor.Of Methods fmap :: (a0 -> b) -> Of a a0 -> Of a b Source # (<$) :: a0 -> Of a b -> Of a a0 Source #
Monoid a => Applicative (Of a)
Instance details Defined in Data.Functor.Of Methods pure :: a0 -> Of a a0 Source # (<>) :: Of a (a0 -> b) -> Of a a0 -> Of a b Source # liftA2 :: (a0 -> b -> c) -> Of a a0 -> Of a b -> Of a c Source # (>) :: Of a a0 -> Of a b -> Of a b Source # (<*) :: Of a a0 -> Of a b -> Of a a0 Source #
Foldable (Of a)
Instance details Defined in Data.Functor.Of Methods fold :: Monoid m => Of a m -> m Source # foldMap :: Monoid m => (a0 -> m) -> Of a a0 -> m Source # foldr :: (a0 -> b -> b) -> b -> Of a a0 -> b Source # foldr' :: (a0 -> b -> b) -> b -> Of a a0 -> b Source # foldl :: (b -> a0 -> b) -> b -> Of a a0 -> b Source # foldl' :: (b -> a0 -> b) -> b -> Of a a0 -> b Source # foldr1 :: (a0 -> a0 -> a0) -> Of a a0 -> a0 Source # foldl1 :: (a0 -> a0 -> a0) -> Of a a0 -> a0 Source # toList :: Of a a0 -> [a0] Source # null :: Of a a0 -> Bool Source # length :: Of a a0 -> Int Source # elem :: Eq a0 => a0 -> Of a a0 -> Bool Source # maximum :: Ord a0 => Of a a0 -> a0 Source # minimum :: Ord a0 => Of a a0 -> a0 Source # sum :: Num a0 => Of a a0 -> a0 Source # product :: Num a0 => Of a a0 -> a0 Source #
Traversable (Of a)
Instance details Defined in Data.Functor.Of Methods traverse :: Applicative f => (a0 -> f b) -> Of a a0 -> f (Of a b) Source # sequenceA :: Applicative f => Of a (f a0) -> f (Of a a0) Source # mapM :: Monad m => (a0 -> m b) -> Of a a0 -> m (Of a b) Source # sequence :: Monad m => Of a (m a0) -> m (Of a a0) Source #
Eq a => Eq1 (Of a)
Instance details Defined in Data.Functor.Of Methods liftEq :: (a0 -> b -> Bool) -> Of a a0 -> Of a b -> Bool Source #
Ord a => Ord1 (Of a)
Instance details Defined in Data.Functor.Of Methods liftCompare :: (a0 -> b -> Ordering) -> Of a a0 -> Of a b -> Ordering Source #
Show a => Show1 (Of a)
Instance details Defined in Data.Functor.Of Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Of a a0 -> ShowS Source # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Of a a0] -> ShowS Source #
Generic1 (Of a :: Type -> Type)
Instance details Defined in Data.Functor.Of Associated Types type Rep1 (Of a) :: k -> Type Source # Methods from1 :: Of a a0 -> Rep1 (Of a) a0 Source # to1 :: Rep1 (Of a) a0 -> Of a a0 Source #
(Eq a, Eq b) => Eq (Of a b)
Instance details Defined in Data.Functor.Of Methods (==) :: Of a b -> Of a b -> Bool Source # (/=) :: Of a b -> Of a b -> Bool Source #
(Data a, Data b) => Data (Of a b)
Instance details Defined in Data.Functor.Of Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Of a b -> c (Of a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Of a b) Source # toConstr :: Of a b -> Constr Source # dataTypeOf :: Of a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Of a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Of a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Of a b -> Of a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Of a b -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Of a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Of a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Of a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Of a b -> m (Of a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Of a b -> m (Of a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Of a b -> m (Of a b) Source #
(Ord a, Ord b) => Ord (Of a b)
Instance details Defined in Data.Functor.Of Methods compare :: Of a b -> Of a b -> Ordering Source # (<) :: Of a b -> Of a b -> Bool Source # (<=) :: Of a b -> Of a b -> Bool Source # (>) :: Of a b -> Of a b -> Bool Source # (>=) :: Of a b -> Of a b -> Bool Source # max :: Of a b -> Of a b -> Of a b Source # min :: Of a b -> Of a b -> Of a b Source #
(Read a, Read b) => Read (Of a b)
Instance details Defined in Data.Functor.Of Methods readsPrec :: Int -> ReadS (Of a b) Source # readList :: ReadS [Of a b] Source # readPrec :: ReadPrec (Of a b) Source # readListPrec :: ReadPrec [Of a b] Source #
(Show a, Show b) => Show (Of a b)
Instance details Defined in Data.Functor.Of Methods showsPrec :: Int -> Of a b -> ShowS Source # show :: Of a b -> String Source # showList :: [Of a b] -> ShowS Source #
Generic (Of a b)
Instance details Defined in Data.Functor.Of Associated Types type Rep (Of a b) :: Type -> Type Source # Methods from :: Of a b -> Rep (Of a b) x Source # to :: Rep (Of a b) x -> Of a b Source #
(Semigroup a, Semigroup b) => Semigroup (Of a b)
Instance details Defined in Data.Functor.Of Methods (<>) :: Of a b -> Of a b -> Of a b Source # sconcat :: NonEmpty (Of a b) -> Of a b Source # stimes :: Integral b0 => b0 -> Of a b -> Of a b Source #
(Monoid a, Monoid b) => Monoid (Of a b)
Instance details Defined in Data.Functor.Of Methods mempty :: Of a b Source # mappend :: Of a b -> Of a b -> Of a b Source # mconcat :: [Of a b] -> Of a b Source #
type Rep1 (Of a :: Type -> Type)
Instance details Defined in Data.Functor.Of type Rep1 (Of a :: Type -> Type) = D1 (MetaData "Of" "Data.Functor.Of" "streaming-0.2.2.0-6BC4Zeul6ZYBVIvxn7NEdF" False) (C1 (MetaCons ":>" (InfixI RightAssociative 5) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))
type Rep (Of a b)
Instance details Defined in Data.Functor.Of type Rep (Of a b) = D1 (MetaData "Of" "Data.Functor.Of" "streaming-0.2.2.0-6BC4Zeul6ZYBVIvxn7NEdF" False) (C1 (MetaCons ":>" (InfixI RightAssociative 5) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)))

data Stream (f :: Type -> Type) (m :: Type -> Type) r #

Instances

(Functor f, MonadState s m) => MonadState s (Stream f m)
Instance details Defined in Streaming.Internal Methods get :: Stream f m s Source # put :: s -> Stream f m () Source # state :: (s -> (a, s)) -> Stream f m a Source #
(Functor f, MonadReader r m) => MonadReader r (Stream f m)
Instance details Defined in Streaming.Internal Methods ask :: Stream f m r Source # local :: (r -> r) -> Stream f m a -> Stream f m a Source # reader :: (r -> a) -> Stream f m a Source #
(Functor f, MonadError e m) => MonadError e (Stream f m)
Instance details Defined in Streaming.Internal Methods throwError :: e -> Stream f m a Source # catchError :: Stream f m a -> (e -> Stream f m a) -> Stream f m a Source #
Functor f => MonadTrans (Stream f)
Instance details Defined in Streaming.Internal Methods lift :: Monad m => m a -> Stream f m a Source #
Functor f => MMonad (Stream f)
Instance details Defined in Streaming.Internal Methods embed :: Monad n => (forall a. m a -> Stream f n a) -> Stream f m b -> Stream f n b #
Functor f => MFunctor (Stream f :: (Type -> Type) -> Type -> Type)
Instance details Defined in Streaming.Internal Methods hoist :: Monad m => (forall a. m a -> n a) -> Stream f m b -> Stream f n b #
(Functor f, Monad m) => Monad (Stream f m)
Instance details Defined in Streaming.Internal Methods (>>=) :: Stream f m a -> (a -> Stream f m b) -> Stream f m b Source # (>>) :: Stream f m a -> Stream f m b -> Stream f m b Source # return :: a -> Stream f m a Source # fail :: String -> Stream f m a Source #
(Functor f, Monad m) => Functor (Stream f m)
Instance details Defined in Streaming.Internal Methods fmap :: (a -> b) -> Stream f m a -> Stream f m b Source # (<$) :: a -> Stream f m b -> Stream f m a Source #
(Functor f, Monad m) => Applicative (Stream f m)
Instance details Defined in Streaming.Internal Methods pure :: a -> Stream f m a Source # (<>) :: Stream f m (a -> b) -> Stream f m a -> Stream f m b Source # liftA2 :: (a -> b -> c) -> Stream f m a -> Stream f m b -> Stream f m c Source # (>) :: Stream f m a -> Stream f m b -> Stream f m b Source # (<*) :: Stream f m a -> Stream f m b -> Stream f m a Source #
(Monad m, Functor f, Eq1 m, Eq1 f) => Eq1 (Stream f m)
Instance details Defined in Streaming.Internal Methods liftEq :: (a -> b -> Bool) -> Stream f m a -> Stream f m b -> Bool Source #
(Monad m, Functor f, Ord1 m, Ord1 f) => Ord1 (Stream f m)
Instance details Defined in Streaming.Internal Methods liftCompare :: (a -> b -> Ordering) -> Stream f m a -> Stream f m b -> Ordering Source #
(Monad m, Functor f, Show (m ShowSWrapper), Show (f ShowSWrapper)) => Show1 (Stream f m)
Instance details Defined in Streaming.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Stream f m a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Stream f m a] -> ShowS Source #
(MonadIO m, Functor f) => MonadIO (Stream f m)
Instance details Defined in Streaming.Internal Methods liftIO :: IO a -> Stream f m a Source #
(Applicative f, Monad m) => Alternative (Stream f m)
Instance details Defined in Streaming.Internal Methods empty :: Stream f m a Source # (<\|>) :: Stream f m a -> Stream f m a -> Stream f m a Source # some :: Stream f m a -> Stream f m [a] Source # many :: Stream f m a -> Stream f m [a] Source #
(Applicative f, Monad m) => MonadPlus (Stream f m)
Instance details Defined in Streaming.Internal Methods mzero :: Stream f m a Source # mplus :: Stream f m a -> Stream f m a -> Stream f m a Source #
(Monad m, Eq (m (Either r (f (Stream f m r))))) => Eq (Stream f m r)
Instance details Defined in Streaming.Internal Methods (==) :: Stream f m r -> Stream f m r -> Bool Source # (/=) :: Stream f m r -> Stream f m r -> Bool Source #
(Monad m, Ord (m (Either r (f (Stream f m r))))) => Ord (Stream f m r)
Instance details Defined in Streaming.Internal Methods compare :: Stream f m r -> Stream f m r -> Ordering Source # (<) :: Stream f m r -> Stream f m r -> Bool Source # (<=) :: Stream f m r -> Stream f m r -> Bool Source # (>) :: Stream f m r -> Stream f m r -> Bool Source # (>=) :: Stream f m r -> Stream f m r -> Bool Source # max :: Stream f m r -> Stream f m r -> Stream f m r Source # min :: Stream f m r -> Stream f m r -> Stream f m r Source #
(Monad m, Show r, Show (m ShowSWrapper), Show (f (Stream f m r))) => Show (Stream f m r)
Instance details Defined in Streaming.Internal Methods showsPrec :: Int -> Stream f m r -> ShowS Source # show :: Stream f m r -> String Source # showList :: [Stream f m r] -> ShowS Source #
(Functor f, Monad m, Semigroup w) => Semigroup (Stream f m w)
Instance details Defined in Streaming.Internal Methods (<>) :: Stream f m w -> Stream f m w -> Stream f m w Source # sconcat :: NonEmpty (Stream f m w) -> Stream f m w Source # stimes :: Integral b => b -> Stream f m w -> Stream f m w Source #
(Functor f, Monad m, Monoid w) => Monoid (Stream f m w)
Instance details Defined in Streaming.Internal Methods mempty :: Stream f m w Source # mappend :: Stream f m w -> Stream f m w -> Stream f m w Source # mconcat :: [Stream f m w] -> Stream f m w Source #

each :: (Monad m, Foldable f) => f a -> Stream (Of a) m () #