silk/http_fetch

Profiles: aarch64-apple-darwin, aarch64-unknown-linux-gnu, aarch64-unknown-linux-gnu-no-libc, wasm32-unknown-unknown, x86_64-unknown-linux-gnu, x86_64-unknown-linux-gnu-no-libc.

Bounded one-shot HTTP delivery over redirects, content decoding, routing, and pooling.

When to use

Use the toSink* operations for sequential external delivery, collect* for bounded atomic in-memory results, and discard* for explicit bounded validation without retaining a body. Select the suffix matching the request body's replay authority.

Details

Fetch owns no transport policy. A FetchClient supplies routed or pooled attempts under one unchanged deadline, silk.http_redirect owns redirect and source authority, and silk.http_client owns response framing and content provenance. Every public destination is finite, and every completed result owns the metadata that outlives the live response.

Import as Fetch with import silk.http_fetch { Fetch }.

Public declarations: 30.

`PoolMode`

pub enum PoolMode

Whether connection acquisition may use the compatible pool retained by the client context.

`UseContextPool`

UseContextPool = 0

Uses a compatible context pool when present and otherwise opens a fresh connection.

`Fresh`

Fresh = 1

Always opens a fresh connection and never checks out or publishes through a pool.

`ProxyMode`

pub enum ProxyMode

Whether acquisition uses configured routing or bypasses it for this operation.

`InheritContext`

InheritContext = 0

Recomputes only the explicit client-context proxy policy for every redirect origin.

`Direct`

Direct = 1

Uses direct routing without environment lookup.

`FetchPhase`

pub enum FetchPhase

The one-shot operation phase associated with bounded fetch-owned context.

`Uri`

Uri = 0

Semantic URI admission or copying.

`Route`

Route = 1

Per-origin route selection.

`Connect`

Connect = 2

Pool checkout, resolution, connection, or TLS acquisition.

`Request`

Request = 3

Request preparation or upload.

`Redirect`

Redirect = 4

Redirect policy and intermediate-response handling.

`Head`

Head = 5

Final response-head selection or copying.

`Decode`

Decode = 6

Content selection, decoding, framing, or trailer validation.

`Destination`

Destination = 7

Sink, collection, or discard delivery.

`Finish`

Finish = 8

Explicit response completion and reuse decision.

`FetchLimit`

pub enum FetchLimit

The independent finite fetch resource that rejected a value.

`EncodedBodyBytes`

EncodedBodyBytes = 0

Deframed representation input accepted by the content layer.

`DeliveredBodyBytes`

DeliveredBodyBytes = 1

Representation bytes successfully accepted by the destination.

`OwnedMetadataBytes`

OwnedMetadataBytes = 2

URI, head, and trailer payload plus owned index storage.

`BufferedBytes`

BufferedBytes = 3

The positive scratch buffer used for response delivery.

`CollectionBytes`

CollectionBytes = 4

Bytes retained by a collection destination.

`DiscardBytes`

DiscardBytes = 5

Bytes validated by a discard destination.

`FetchContentReason`

pub union FetchContentReason

An owned isomorphic form of a content failure whose unsupported token cannot borrow the head.

`InvalidLimit`

FetchContentReason.InvalidLimit { limit: ContentLimitKind, allowed: u64, attempted: u64 }: FetchContentReason

A content configuration or byte count exceeds its admitted range.

Field `limit`

pub limit: ContentLimitKind

The rejected configuration or byte class.

Field `allowed`

pub allowed: u64

The applicable maximum.

Field `attempted`

pub attempted: u64

The rejected value or count.

`CodingSyntax`

FetchContentReason.CodingSyntax { position: CodingPosition }: FetchContentReason

A Content-Encoding element is empty or malformed.

Field `position`

pub position: CodingPosition

The exact location of the invalid token or byte.

`UnsupportedCoding`

FetchContentReason.UnsupportedCoding { position: CodingPosition, token: Bytes }: FetchContentReason

A valid coding name has no selected decoder; the exact token is independently owned.

Field `position`

pub position: CodingPosition

The token position in the original response.

Field `token`

pub token: Bytes

An owned copy of the exact unsupported token.

`PartialResponse`

FetchContentReason.PartialResponse { position: CodingPosition }: FetchContentReason

A partial response selected a nonidentity decoder.

Field `position`

pub position: CodingPosition

The first nonidentity coding in wire order.

`Tunnel`

FetchContentReason.Tunnel: FetchContentReason

The response body is a protocol tunnel rather than a representation.

`Body`

FetchContentReason.Body { error: BodyError }: FetchContentReason

HTTP framing rejected the response body.

Field `error`

pub error: BodyError

The original body error, including committed wire progress.

`Buffer`

FetchContentReason.Buffer { error: BufferError }: FetchContentReason

Buffered input or its transport failed.

Field `error`

pub error: BufferError

The original buffer error and its transport cause.

`Inflate`

FetchContentReason.Inflate { stage: usize, wireIndex: usize, error: DecodeError }: FetchContentReason

Gzip or zlib decoding failed.

Field `stage`

pub stage: usize

The zero-based reverse application stage.

Field `wireIndex`

pub wireIndex: usize

The original coding position in wire order.

Field `error`

pub error: DecodeError

The exact inflate failure and decoder-call progress.

`Zstandard`

FetchContentReason.Zstandard { stage: usize, wireIndex: usize, error: ZstdError }: FetchContentReason

Zstandard decoding failed.

Field `stage`

pub stage: usize

The zero-based reverse application stage.

Field `wireIndex`

pub wireIndex: usize

The original coding position in wire order.

Field `error`

pub error: ZstdError

The exact Zstandard failure and decoder-call progress.

`TrailingEncodedData`

FetchContentReason.TrailingEncodedData { stage: usize, wireIndex: usize }: FetchContentReason

A finished coding stream had additional encoded bytes.

Field `stage`

pub stage: usize

The zero-based reverse application stage.

Field `wireIndex`

pub wireIndex: usize

The original coding position in wire order.

`ArithmeticOverflow`

FetchContentReason.ArithmeticOverflow: FetchContentReason

Checked content accounting overflowed.

`InvalidState`

FetchContentReason.InvalidState: FetchContentReason

The content reader was already failed or abandoned.

`FetchContentError`

pub struct FetchContentError

Exact owned content-failure coordinates safe to return after the response head is released.

Field `reason`

pub reason: FetchContentReason

The owned failure category and original lower-level cause.

Field `written`

pub written: usize

Bytes written into the current provisional output chunk.

Field `totalEncoded`

pub totalEncoded: u64

Cumulative deframed encoded bytes accepted.

Field `totalIntermediate`

pub totalIntermediate: u64

Cumulative nonfinal decoder-stage output.

Field `totalDecoded`

pub totalDecoded: u64

Cumulative selected-representation output.

`FetchReason`

pub union FetchReason

A fetch-owned admission, limit, or unsupported-response reason.

`InvalidOptions`

FetchReason.InvalidOptions: FetchReason

One or more finite options are inconsistent or outside their admitted domain.

`InvalidHttpOptions`

FetchReason.InvalidHttpOptions { error: ClientError }: FetchReason

The supplied HTTP connection limits failed their owning client's pre-contact admission.

Field `error`

pub error: ClientError

The client's original pre-contact admission failure.

`HttpValue`

FetchReason.HttpValue { error: ValueError }: FetchReason

HTTP value copying failed while Fetch owned the final-head boundary.

Field `error`

pub error: ValueError

The original HTTP value validation or copying failure.

`HttpBody`

FetchReason.HttpBody { error: BodyError }: FetchReason

HTTP body or trailer validation failed after final-response selection.

Field `error`

pub error: BodyError

The original body or trailer validation failure.

`HttpClient`

FetchReason.HttpClient { error: ClientError }: FetchReason

The streaming client failed inside Fetch's final-response delivery boundary.

Field `error`

pub error: ClientError

The original final-response client failure.

`SizeOverflow`

FetchReason.SizeOverflow: FetchReason

Checked accounting cannot represent the required total.

`DestinationRejected`

FetchReason.DestinationRejected: FetchReason

A caller-defined sink rejected the current offered chunk.

`Content`

FetchReason.Content { error: FetchContentError }: FetchReason

Content selection failed; borrowed coding tokens are copied into bounded owned storage.

Field `error`

pub error: FetchContentError

The owned content failure, including coding coordinates and byte totals.

`LimitExceeded`

FetchReason.LimitExceeded { limit: FetchLimit, allowed: u64, attempted: u64 }: FetchReason

One independent finite resource would exceed its inclusive limit.

Field `limit`

pub limit: FetchLimit

The resource whose bound was reached.

Field `allowed`

pub allowed: u64

The inclusive admitted maximum.

Field `attempted`

pub attempted: u64

The rejected cumulative value.

`UnsupportedSwitchingResponse`

FetchReason.UnsupportedSwitchingResponse { status: Status }: FetchReason

The final response would require transferring duplex protocol authority.

Field `status`

pub status: Status

The final protocol-switching or successful CONNECT status.

`FetchError`

pub struct FetchError

Safe independently owned failure context added by the one-shot boundary.

Field `phase`

pub phase: FetchPhase

The operation phase that rejected the value or observed the failure.

Field `reason`

pub reason: FetchReason

The stable fetch-owned failure category.

Field `status`

pub status: silk/option.Option<silk/http.Status>

Final status when it is known without retaining the response owner.

Field `uri`

pub uri: silk/option.Option<silk/uri.OwnedUri>

Independently copied current URI when bounded context is available.

Field `deliveredBodyBytes`

pub deliveredBodyBytes: u64

Bytes accepted by the destination before the failing operation.

Field `offeredBodyBytes`

pub offeredBodyBytes: usize

Current chunk length offered to a failing destination, otherwise zero.

`DestinationFailure`

pub struct DestinationFailure<E>

A typed sink failure paired with only fetch-known delivery progress.

Field `error`

pub error: E

The original caller-defined sink failure.

Field `context`

pub context: FetchError

Bounded destination context excluding claims about partial external effects.

`RepresentationMetadata`

pub struct RepresentationMetadata

Representation policy selected from the final wire response.

Field `applied`

pub applied: AppliedPlan

The exact applied Raw or Decode plan and coding counts.

Field `completed`

pub completed: bool

Whether framing and every selected content stage completed successfully.

Field `deliveredBytes`

pub deliveredBytes: silk/option.Option<u64>

Final delivered representation bytes, available only after completion.

`ResponseMetadata`

pub struct ResponseMetadata

Immutable owned header-only metadata lent before each body chunk.

Field `finalUri`

pub finalUri: OwnedUri

The independently owned final URI.

Field `head`

pub head: OwnedResponseHead

The independently owned final status, reason, and ordered wire headers.

Field `representation`

pub representation: RepresentationMetadata

Content-plan provenance separate from unchanged wire headers.

Field `ownedBytes`

pub ownedBytes: usize

Counted URI and head payload plus owned index storage.

`FetchResult`

pub struct FetchResult

One verified completed response without retained body bytes.

Field `metadata`

pub metadata: ResponseMetadata

Final owned header metadata.

Field `trailers`

pub trailers: silk/option.Option<silk/http_body.OwnedTrailers>

Final ordered trailers copied only after content completion.

Field `redirectCount`

pub redirectCount: usize

Number of redirects followed before this response.

Field `encodedBodyBytes`

pub encodedBodyBytes: u64

Deframed encoded representation bytes accepted by the content layer.

Field `deliveredBodyBytes`

pub deliveredBodyBytes: u64

Representation bytes successfully accepted by the destination.

Field `ownedMetadataBytes`

pub ownedMetadataBytes: usize

URI, head, and trailer payload plus owned index storage.

`CollectedResponse`

pub struct CollectedResponse

One atomically published bounded in-memory response.

Field `result`

pub result: FetchResult

The verified completed response metadata and counters.

Field `body`

pub body: Bytes

The complete selected representation body.

`FetchRequest`

pub struct FetchRequest<'uri, 'method, 'headers, 'policy>

A semantic request whose body authority is supplied by one source-specific operation.

Associated function `FetchRequest.make`

pub fn make<'uri, 'method, 'headers, 'policy>(uri: silk/uri.Uri<'uri>, method: silk/http.Method<'method>, headers: silk/http_headers.Headers<'headers>, headerPolicy: silk/http_request.HeaderPolicy<'policy>, version: Version, continuePolicy: ContinuePolicy, limits: HeaderLimits, maxHeadBytes: usize, maxCredentialBytes: usize) -> FetchRequest<'uri, 'method, 'headers, 'policy>

Constructs a semantic request while preserving its explicit method and ordered headers.

Associated function `FetchRequest.get`

pub fn get<'uri, 'method, 'headers, 'policy>(uri: silk/uri.Uri<'uri>) -> FetchRequest<'uri, 'method, 'headers, 'policy>

Constructs GET with empty caller headers and the standard request policy and limits.

`FetchOptions`

pub struct FetchOptions

Finite one-shot policies admitted before route selection or transport contact.

Field `redirect`

pub redirect: RedirectPolicy

Redirect policy, including Manual or Follow behavior and intermediate-response bounds.

Field `content`

pub content: ContentMode

Raw or decoded representation selection.

Field `pool`

pub pool: PoolMode

Compatible context-pool or forced-fresh acquisition.

Field `proxy`

pub proxy: ProxyMode

Explicit client-context routing or forced direct routing.

Field `deadline`

pub deadline: silk/option.Option<silk/system_clock.Instant>

One optional absolute operation deadline, never renewed between phases or hops.

Field `http`

pub http: ClientLimits

Existing finite HTTP parser, framing, trailer, and transport-buffer limits.

Field `contentLimits`

pub contentLimits: ContentLimits

Existing finite content planning and codec limits.

Field `maxEncodedBodyBytes`

pub maxEncodedBodyBytes: u64

Additional inclusive encoded representation allowance.

Field `maxDeliveredBodyBytes`

pub maxDeliveredBodyBytes: u64

Inclusive representation bytes accepted by any destination.

Field `maxOwnedMetadataBytes`

pub maxOwnedMetadataBytes: usize

Inclusive owned URI, head, and trailer payload-plus-index allowance.

Field `maxBufferedBytes`

pub maxBufferedBytes: usize

Positive per-read response delivery scratch capacity.

Associated function `FetchOptions.defaults`

pub fn defaults() -> FetchOptions

Returns Manual, Raw, context-pool, inherited-route policy with finite standard limits.

Method `FetchOptions.validate`

pub fn validate<'life0>(self: &'life0 FetchOptions) -> silk/result.Result<(), silk/http_fetch.FetchError>

Checks local capacities and content configuration without allocation or provider access.

`Fetch`

pub struct Fetch<C>

An owned target-neutral facade around one explicit acquisition context.

Associated function `Fetch.make`

pub fn make<C>(client: C) -> silk/http_fetch.Fetch<C>

Seals one caller-supplied client context into a fetch facade.

`Sink`

pub interface Sink<E, ?R>

A sequential effectful destination whose metadata and current chunk loans cannot escape.

Operation `write`

effect<'call> fn write<'call: 'call, 'life3: 'call>(sink: &'life3 mut Self, metadata: &'call silk/http_fetch.ResponseMetadata, chunk: &'call [u8], deadline: &'call silk/option.Option<silk/system_clock.Instant>) -> () ! E ? R

Accepts the complete offered chunk under the unchanged operation deadline.

Details

deadline is the original absolute fetch deadline. None permits an unbounded wait. The callback must return before Fetch reads or offers another chunk.

`FetchClient`

pub interface FetchClient<'policy, RoutedP, DirectP, A, HandlerError, AcquisitionError, ?HandlerRequirements, ?AcquisitionRequirements>

Target-neutral routed or pooled acquisition for one current redirect attempt.

Details

Implementations admit options before contact, recompute routes for the current request URI, and lend exactly one scoped exchange. deadline is the unchanged operation deadline. Fresh never consults a pool, and Direct never consults configured or ambient proxy policy.

Operation `withAttempt`

effect<'env> fn withAttempt<'life8: 'env, 'env>(client: &'life8 mut Self, request: silk/http_redirect.AttemptRequest<'policy>, httpLimits: ClientLimits, poolMode: PoolMode, proxyMode: ProxyMode, deadline: silk/option.Option<silk/system_clock.Instant>) -> A ! HandlerError | AcquisitionError ? HandlerRequirements | AcquisitionRequirements | &mut silk/http_redirect.HybridAttempt<'policy, RoutedP, DirectP, A, HandlerError, ? HandlerRequirements> where HandlerRequirements in Without<HandlerRequirements, &ByteDuplex>, HandlerRequirements in Without<HandlerRequirements, &HttpTransport>

Rebuilds and drives one scoped request under the selected acquisition modes.

`toSinkEmpty`

pub effect<'env> fn toSinkEmpty<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, SinkError, AcquisitionError, ?SinkRequirements, ?AcquisitionRequirements, S: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, options: FetchOptions, sink: S) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | silk/http_fetch.DestinationFailure<SinkError> | ClientError | OutOfMemoryError | AcquisitionError ? SinkRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, SinkRequirements in Without<SinkRequirements, &ByteDuplex>, SinkRequirements in Without<SinkRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a body-free request and sequentially offers the selected representation to sink.

`collectEmpty`

pub effect<'env> fn collectEmpty<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, AcquisitionError, ?AcquisitionRequirements, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, options: FetchOptions, maxBodyBytes: usize) -> CollectedResponse ! RedirectError | FetchError | ValueError | BodyError | ClientError | OutOfMemoryError | AcquisitionError ? AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a body-free request and atomically publishes a bounded in-memory body.

`discardEmpty`

pub effect<'env> fn discardEmpty<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, AcquisitionError, ?AcquisitionRequirements, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, options: FetchOptions, maxDiscardBytes: u64) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | ClientError | OutOfMemoryError | AcquisitionError ? AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a body-free request and validates an explicitly bounded discarded representation.

`toSinkBytes`

pub effect<'env> fn toSinkBytes<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, 'bytes: 'env, RoutedP, DirectP, SinkError, AcquisitionError, ?SinkRequirements, ?AcquisitionRequirements, S: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, bytes: &'bytes [u8], options: FetchOptions, sink: S) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | silk/http_fetch.DestinationFailure<SinkError> | ClientError | OutOfMemoryError | AcquisitionError ? SinkRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, SinkRequirements in Without<SinkRequirements, &ByteDuplex>, SinkRequirements in Without<SinkRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a repeatable byte-body request and sequentially offers the selected representation.

`collectBytes`

pub effect<'env> fn collectBytes<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, 'bytes: 'env, RoutedP, DirectP, AcquisitionError, ?AcquisitionRequirements, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, bytes: &'bytes [u8], options: FetchOptions, maxBodyBytes: usize) -> CollectedResponse ! RedirectError | FetchError | ValueError | BodyError | ClientError | OutOfMemoryError | AcquisitionError ? AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a repeatable byte-body request and atomically publishes a bounded body.

`discardBytes`

pub effect<'env> fn discardBytes<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, 'bytes: 'env, RoutedP, DirectP, AcquisitionError, ?AcquisitionRequirements, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, bytes: &'bytes [u8], options: FetchOptions, maxDiscardBytes: u64) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | ClientError | OutOfMemoryError | AcquisitionError ? AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a repeatable byte-body request and validates bounded discarded content.

`toSinkOneShot`

pub effect<'env> fn toSinkOneShot<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, ProducerError, SinkError, AcquisitionError, ?ProducerRequirements, ?SinkRequirements, ?AcquisitionRequirements, Producer: 'env, S: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, producer: Producer, options: FetchOptions, sink: S) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | ProducerError | silk/http_fetch.DestinationFailure<SinkError> | ClientError | OutOfMemoryError | AcquisitionError ? ProducerRequirements | SinkRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, SinkRequirements in Without<SinkRequirements, &ByteDuplex>, SinkRequirements in Without<SinkRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes an affine producer request and sequentially offers the selected representation.

`collectOneShot`

pub effect<'env> fn collectOneShot<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, ProducerError, AcquisitionError, ?ProducerRequirements, ?AcquisitionRequirements, Producer: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, producer: Producer, options: FetchOptions, maxBodyBytes: usize) -> CollectedResponse ! RedirectError | FetchError | ValueError | BodyError | ProducerError | ClientError | OutOfMemoryError | AcquisitionError ? ProducerRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes an affine producer request and atomically publishes a bounded body.

`discardOneShot`

pub effect<'env> fn discardOneShot<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, ProducerError, AcquisitionError, ?ProducerRequirements, ?AcquisitionRequirements, Producer: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, producer: Producer, options: FetchOptions, maxDiscardBytes: u64) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | ProducerError | ClientError | OutOfMemoryError | AcquisitionError ? ProducerRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes an affine producer request and validates bounded discarded content.

`toSinkReplay`

pub effect<'env> fn toSinkReplay<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, FactoryError, ProducerError, SinkError, AcquisitionError, ?FactoryRequirements, ?ProducerRequirements, ?SinkRequirements, ?AcquisitionRequirements, Factory: 'env, Producer, S: 'env, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, factory: Factory, options: FetchOptions, sink: S) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | FactoryError | ProducerError | silk/http_fetch.DestinationFailure<SinkError> | ClientError | OutOfMemoryError | AcquisitionError ? FactoryRequirements | ProducerRequirements | SinkRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, FactoryRequirements in Without<FactoryRequirements, &ByteDuplex>, FactoryRequirements in Without<FactoryRequirements, &HttpTransport>, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, SinkRequirements in Without<SinkRequirements, &ByteDuplex>, SinkRequirements in Without<SinkRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a replay-factory request and sequentially offers the selected representation.

`collectReplay`

pub effect<'env> fn collectReplay<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, FactoryError, ProducerError, AcquisitionError, ?FactoryRequirements, ?ProducerRequirements, ?AcquisitionRequirements, Factory: 'env, Producer, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, factory: Factory, options: FetchOptions, maxBodyBytes: usize) -> CollectedResponse ! RedirectError | FetchError | ValueError | BodyError | FactoryError | ProducerError | ClientError | OutOfMemoryError | AcquisitionError ? FactoryRequirements | ProducerRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, FactoryRequirements in Without<FactoryRequirements, &ByteDuplex>, FactoryRequirements in Without<FactoryRequirements, &HttpTransport>, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a replay-factory request and atomically publishes a bounded body.

`discardReplay`

pub effect<'env> fn discardReplay<'fetch: 'env, 'uri: 'env, 'method: 'env, 'headers: 'env, 'policy: 'env, RoutedP, DirectP, FactoryError, ProducerError, AcquisitionError, ?FactoryRequirements, ?ProducerRequirements, ?AcquisitionRequirements, Factory: 'env, Producer, C: 'env, 'env>(fetch: &'fetch mut silk/http_fetch.Fetch<C>, request: silk/http_fetch.FetchRequest<'uri, 'method, 'headers, 'policy>, factory: Factory, options: FetchOptions, maxDiscardBytes: u64) -> FetchResult ! RedirectError | FetchError | ValueError | BodyError | FactoryError | ProducerError | ClientError | OutOfMemoryError | AcquisitionError ? FactoryRequirements | ProducerRequirements | AcquisitionRequirements | &mut MonotonicClock | &mut Allocator | &mut Random where &mut RoutedP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &HttpTransport from &mut HttpTransport, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock | &mut Allocator | &mut Random, &mut RoutedP provides &ByteDuplex from &mut ByteDuplex, &mut DirectP provides &HttpTransport from &mut HttpTransport | &mut MonotonicClock | &mut Allocator | &mut Random, &mut DirectP provides &HttpTransport from &mut HttpTransport, FactoryRequirements in Without<FactoryRequirements, &ByteDuplex>, FactoryRequirements in Without<FactoryRequirements, &HttpTransport>, ProducerRequirements in Without<ProducerRequirements, &ByteDuplex>, ProducerRequirements in Without<ProducerRequirements, &HttpTransport>, AcquisitionRequirements in Without<AcquisitionRequirements, &ByteDuplex>, AcquisitionRequirements in Without<AcquisitionRequirements, &HttpTransport>

Executes a replay-factory request and validates bounded discarded content.

silk/http_fetch

On this page