Streamly.Data.Stream.MkType

Create a type with a zip-like applicative.

>>> expr <- runQ (mkZipType "ZipStream" "zipApply" False)>>> putStrLn $ pprint exprnewtype ZipStream m a    = ZipStream (Stream.Stream m a)    deriving FoldablemkZipStream :: Stream.Stream m a -> ZipStream m amkZipStream = ZipStreamunZipStream :: ZipStream m a -> Stream.Stream m aunZipStream (ZipStream strm) = strmderiving 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 exprnewtype Parallel m a = Parallel (Stream.Stream m a)mkParallel :: Stream.Stream m a -> Parallel m amkParallel = ParallelunParallel :: Parallel m a -> Stream.Stream m aunParallel (Parallel strm) = strminstance 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)}

Parsing of Strings, producing values.

Derived instances of Read make the following assumptions, which derived instances of Text.Show.Show obey:

• If the constructor is defined to be an infix operator, then the derived Read instance will parse only infix applications of the constructor (not the prefix form).

• Associativity is not used to reduce the occurrence of parentheses, although precedence may be.

• If the constructor is defined using record syntax, the derived Read will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.

• The derived Read instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Read in Haskell 2010 is equivalent to

instance (Read a) => Read (Tree a) where

        readsPrec d r =  readParen (d > app_prec)
                         (\r -> [(Leaf m,t) |
                                 ("Leaf",s) <- lex r,
                                 (m,t) <- readsPrec (app_prec+1) s]) r

                      ++ readParen (d > up_prec)
                         (\r -> [(u:^:v,w) |
                                 (u,s) <- readsPrec (up_prec+1) r,
                                 (":^:",t) <- lex s,
                                 (v,w) <- readsPrec (up_prec+1) t]) r

          where app_prec = 10
                up_prec = 5

Note that right-associativity of :^: is unused.

The derived instance in GHC is equivalent to

instance (Read a) => Read (Tree a) where

        readPrec = parens $ (prec app_prec $ do
                                 Ident "Leaf" <- lexP
                                 m <- step readPrec
                                 return (Leaf m))

                     +++ (prec up_prec $ do
                                 u <- step readPrec
                                 Symbol ":^:" <- lexP
                                 v <- step readPrec
                                 return (u :^: v))

          where app_prec = 10
                up_prec = 5

        readListPrec = readListPrecDefault

Why do both readsPrec and readPrec exist, and why does GHC opt to implement readPrec in derived Read instances instead of readsPrec? The reason is that readsPrec is based on the ReadS type, and although ReadS is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.

readPrec, on the other hand, is based on a much more efficient ReadPrec datatype (a.k.a "new-style parsers"), but its definition relies on the use of the RankNTypes language extension. Therefore, readPrec (and its cousin, readListPrec) are marked as GHC-only. Nevertheless, it is recommended to use readPrec instead of readsPrec whenever possible for the efficiency improvements it brings.

As mentioned above, derived Read instances in GHC will implement readPrec instead of readsPrec. The default implementations of readsPrec (and its cousin, readList) will simply use readPrec under the hood. If you are writing a Read instance by hand, it is recommended to write it like so:

instance Read T where
  readPrec     = ...
  readListPrec = readListPrecDefault

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

These versions of GHC have a bug (https://gitlab.haskell.org/ghc/ghc/-/issues/20582) which causes constraints like

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

to be reported as ambiguous. For transformers 0.6 and later, this can be fixed by removing the second constraint, which is implied by the first.

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

Examples

>>> fmap (+1) (Identity 0)Identity 1

>>> Identity [1, 2, 3] <> Identity [4, 5, 6]Identity [1,2,3,4,5,6]

>>> do
      x <- Identity 10
      y <- Identity (x + 5)
      pure (x + y)
Identity 25

The IsList class and its methods are intended to be used in conjunction with the OverloadedLists extension.

IsString is used in combination with the -XOverloadedStrings language extension to convert the literals to different string types.

For example, if you use the text package, you can say

{-# LANGUAGE OverloadedStrings  #-}

myText = "hello world" :: Text

Internally, the extension will convert this to the equivalent of

myText = fromString @Text ("hello world" :: String)

Note: You can use fromString in normal code as well, but the usual performance/memory efficiency problems with String apply.

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

liftM<n> f x1 x2 ... xn

Examples

>>> pure (\x y z -> x + y * z) `ap` Just 1 `ap` Just 5 `ap` Just 10Just 51