Pipes.Core

type Effect = Proxy X Unit Unit X

type Producer b = Proxy X Unit Unit b

type Pipe a b = Proxy Unit a Unit b

type Consumer a = Proxy Unit a Unit X

type Client a' a = Proxy a' a Unit X

type Server b' b = Proxy X Unit b' b

type Effect_ m r = forall y y' x x'. Proxy x' x y' y m r

type Producer_ b m r = forall x x'. Proxy x' x Unit b m r

type Consumer_ a m r = forall y y'. Proxy Unit a y' y m r

type Server_ b' b m r = forall x x'. Proxy x' x b' b m r

type Client_ a' a m r = forall y y'. Proxy a' a y' y m r

runEffect :: forall r m. Monad m => Effect m r -> m r

runEffectRec :: forall r m. MonadRec m => Effect m r -> m r

respond :: forall x' x a' a m. Monad m => a -> Proxy x' x a' a m a'

Operator alias for Pipes.Core.composeResponse (left-associative / precedence 4)

Operator alias for Pipes.Core.composeResponse' (right-associative / precedence 4)

Operator alias for Pipes.Core.composeRequest (left-associative / precedence 5)

Operator alias for Pipes.Core.composeRequest' (right-associative / precedence 4)

Operator alias for Pipes.Core.composePull' (right-associative / precedence 6)

Operator alias for Pipes.Core.composePull (left-associative / precedence 7)

Operator alias for Pipes.Core.composePush' (left-associative / precedence 7)

Operator alias for Pipes.Core.composePush (right-associative / precedence 8)

Operator alias for Pipes.Core.flippedComposeResponse' (left-associative / precedence 4)

Operator alias for Pipes.Core.flippedComposeRequest' (right-associative / precedence 4)

Operator alias for Pipes.Core.flippedComposePush (left-associative / precedence 8)

Operator alias for Pipes.Core.flippedComposePull (right-associative / precedence 7)

Operator alias for Pipes.Core.flippedComposeResponse (right-associative / precedence 3)

Operator alias for Pipes.Core.flippedComposeRequest (left-associative / precedence 4)

Operator alias for Pipes.Core.flippedComposePush' (right-associative / precedence 7)

Operator alias for Pipes.Core.flippedComposePull' (left-associative / precedence 6)

composeResponse :: forall c' c b' b a' x' x m. Monad m => Proxy x' x b' b m a' -> (b -> Proxy x' x c' c m b') -> Proxy x' x c' c m a'

composeResponse' :: forall c' c b' b a' a x' x m. Monad m => (a -> Proxy x' x b' b m a') -> (b -> Proxy x' x c' c m b') -> (a -> Proxy x' x c' c m a')

request :: forall m y' y a' a. Monad m => a' -> Proxy a' a y' y m a

composeRequest :: forall m y' y c b' b a' a. Monad m => (b' -> Proxy a' a y' y m b) -> Proxy b' b y' y m c -> Proxy a' a y' y m c

composeRequest' :: forall m y' y c' c b' b a' a. Monad m => (b' -> Proxy a' a y' y m b) -> (c' -> Proxy b' b y' y m c) -> (c' -> Proxy a' a y' y m c)

pull :: forall r m a' a. Monad m => a' -> Proxy a' a a' a m r

composePull :: forall r m _c' c' c b' b a' a. Monad m => (b' -> Proxy a' a b' b m r) -> (_c' -> Proxy b' b c' c m r) -> (_c' -> Proxy a' a c' c m r)

composePull' :: forall r m c' c b' b a' a. Monad m => (b' -> Proxy a' a b' b m r) -> Proxy b' b c' c m r -> Proxy a' a c' c m r

push :: forall r m a' a. Monad m => a -> Proxy a' a a' a m r

composePush :: forall r m c' c b' b a' a _a. Monad m => (_a -> Proxy a' a b' b m r) -> (b -> Proxy b' b c' c m r) -> (_a -> Proxy a' a c' c m r)

composePush' :: forall r m c' c b' b a' a. Monad m => Proxy a' a b' b m r -> (b -> Proxy b' b c' c m r) -> Proxy a' a c' c m r

reflect :: forall r m b' b a' a. Monad m => Proxy a' a b' b m r -> Proxy b b' a a' m r

flippedComposeResponse' :: forall c' c b' b a' a x' x m. Monad m => (b -> Proxy x' x c' c m b') -> (a -> Proxy x' x b' b m a') -> (a -> Proxy x' x c' c m a')

Equivalent to ('/>/') with the arguments flipped

flippedComposeRequest' :: forall m y' y c' c b' b a' a. Monad m => (c' -> Proxy b' b y' y m c) -> (b' -> Proxy a' a y' y m b) -> (c' -> Proxy a' a y' y m c)

Equivalent to ('>') with the arguments flipped

flippedComposePush :: forall r m c' c b' b a' a. Monad m => (b -> Proxy b' b c' c m r) -> (a -> Proxy a' a b' b m r) -> (a -> Proxy a' a c' c m r)

Equivalent to ('>~>') with the arguments flipped

flippedComposePull :: forall r m c' c b' b a' a. Monad m => (c' -> Proxy b' b c' c m r) -> (b' -> Proxy a' a b' b m r) -> (c' -> Proxy a' a c' c m r)

Equivalent to ('>+>') with the arguments flipped

flippedComposeResponse :: forall c' c b' b a' x' x m. Monad m => (b -> Proxy x' x c' c m b') -> Proxy x' x b' b m a' -> Proxy x' x c' c m a'

Equivalent to ('//>') with the arguments flipped

flippedComposeRequest :: forall m y' y c b' b a' a. Monad m => Proxy b' b y' y m c -> (b' -> Proxy a' a y' y m b) -> Proxy a' a y' y m c

Equivalent to ('>\') with the arguments flipped

flippedComposePush' :: forall r m c' c b' b a' a. Monad m => (b -> Proxy b' b c' c m r) -> Proxy a' a b' b m r -> Proxy a' a c' c m r

Equivalent to ('>>~') with the arguments flipped

flippedComposePull' :: forall r m c' c b' b a' a. Monad m => Proxy b' b c' c m r -> (b' -> Proxy a' a b' b m r) -> Proxy a' a c' c m r

Equivalent to ('+>>') with the arguments flipped

newtype X

data Proxy a' a b' b m r

Instances

• (Monad m) => Functor (Proxy a' a b' b m)
• (Monad m) => Apply (Proxy a' a b' b m)
• (Monad m) => Applicative (Proxy a' a b' b m)
• (Monad m) => Bind (Proxy a' a b' b m)
• (Monad m) => Monad (Proxy a' a b' b m)
• (Monad m, Monoid r) => Monoid (Proxy a' a b' b m r)
• (Monad m, Semigroup r) => Semigroup (Proxy a' a b' b m r)
• MonadTrans (Proxy a' a b' b)
• MFunctor (Proxy a' a b' b)
• MMonad (Proxy a' a b' b)
• (MonadEff e m) => MonadEff e (Proxy a' a b' b m)
• (MonadAff e m) => MonadAff e (Proxy a' a b' b m)
• (MonadIO m) => MonadIO (Proxy a' a b' b m)
• (MonadAsk r m) => MonadAsk r (Proxy a' a b' b m)
• (MonadReader r m) => MonadReader r (Proxy a' a b' b m)
• (MonadState s m) => MonadState s (Proxy a' a b' b m)
• (Monoid w, MonadTell w m) => MonadTell w (Proxy a' a b' b m)
• (Monoid w, MonadWriter w m) => MonadWriter w (Proxy a' a b' b m)
• (MonadPlus m) => Alt (Proxy a' a b' b m)
• (MonadPlus m) => Plus (Proxy a' a b' b m)
• (MonadPlus m) => Alternative (Proxy a' a b' b m)
• (MonadThrow e m) => MonadThrow e (Proxy a' a b' b m)
• (MonadError e m) => MonadError e (Proxy a' a b' b m)
• (Monad m) => MonadRec (Proxy a' a b' b m)

closed :: forall a. X -> a