Enum Type 

pub enum Type {
    Unit,
    Bool,
    U8,
    U16,
    U32,
    U64,
    S8,
    S16,
    S32,
    S64,
    F32,
    F64,
    Char,
    String,
    List(Box<Type>),
    Option(Box<Type>),
    Result {
        ok: Box<Type>,
        err: Box<Type>,
    },
    Tuple(Vec<Type>),
    Ref(TypePath),
    Value,
}

A type reference.

This enum represents all possible types in the Pack type system. Types can be primitive, compound, or references to named types.

Variants

Unit

Bool

U8

U16

U32

U64

S8

S16

S32

S64

F32

F64

Char

String

List(Box<Type>)

Option(Box<Type>)

Result

Fields

ok: Box<Type>

err: Box<Type>

Tuple(Vec<Type>)

Ref(TypePath)

Value

Implementations

impl Type

pub fn list(inner: Type) -> Self

Create a list type.

pub fn option(inner: Type) -> Self

Create an option type.

pub fn result(ok: Type, err: Type) -> Self

Create a result type.

pub fn tuple(types: Vec<Type>) -> Self

Create a tuple type.

pub fn named(name: impl Into<String>) -> Self

Create a reference to a named type by simple name.

pub fn self_ref() -> Self

Create a self-reference (reference to the containing type). This is syntactic sugar for a relative path with no segments.

pub fn is_unit(&self) -> bool

Check if this type is Unit.

pub fn is_self_ref(&self) -> bool

Check if this type is a self-reference.

pub fn contains_recursion(&self) -> bool

Check if this type contains any recursive references.

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 Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Type

impl Hash for Type

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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 Serialize for Type

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Type