🥮 mooncakes.io
    Sign in

    moonbitstack/moonapi/socket does not have a README file

    WsHandler

    source
    type WsHandler = async (WebSocket) -> Unit

    A WebSocket route's handler (← FastAPI's @app.websocket endpoint).

    Disconnected

    source
    pub(all) suberror Disconnected {
      Disconnected(code~ : Int, reason~ : String?)
    } derive(Eq, 
    Debug    )

    The peer left: its close code and reason (← Starlette's WebSocketDisconnect). receive raises it; a handler that lets it propagate simply ends.

    Disconnected::equal

    source

    Disconnected::not_equal

    source
    fn Disconnected::not_equal(x : Disconnected, y : Disconnected) -> Bool

    Disconnected::to_repr

    source

    WebSocket

    source
    pub struct WebSocket {
      scope : 
    WebSocketScope
      params : Map[String, String]
      // private fields
    }

    A WebSocket connection as a handler sees it.

    WebSocket::accept

    source
    async fn WebSocket::accept(self : WebSocket, subprotocol? : String, headers? : Array[(String, String)]) -> Unit

    Take the connect, then accept with subprotocol and extra headers on the handshake.

    WebSocket::close

    source
    async fn WebSocket::close(self : WebSocket, code? : Int, reason? : String) -> Unit

    Close with code and reason. Before accept this declines the handshake, which a server answers with 403.

    WebSocket::header

    source
    fn WebSocket::header(self : WebSocket, name : String) -> String?

    The first request header named name (lowercase, as ASGI carries them).

    WebSocket::new

    source

    A WebSocket over an ASGI connection. The app makes one per connection; a driver of its own makes one over its receive and send.

    WebSocket::offered_subprotocols

    source
    fn WebSocket::offered_subprotocols(self : WebSocket) -> Array[String]

    The subprotocols the client offered, in its order of preference.

    WebSocket::param

    source
    fn WebSocket::param(self : WebSocket, name : String) -> String?

    A path parameter by name.

    WebSocket::receive

    source
    async fn WebSocket::receive(self : WebSocket) -> WsMessage

    The next message. Raises Disconnected when the peer has left.

    WebSocket::receive_bytes

    source
    async fn WebSocket::receive_bytes(self : WebSocket) -> Bytes

    The next message, which must be binary; a text message is taken as its UTF-8.

    WebSocket::receive_json

    source
    async fn WebSocket::receive_json(self : WebSocket) -> Json

    The next message parsed as JSON.

    WebSocket::receive_text

    source
    async fn WebSocket::receive_text(self : WebSocket) -> String

    The next message, which must be text; a binary message is taken as its UTF-8.

    WebSocket::send

    source
    async fn WebSocket::send(self : WebSocket, message : WsMessage) -> Unit

    Send message.

    WebSocket::send_bytes

    source
    async fn WebSocket::send_bytes(self : WebSocket, bytes : Bytes) -> Unit

    Send a binary message.

    WebSocket::send_json

    source
    async fn WebSocket::send_json(self : WebSocket, value : Json) -> Unit

    Send value serialised as a text message.

    WebSocket::send_text

    source
    async fn WebSocket::send_text(self : WebSocket, text : String) -> Unit

    Send a text message.

    WsMessage

    source
    pub(all) enum WsMessage {
      WsText(String)
      WsBinary(Bytes)
    } derive(Eq, 
    Debug    )

    One WebSocket message: text or binary.

    WsMessage::equal

    source
    fn WsMessage::equal(WsMessage, WsMessage) -> Bool

    WsMessage::not_equal

    source
    fn WsMessage::not_equal(x : WsMessage, y : WsMessage) -> Bool

    WsMessage::to_repr

    source

    WsRoute

    source
    pub(all) struct WsRoute {
      path : String
      handler : async (WebSocket) -> Unit
    }

    A registered WebSocket route.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io