FSharp.FIO.WebSockets 0.4.0-beta

FIO.WebSockets

WebSockets for FIO. Open connections, send frames, and pattern match on incoming messages as composable effects — connections are scoped and released for you, and failures surface as a typed WsError rather than raw exceptions.

• Client — WebSocketClient.connectDefault opens a connection (dispose it with use!), or withConnectionString scopes it and closes it for you
• Server — WebSocketServer.start / acceptDefault / close for manual control, or WebSocketServer.serve / acceptLoop to run a handler per connection, stopping the listener when interrupted; accepted sockets expose the peer's RemoteEndPoint and the LocalEndPoint
• Typed messages — match on Frame(Text …) / Frame(Binary …) / ConnectionClosed
• Custom codecs — send and receive typed payloads

Install

dotnet add package FSharp.FIO.WebSockets

Quick Start

open FIO.DSL
open FIO.WebSockets
open FIO.WebSockets.WebSocketExtensions

let client = fio {
    use! ws = WebSocketClient.connectDefault "ws://localhost:8080/ws"
    do! ws.SendString "Hello, server!"
    return! ws.ReceiveString()
}

Server

open FIO.DSL
open FIO.WebSockets

let server = fio {
    let! listener = WebSocketServer.start "http://localhost:8080/ws/"
    let! webSocket = WebSocketServer.acceptDefault listener WebSocketConfig.defaultConfig

    match! webSocket.ReceiveMessage() with
    | Frame(Text text) -> do! webSocket.SendText $"echo: {text}"
    | _ -> do! WebSocketServer.close listener
}

Errors

Operations fail with a typed WsError; each case says what went wrong, so a receive loop can decide without inspecting messages:

WsError.fromException / WsError.toException bridge raw exceptions. A chat-style loop that stops on close and skips malformed messages is a CatchAll away:

socket.Receive(codec).Map(Message).CatchAll(function
    | Closed _ -> FIO.succeed PeerClosed
    | CodecError reason -> FIO.succeed (Unreadable reason)
    | error -> FIO.fail error)

Closing

withConnection and acceptLoop close the socket for you, but only when it can still complete the closing handshake. Interrupting a fiber that is blocked in ReceiveMessage — losing a race, Stop() — aborts the connection instead. For a graceful close while a reader is pending, call Close from another fiber first: it closes the outgoing side, and the pending receive then observes the peer's close frame as ConnectionClosed.

The handshake waits for the peer's close frame, so Close is bounded by SendTimeout like a send: a peer that has stopped reading makes it fail with TimeoutError and the connection is aborted, instead of holding the finalizer — and with it an app's shutdown — open indefinitely.

Links

Examples · FIO core · MIT