Std.Net

25 public declarations

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

  Wait for the next connection.

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

  Close a connection.

  fn
• closeListener&Std.Net.Listener -> Result[(), Std.Net.NetError]

  Stop listening.

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

  Open a connection to somewhere else.

  fn
• Connection

  A connection, open in both directions.

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

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

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

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

  fn
• 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
• listenStr -> Int -> Result[Std.Net.Listener, Std.Net.NetError]

  Wait for connections on a port.

  fn
• Listener

  An endpoint waiting for connections.

  type
• listenLocalInt -> Result[Std.Net.Listener, Std.Net.NetError]

  Wait for connections reachable only from this machine.

  fn
• NetError

  Why an operation over the network did not do what it was asked.

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

  Who is at the other end.

  fn
• portOf&Std.Net.Listener -> Result[Int, Std.Net.NetError]

  Which port a listener is actually on.

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

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

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

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

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

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

  fn
• 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
• receiveWithin&Std.Net.Connection -> Int -> Int -> Result[Option[Bytes], Std.Net.NetError]

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

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

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

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

  Send text, as its UTF-8 encoding.

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

  Send text, waiting no longer than the stated milliseconds.

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

  Send bytes, waiting no longer than the stated milliseconds.

  fn
• 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
• 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