Enum Type

pub enum Type {
    Primitive(PrimitiveType, bool),
    Compound(CompoundType, bool),
    Object,
    OptionalObject,
    Union,
    None,
    Task,
    Hints,
    Input,
    Output,
    Call(CallType),
}

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.

Task

A special hidden type for task that is available in command and task output sections in WDL 1.2.

Hints

A special hidden type for hints that is available in task hints sections.

Input

A special hidden type for input that is available in task hints sections.

Output

A special hidden type for output that is available in task hints sections.

Call(CallType)

The type is a call output.

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_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(&self, kind: PromotionKind) -> Self

Promotes the type from one scope to another.

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.

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<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