Struct witnext::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 infer_repr(cases: usize) -> IntRepr

pub fn as_option(&self) -> Option<&TypeRef>

If this variant looks like an option shorthand, return the type associated with option.

Only matches variants fo the form:

(variant
    (case "none")
    (case "some" ty))

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.

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

impl Variant

pub fn payload_offset(&self, export: bool) -> usize

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, export: bool) -> SizeAlign

fn mem_size(&self, export: bool) -> usize

fn mem_align(&self, export: bool) -> 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 Eq for Variant

impl StructuralEq for Variant

impl StructuralPartialEq for Variant