LanguageExt.Core

LanguageExt.Core ► Effects ► Pipes ► Client

Contents

class Client 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

Methods

method Client<RT, REQ, RES, R> Pure <RT, REQ, RES, R> (R value) Source #

where RT : struct, HasCancel<RT>

Monad return / pure

method Client<RT, REQ, RES, RES> request <RT, REQ, RES> (REQ value) Source #

where RT : struct, HasCancel<RT>

Send a value of type RES downstream and block waiting for a reply of type REQ

respond is the identity of the respond category.

method Client<RT, REQ, RES, R> lift <RT, REQ, RES, R> (Aff<R> ma) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> lift <RT, REQ, RES, R> (Eff<R> ma) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> lift <RT, REQ, RES, R> (Aff<RT, R> ma) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> lift <RT, REQ, RES, R> (Eff<RT, R> ma) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Aff<R> ma) Source #

where RT : struct, HasCancel<RT>
where R : IDisposable

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Eff<R> ma) Source #

where RT : struct, HasCancel<RT>
where R : IDisposable

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Aff<RT, R> ma) Source #

where RT : struct, HasCancel<RT>
where R : IDisposable

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Eff<RT, R> ma) Source #

where RT : struct, HasCancel<RT>
where R : IDisposable

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Aff<R> ma, Func<R, Unit> dispose) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Eff<R> ma, Func<R, Unit> dispose) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Aff<RT, R> ma, Func<R, Unit> dispose) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, R> use <RT, REQ, RES, R> (Eff<RT, R> ma, Func<R, Unit> dispose) Source #

where RT : struct, HasCancel<RT>

Lift am IO monad into the Proxy monad transformer

method Client<RT, REQ, RES, Unit> release <RT, REQ, RES, R> (R dispose) Source #

where RT : struct, HasCancel<RT>

Release a previously used resource

class Client <RT, REQ, RES, A> Source #

where RT : struct, HasCancel<RT>

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

Fields

field Proxy<RT, REQ, RES, Unit, Void, A> Value Source #

Constructors

constructor Client (Proxy<RT, REQ, RES, Unit, Void, A> value) Source #

Constructor

Parameters

param value

Correctly shaped Proxy that represents a Client

Methods

method Proxy<RT, REQ, RES, Unit, Void, A> ToProxy () Source #

Calling this will effectively cast the sub-type 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 Proxy type from a more specialised type

method Proxy<RT, REQ, RES, Unit, Void, S> Bind <S> (Func<A, Proxy<RT, REQ, RES, Unit, Void, S>> 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 Proxy that represents the composition of this Proxy and the result of the bind operation

method Proxy<RT, REQ, RES, Unit, Void, S> Map <S> (Func<A, S> 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 Proxy that represents the composition of this Proxy and the result of the map operation

method Client<RT, REQ, RES, B> Bind <B> (Func<A, Client<RT, REQ, RES, 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 Proxy that represents the composition of this Proxy and the result of the bind operation

method Client<RT, REQ, RES, B> SelectMany <B> (Func<A, Client<RT, REQ, RES, 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 Proxy that represents the composition of this Proxy and the result of the bind operation

method Client<RT, REQ, RES, C> SelectMany <B, C> (Func<A, Client<RT, REQ, RES, 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 Proxy that represents the composition of this Proxy and the result of the bind operation

method Client<RT, REQ, RES, 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 Proxy that represents the composition of this Proxy and the result of the map operation

method Proxy<RT, REQ, RES, C1, C, A> For <C1, C> (Func<Void, Proxy<RT, REQ, RES, C1, C, Unit>> body) Source #

For(body) loops over the Proxy p replacing each yield with body

Parameters

param body

Any yield found in the Proxy will be replaced with this function. It will be composed so that the value yielded will be passed to the argument of the function. That returns a Proxy to continue the processing of the computation

returns

A new Proxy that represents the composition of this Proxy and the function provided

method Proxy<RT, REQ, RES, Unit, Void, S> Action <S> (Proxy<RT, REQ, RES, Unit, Void, S> r) Source #

Applicative action

Invokes this Proxy, then the Proxy r

Parameters

param r

Proxy to run after this one

method Proxy<RT, UOutA, AUInA, Unit, Void, A> PairEachRequestWithRespond <UOutA, AUInA> (Func<REQ, Proxy<RT, UOutA, AUInA, REQ, RES, 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<RT, UOutA, AUInA, Unit, Void, A> ReplaceRequest <UOutA, AUInA> (Func<REQ, Proxy<RT, UOutA, AUInA, Unit, Void, 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<RT, REQ, RES, DInC, DOutC, A> PairEachRespondWithRequest <DInC, DOutC> (Func<Void, Proxy<RT, Unit, Void, DInC, DOutC, 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<RT, REQ, RES, DInC, DOutC, A> ReplaceRespond <DInC, DOutC> (Func<Void, Proxy<RT, REQ, RES, DInC, DOutC, 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<RT, Void, Unit, RES, REQ, A> Reflect () Source #

Reverse the arrows of the Proxy to find its dual.

Parameters

returns

The dual of this

method Proxy<RT, REQ, RES, Unit, Void, 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<RT, REQ, RES, Unit, Void, A> value) Source #

method Client<RT, REQ, RES, B> SelectMany <B> (Func<A, Release<B>> bind) 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 Proxy that represents the composition of this Proxy and the result of the bind operation

method Client<RT, REQ, RES, C> SelectMany <B, C> (Func<A, Release<B>> bind, 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 Proxy that represents the composition of this Proxy and the result of the bind operation

Operators

operator | (Func<REQ, Server<RT, REQ, RES, A>> x, Client<RT, REQ, RES, 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

Server

param y

Client

returns

Effect

operator & ( Client<RT, REQ, RES, A> lhs, Client<RT, REQ, RES, A> rhs) Source #

Chain one client after another