Results for “Std.Net.Connection”

Use module:Std.List, kind:fn, or is:exact. Put a Pudu type after ::.

• Std.Net.Connection

  A connection, open in both directions.

  type · Std.Net
• Std.Http.Server.Stream.finishChunked&Std.Net.Connection -> Int -> Result[(), Std.Net.NetError]

  Emits the HTTP/1.1 chunked terminator frame 0\r\n\r\n.

  fn · Std.Http.Server.Stream
• Std.Http.Server.Stream.sendChunk&Std.Net.Connection -> &Bytes -> Int -> Result[(), Std.Net.NetError]

  Sends a single chunk framed as <hex-length>\r\n<data>\r\n.

  fn · Std.Http.Server.Stream
• Std.Http.Server.Stream.sendHead&Std.Net.Connection -> Int -> &Array[(Str, Str)] -> Int -> Result[(), Std.Net.NetError]

  Sends HTTP status and headers immediately with Transfer-Encoding: chunked.

  fn · Std.Http.Server.Stream
• Std.Http.Server.Stream.streamChunks&Std.Net.Connection -> Int -> &Array[(Str, Str)] -> &Array[Bytes] -> Int -> Result[(), Std.Net.NetError]

  Coordinates complete chunked response delivery over the socket.

  fn · Std.Http.Server.Stream
• Std.Http.Server.serveConnection&Std.Http.Server.Server -> &Std.Net.Connection -> Bool

  Serve one connection: read a request, answer it, and say whether the

  fn · Std.Http.Server
• Std.Net.Read.exactly&Std.Net.Connection -> Int -> Int -> Result[Bytes, Std.Net.NetError]

  Read this many bytes, or fail rather than answer fewer.

  fn · Std.Net.Read
• Std.Net.Read.until&Std.Net.Connection -> &Bytes -> Int -> Int -> Result[(Bytes, Bytes), Std.Net.NetError]

  Read up to and including a separator, within a limit.

  fn · Std.Net.Read
• Std.Net.accept&Std.Net.Listener -> Result[Std.Net.Connection, Std.Net.NetError]

  Wait for the next connection.

  fn · Std.Net
• Std.Net.close&Std.Net.Connection -> Result[(), Std.Net.NetError]

  Close a connection.

  fn · Std.Net
• Std.Net.connectStr -> Int -> Result[Std.Net.Connection, Std.Net.NetError]

  Open a connection to somewhere else.

  fn · Std.Net
• Std.Net.connectWithinStr -> Int -> Int -> Result[Std.Net.Connection, Std.Net.NetError]

  Open a connection, waiting no longer than the stated milliseconds.

  fn · Std.Net
• Std.Net.finish&Std.Net.Connection -> Result[(), Std.Net.NetError]

  Say that nothing more will be sent, while still reading what comes back.

  fn · Std.Net
• Std.Net.foldChunks&Std.Net.Connection -> T -> fn(T, Bytes) -> T -> Result[T, Std.Net.NetError]

  Combine everything a peer sends into one value, holding one chunk at a

  fn · Std.Net
• Std.Net.peerOf&Std.Net.Connection -> Result[Str, Std.Net.NetError]

  Who is at the other end.

  fn · Std.Net
• Std.Net.receive&Std.Net.Connection -> Int -> Result[Option[Bytes], Std.Net.NetError]

  The next bytes, or nothing when the other end has closed.

  fn · Std.Net
• Std.Net.receiveAll&Std.Net.Connection -> Result[Bytes, Std.Net.NetError]

  Everything a peer sends until it closes, joined once rather than once per

  fn · Std.Net
• Std.Net.receiveExactly&Std.Net.Connection -> Int -> Result[Bytes, Std.Net.NetError]

  Read exactly the requested count of bytes, or report that the peer closed

  fn · Std.Net
• Std.Net.receiveUntil&Std.Net.Connection -> &Bytes -> Int -> Result[(Bytes, Bytes), Std.Net.NetError]

  Read until a marker has arrived, answering what came before it and what

  fn · Std.Net
• Std.Net.receiveWithin&Std.Net.Connection -> Int -> Int -> Result[Option[Bytes], Std.Net.NetError]

  Read the next bytes, waiting no longer than the stated milliseconds.

  fn · Std.Net
• Std.Net.send&Std.Net.Connection -> &Bytes -> Result[(), Std.Net.NetError]

  Send bytes, and keep sending until every one has gone.

  fn · Std.Net
• Std.Net.sendText&Std.Net.Connection -> Str -> Result[(), Std.Net.NetError]

  Send text, as its UTF-8 encoding.

  fn · Std.Net
• Std.Net.sendTextWithin&Std.Net.Connection -> Str -> Int -> Result[(), Std.Net.NetError]

  Send text, waiting no longer than the stated milliseconds.

  fn · Std.Net
• Std.Net.sendWithin&Std.Net.Connection -> &Bytes -> Int -> Result[(), Std.Net.NetError]

  Send bytes, waiting no longer than the stated milliseconds.

  fn · Std.Net
• Std.Net.serve&Std.Net.Listener -> Int -> fn(Std.Net.Connection) -> Bool -> Result[Int, Std.Net.NetError]

  Wait for connections, hand each to an action, and close it however the

  fn · Std.Net
• Std.Net.withConnectionStr -> Int -> fn(Std.Net.Connection) -> Result[T, Std.Net.NetError] -> Result[T, Std.Net.NetError]

  Open a connection, hand it to an action, and close it however the action

  fn · Std.Net
• Std.Tls.upgradeWithin&Std.Net.Connection -> Str -> Int -> Result[Std.Tls.Secured, Std.Tls.TlsError]

  Consume a plain connection at an agreed TLS boundary, verifying the host.

  fn · Std.Tls