SYMBOL INDEX (401 symbols across 14 files)

FILE: examples/epmd_cli.rs
  function main (line 12) | fn main() -> noargs::Result<()> {

FILE: examples/handshake.rs
  function main (line 10) | fn main() -> noargs::Result<()> {

FILE: examples/recv_msg.rs
  function main (line 18) | fn main() -> noargs::Result<()> {
  function handle_client (line 88) | async fn handle_client(

FILE: examples/send_msg.rs
  function main (line 12) | fn main() -> noargs::Result<()> {

FILE: src/channel.rs
  function channel (line 17) | pub fn channel<T>(connection: T, flags: DistributionFlags) -> (Sender<T>...
  constant TYPE_TAG (line 25) | const TYPE_TAG: u8 = 112;
  type Sender (line 29) | pub struct Sender<T> {
  function new (line 37) | fn new(connection: T) -> Self {
  function send (line 44) | pub async fn send(&mut self, message: Message) -> Result<(), SendError> {
  type Receiver (line 62) | pub struct Receiver<T> {
  function new (line 70) | fn new(connection: T) -> Self {
  function recv (line 77) | pub async fn recv(&mut self) -> Result<Message, RecvError> {
  function recv_owned (line 103) | pub async fn recv_owned(mut self) -> Result<(Message, Self), RecvError> {
  type SendError (line 113) | pub enum SendError {
    method fmt (line 122) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 131) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 140) | fn from(value: std::io::Error) -> Self {
    method from (line 146) | fn from(value: eetf::EncodeError) -> Self {
  type RecvError (line 155) | pub enum RecvError {
    method fmt (line 173) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 187) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 197) | fn from(value: std::io::Error) -> Self {
    method from (line 203) | fn from(value: eetf::DecodeError) -> Self {

FILE: src/eetf_ext.rs
  function nil (line 4) | pub fn nil() -> Term {
  function check_tuple_len (line 8) | pub fn check_tuple_len(tuple: &Tuple, n: usize) -> Result<(), DecodeErro...
  function try_from_tagged_tuple3 (line 19) | pub fn try_from_tagged_tuple3<T0, T1>(mut tuple: Tuple) -> Result<(T0, T...
  function try_from_tagged_tuple4 (line 31) | pub fn try_from_tagged_tuple4<T0, T1, T2>(mut tuple: Tuple) -> Result<(T...
  function try_from_tagged_tuple5 (line 45) | pub fn try_from_tagged_tuple5<T0, T1, T2, T3>(
  function try_from_tagged_tuple6 (line 63) | pub fn try_from_tagged_tuple6<T0, T1, T2, T3, T4>(
  function try_from_tagged_tuple7 (line 83) | pub fn try_from_tagged_tuple7<T0, T1, T2, T3, T4, T5>(
  type TryFromTerm (line 105) | pub trait TryFromTerm: Sized {
    method try_from_term (line 106) | fn try_from_term(term: Term) -> Result<Self, DecodeError>;
    method try_from_term (line 110) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 116) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 122) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 128) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 134) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 140) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 146) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
    method try_from_term (line 158) | fn try_from_term(term: Term) -> Result<Self, DecodeError> {
  function try_from_term (line 169) | pub fn try_from_term<T>(term: Term, expected: &str) -> Result<T, DecodeE...

FILE: src/epmd.rs
  constant DEFAULT_EPMD_PORT (line 17) | pub const DEFAULT_EPMD_PORT: u16 = 4369;
  constant TAG_DUMP_REQ (line 19) | const TAG_DUMP_REQ: u8 = 100;
  constant TAG_KILL_REQ (line 20) | const TAG_KILL_REQ: u8 = 107;
  constant TAG_NAMES_REQ (line 21) | const TAG_NAMES_REQ: u8 = 110;
  constant TAG_ALIVE2_X_RESP (line 22) | const TAG_ALIVE2_X_RESP: u8 = 118;
  constant TAG_PORT2_RESP (line 23) | const TAG_PORT2_RESP: u8 = 119;
  constant TAG_ALIVE2_REQ (line 24) | const TAG_ALIVE2_REQ: u8 = 120;
  constant TAG_ALIVE2_RESP (line 25) | const TAG_ALIVE2_RESP: u8 = 121;
  constant TAG_PORT_PLEASE2_REQ (line 26) | const TAG_PORT_PLEASE2_REQ: u8 = 122;
  type NodeEntry (line 30) | pub struct NodeEntry {
    method new (line 57) | pub fn new(name: &str, port: u16) -> Self {
    method new_hidden (line 70) | pub fn new_hidden(name: &str, port: u16) -> Self {
    method bytes_len (line 82) | fn bytes_len(&self) -> usize {
  type EpmdError (line 97) | pub enum EpmdError {
    method fmt (line 118) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 156) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 166) | fn from(value: std::io::Error) -> Self {
  type EpmdClient (line 173) | pub struct EpmdClient<T> {
  function new (line 184) | pub fn new(connection: T) -> Self {
  function register (line 194) | pub async fn register(mut self, node: NodeEntry) -> Result<(T, Creation)...
  function get_names (line 239) | pub async fn get_names(mut self) -> Result<Vec<(String, u16)>, EpmdError> {
  function get_node (line 259) | pub async fn get_node(mut self, node_name: &str) -> Result<Option<NodeEn...
  function kill (line 304) | pub async fn kill(mut self) -> Result<String, EpmdError> {
  function dump (line 332) | pub async fn dump(mut self) -> Result<String, EpmdError> {
  type NodeNameAndPort (line 346) | struct NodeNameAndPort {
  type Err (line 352) | type Err = EpmdError;
  method from_str (line 354) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type TransportProtocol (line 372) | pub enum TransportProtocol {
    method from (line 381) | fn from(v: u8) -> Self {
  function from (line 390) | fn from(v: TransportProtocol) -> Self {
  type NodeType (line 401) | pub enum NodeType {
    method from (line 413) | fn from(v: u8) -> Self {
  function from (line 423) | fn from(v: NodeType) -> Self {
  function epmd_client_works (line 437) | fn epmd_client_works() {

FILE: src/flags.rs
  type DistributionFlags (line 3) | pub struct DistributionFlags(u64);
    constant PUBLISHED (line 7) | pub const PUBLISHED: Self = Self(0x01);
    constant ATOM_CACHE (line 10) | pub const ATOM_CACHE: Self = Self(0x02);
    constant EXTENDED_REFERENCES (line 15) | pub const EXTENDED_REFERENCES: Self = Self(0x04);
    constant DIST_MONITOR (line 20) | pub const DIST_MONITOR: Self = Self(0x08);
    constant FUN_TAGS (line 23) | pub const FUN_TAGS: Self = Self(0x10);
    constant DIST_MONITOR_NAME (line 26) | pub const DIST_MONITOR_NAME: Self = Self(0x20);
    constant HIDDEN_ATOM_CACHE (line 29) | pub const HIDDEN_ATOM_CACHE: Self = Self(0x40);
    constant NEW_FUN_TAGS (line 34) | pub const NEW_FUN_TAGS: Self = Self(0x80);
    constant EXTENDED_PIDS_PORTS (line 39) | pub const EXTENDED_PIDS_PORTS: Self = Self(0x100);
    constant EXPORT_PTR_TAG (line 44) | pub const EXPORT_PTR_TAG: Self = Self(0x200);
    constant BIT_BINARIES (line 49) | pub const BIT_BINARIES: Self = Self(0x400);
    constant NEW_FLOATS (line 54) | pub const NEW_FLOATS: Self = Self(0x800);
    constant UNICODE_IO (line 57) | pub const UNICODE_IO: Self = Self(0x1000);
    constant DIST_HDR_ATOM_CACHE (line 62) | pub const DIST_HDR_ATOM_CACHE: Self = Self(0x2000);
    constant SMALL_ATOM_TAGS (line 65) | pub const SMALL_ATOM_TAGS: Self = Self(0x4000);
    constant UTF8_ATOMS (line 70) | pub const UTF8_ATOMS: Self = Self(0x10000);
    constant MAP_TAGS (line 75) | pub const MAP_TAGS: Self = Self(0x20000);
    constant BIG_CREATION (line 80) | pub const BIG_CREATION: Self = Self(0x40000);
    constant SEND_SENDER (line 83) | pub const SEND_SENDER: Self = Self(0x80000);
    constant BIG_SEQTRACE_LABELS (line 86) | pub const BIG_SEQTRACE_LABELS: Self = Self(0x100000);
    constant EXIT_PAYLOAD (line 89) | pub const EXIT_PAYLOAD: Self = Self(0x400000);
    constant FRAGMENTS (line 92) | pub const FRAGMENTS: Self = Self(0x800000);
    constant HANDSHAKE_23 (line 95) | pub const HANDSHAKE_23: Self = Self(0x1000000);
    constant UNLINK_ID (line 102) | pub const UNLINK_ID: Self = Self(0x2000000);
    constant SPAWN (line 105) | pub const SPAWN: Self = Self(1 << 32);
    constant NAME_ME (line 111) | pub const NAME_ME: Self = Self(1 << 33);
    constant V4_NC (line 121) | pub const V4_NC: Self = Self(1 << 34);
    constant ALIAS (line 126) | pub const ALIAS: Self = Self(1 << 35);
    constant MANDATORY_25_DIGEST (line 132) | pub const MANDATORY_25_DIGEST: Self = Self(1 << 36);
    method bits (line 135) | pub const fn bits(self) -> u64 {
    method from_bits_truncate (line 140) | pub const fn from_bits_truncate(bits: u64) -> Self {
    method contains (line 145) | pub const fn contains(self, other: Self) -> bool {
    method new (line 157) | pub fn new() -> Self {
    method mandatory (line 162) | pub fn mandatory() -> Self {
    type Output (line 187) | type Output = Self;
    method bitor (line 189) | fn bitor(self, rhs: Self) -> Self {
    method bitor_assign (line 195) | fn bitor_assign(&mut self, rhs: Self) {
    type Output (line 201) | type Output = Self;
    method bitand (line 203) | fn bitand(self, rhs: Self) -> Self {
  method default (line 181) | fn default() -> Self {
  function flag_bit_values (line 213) | fn flag_bit_values() {
  function from_bits_truncate_roundtrip (line 226) | fn from_bits_truncate_roundtrip() {
  function from_bits_truncate_preserves_unknown_bits (line 233) | fn from_bits_truncate_preserves_unknown_bits() {
  function contains_single_flag (line 239) | fn contains_single_flag() {
  function contains_multiple_flags (line 247) | fn contains_multiple_flags() {
  function contains_empty_is_always_true (line 254) | fn contains_empty_is_always_true() {
  function bitor_combines_flags (line 261) | fn bitor_combines_flags() {
  function bitor_assign_combines_flags (line 271) | fn bitor_assign_combines_flags() {
  function bitand_intersects_flags (line 279) | fn bitand_intersects_flags() {
  function default_equals_mandatory (line 289) | fn default_equals_mandatory() {
  function mandatory_contains_expected_flags (line 295) | fn mandatory_contains_expected_flags() {
  function high_and_low_bits_coexist (line 320) | fn high_and_low_bits_coexist() {
  function clone_and_copy (line 333) | fn clone_and_copy() {
  function debug_format (line 342) | fn debug_format() {
  function hash_consistent (line 348) | fn hash_consistent() {

FILE: src/handshake.rs
  constant PROTOCOL_VERSION (line 13) | const PROTOCOL_VERSION: u16 = LOWEST_DISTRIBUTION_PROTOCOL_VERSION;
  constant NODE_NAME_VERSION (line 14) | const NODE_NAME_VERSION: u16 = 5;
  type ClientSideHandshake (line 18) | pub struct ClientSideHandshake<T> {
  function new (line 32) | pub fn new(connection: T, local_node: LocalNode, cookie: &str) -> Self {
  function execute_send_name (line 47) | pub async fn execute_send_name(
  function execute_rest (line 65) | pub async fn execute_rest(
  function send_name (line 99) | async fn send_name(&mut self, protocol_version: u16) -> Result<(), Hands...
  function recv_status (line 122) | async fn recv_status(&mut self) -> Result<HandshakeStatus, HandshakeErro...
  function send_status (line 180) | async fn send_status(&mut self, status: &str) -> Result<(), HandshakeErr...
  function recv_challenge (line 187) | async fn recv_challenge(&mut self) -> Result<(PeerNode, Challenge), Hand...
  function send_complement (line 229) | async fn send_complement(&mut self) -> Result<(), HandshakeError> {
  function send_challenge_reply (line 238) | async fn send_challenge_reply(
  function recv_challenge_ack (line 250) | async fn recv_challenge_ack(&mut self) -> Result<(), HandshakeError> {
  type ServerSideHandshake (line 273) | pub struct ServerSideHandshake<T> {
  function new (line 286) | pub fn new(connection: T, local_node: LocalNode, cookie: &str) -> Self {
  function execute_recv_name (line 303) | pub async fn execute_recv_name(&mut self) -> Result<Option<NodeName>, Ha...
  function execute_rest (line 357) | pub async fn execute_rest(
  function send_status (line 386) | async fn send_status(&mut self, status: HandshakeStatus) -> Result<(), H...
  function send_challenge (line 417) | async fn send_challenge(
  function recv_complement (line 440) | async fn recv_complement(&mut self) -> Result<(), HandshakeError> {
  function recv_challenge_reply (line 461) | async fn recv_challenge_reply(&mut self) -> Result<Challenge, HandshakeE...
  function send_challenge_ack (line 482) | async fn send_challenge_ack(
  type HandshakeStatus (line 496) | pub enum HandshakeStatus {
  type Challenge (line 537) | struct Challenge(u32);
    method new (line 540) | fn new() -> Self {
    method digest (line 544) | fn digest(self, cookie: &str) -> Digest {
  type Digest (line 550) | struct Digest([u8; 16]);
  type HandshakeError (line 556) | pub enum HandshakeError {
    method fmt (line 595) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 637) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method from (line 647) | fn from(value: std::io::Error) -> Self {
    method from (line 653) | fn from(value: NodeNameError) -> Self {
  function client_side_handshake_works (line 664) | fn client_side_handshake_works() {
  function server_side_handshake_works (line 700) | fn server_side_handshake_works() {

FILE: src/io.rs
  type Connection (line 6) | pub struct Connection<T> {
  function new (line 14) | pub fn new(inner: T) -> Self {
  function into_inner (line 18) | pub fn into_inner(self) -> T {
  function handshake_message_writer (line 22) | pub fn handshake_message_writer(&mut self) -> HandshakeMessageWriter<'_,...
  function handshake_message_reader (line 30) | pub async fn handshake_message_reader<'a>(
  function write_u8 (line 40) | pub async fn write_u8(&mut self, v: u8) -> std::io::Result<()> {
  function write_u16 (line 44) | pub async fn write_u16(&mut self, v: u16) -> std::io::Result<()> {
  function write_u32 (line 48) | pub async fn write_u32(&mut self, v: u32) -> std::io::Result<()> {
  function write_all (line 52) | pub async fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
  function flush (line 56) | pub async fn flush(&mut self) -> std::io::Result<()> {
  function read_u8 (line 60) | pub async fn read_u8(&mut self) -> std::io::Result<u8> {
  function read_u16 (line 66) | pub async fn read_u16(&mut self) -> std::io::Result<u16> {
  function read_u32 (line 72) | pub async fn read_u32(&mut self) -> std::io::Result<u32> {
  function read_u64 (line 78) | pub async fn read_u64(&mut self) -> std::io::Result<u64> {
  function read_exact (line 84) | pub async fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
  function read_string (line 88) | pub async fn read_string(&mut self) -> std::io::Result<String> {
  function read_stringn (line 94) | pub async fn read_stringn(&mut self, size: usize) -> std::io::Result<Str...
  function read_u16_bytes (line 105) | pub async fn read_u16_bytes(&mut self) -> std::io::Result<Vec<u8>> {
  function read_u16_string (line 111) | pub async fn read_u16_string(&mut self) -> std::io::Result<String> {
  type HandshakeMessageWriter (line 123) | pub struct HandshakeMessageWriter<'a, T> {
  function finish (line 132) | pub async fn finish(self) -> std::io::Result<()> {
  function write_u8 (line 149) | pub fn write_u8(&mut self, v: u8) -> std::io::Result<()> {
  function write_u16 (line 154) | pub fn write_u16(&mut self, v: u16) -> std::io::Result<()> {
  function write_u32 (line 159) | pub fn write_u32(&mut self, v: u32) -> std::io::Result<()> {
  function write_u64 (line 164) | pub fn write_u64(&mut self, v: u64) -> std::io::Result<()> {
  function write_all (line 169) | pub fn write_all(&mut self, bytes: &[u8]) -> std::io::Result<()> {
  type HandshakeMessageReader (line 176) | pub struct HandshakeMessageReader<'a, T> {
  function read_u8 (line 185) | pub async fn read_u8(&mut self) -> std::io::Result<u8> {
  function read_u16 (line 192) | pub async fn read_u16(&mut self) -> std::io::Result<u16> {
  function read_u32 (line 199) | pub async fn read_u32(&mut self) -> std::io::Result<u32> {
  function read_u64 (line 206) | pub async fn read_u64(&mut self) -> std::io::Result<u64> {
  function read_string (line 213) | pub async fn read_string(&mut self) -> std::io::Result<String> {
  function read_bytes (line 219) | pub async fn read_bytes(&mut self) -> std::io::Result<Vec<u8>> {
  function read_exact (line 226) | pub async fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
  function read_u16_string (line 234) | pub async fn read_u16_string(&mut self) -> std::io::Result<String> {
  function consume_remaining_bytes (line 242) | pub async fn consume_remaining_bytes(&mut self) -> std::io::Result<()> {
  function finish (line 249) | pub async fn finish(mut self) -> std::io::Result<()> {
  type ReadTermExt (line 254) | pub trait ReadTermExt: Read {
    method read_tuple (line 255) | fn read_tuple(&mut self) -> Result<Tuple, DecodeError> {
    method read_term (line 264) | fn read_term(&mut self) -> Result<Term, DecodeError> {
  type WriteTermExt (line 271) | pub trait WriteTermExt: Write {
    method write_tagged_tuple1 (line 272) | fn write_tagged_tuple1(&mut self, tag: i32) -> Result<(), EncodeError> {
    method write_tagged_tuple3 (line 279) | fn write_tagged_tuple3<T0, T1>(
    method write_tagged_tuple4 (line 299) | fn write_tagged_tuple4<T0, T1, T2>(
    method write_tagged_tuple5 (line 322) | fn write_tagged_tuple5<T0, T1, T2, T3>(
    method write_tagged_tuple6 (line 348) | fn write_tagged_tuple6<T0, T1, T2, T3, T4>(
    method write_tagged_tuple7 (line 378) | fn write_tagged_tuple7<T0, T1, T2, T3, T4, T5>(
    method write_term (line 410) | fn write_term<T>(&mut self, term: T) -> Result<(), EncodeError>

FILE: src/lib.rs
  constant LOWEST_DISTRIBUTION_PROTOCOL_VERSION (line 90) | pub const LOWEST_DISTRIBUTION_PROTOCOL_VERSION: u16 = 6;
  constant HIGHEST_DISTRIBUTION_PROTOCOL_VERSION (line 93) | pub const HIGHEST_DISTRIBUTION_PROTOCOL_VERSION: u16 = 6;
  type BoxError (line 99) | type BoxError = Box<dyn std::error::Error + Send + Sync>;
  constant COOKIE (line 101) | pub const COOKIE: &str = "test-cookie";
  type TestErlangNode (line 104) | pub struct TestErlangNode {
    method new (line 109) | pub async fn new(name: &str) -> Result<Self, BoxError> {
  method drop (line 130) | fn drop(&mut self) {
  function try_epmd_client (line 135) | pub async fn try_epmd_client() -> Result<crate::epmd::EpmdClient<smol::n...
  function epmd_client (line 143) | pub async fn epmd_client() -> crate::epmd::EpmdClient<smol::net::TcpStre...

FILE: src/message.rs
  type DistributionMessage (line 16) | trait DistributionMessage: Sized {
    constant OP (line 17) | const OP: i32;
    method write_into (line 18) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeError>;
    method read_from (line 19) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 31) | const OP: i32 = 1;
    method write_into (line 33) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 38) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 53) | const OP: i32 = 2;
    method write_into (line 55) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 61) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 78) | const OP: i32 = 3;
    method write_into (line 80) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 85) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 107) | const OP: i32 = 4;
    method write_into (line 109) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 114) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 125) | const OP: i32 = 5;
    method write_into (line 127) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 132) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 148) | const OP: i32 = 6;
    method write_into (line 150) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 156) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 176) | const OP: i32 = 7;
    method write_into (line 178) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 183) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 199) | const OP: i32 = 8;
    method write_into (line 201) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 206) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 226) | const OP: i32 = 12;
    method write_into (line 228) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 234) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 256) | const OP: i32 = 13;
    method write_into (line 258) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 269) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 291) | const OP: i32 = 16;
    method write_into (line 293) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 305) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 329) | const OP: i32 = 18;
    method write_into (line 331) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 342) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 363) | const OP: i32 = 19;
    method write_into (line 365) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 370) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 392) | const OP: i32 = 20;
    method write_into (line 394) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 399) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 420) | const OP: i32 = 21;
    method write_into (line 422) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 433) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 454) | const OP: i32 = 22;
    method write_into (line 456) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 462) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 484) | const OP: i32 = 23;
    method write_into (line 486) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 492) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 514) | const OP: i32 = 24;
    method write_into (line 516) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 522) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 544) | const OP: i32 = 25;
    method write_into (line 546) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 552) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 574) | const OP: i32 = 26;
    method write_into (line 576) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 582) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 604) | const OP: i32 = 27;
    method write_into (line 606) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 612) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 635) | const OP: i32 = 28;
    method write_into (line 637) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 643) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 668) | const OP: i32 = 29;
    method write_into (line 670) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 683) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 712) | const OP: i32 = 30;
    method write_into (line 714) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 728) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 755) | const OP: i32 = 31;
    method write_into (line 757) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 762) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 785) | const OP: i32 = 32;
    method write_into (line 787) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 799) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 825) | const OP: i32 = 35;
    method write_into (line 827) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 832) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 854) | const OP: i32 = 36;
    method write_into (line 856) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 861) | fn read_from<R: Read>(_reader: &mut R, ctrl_msg: Tuple) -> Result<Self...
    constant OP (line 883) | const OP: i32 = 33;
    method write_into (line 885) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 891) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
    constant OP (line 913) | const OP: i32 = 34;
    method write_into (line 915) | fn write_into<W: Write>(self, writer: &mut W) -> Result<(), EncodeErro...
    method read_from (line 921) | fn read_from<R: Read>(reader: &mut R, ctrl_msg: Tuple) -> Result<Self,...
  type Link (line 25) | pub struct Link {
  type Send (line 47) | pub struct Send {
  type Exit (line 71) | pub struct Exit {
  type Unlink (line 101) | pub struct Unlink {
  type NodeLink (line 122) | pub struct NodeLink;
  type RegSend (line 141) | pub struct RegSend {
  type GroupLeader (line 170) | pub struct GroupLeader {
  type Exit2 (line 192) | pub struct Exit2 {
  type SendTt (line 219) | pub struct SendTt {
  type ExitTt (line 248) | pub struct ExitTt {
  type RegSendTt (line 283) | pub struct RegSendTt {
  type Exit2Tt (line 321) | pub struct Exit2Tt {
  type MonitorP (line 356) | pub struct MonitorP {
  type DemonitorP (line 385) | pub struct DemonitorP {
  type MonitorPExit (line 412) | pub struct MonitorPExit {
  type SendSender (line 447) | pub struct SendSender {
  type SendSenderTt (line 476) | pub struct SendSenderTt {
  type PayloadExit (line 507) | pub struct PayloadExit {
  type PayloadExitTt (line 536) | pub struct PayloadExitTt {
  type PayloadExit2 (line 567) | pub struct PayloadExit2 {
  type PayloadExit2Tt (line 596) | pub struct PayloadExit2Tt {
  type PayloadMonitorPExit (line 627) | pub struct PayloadMonitorPExit {
  type SpawnRequest (line 658) | pub struct SpawnRequest {
  type SpawnRequestTt (line 701) | pub struct SpawnRequestTt {
  type SpawnReply (line 747) | pub struct SpawnReply {
  type SpawnReplyTt (line 776) | pub struct SpawnReplyTt {
  type UnlinkId (line 818) | pub struct UnlinkId {
  type UnlinkIdAck (line 847) | pub struct UnlinkIdAck {
  type AliasSend (line 876) | pub struct AliasSend {
  type AliasSendTt (line 905) | pub struct AliasSendTt {
  type Message (line 936) | pub enum Message {
    method link (line 976) | pub fn link(from_pid: Pid, to_pid: Pid) -> Self {
    method send (line 981) | pub fn send(to_pid: Pid, message: Term) -> Self {
    method exit (line 986) | pub fn exit(from_pid: Pid, to_pid: Pid, reason: Term) -> Self {
    method unlink (line 995) | pub fn unlink(from_pid: Pid, to_pid: Pid) -> Self {
    method node_link (line 1000) | pub fn node_link() -> Self {
    method reg_send (line 1005) | pub fn reg_send(from_pid: Pid, to_name: Atom, message: Term) -> Self {
    method group_leader (line 1014) | pub fn group_leader(from_pid: Pid, to_pid: Pid) -> Self {
    method exit2 (line 1019) | pub fn exit2(from_pid: Pid, to_pid: Pid, reason: Term) -> Self {
    method send_tt (line 1028) | pub fn send_tt(to_pid: Pid, message: Term, trace_token: Term) -> Self {
    method exit_tt (line 1037) | pub fn exit_tt(from_pid: Pid, to_pid: Pid, reason: Term, trace_token: ...
    method reg_send_tt (line 1047) | pub fn reg_send_tt(from_pid: Pid, to_name: Atom, message: Term, trace_...
    method exit2_tt (line 1057) | pub fn exit2_tt(from_pid: Pid, to_pid: Pid, reason: Term, trace_token:...
    method monitor_p (line 1067) | pub fn monitor_p(from_pid: Pid, to_proc: PidOrAtom, reference: Referen...
    method demonitor_p (line 1076) | pub fn demonitor_p(from_pid: Pid, to_proc: PidOrAtom, reference: Refer...
    method monitor_p_exit (line 1085) | pub fn monitor_p_exit(
    method send_sender (line 1100) | pub fn send_sender(from_pid: Pid, to_pid: Pid, message: Term) -> Self {
    method send_sender_tt (line 1109) | pub fn send_sender_tt(from_pid: Pid, to_pid: Pid, message: Term, trace...
    method payload_exit (line 1119) | pub fn payload_exit(from_pid: Pid, to_pid: Pid, reason: Term) -> Self {
    method payload_exit_tt (line 1128) | pub fn payload_exit_tt(from_pid: Pid, to_pid: Pid, reason: Term, trace...
    method payload_exit2 (line 1138) | pub fn payload_exit2(from_pid: Pid, to_pid: Pid, reason: Term) -> Self {
    method payload_exit2_tt (line 1147) | pub fn payload_exit2_tt(from_pid: Pid, to_pid: Pid, reason: Term, trac...
    method payload_monitor_p_exit (line 1157) | pub fn payload_monitor_p_exit(
    method spawn_request (line 1172) | pub fn spawn_request(
    method spawn_request_tt (line 1191) | pub fn spawn_request_tt(
    method spawn_reply (line 1212) | pub fn spawn_reply(
    method spawn_reply_tt (line 1227) | pub fn spawn_reply_tt(
    method unlink_id (line 1244) | pub fn unlink_id(id: Term, from_pid: Pid, to_pid: Pid) -> Self {
    method unlink_id_ack (line 1253) | pub fn unlink_id_ack(id: Term, from_pid: Pid, to_pid: Pid) -> Self {
    method alias_send (line 1262) | pub fn alias_send(from_pid: Pid, alias: Reference, message: Term) -> S...
    method alias_send_tt (line 1271) | pub fn alias_send_tt(
    method write_into (line 1286) | pub fn write_into<W: Write>(self, writer: &mut W) -> Result<(), crate:...
    method read_from (line 1325) | pub fn read_from<R: Read>(reader: &mut R) -> Result<Self, crate::chann...

FILE: src/node.rs
  type LocalNode (line 6) | pub struct LocalNode {
    method new (line 19) | pub fn new(name: NodeName, creation: Creation) -> Self {
  type PeerNode (line 32) | pub struct PeerNode {
  type NodeNameError (line 47) | pub enum NodeNameError {
    method fmt (line 62) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type NodeName (line 81) | pub struct NodeName {
    method new (line 88) | pub fn new(name: &str, host: &str) -> Result<Self, NodeNameError> {
    method name (line 105) | pub fn name(&self) -> &str {
    method host (line 110) | pub fn host(&self) -> &str {
    method len (line 118) | pub fn len(&self) -> usize {
    type Err (line 124) | type Err = NodeNameError;
    method from_str (line 126) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method fmt (line 137) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Creation (line 147) | pub struct Creation(u32);
    method new (line 151) | pub const fn new(n: u32) -> Self {
    method random (line 156) | pub fn random() -> Self {
    method get (line 161) | pub const fn get(self) -> u32 {

FILE: src/term.rs
  type PidOrAtom (line 10) | pub enum PidOrAtom {
  method from (line 16) | fn from(v: PidOrAtom) -> Self {
  type Mfa (line 27) | pub struct Mfa {
  method from (line 34) | fn from(v: Mfa) -> Self {