Enum Type 

pub enum Type {
    Primitive(PrimitiveType, bool),
    Compound(CompoundType, bool),
    Object,
    OptionalObject,
    Union,
    None,
    Hidden(HiddenType),
    Call(CallType),
    TypeNameRef(CustomType),
}

Represents a WDL type.

Variants

Primitive(PrimitiveType, bool)

The type is a primitive type.

The second field is whether or not the primitive type is optional.

Compound(CompoundType, bool)

The type is a compound type.

The second field is whether or not the compound type is optional.

Object

The type is Object.

OptionalObject

The type is Object?.

Union

A special hidden type for a value that may have any one of several concrete types.

This variant is also used to convey an “indeterminate” type; an indeterminate type may result from a previous type error.

None

A special type that behaves like an optional Union.

Hidden(HiddenType)

A special hidden type that is not directly expressible in WDL source.

Hidden types are used for type checking special values like task, task.previous, hints, input, and output.

Call(CallType)

The type is a call output.

TypeNameRef(CustomType)

A reference to a custom type name (struct or enum).

Implementations

impl Type

pub fn as_primitive(&self) -> Option<PrimitiveType>

Casts the type to a primitive type.

Returns None if the type is not primitive.

pub fn as_compound(&self) -> Option<&CompoundType>

Casts the type to a compound type.

Returns None if the type is not a compound type.

pub fn as_array(&self) -> Option<&ArrayType>

Converts the type to an array type.

Returns None if the type is not an array type.

pub fn as_pair(&self) -> Option<&PairType>

Converts the type to a pair type.

Returns None if the type is not a pair type.

pub fn as_map(&self) -> Option<&MapType>

Converts the type to a map type.

Returns None if the type is not a map type.

pub fn as_struct(&self) -> Option<&StructType>

Converts the type to a struct type.

Returns None if the type is not a struct type.

pub fn as_enum(&self) -> Option<&EnumType>

Converts the type to an enum type.

Returns None if the type is not an enum type.

pub fn as_custom(&self) -> Option<&CustomType>

Converts the type to a custom type.

Returns None if the type is not a custom type.

pub fn as_type_name_ref(&self) -> Option<&CustomType>

Converts the type to a type name reference.

Returns None if the type is not a type name reference.

pub fn as_call(&self) -> Option<&CallType>

Converts the type to a call type

Returns None if the type if not a call type.

pub fn is_union(&self) -> bool

Determines if the type is Union.

pub fn is_none(&self) -> bool

Determines if the type is None.

pub fn promote_scatter(&self) -> Self

Promotes a type from a scatter statement into the parent scope.

For most types, this wraps them in an array. For call types, this promotes each output type into an array.

pub fn common_type(&self, other: &Type) -> Option<Type>

Calculates a common type between this type and the given type.

Returns None if the types have no common type.

pub fn type_name_ref(&self) -> Option<Type>

Attempts to transform the type into the analogous type name reference.

This is only supported for custom types (structs and enums).

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Coercible for Type

fn is_coercible_to(&self, target: &Self) -> bool

Determines if the type is coercible to the target type.

impl Debug for Type

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

Formats the value using the given formatter.

impl Display for Type

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

Formats the value using the given formatter.

impl From<ArrayType> for Type

fn from(value: ArrayType) -> Self

Converts to this type from the input type.

impl From<CallType> for Type

fn from(value: CallType) -> Self

Converts to this type from the input type.

impl From<CompoundType> for Type

fn from(value: CompoundType) -> Self

Converts to this type from the input type.

impl From<EnumType> for Type

fn from(value: EnumType) -> Self

Converts to this type from the input type.

impl From<MapType> for Type

fn from(value: MapType) -> Self

Converts to this type from the input type.

impl From<PairType> for Type

fn from(value: PairType) -> Self

Converts to this type from the input type.

impl From<PrimitiveType> for Type

fn from(value: PrimitiveType) -> Self

Converts to this type from the input type.

impl From<StructType> for Type

fn from(value: StructType) -> Self

Converts to this type from the input type.

impl From<Type> for FunctionalType

fn from(value: Type) -> Self

Converts to this type from the input type.

impl Optional for Type

fn is_optional(&self) -> bool

Determines if the type is optional.

fn optional(&self) -> Self

Makes the type optional if it isn’t already optional.

fn require(&self) -> Self

Makes the type required if it isn’t already required.

impl PartialEq for Type

fn eq(&self, other: &Type) -> 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 Eq for Type

impl StructuralPartialEq for Type