Hoogle Search

Within LTS Haskell 23.0 (ghc-9.8.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r

   conduit	Data.Conduit

   Combine two Conduits together into a new Conduit (aka fuse). Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded. Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version. Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

   • The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
   • The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
   • Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

2. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r

   conduit	Data.Conduit.Internal

   Combine two Conduits together into a new Conduit (aka fuse). Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded. Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version. Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

   • The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
   • The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
   • Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

3. (.|) :: (b -> c) -> Strategy b -> (a -> b) -> a -> c

   parallel	Control.Parallel.Strategies

   Sequential function composition. The result of the second function is evaluated using the given strategy, and then given to the first function.

4. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => Conduit a b m () -> Conduit b c m r -> Conduit a c m r

   foundation	Foundation.Conduit

   Operator version of fuse.

5. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r

   classy-prelude-conduit	ClassyPrelude.Conduit

   Combine two Conduits together into a new Conduit (aka fuse). Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded. Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version. Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

   • The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
   • The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
   • Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

6. (.|) :: forall (m :: Type -> Type) a b u v c r . Monad m => Pipe a b u m v -> Pipe b c v m r -> Pipe a c u m r

   conduino	Data.Conduino

   The main operator for chaining pipes together. pipe1 .| pipe2 will connect the output of pipe1 to the input of pipe2. Running a pipe will draw from pipe2, and if pipe2 ever asks for input (with await or something similar), it will block until pipe1 outputs something (or signals termination). The structure of a full pipeline usually looks like:

   runPipe $ someSource
   .| somePipe
   .| someOtherPipe
   .| someSink
   

   Where you route a source into a series of pipes, which eventually ends up at a sink. runPipe will then produce the result of that sink.

7. (.|) :: Hex -> Hex -> Hex

   ghci-hexcalc	Data.GHex

   Bitwise "or"

   >>> 0xf000 .| 0xa
   0x0000_0000_0000_f00a
   

8. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r

   stack	Stack.Prelude

   Combine two Conduits together into a new Conduit (aka fuse). Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded. Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version. Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

   • The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
   • The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
   • Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

9. (.|) :: forall (m :: Type -> Type) a b c r . Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r

   classy-prelude-yesod	ClassyPrelude.Yesod

   Combine two Conduits together into a new Conduit (aka fuse). Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded. Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version. Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

   • The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
   • The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
   • Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

10. (.|) :: OnObject o a => o a -> a -> o a

    json-stream	Data.JsonStream.Parser

    Return default value if the parsers on the left hand didn't produce a result.

    p .| defval = p <|> pure defval
    

    The operator works on complete left side, the following statements are equal:

    Record <$>  "key1" .: "nested-key" .: value .| defaultValue
    Record <$> (("key1" .: "nested-key" .: value) .| defaultValue)
    

Page 1 of many | Next