Struct EnumChoice 

pub struct EnumChoice(/* private fields */);

An enum choice value.

An enum choice is identified by its enum type and choice name.

This type is cheaply cloneable.

Implementations

impl EnumChoice

pub fn new( enum_ty: impl Into<EnumType>, name: &str, value: impl Into<Value>, ) -> Self

Attempts to create a new enum choice from an enum type and choice name.

Panics

Panics if the given choice name is not present in the given enum type.

pub fn enum_ty(&self) -> EnumType

Gets the type of the enum.

pub fn name(&self) -> &str

Gets the name of the choice.

pub fn value(&self) -> &Value

Gets the value of the choice.

Trait Implementations

impl Clone for EnumChoice

fn clone(&self) -> EnumChoice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnumChoice

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

Formats the value using the given formatter.

impl Display for EnumChoice

Displays the choice name when an enum is used in string interpolation.

Design Decision

When an enum choice is interpolated in a WDL string (e.g., "~{Color.Red}" where Red = "#FF0000"), this implementation displays the choice name ("Red") rather than the underlying value ("#FF0000").

This design choice treats enum choices as named identifiers, providing stable, human-readable output that doesn’t depend on the underlying value representation. To access the underlying value explicitly, use the value() standard library function.

Example

enum Color {
    Red = "#FF0000",
    Green = "#00FF00"
}

String name = "~{Color.Red}"       # Produces "Red"
String hex_value = value(Color.Red)  # Produces "#FF0000"

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

Formats the value using the given formatter.

impl PartialEq for EnumChoice

fn eq(&self, other: &Self) -> 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.