Struct witx::Variant

pub struct Variant {
    pub tag_repr: IntRepr,
    pub cases: Vec<Case>,
}

A type which represents how values can be one of a set of possible cases.

This type maps to an enum in languages like Rust, but doesn’t have an equivalent in languages like JS or C. The closest analog in C is a tagged union, but a Variant is always consistent whereas a tagged union in C could be mis-tagged or such.

Variants are used to represent one of a possible set of types. For example an enum-like variant, a result that is either success or failure, or even a simple bool. Variants are primarily used heavily with various kinds of shorthands in the *.witx format to represent idioms in languages.

Fields

tag_repr: IntRepr

The bit representation of the width of this variant’s tag when the variant is stored in memory.

cases: Vec<Case>

The possible cases that values of this variant type can take.

Implementations

impl Variant

pub fn as_expected(&self) -> Option<(Option<&TypeRef>, Option<&TypeRef>)>

If this variant looks like an expected shorthand, return the ok/err types associated with this result.

Only matches variants fo the form:

(variant
    (case "ok" ok?)
    (case "err" err?))

pub fn is_bool(&self) -> bool

Returns whether this variant type is “bool-like” meaning that it matches this type:

(variant
    (case "false")
    (case "true"))

pub fn is_enum(&self) -> bool

Returns whether this variant type is “enum-like” meaning that all of its cases have no payload associated with them.

impl Variant

pub fn payload_offset(&self) -> usize

impl Variant

pub fn to_sexpr(&self) -> SExpr

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Variant

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

Formats the value using the given formatter.

impl Hash for Variant

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Layout for Variant

fn mem_size_align(&self) -> SizeAlign

fn mem_size(&self) -> usize

fn mem_align(&self) -> usize

impl PartialEq<Variant> for Variant

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Representable for Variant

fn representable(&self, by: &Self) -> RepEquality

impl Eq for Variant

impl StructuralEq for Variant

impl StructuralPartialEq for Variant