Enum TermType 

#[repr(i32)]
pub enum TermType {
    Atom = 1,
    Bitstring = 2,
    Float = 3,
    Fun = 4,
    Integer = 5,
    List = 6,
    Map = 7,
    Pid = 8,
    Port = 9,
    Reference = 10,
    Tuple = 11,
}

The canonical term types returned by term_type.

The C header reserves a -1 sentinel and may add new types, so an unrecognized code must never be transmuted into this enum.

ErlNifTermType — NIF 2.15 — OTP 22

Variants

Atom = 1

Matches an atom.

ERL_NIF_TERM_TYPE_ATOM — NIF 2.15 — OTP 22

Bitstring = 2

Matches a bitstring (binaries included).

ERL_NIF_TERM_TYPE_BITSTRING — NIF 2.15 — OTP 22

Float = 3

Matches a float.

ERL_NIF_TERM_TYPE_FLOAT — NIF 2.15 — OTP 22

Fun = 4

Matches a fun.

ERL_NIF_TERM_TYPE_FUN — NIF 2.15 — OTP 22

Integer = 5

Matches an integer.

ERL_NIF_TERM_TYPE_INTEGER — NIF 2.15 — OTP 22

List = 6

Matches a list (the empty list included).

ERL_NIF_TERM_TYPE_LIST — NIF 2.15 — OTP 22

Map = 7

Matches a map.

ERL_NIF_TERM_TYPE_MAP — NIF 2.15 — OTP 22

Pid = 8

Matches a pid.

ERL_NIF_TERM_TYPE_PID — NIF 2.15 — OTP 22

Port = 9

Matches a port.

ERL_NIF_TERM_TYPE_PORT — NIF 2.15 — OTP 22

Reference = 10

Matches a reference.

ERL_NIF_TERM_TYPE_REFERENCE — NIF 2.15 — OTP 22

Tuple = 11

Matches a tuple.

ERL_NIF_TERM_TYPE_TUPLE — NIF 2.15 — OTP 22

Implementations

impl TermType

pub fn from_raw(code: c_int) -> Option<Self>

Map a raw term_type return code to a known variant, or None for any code outside the canonical 1..=11 (an unknown/future term type).

Trait Implementations

impl Clone for TermType

fn clone(&self) -> TermType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for TermType

impl Debug for TermType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for TermType

impl PartialEq for TermType

fn eq(&self, other: &TermType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TermType