NetworkFailure

Classifies portable networking failures independently of errno. WouldBlock/InProgress preserve socket ownership and require readiness before retry. Cancelled/TimedOut belong to async operation policy; immediate calls do not manufacture them. Packet truncation is DatagramReceipt.IsTruncated instead.

Module std.net

import std.net;

Public declaration contracts and authored examples. A page can document several related symbols. Implementation bodies are excluded.

NetworkFailure

pub enum NetworkFailure

NetworkFailure.InvalidInput

InvalidInput;

An endpoint, capacity or operation argument violates the contract.

NetworkFailure.Closed

Closed;

The socket has no live close authority, including moved-from state.

NetworkFailure.WouldBlock

WouldBlock;

No immediate progress is available; retain ownership for readiness.

NetworkFailure.InProgress

InProgress;

Connection establishment remains pending.

NetworkFailure.Interrupted

Interrupted;

The one-shot native operation was interrupted.

NetworkFailure.AddressInUse

AddressInUse;

The local endpoint is already occupied.

NetworkFailure.AccessDenied

AccessDenied;

Platform policy refused the operation.

NetworkFailure.ConnectionRefused

ConnectionRefused;

The peer refused connection establishment.

NetworkFailure.ConnectionReset

ConnectionReset;

Peer reset or broken-pipe failure ended transfer.

NetworkFailure.NotConnected

NotConnected;

A required peer attachment is absent.

NetworkFailure.MessageTooLarge

MessageTooLarge;

The selected transport cannot accept this packet size.

NetworkFailure.ResourceUnavailable

ResourceUnavailable;

Native descriptor or memory capacity prevented admission.

NetworkFailure.Unsupported

Unsupported;

The selected capability or family is unavailable.

NetworkFailure.NativeFailure

NativeFailure;

Native failure has no narrower portable identity.

NetworkFailure.Cancelled

Cancelled;

Cancellation ended the async operation according to its progress contract.

NetworkFailure.TimedOut

TimedOut;

The explicit monotonic deadline expired.

NetworkFailure.ClockUnavailable

ClockUnavailable;

Monotonic deadline sampling is unavailable.

Example

module example.socket_deadline;
from std.net import TcpStream, TcpListener, UdpSocket, Endpoint;
from std.time import Deadline, Instant;
from std.task import Task;
async fn Main() -> Task<i32> {
    let Now = switch Instant.TryNow() { case .Ok { Value = Value } => break Value; case .Err => return 1; };
    let Expired: Deadline = .Finite { At = Now };
    var Stream = TcpStream();
    var Listener = TcpListener();
    var Packet = UdpSocket();
    var Output: byte[1] = [0xA1_byte];
    let Input: byte[1] = [0xB2_byte];
    // Match one enum layer at a time while preserving each original fallback.
    switch await Stream.ReadAsync(Output, Expired) {
        case .Err { Error = PatternPayload5105 } => {
            switch PatternPayload5105 {
                case .Failure { Reason = PatternPayload5106, Transferred = Count } => {
                    switch PatternPayload5106 {
                        case .Network { Reason = PatternPayload5107 } if (PatternPayload5107 is .TimedOut) => { if Count != 0 { return 2; } }
                        default => return 3;
                    }
                }
                default => return 3;
            }
        }
        default => return 3;
    }
    switch await Stream.WriteAsync(Input, Expired) {
        case .Err { Error = PatternPayload5108 } => {
            switch PatternPayload5108 {
                case .Failure { Reason = PatternPayload5109 } => {
                    switch PatternPayload5109 {
                        case .Network { Reason = PatternPayload5110 } if (PatternPayload5110 is .TimedOut) => {}
                        default => return 4;
                    }
                }
                default => return 4;
            }
        }
        default => return 4;
    }
    switch await Stream.FlushAsync(Expired) {
        case .Err { Error = PatternPayload5111 } => {
            switch PatternPayload5111 {
                case .Failure { Reason = PatternPayload5112 } => {
                    switch PatternPayload5112 {
                        case .Network { Reason = PatternPayload5113 } if (PatternPayload5113 is .TimedOut) => {}
                        default => return 5;
                    }
                }
                default => return 5;
            }
        }
        default => return 5;
    }
    switch await Listener.AcceptAsync(Expired) {
        case .Err { Error = PatternPayload5114 } => {
            switch PatternPayload5114 {
                case .Failure { Reason = PatternPayload5115 } if (PatternPayload5115 is .TimedOut) => {}
                default => return 6;
            }
        }
        default => return 6;
    }
    switch await TcpStream.ConnectAsync(default(Endpoint), Expired) {
        case .Err { Error = PatternPayload5116 } => {
            switch PatternPayload5116 {
                case .Failure { Reason = PatternPayload5117 } if (PatternPayload5117 is .TimedOut) => {}
                default => return 7;
            }
        }
        default => return 7;
    }
    switch await Packet.SendToAsync(default(Endpoint), Input, Expired) {
        case .Err { Error = PatternPayload5118 } => {
            switch PatternPayload5118 {
                case .Failure { Reason = PatternPayload5119 } if (PatternPayload5119 is .TimedOut) => {}
                default => return 8;
            }
        }
        default => return 8;
    }
    switch await Packet.ReceiveFromAsync(Output, Expired) {
        case .Err { Error = PatternPayload5120 } => {
            switch PatternPayload5120 {
                case .Failure { Reason = PatternPayload5121 } if (PatternPayload5121 is .TimedOut) => {}
                default => return 9;
            }
        }
        default => return 9;
    }
    if Output[0] != 0xA1_byte || !Stream.IsClosed || !Listener.IsClosed || !Packet.IsClosed { return 10; }
    let Invalid: Deadline = .Finite { At = default(Instant) };
    switch await Stream.ReadAsync(Output, Invalid) {
        case .Err { Error = PatternPayload5122 } => {
            switch PatternPayload5122 {
                case .Failure { Reason = PatternPayload5123 } => {
                    switch PatternPayload5123 {
                        case .Network { Reason = PatternPayload5124 } if (PatternPayload5124 is .IncompatibleClockDomain) => {}
                        default => return 11;
                    }
                }
                default => return 11;
            }
        }
        default => return 11;
    }
    let Forever: Deadline = .Endless;
    switch await Stream.ReadAsync(Output, Forever) {
        case .Err { Error = PatternPayload5125 } => {
            switch PatternPayload5125 {
                case .Failure { Reason = PatternPayload5126 } => {
                    switch PatternPayload5126 {
                        case .Network { Reason = PatternPayload5127 } if (PatternPayload5127 is .Closed) => {}
                        default => return 12;
                    }
                }
                default => return 12;
            }
        }
        default => return 12;
    }
    return 0;
}

NetworkFailure.IncompatibleClockDomain

IncompatibleClockDomain;

A finite deadline carries an invalid or incompatible domain.

NetworkFailure.RangeOverflow

RangeOverflow;

The finite deadline exceeds native tick range.

NetworkFailure.NameNotFound

NameNotFound;

Platform resolver found no address in the selected family.

NetworkFailure.TemporaryFailure

TemporaryFailure;

Platform resolution requests a later attempt; no automatic retry.