Repository F# setup

open System
open System.Net.Http
open System.Threading
open System.Threading.Tasks
open Axial
open Axial.HttpClient
open Axial.PlatformService

Responses And Errors

The Response Transcript

Every exchange produces a complete HttpResponse. The examples on this page run against a scripted service that replies with fixed statuses and bodies:

Show page setup

// Setup for the checked examples on this page.
open System
open Axial
open Axial.HttpClient
/// Fails the docs test when an example's result differs from the value shown.
let shouldEqual expected actual =
    if actual <> expected then failwithf "Expected %A but got %A" expected actual

Verified

open Axial.HttpClient.DSL

type User = { Id: int; Name: string }

type TestEnv =
    { Http: IHttp }
    interface IHasHttp with
        member this.Http = this.Http

/// A hand-written decoder for {"id":1,"name":"Ada"}; a JSON library's decoder fits the same signature.
let decodeUser (json: string) : Result<User, string> =
    let found = Text.RegularExpressions.Regex.Match(json, """^\{"id":(\d+),"name":"([^"]*)"\}$""")

    if found.Success then Ok { Id = int found.Groups[1].Value; Name = found.Groups[2].Value }
    else Error $"not a user: {json}"

/// A double that replies with one fixed status/body and records the requests it received.
/// The multi-reply scripted double used by the reliability examples lives in the testing guide.
type RecordingHttp(status: int, body: string) =
    let sent = ResizeArray<HttpRequest>()
    member _.Sent = List.ofSeq sent
    member this.Env : TestEnv = { Http = this }

    interface IHttp with
        member _.Send(request) =
            sent.Add request
            Flow.succeed (Response.create (DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero)) status body)

Axial

HttpClient

Axial.HttpClient.DSL

FsLiveDocsGeneratedPage1_03F7AABF2A94.User

Id: int

int

An abbreviation for the CLI type . Basic Types

Name: string

string

An abbreviation for the CLI type . Basic Types

FsLiveDocsGeneratedPage1_03F7AABF2A94.TestEnv

Http: IHttp

Axial.HttpClient.IHttp

Sends fully described HTTP requests for a concrete host platform.

Axial.HttpClient.IHasHttp

Declares that an environment supplies the HTTP service. Implement this on the environment supplied at the host edge. A workflow that sends requests constrains its environment with 'env :> IHasHttp.

this: TestEnv

Http: TestEnv -> unit -> IHttp

decodeUser: string -> Result<User,string>

json: string

Microsoft.FSharp.Core.FSharpResult`2

Helper type for error handling without exceptions. Choices and Results

found: Text.RegularExpressions.Match

Text

Match: string * string -> Text.RegularExpressions.Match

Searches the specified input string for the first occurrence of the specified regular expression. The string to search for a match. The regular expression pattern to match. An object that contains information about the match. A regular expression parsing error occurred. or is . A time-out occurred. For more information about time-outs, see the Remarks section.

RegularExpressions

System.Text.RegularExpressions.Regex

Represents an immutable regular expression.

Success: bool

Gets a value indicating whether the match is successful. if the match is successful; otherwise, .

Ok

Represents an OK or a Successful result. The code succeeded with a value of 'T.

int: ^T -> int

Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using Int32.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted int int 'A' // evaluates to 65 int 0xff // evaluates to 255 int -10 // evaluates to -10

Groups: Text.RegularExpressions.GroupCollection

Gets a collection of groups matched by the regular expression. The character groups matched by the pattern.

Item: Text.RegularExpressions.Group

Enables access to a member of the collection by integer index. The zero-based index of the collection member to be retrieved. The member of the collection specified by .

Value: string

Gets the captured substring from the input string. The substring that is captured by the match.

Error

Represents an Error or a Failure. The code failed with a value of 'TError representing what went wrong.

FsLiveDocsGeneratedPage1_03F7AABF2A94.RecordingHttp

status: int

body: string

sent: ResizeArray<HttpRequest>

``.ctor``: unit -> unit

Initializes a new instance of the class that is empty and has the default initial capacity.

Axial.HttpClient.HttpRequest

An immutable, fully described HTTP request.

_: RecordingHttp

Sent: RecordingHttp -> unit -> HttpRequest list

Microsoft.FSharp.Collections.ListModule

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

ofSeq: 'T seq -> 'T list

Builds a new list from the given enumerable object. The input sequence. The list of elements from the sequence. let inputs = seq { 1; 2; 5 } inputs |> List.ofSeq Evaluates to [ 1; 2; 5 ]. This is an O(n) operation, where n is the length of the sequence.

this: RecordingHttp

Env: RecordingHttp -> unit -> TestEnv

Send: RecordingHttp -> HttpRequest -> Flow<unit,HttpError,HttpResponse>

request: HttpRequest

Add: HttpRequest -> unit

Adds an object to the end of the . The object to be added to the end of the . The value can be for reference types.

Axial.Flow

succeed: 'value -> Flow<'env,'error,'value>

Same as ok. The value to wrap in a successful flow. A flow that always succeeds with the provided value. let result = Flow.succeed 42 |> Flow.run () // result = Success 42

Axial.HttpClient.ResponseModule

create: DateTimeOffset -> int -> string -> HttpResponse

Creates a synthetic response transcript at an explicit start time, primarily for test fakes. <example><code>Response.create startedAt 200 """{"ok":true}"""</code></example>

``.ctor``: int * int * int * int * int * int * TimeSpan -> unit

Initializes a new instance of the structure using the specified year, month, day, hour, minute, second, and offset. The year (1 through 9999). The month (1 through 12). The day (1 through the number of days in ). The hours (0 through 23). The minutes (0 through 59). The seconds (0 through 59). The time's offset from Coordinated Universal Time (UTC). does not represent whole minutes. is less than one or greater than 9999. -or- is less than one or greater than 12. -or- is less than one or greater than the number of days in . -or- is less than zero or greater than 23. -or- is less than 0 or greater than 59. -or- is less than 0 or greater than 59. -or- is less than -14 hours or greater than 14 hours. -or- The property is earlier than or later than .

System.TimeSpan

Represents a time interval.

Zero: TimeSpan

Represents the zero value. This field is read-only.

Requires & types

Requires: open Axial; open Axial.HttpClient; open System (packages: Axial, Axial.HttpClient)

val decodeUser: string -> Result<User,string>

Verified

let summary : Flow<TestEnv, HttpError, int * string * string option> =
    flow {
        let! response = Http.get "https://api.example.com/users" |> Http.send
        let etag = response |> Response.tryHeader "ETag"   // case-insensitive
        return response.StatusCode, response.Text, etag
    }

summary: Flow<TestEnv,HttpError,(int * string * string option)>

Axial.Flow`3

FsLiveDocsGeneratedPage1_03F7AABF2A94.TestEnv

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

int

An abbreviation for the CLI type . Basic Types

string

An abbreviation for the CLI type . Basic Types

option

The type of optional values. When used from other CLI languages the empty option is the null value. Use the constructors Some and None to create values of this type. Use the values in the Option module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value null to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of null as a value representation. Options

flow: FlowBuilder

The universal flow { } computation expression.

response: HttpResponse

Axial.HttpClient.HttpModule

get: string -> HttpRequest

Creates a GET request. <example><code>Http.get "https://api.example.com/users"</code></example>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

send: HttpRequest -> Flow<'env,HttpError,HttpResponse>

Sends a request and fails with <c>HttpError.Status</c> when the response is outside the expectation. <example><code>request |> Http.send</code></example>

etag: string option

Axial.HttpClient.ResponseModule

tryHeader: string -> HttpResponse -> string option

Finds the first header with the given case-insensitive name. <example><code>response |> Response.tryHeader "ETag"</code></example>

StatusCode: int

The numeric response status code.

Text: string

The response body decoded with the response charset (UTF-8 when unspecified).

Requires & types

Requires: open Axial; open Axial.HttpClient (packages: Axial, Axial.HttpClient)

val summary: Flow<TestEnv,HttpError,(int * string * string option)>

Verified

summary |> Flow.run (RecordingHttp(200, "[]").Env) |> shouldEqual (Exit.Success(200, "[]", None))

summary: Flow<TestEnv,HttpError,(int * string * string option)>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

``.ctor``: int * string -> RecordingHttp

Env: TestEnv

shouldEqual: 'a -> 'a -> unit

Axial.Exit`2

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

Success

The workflow completed successfully.

None

The representation of "No value"

Requires & types

Requires: open Axial (packages: Axial)

response.Duration records how long the exchange took, measured with the service's IClock.

StatusCode, ReasonPhrase, and Headers (response plus content headers, in arrival order).
Body is the exact bytes; Text is decoded with the response charset, defaulting to UTF-8. Neither is redacted, so treat them as sensitive: a body may contain credentials or personal data.
Request is the redacted request line (secret query values and headers are replaced with ***), so the request line is safe to log as-is. Do not log the full transcript without bounding Body/Text.
StartedAt and Duration time the full exchange including body download.

Typed JSON Decoding

Response.json and the fetchJson/Http.getJson terminals take a decoder of type string -> Result<'value, string>. Any JSON library fits that shape:

Verified

let user (userId: int) : Flow<TestEnv, HttpError, User> =
    GET $"https://api.example.com/users/{userId}"
    |> fetchJson decodeUser   // Reified.Schema, Thoth, or hand-written

user: int -> Flow<TestEnv,HttpError,User>

userId: int

int

An abbreviation for the CLI type . Basic Types

Axial.Flow`3

FsLiveDocsGeneratedPage1_03F7AABF2A94.TestEnv

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

FsLiveDocsGeneratedPage1_03F7AABF2A94.User

GET: FormattableString -> HttpRequest

Creates a GET request from an interpolated URL. Every hole is URL-encoded as one value. <example><code>GET $"https://api.example.com/users/{userId}"</code></example>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

fetchJson: (string -> Result<'a,string>) -> HttpRequest -> Flow<'b,HttpError,'a>

Sends the request and decodes the JSON response. <example><code>GET $"{root}/users/{id}" |> fetchJson (Json.deserializeResult codec)</code></example>

decodeUser: string -> Result<User,string>

Requires & types

Requires: open Axial; open Axial.HttpClient; open Axial.HttpClient.DSL (packages: Axial, Axial.HttpClient)

val user: int -> Flow<TestEnv,HttpError,User>

Verified

user 1 |> Flow.run (RecordingHttp(200, """{"id":1,"name":"Ada"}""").Env) |> shouldEqual (Exit.Success { Id = 1; Name = "Ada" })

match user 1 |> Flow.run (RecordingHttp(200, "not json").Env) with
| Exit.Failure(Cause.Fail(HttpError.DecodeFailed _)) -> ()
| other -> failwithf "expected a decode failure, got %A" other

user: int -> Flow<TestEnv,HttpError,User>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

``.ctor``: int * string -> RecordingHttp

Env: TestEnv

shouldEqual: 'a -> 'a -> unit

Axial.Exit`2

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

Success

The workflow completed successfully.

Id: int

Name: string

Failure

The workflow failed due to a specific cause.

Axial.Cause`1

Represents the cause of a failed workflow. The type of the domain-specific failure value.

Fail

An expected domain-specific failure.

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

DecodeFailed

The response body could not be decoded into the requested value.

other: Exit<User,HttpError>

failwithf: Printf.StringFormat<'T,'Result> -> 'T

Print to a string buffer and raise an exception with the given result. Helper printers must return strings. The formatter. The formatted result. See Printf.failwithf (link: ) for examples.

Requires & types

Requires: open Axial; open Axial.HttpClient (packages: Axial, Axial.HttpClient)

A decoder failure becomes HttpError.DecodeFailed(message, response). It carries the full transcript, so the error handler can log the offending payload without re-fetching it.

To POST a value and decode the reply in one step:

Verified

let encodeUser (user: User) = $"{{\"id\":{user.Id},\"name\":\"{user.Name}\"}}"

let created (newUser: User) : Flow<TestEnv, HttpError, User> =
    Http.postJson encodeUser decodeUser "https://api.example.com/users" newUser

encodeUser: User -> string

user: User

FsLiveDocsGeneratedPage1_03F7AABF2A94.User

created: User -> Flow<TestEnv,HttpError,User>

newUser: User

Axial.Flow`3

FsLiveDocsGeneratedPage1_03F7AABF2A94.TestEnv

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

Axial.HttpClient.HttpModule

postJson: ('input -> string) -> (string -> Result<'value,string>) -> string -> 'input -> Flow<'env,HttpError,'value>

Encodes a value as JSON, POSTs it, and decodes the JSON response. <example><code>Http.postJson (Json.serialize codec) (Json.deserializeResult codec) url user</code></example>

decodeUser: string -> Result<User,string>

Requires & types

Requires: open Axial; open Axial.HttpClient (packages: Axial, Axial.HttpClient)

val encodeUser: User -> string

val created: User -> Flow<TestEnv,HttpError,User>

Verified

let service = RecordingHttp(201, """{"id":7,"name":"Ada"}""")
created { Id = 0; Name = "Ada" } |> Flow.run service.Env |> shouldEqual (Exit.Success { Id = 7; Name = "Ada" })
service.Sent |> List.map (Request.plan >> _.Body) |> shouldEqual [ "application/json (22 characters)" ]

service: RecordingHttp

``.ctor``: int * string -> RecordingHttp

created: User -> Flow<TestEnv,HttpError,User>

Id: int

Name: string

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Env: TestEnv

shouldEqual: 'a -> 'a -> unit

Axial.Exit`2

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

Success

The workflow completed successfully.

Sent: HttpRequest list

Microsoft.FSharp.Collections.ListModule

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

map: ('T -> 'U) -> 'T list -> 'U list

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ] This is an O(n) operation, where n is the length of the list.

Axial.HttpClient.RequestModule

plan: HttpRequest -> RequestPlan

Returns a redacted request plan without sending anything. <example><code>Request.plan request</code></example>

(>>): ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3

Compose two functions, the function on the left being applied first The first function to apply. The second function to apply. The composition of the input functions. let addOne x = x + 1 let doubleIt x = x * 2 let addThenDouble = addOne >> doubleIt addThenDouble 3 // Evaluates to 8

_arg1: RequestPlan

Body: string

Requires & types

Requires: open Axial; open Axial.HttpClient (packages: Axial, Axial.HttpClient)

val service: RecordingHttp

One Error Type

HTTP failures are cases of HttpError. Handle the cases your workflow can recover from, and fall back to HttpError.describe for the rest:

Verified

let explain (error: HttpError) =
    match error with
    | HttpError.Status response -> $"status {response.StatusCode}"              // outside the expectation, full transcript
    | HttpError.DecodeFailed(message, _) -> $"unexpected body: {message}"       // did not decode, full transcript
    | other -> HttpError.describe other

explain: HttpError -> string

error: HttpError

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

Status

The response arrived with a status outside the request's expectation.

response: HttpResponse

DecodeFailed

The response body could not be decoded into the requested value.

message: string

other: HttpError

Axial.HttpClient.HttpErrorModule

describe: HttpError -> string

Formats an HTTP error with its redacted request context. <example><code>error |> HttpError.describe</code></example>

Requires & types

Requires: open Axial.HttpClient (packages: Axial.HttpClient)

val explain: HttpError -> string

Verified

match user 1 |> Flow.run (RecordingHttp(503, "").Env) with
| Exit.Failure(Cause.Fail error) -> explain error |> shouldEqual "status 503"
| other -> failwithf "expected a status error, got %A" other

user: int -> Flow<TestEnv,HttpError,User>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

``.ctor``: int * string -> RecordingHttp

Env: TestEnv

Axial.Exit`2

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

Failure

The workflow failed due to a specific cause.

Axial.Cause`1

Represents the cause of a failed workflow. The type of the domain-specific failure value.

Fail

An expected domain-specific failure.

error: HttpError

explain: HttpError -> string

shouldEqual: 'a -> 'a -> unit

other: Exit<User,HttpError>

failwithf: Printf.StringFormat<'T,'Result> -> 'T

Print to a string buffer and raise an exception with the given result. Helper printers must return strings. The formatter. The formatted result. See Printf.failwithf (link: ) for examples.

Requires & types

Requires: open Axial (packages: Axial)

Interrupting the workflow is not one of them: the request is abandoned and the flow ends with Cause.Interrupt, so no error handler has to recognize a cancellation it did not ask for.

The full six-case union, together with HttpError.describe, HttpError.tryResponse, HttpError.isTransient, and HttpError.transientRetry, is listed in the HttpError reference.

Statuses Are Data, Not Exceptions

Http.send fails with HttpError.Status for anything outside the request's expectation (2xx by default). When a "failure" status is a normal outcome, widen the expectation and branch on the code:

Verified

let findUser (userId: int) : Flow<TestEnv, HttpError, User option> =
    flow {
        let! response =
            GET $"https://api.example.com/users/{userId}"
            |> expect [ 200; 404 ]
            |> fetch
        if response.StatusCode = 404 then return None
        else return! response |> Response.json decodeUser |> Result.map Some
    }

findUser: int -> Flow<TestEnv,HttpError,User option>

userId: int

int

An abbreviation for the CLI type . Basic Types

Axial.Flow`3

FsLiveDocsGeneratedPage1_03F7AABF2A94.TestEnv

Axial.HttpClient.HttpError

A recoverable HTTP transport, timeout, status, or decoding failure.

FsLiveDocsGeneratedPage1_03F7AABF2A94.User

option

flow: FlowBuilder

The universal flow { } computation expression.

response: HttpResponse

GET: FormattableString -> HttpRequest

Creates a GET request from an interpolated URL. Every hole is URL-encoded as one value. <example><code>GET $"https://api.example.com/users/{userId}"</code></example>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

expect: int seq -> HttpRequest -> HttpRequest

Replaces the statuses treated as success. <example><code>request |> expect [ 200; 404 ]</code></example>

fetch: HttpRequest -> Flow<'a,HttpError,HttpResponse>

Sends the request and returns the full transcript, failing on unexpected statuses. <example><code>GET $"{root}/users" |> fetch</code></example>

StatusCode: int

The numeric response status code.

(=): 'T -> 'T -> bool

Structural equality The first parameter. The second parameter. The result of the comparison. 5 = 5 // Evaluates to true 5 = 6 // Evaluates to false [1; 2] = [1; 2] // Evaluates to true (1, 5) = (1, 6) // Evaluates to false

None

The representation of "No value"

Axial.HttpClient.ResponseModule

json: (string -> Result<'value,string>) -> HttpResponse -> Result<'value,HttpError>

Decodes the response body with the supplied decoder, mapping failure to <c>HttpError.DecodeFailed</c>. <example><code>response |> Response.json (Json.deserializeResult codec)</code></example>

decodeUser: string -> Result<User,string>

Microsoft.FSharp.Core.ResultModule

Contains operations for working with values of type . Choices and Results

map: ('T -> 'U) -> Result<'T,'TError> -> Result<'U,'TError>

map f inp evaluates to match inp with Error e -> Error e | Ok x -> Ok (f x). A function to apply to the OK result value. The input result. A result of the input value after applying the mapping function, or Error if the input is Error. Ok 1 |> Result.map (fun x -> "perfect") // evaluates to Ok "perfect" Error "message" |> Result.map (fun x -> "perfect") // evaluates to Error "message"

Some

The representation of "Value of type 'T" The input value. An option representing the value.

Requires & types

Requires: open Axial; open Axial.HttpClient; open Axial.HttpClient.DSL (packages: Axial, Axial.HttpClient)

val findUser: int -> Flow<TestEnv,HttpError,User option>

Verified

findUser 9 |> Flow.run (RecordingHttp(404, "").Env) |> shouldEqual (Exit.Success None)
findUser 1 |> Flow.run (RecordingHttp(200, """{"id":1,"name":"Ada"}""").Env) |> shouldEqual (Exit.Success(Some { Id = 1; Name = "Ada" }))

findUser: int -> Flow<TestEnv,HttpError,User option>

(|>): 'T1 -> ('T1 -> 'U) -> 'U

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Axial.Flow

run: 'env -> Flow<'env,'error,'value> -> Exit<'value,'error>

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

``.ctor``: int * string -> RecordingHttp

Env: TestEnv

shouldEqual: 'a -> 'a -> unit

Axial.Exit`2

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

Success

The workflow completed successfully.

None

The representation of "No value"

Some

The representation of "Value of type 'T" The input value. An option representing the value.

Id: int

Name: string

Requires & types

Requires: open Axial (packages: Axial)

Http.sendResult skips status interpretation entirely and returns whatever arrived; use it when a proxy or health check needs the raw exchange.

When Not To Decode

fetchText and fetchBytes return the body directly for HTML scraping, file downloads, and pass-through proxying. Use fetchJson only when the payload should become a typed value; decoding a body you will immediately re-serialize wastes the transcript you already have.

Responses And Errors

The Response Transcript

Typed JSON Decoding

One Error Type

Statuses Are Data, Not Exceptions

When Not To Decode

Overview

Docs

API Reference