Contents
- Client
- Pure <REQ, RES, M, R> (R value)
- request <REQ, M, RES> (REQ value)
- lift <REQ, RES, M, R> (K<M, R> ma)
- liftIO <REQ, RES, M, R> (IO<R> ma)
- Client <REQ, RES, M, A>
- Value
- Client (Proxy<REQ, RES, Unit, Void, M, A> value)
- ToProxy ()
- Bind <B> (Func<A, Proxy<REQ, RES, Unit, Void, M, B>> f)
- Map <B> (Func<A, B> f)
- MapM <B> (Func<K<M, A>, K<M, B>> f)
- ToIO ()
- Bind <B> (Func<A, Client<REQ, RES, M, B>> f)
- SelectMany <B> (Func<A, Client<REQ, RES, M, B>> f)
- SelectMany <B, C> (Func<A, Client<REQ, RES, M, B>> f, Func<A, B, C> project)
- Select <B> (Func<A, B> f)
- For <C1, C> (Func<Void, Proxy<REQ, RES, C1, C, M, Unit>> body)
- Action <S> (Proxy<REQ, RES, Unit, Void, M, S> r)
- PairEachRequestWithRespond <UOutA, AUInA> (Func<REQ, Proxy<UOutA, AUInA, REQ, RES, M, A>> lhs)
- ReplaceRequest <UOutA, AUInA> (Func<REQ, Proxy<UOutA, AUInA, Unit, Void, M, RES>> lhs)
- PairEachRespondWithRequest <DInC, DOutC> (Func<Void, Proxy<Unit, Void, DInC, DOutC, M, A>> rhs)
- ReplaceRespond <DInC, DOutC> (Func<Void, Proxy<REQ, RES, DInC, DOutC, M, Unit>> rhs)
- Reflect ()
- Observe ()
- Deconstruct (out Proxy<REQ, RES, Unit, Void, M, A> value)
- | (Func<REQ, Server<REQ, RES, M, A>> x, Client<REQ, RES, M, A> y)
- & ( Client<REQ, RES, M, A> lhs, Client<REQ, RES, M, A> rhs)
- ToString ()
Client sends requests of type REQ and receives responses of type RES.
Clients only request and never respond.
Upstream | Downstream
+---------+
| |
REQ <== <== Unit
| |
RES ==> ==> Void
| | |
+----|----+
|
A
Methods
method Client<REQ, RES, M, R> Pure <REQ, RES, M, R> (R value) Source #
Monad return / pure
method Client<REQ, RES, M, RES> request <REQ, M, RES> (REQ value) Source #
Send a value of type RES downstream and block waiting for a reply of type REQ
respond is the identity of the respond category.
record Client <REQ, RES, M, A> Source #
Client sends requests of type REQ and receives responses of type RES.
Clients only request and never respond.
Upstream | Downstream
+---------+
| |
REQ <== <== Unit
| |
RES ==> ==> Void
| | |
+----|----+
|
A
Constructors
Methods
method Proxy<REQ, RES, Unit, Void, M, A> ToProxy () Source #
Calling this will effectively cast the subtype to the base.
This type wraps up a Proxy for convenience, and so it's a Proxy proxy. So calling this method
isn't exactly the same as a cast operation, as it unwraps the Proxy from within. It has the same effect
however, and removes a level of indirection
Parameters
| returns | A general | |
method Proxy<REQ, RES, Unit, Void, M, B> Bind <B> (Func<A, Proxy<REQ, RES, Unit, Void, M, B>> f) Source #
Monadic bind operation, for chaining Proxy computations together.
Parameters
| type | B | The mapped bound value type |
| param | f | The bind function |
| returns | A new | |
method Proxy<REQ, RES, Unit, Void, M, B> Map <B> (Func<A, B> f) Source #
Lifts a pure function into the Proxy domain, causing it to map the bound value within
Parameters
| type | B | The mapped bound value type |
| param | f | The map function |
| returns | A new | |
method Proxy<REQ, RES, Unit, Void, M, B> MapM <B> (Func<K<M, A>, K<M, B>> f) Source #
Map the lifted monad
Parameters
| type | B | The mapped bound value type |
| param | f | The map function |
| returns | A new | |
method Proxy<REQ, RES, Unit, Void, M, IO<A>> ToIO () Source #
Extract the lifted IO monad (if there is one)
Parameters
| param | f | The map function |
| returns | A new | |
method Client<REQ, RES, M, B> Bind <B> (Func<A, Client<REQ, RES, M, B>> f) Source #
Monadic bind operation, for chaining Client computations together.
Parameters
| type | B | The mapped bound value type |
| param | f | The bind function |
| returns | A new | |
method Client<REQ, RES, M, B> SelectMany <B> (Func<A, Client<REQ, RES, M, B>> f) Source #
Monadic bind operation, for chaining Client computations together.
Parameters
| type | B | The mapped bound value type |
| param | f | The bind function |
| returns | A new | |
method Client<REQ, RES, M, C> SelectMany <B, C> (Func<A, Client<REQ, RES, M, B>> f, Func<A, B, C> project) Source #
Monadic bind operation, for chaining Client computations together.
Parameters
| type | B | The mapped bound value type |
| param | f | The bind function |
| returns | A new | |
method Client<REQ, RES, M, B> Select <B> (Func<A, B> f) Source #
Lifts a pure function into the Proxy domain, causing it to map the bound value within
Parameters
| type | B | The mapped bound value type |
| param | f | The map function |
| returns | A new | |
method Proxy<REQ, RES, C1, C, M, A> For <C1, C> (Func<Void, Proxy<REQ, RES, C1, C, M, Unit>> body) Source #
For(body) loops over the Proxy p replacing each yield with body
Parameters
| param | body | Any |
| returns | A new | |
method Proxy<REQ, RES, Unit, Void, M, S> Action <S> (Proxy<REQ, RES, Unit, Void, M, S> r) Source #
Applicative action
Invokes this Proxy, then the Proxy r
Parameters
| param | r |
|
method Proxy<UOutA, AUInA, Unit, Void, M, A> PairEachRequestWithRespond <UOutA, AUInA> (Func<REQ, Proxy<UOutA, AUInA, REQ, RES, M, A>> lhs) Source #
Used by the various composition functions and when composing proxies with the | operator. You usually
wouldn't need to call this directly, instead either pipe them using | or call Proxy.compose(lhs, rhs)
(f +>> p) pairs each 'request' in this with a 'respond' in lhs.
method Proxy<UOutA, AUInA, Unit, Void, M, A> ReplaceRequest <UOutA, AUInA> (Func<REQ, Proxy<UOutA, AUInA, Unit, Void, M, RES>> lhs) Source #
Used by the various composition functions and when composing proxies with the | operator. You usually
wouldn't need to call this directly, instead either pipe them using | or call Proxy.compose(lhs, rhs)
method Proxy<REQ, RES, DInC, DOutC, M, A> PairEachRespondWithRequest <DInC, DOutC> (Func<Void, Proxy<Unit, Void, DInC, DOutC, M, A>> rhs) Source #
Used by the various composition functions and when composing proxies with the | operator. You usually
wouldn't need to call this directly, instead either pipe them using | or call Proxy.compose(lhs, rhs)
method Proxy<REQ, RES, DInC, DOutC, M, A> ReplaceRespond <DInC, DOutC> (Func<Void, Proxy<REQ, RES, DInC, DOutC, M, Unit>> rhs) Source #
Used by the various composition functions and when composing proxies with the | operator. You usually
wouldn't need to call this directly, instead either pipe them using | or call Proxy.compose(lhs, rhs)
method Proxy<Void, Unit, RES, REQ, M, A> Reflect () Source #
Reverse the arrows of the Proxy to find its dual.
Parameters
| returns | The dual of | |
method Proxy<REQ, RES, Unit, Void, M, A> Observe () Source #
Observe(lift (Pure(r))) = Observe(Pure(r))
Observe(lift (m.Bind(f))) = Observe(lift(m.Bind(x => lift(f(x)))))
This correctness comes at a small cost to performance, so use this function sparingly. This function is a convenience for low-level pipes implementers. You do not need to use observe if you stick to the safe API.
method void Deconstruct (out Proxy<REQ, RES, Unit, Void, M, A> value) Source #
Operators
operator | (Func<REQ, Server<REQ, RES, M, A>> x, Client<REQ, RES, M, A> y) Source #
Compose a Server and a Client together into an Effect. Note the Server is provided as a function
that takes a value of REQ. This is how we model the request coming into the Server. The resulting
Server computation can then call Server.respond(response) to reply to the Client.
The Client simply calls Client.request(req) to post a request to the Server, it is like an awaiting
that also posts. It will await the response from the Server.
Parameters
| param | x |
|
| param | y |
|
| returns |
| |