module

Std.Http

104 public declarations

allowsBody&Std.Http.Status -> Bool
Whether a status is defined to carry no body, whatever the headers say.
fn
base64Str -> Str
Text encoded as base64, without line breaks.
fn
basicAuthStr -> Str -> Str
A user name and password written as a basic authorization value.
fn
bearerAuthStr -> Str
A bearer token written as an authorization value.
fn
contentLength&Array[(Str, Str)] -> Option[Int]
The length a `content-length` header reports, or `None`.
fn
Cookie
A cookie as a request carries it: a name and a value.
type
endToEnd&Array[(Str, Str)] -> Array[(Str, Str)]
The headers a proxy may forward, with the connection's own removed.
fn
expectsBody&Std.Http.Method -> Bool
Whether a method carries a body describing what to do.
fn
hasHeader&Array[(Str, Str)] -> Str -> Bool
Whether a header is present.
fn
header&Array[(Str, Str)] -> Str -> Option[Str]
The first value given for a header, matched without regard to case.
fn
headerAcceptStr
The header names the protocol defines, so a caller never spells one wrong.
fn
headerAcceptCharsetStr
The character sets a client will accept.
fn
headerAcceptEncodingStr
The content codings a client will accept, such as gzip.
fn
headerAcceptLanguageStr
The languages a client prefers.
fn
headerAcceptRangesStr
The range units a server accepts, or `none`.
fn
headerAgeStr
How long a cached response has been held, in seconds.
fn
headerAllowStr
The methods a resource supports.
fn
headerAuthorizationStr
The client's credentials for the request.
fn
headerCacheControlStr
How the response may be cached, and for how long.
fn
headerConnectionStr
Options for this connection only, such as `close`.
fn
headerContentEncodingStr
The codings applied to the body, in the order applied.
fn
headerContentLanguageStr
The languages the body is intended for.
fn
headerContentLengthStr
The length of the body in bytes.
fn
headerContentLocationStr
Where the body can be found on its own.
fn
headerContentRangeStr
Which part of the whole this body is.
fn
headerContentTypeStr
The media type of the body, and its character set.
fn
headerCookieStr
Cookies the client is sending back.
fn
headerDateStr
When the message was produced.
fn
headerETagStr
A tag identifying this version of the resource.
fn
headerExpectStr
What the client requires the server to support.
fn
headerExpiresStr
When the response stops being fresh.
fn
headerHostStr
The host and port the request is addressed to.
fn
headerIfMatchStr
Act only if the resource matches one of these tags.
fn
headerIfModifiedSinceStr
Act only if the resource changed after this time.
fn
headerIfNoneMatchStr
Act only if the resource matches none of these tags.
fn
headerIfRangeStr
Send the range only if the resource is unchanged.
fn
headerIfUnmodifiedSinceStr
Act only if the resource has not changed since this time.
fn
headerLastModifiedStr
When the resource last changed.
fn
headerLocationStr
Where to go instead, or where a new resource was created.
fn
headerOriginStr
The origin the request was made from.
fn
headerPragmaStr
Directives kept for caches that predate `cache-control`.
fn
headerRangeStr
The part of the resource the client is asking for.
fn
headerRefererStr
The page the request was made from.
fn
headerRetryAfterStr
How long to wait before asking again.
fn
headerServerStr
What software answered the request.
fn
headerSetCookieStr
A cookie for the client to store and send back.
fn
headerTransferEncodingStr
The codings applied for transfer, such as `chunked`.
fn
headerUpgradeStr
Other protocols the sender would rather speak.
fn
headerUserAgentStr
What software made the request.
fn
headerValues&Array[(Str, Str)] -> Str -> Array[Str]
Every value given for a header.
fn
headerVaryStr
Which request headers a cached response depends on.
fn
headerWwwAuthenticateStr
How the client should authenticate.
fn
isCacheable&Std.Http.Method -> Bool
Whether a response to a method may be kept and used again.
fn
isChunked&Array[(Str, Str)] -> Bool
Whether a message says its body is sent in chunks.
fn
isClientError&Std.Http.Status -> Bool
Whether a status blames the caller.
fn
isError&Std.Http.Status -> Bool
Whether a status reports any kind of failure.
fn
isHopByHopStr -> Bool
Whether a header belongs to one connection rather than to the message.
fn
isIdempotent&Std.Http.Method -> Bool
Whether repeating a method has the same effect as sending it once.
fn
isInformational&Std.Http.Status -> Bool
Whether a status reports a provisional response.
fn
isRedirect&Std.Http.Status -> Bool
Whether a status asks the caller to look elsewhere.
fn
isSafe&Std.Http.Method -> Bool
Whether a method is defined to have no effect on the server.
fn
isServerError&Std.Http.Status -> Bool
Whether a status blames the server.
fn
isSuccess&Std.Http.Status -> Bool
Whether a status reports success.
fn
keepsAlive&Std.Http.Version -> Bool
Whether a version keeps the connection open unless told otherwise.
fn
keepsMethodOnRedirect&Std.Http.Status -> Bool
The status a redirect answers with, and whether the method must be kept.
fn
mediaType&Array[(Str, Str)] -> Option[Str]
The media type a `content-type` header names, without its parameters.
fn
Method
A request method.
type
methodFromStr -> Std.Http.Method
The method a name stands for, or the fallback when it names none.
fn
methodName&Std.Http.Method -> Str
A method written the way the protocol writes it.
fn
negotiateStr -> &Array[Str] -> Option[Str]
The first offered choice the caller will accept, or `None`.
fn
parseAuthStr -> Option[(Str, Str)]
The scheme and the credentials an authorization header carries.
fn
parseCookiesStr -> Array[Std.Http.Cookie]
Every cookie a `cookie` header carries.
fn
parseFormStr -> Array[(Str, Str)]
A form body read back into fields.
fn
parsePreferencesStr -> Array[Std.Http.Preference]
An `accept`-style header read into choices, best first.
fn
parseRangesStr -> Array[Std.Http.Range]
The ranges a `range` header asks for, or nothing when it asks for none.
fn
Preference
One offered choice and the weight the caller gave it.
type
Range
A byte range a request asked for: a first position and an optional last.
type
reasonForInt -> Str
The reason phrase that goes with a status code.
fn
redirectTarget&Std.Http.Response -> Option[Str]
The target a redirect names, or `None` when the response is not one.
fn
renderChunkedStr -> Str
A body written as one chunk followed by the terminator.
fn
renderContentRangeInt -> Int -> Int -> Str
A `content-range` header value for a range of a known total length.
fn
renderCookies&Array[Std.Http.Cookie] -> Str
Cookies written as a `cookie` header value.
fn
renderForm&Array[(Str, Str)] -> Str
A form body written as `application/x-www-form-urlencoded`.
fn
renderHead&Std.Http.Request -> Str
A request written as the protocol writes it, without a body.
fn
renderSetCookie&Std.Http.SetCookie -> Str
A cookie written as a `set-cookie` header value.
fn
renderStatusLine&Std.Http.Status -> Str
A response's first line, as the protocol writes it.
fn
requestStd.Http.Method -> Str -> Std.Http.Request
A request with a method and a target and nothing else.
fn
Request
A request, with nothing about how it will be sent.
type
requestBytes&Std.Http.Request -> Bytes
A request's body as bytes, with a byte body taking precedence over the text
fn
Response
A response, with nothing about how it arrived.
type
responseBytes&Std.Http.Response -> Bytes
The body as bytes, with a binary body taking precedence over the text one.
fn
setCookieStr -> Str -> Std.Http.SetCookie
A cookie with only a name and a value, and the safe attributes set.
fn
SetCookie
The attributes a response attaches when it sets a cookie.
type
setHeader&Array[(Str, Str)] -> Str -> Str -> Array[(Str, Str)]
Headers with every value for a name removed, then one added.
fn
statusInt -> Std.Http.Status
A status built from its number, with the reason the protocol gives.
fn
Status
A response status: its number and the reason given with it.
type
Version
The protocol version a message was written in.
type
versionFromStr -> Std.Http.Version
The protocol version a name stands for.
fn
versionName&Std.Http.Version -> Str
A version written the way the protocol writes it.
fn
withBody&Std.Http.Request -> Str -> Std.Http.Request
A request with a text body, and the length header that goes with it.
fn
withBytes&Std.Http.Request -> &Bytes -> Std.Http.Request
A request carrying exact bytes as its body, and the length header that goes
fn
withForm&Std.Http.Request -> &Array[(Str, Str)] -> Std.Http.Request
A request with a form body and the headers that describe it.
fn
withHeader&Std.Http.Request -> Str -> Str -> Std.Http.Request
A request with one header added, keeping any it already had.
fn
withJson&Std.Http.Request -> Str -> Std.Http.Request
A request with a JSON body and the headers that describe it.
fn