Create a type with a zip-like applicative.

>>> expr <- runQ (mkZipType "ZipStream" "zipApply" False)
>>> putStrLn $ pprint expr
newtype ZipStream m a
    = ZipStream (Stream.Stream m a)
    deriving Foldable
mkZipStream :: Stream.Stream m a -> ZipStream m a
mkZipStream = ZipStream
unZipStream :: ZipStream m a -> Stream.Stream m a
unZipStream (ZipStream strm) = strm
deriving instance IsList (ZipStream Identity a)
deriving instance a ~
                  GHC.Types.Char => IsString (ZipStream Identity a)
deriving instance GHC.Classes.Eq a => Eq (ZipStream Identity a)
deriving instance GHC.Classes.Ord a => Ord (ZipStream Identity a)
instance Show a => Show (ZipStream Identity a)
    where {{-# INLINE show #-}; show (ZipStream strm) = show strm}
instance Read a => Read (ZipStream Identity a)
    where {{-# INLINE readPrec #-}; readPrec = fmap ZipStream readPrec}
instance Monad m => Functor (ZipStream m)
    where {{-# INLINE fmap #-};
           fmap f (ZipStream strm) = ZipStream (fmap f strm)}
instance Monad m => Applicative (ZipStream m)
    where {{-# INLINE pure #-};
           pure = ZipStream . Stream.repeat;
           {-# INLINE (<*>) #-};
           (<*>) (ZipStream strm1) (ZipStream strm2) = ZipStream (zipApply strm1 strm2)}

Create a type with specific stream combination properties.

>>> expr <- runQ (mkCrossType "Parallel" "parBind" True)
>>> putStrLn $ pprint expr
newtype Parallel m a = Parallel (Stream.Stream m a)
mkParallel :: Stream.Stream m a -> Parallel m a
mkParallel = Parallel
unParallel :: Parallel m a -> Stream.Stream m a
unParallel (Parallel strm) = strm
instance Monad m => Functor (Parallel m)
    where {{-# INLINE fmap #-};
           fmap f (Parallel strm) = Parallel (fmap f strm)}
instance Stream.MonadAsync m => Monad (Parallel m)
    where {{-# INLINE (>>=) #-};
           (>>=) (Parallel strm1) f = let f1 a = unParallel (f a)
                                       in Parallel (parBind strm1 f1)}
instance Stream.MonadAsync m => Applicative (Parallel m)
    where {{-# INLINE pure #-};
           pure = Parallel . Stream.fromPure;
           {-# INLINE (<*>) #-};
           (<*>) = ap}
instance (Monad (Parallel m), MonadIO m) => MonadIO (Parallel m)
    where {{-# INLINE liftIO #-};
           liftIO = Parallel . (Stream.fromEffect . liftIO)}
instance (Monad (Parallel m),
          MonadThrow m) => MonadThrow (Parallel m)
    where {{-# INLINE throwM #-};
           throwM = Parallel . (Stream.fromEffect . throwM)}

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)

A class for monads in which exceptions may be thrown.

Instances should obey the following law:

throwM e >> x = throwM e

In other words, throwing an exception short-circuits the rest of the monadic computation.

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

The class of monad transformers. For any monad m, the result t m should also be a monad, and lift should be a monad transformation from m to t m, i.e. it should satisfy the following laws:

• lift . return = return

• lift (m >>= f) = lift m >>= (lift . f)

Since 0.6.0.0 and for GHC 8.6 and later, the requirement that t m be a Monad is enforced by the implication constraint forall m. Monad m => Monad (t m) enabled by the QuantifiedConstraints extension.

Ambiguity error with GHC 9.0 to 9.2.2

(MonadTrans t, forall m. Monad m => Monad (t m)) => ...

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftMn f x1 x2 ... xn