Module

Pipes.Core

#runEffect

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

#runEffectRec

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

#respond

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

#composeResponse'

composeResponse' :: forall m x x' a a' b b' c c'. 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')

#(/>/)

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

#composeResponse

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

#(//>)

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

#request

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

#composeRequest'

composeRequest' :: forall a a' b b' c c' y y' m. 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)

#(\>\)

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

#composeRequest

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

#(>\\)

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

#push

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

#composePush

composePush :: forall _a a a' b b' c c' m r. 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)

#(>~>)

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

#composePush'

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

#(>>~)

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

#pull

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

#composePull

composePull :: forall a a' b b' c c' _c' m r. 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)

#(>+>)

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

#composePull'

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

#(+>>)

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

#reflect

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

#Effect

type Effect :: (Type -> Type) -> Type -> Typetype Effect = Proxy X Unit Unit X

#Producer

type Producer :: Type -> (Type -> Type) -> Type -> Typetype Producer b = Proxy X Unit Unit b

#Pipe

type Pipe :: Type -> Type -> (Type -> Type) -> Type -> Typetype Pipe a b = Proxy Unit a Unit b

#Consumer

type Consumer :: Type -> (Type -> Type) -> Type -> Typetype Consumer a = Proxy Unit a Unit X

#Client

type Client :: Type -> Type -> (Type -> Type) -> Type -> Typetype Client a' a = Proxy a' a Unit X

#Server

type Server :: Type -> Type -> (Type -> Type) -> Type -> Typetype Server b' b = Proxy X Unit b' b

#Effect_

type Effect_ :: (Type -> Type) -> Type -> Typetype Effect_ m r = forall x' x y' y. Proxy x' x y' y m r

#Producer_

type Producer_ :: Type -> (Type -> Type) -> Type -> Typetype Producer_ b m r = forall x' x. Proxy x' x Unit b m r

#Consumer_

type Consumer_ :: Type -> (Type -> Type) -> Type -> Typetype Consumer_ a m r = forall y' y. Proxy Unit a y' y m r

#Client_

type Client_ :: Type -> Type -> (Type -> Type) -> Type -> Typetype Client_ a' a m r = forall y' y. Proxy a' a y' y m r

#Server_

type Server_ :: Type -> Type -> (Type -> Type) -> Type -> Typetype Server_ b' b m r = forall x' x. Proxy x' x b' b m r

#flippedComposeResponse'

flippedComposeResponse' :: forall m x x' a a' b b' c c'. 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

#(\<\)

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

#flippedComposeRequest'

flippedComposeRequest' :: forall a a' b b' c c' y y' m. 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

#(/</)

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

#flippedComposePush

flippedComposePush :: forall a a' b b' c c' m r. 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

#(<~<)

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

#flippedComposePush'

flippedComposePush' :: forall a a' b b' c c' m r. 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

#(~<<)

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

#flippedComposePull

flippedComposePull :: forall a a' b b' c c' m r. 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

#(<+<)

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

#flippedComposePull'

flippedComposePull' :: forall a a' b b' c c' m r. 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

#(<<+)

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

#flippedComposeResponse

flippedComposeResponse :: forall m x x' a' b b' c c'. 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

#(<\\)

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

#flippedComposeRequest

flippedComposeRequest :: forall a a' b b' c y y' m. 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

#(//<)

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

Re-exports from Pipes.Internal

#X

newtype X

#Proxy

data Proxy :: Type -> Type -> Type -> Type -> (Type -> Type) -> Type -> Typedata Proxy a' a b' b m r

Instances

#closed

closed :: forall a. X -> a

Modules