Hoogle Search

Within LTS Haskell 22.18 (ghc-9.6.4)

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

  1. (.|) :: 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. (.|) :: 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. (.|) :: Monad m => Conduit a b m () -> Conduit b c m r -> Conduit a c m r

    foundation Foundation.Conduit

    Operator version of fuse.

  5. (.|) :: Strategy a -> Strategy a -> Strategy a

    LambdaHack Game.LambdaHack.Client.AI.Strategy

    Strategy with the actions from both argument strategies, with original frequencies.

  6. (.|) :: 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.

  7. (.|) :: 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.

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

    ghci-hexcalc Data.GHex

    Bitwise "or" 

    >>> 0xf000 .| 0xa
0x0000_0000_0000_f00a

  9. (.|) :: Operator (null 'PGtsquery) (null 'PGtsquery) (null 'PGtsquery)

    squeal-postgresql Squeal.PostgreSQL.Expression.TextSearch

    OR tsquerys together

  10. (.|) :: 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.

Page 1 of many | Next