package riot

You can search for identifiers within the package.

in-package search v0.2.0

package riot

riot
- Riot
  - Application
    
    Intf
  - Gen_server
    
    Impl
  - Logger
    
    Intf
    
    Make
    
    _
    
    Namespace
  - Message
  - Net
    
    Addr
    
    Socket
  - Pid
  - Process
    
    Messages
  - Queue
  - Ref
  - Supervisor
  - Telemetry
  - Timer
riot.core
- Core
  - Mailbox
  - Message
  - Pid
  - Proc_effect
  - Proc_queue
  - Proc_registry
    
    Exn
  - Proc_set
  - Proc_state
  - Proc_table
  - Process
    
    Messages
  - Ref
  - Scheduler_uid
riot.lib
- Lib
  - Application
    
    Intf
  - Gen_server
    
    Impl
  - Logger
    
    Formatter
  - Process
  - Supervisor
  - Telemetry
riot.lib.logger
- Logger
  - Intf
  - Level
  - Make
    
    _
  - Namespace
riot.lib.net
- Lib_net
  - Addr
  - Socket
riot.log
- Log
riot.net
- Net
  - Addr
  - Io
  - Socket
riot.runtime
- Runtime
  - Timer
riot.runtime.time
- Time
  - Timer_wheel
    
    Timer
riot.scheduler
- Scheduler
  - Pool
  - Tracer
riot.util
- Util
  - Dashmap
  - Fd
    
    Mode
  - Lf_queue
  - Thread_local
  - Uid

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'kind socket = Runtime.Fd.t

type listen_socket = Runtime.Fd.t

type stream_socket = Runtime.Fd.t

type listen_opts = {

reuse_addr : bool;
reuse_port : bool;
backlog : int;
addr : string;

}

type timeout =

| Infinity
| Bounded of float

type unix_error = [

| `Unix_error of Unix.error

]

type nonrec ('ok, 'err) result = ('ok, 'err) result constraint 'err = [> unix_error ]

val default_listen_opts : listen_opts

val close : Runtime.Fd.t -> unit

val listen : ?opts:listen_opts -> port:int -> unit -> (Runtime.Fd.t, 'a) result

val connect : 
  Runtime.Net.Addr.stream_addr ->
  (Runtime.Fd.t, [> `Unix_error of Unix.error ]) result

val accept : 
  ?timeout:timeout ->
  Runtime.Fd.t ->
  (Runtime.Net.Socket.stream_socket * Runtime.Net.Addr.stream_addr,
    [> `Unix_error of Unix.error | `Closed ])
    result

val controlling_process : 'a -> new_owner:'b -> (unit, 'c) result

val receive : 
  ?timeout:timeout ->
  len:int ->
  Runtime.Fd.t ->
  (Bigstringaf.t, [> `Unix_error of Unix.error | `Closed ]) result

val send : 
  Bigstringaf.t ->
  Runtime.Fd.t ->
  (int, [> `Unix_error of Unix.error | `Closed ]) result

val pp : Format.formatter -> _ socket -> unit

val pp_err : 
  Format.formatter ->
  [ unix_error | `Closed | `Timeout | `System_limit ] ->
  unit