Enum TyKind

pub enum TyKind {
    Ident(Ident),
    Primitive(PrimitiveSet),
    Singleton(Literal),
    Union(Vec<(Option<String>, Ty)>),
    Tuple(Vec<TyTupleField>),
    Array(Box<Ty>),
    Function(Option<TyFunc>),
    Any,
    Difference {
        base: Box<Ty>,
        exclude: Box<Ty>,
    },
    GenericArg((usize, String)),
}

Variants

Ident(Ident)

Identifier that still needs to be resolved.

Primitive(PrimitiveSet)

Type of a built-in primitive type

Singleton(Literal)

Type that contains only a one value

Union(Vec<(Option<String>, Ty)>)

Union of sets (sum)

Tuple(Vec<TyTupleField>)

Type of tuples (product)

Array(Box<Ty>)

Type of arrays

Function(Option<TyFunc>)

Type of functions with defined params and return types.

Any

Type of every possible value. Super type of all other types. The breaker of chains. Mother of types.

Difference

Type that is the largest subtype of base while not a subtype of exclude.

Fields

base: Box<Ty>

exclude: Box<Ty>

GenericArg((usize, String))

A generic argument. Contains id of the function call node and generic type param name.

Implementations

impl TyKind

pub fn is_ident(&self) -> bool

Returns true if this is a TyKind::Ident, otherwise false

pub fn as_ident_mut(&mut self) -> Option<&mut Ident>

Optionally returns mutable references to the inner fields if this is a TyKind::Ident, otherwise None

pub fn as_ident(&self) -> Option<&Ident>

Optionally returns references to the inner fields if this is a TyKind::Ident, otherwise None

pub fn into_ident(self) -> Result<Ident, Self>

Returns the inner fields if this is a TyKind::Ident, otherwise returns back the enum in the Err case of the result

pub fn is_primitive(&self) -> bool

Returns true if this is a TyKind::Primitive, otherwise false

pub fn as_primitive_mut(&mut self) -> Option<&mut PrimitiveSet>

Optionally returns mutable references to the inner fields if this is a TyKind::Primitive, otherwise None

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

Optionally returns references to the inner fields if this is a TyKind::Primitive, otherwise None

pub fn into_primitive(self) -> Result<PrimitiveSet, Self>

Returns the inner fields if this is a TyKind::Primitive, otherwise returns back the enum in the Err case of the result

pub fn is_singleton(&self) -> bool

Returns true if this is a TyKind::Singleton, otherwise false

pub fn as_singleton_mut(&mut self) -> Option<&mut Literal>

Optionally returns mutable references to the inner fields if this is a TyKind::Singleton, otherwise None

pub fn as_singleton(&self) -> Option<&Literal>

Optionally returns references to the inner fields if this is a TyKind::Singleton, otherwise None

pub fn into_singleton(self) -> Result<Literal, Self>

Returns the inner fields if this is a TyKind::Singleton, otherwise returns back the enum in the Err case of the result

pub fn is_union(&self) -> bool

Returns true if this is a TyKind::Union, otherwise false

pub fn as_union_mut(&mut self) -> Option<&mut Vec<(Option<String>, Ty)>>

Optionally returns mutable references to the inner fields if this is a TyKind::Union, otherwise None

pub fn as_union(&self) -> Option<&Vec<(Option<String>, Ty)>>

Optionally returns references to the inner fields if this is a TyKind::Union, otherwise None

pub fn into_union(self) -> Result<Vec<(Option<String>, Ty)>, Self>

Returns the inner fields if this is a TyKind::Union, otherwise returns back the enum in the Err case of the result

pub fn is_tuple(&self) -> bool

Returns true if this is a TyKind::Tuple, otherwise false

pub fn as_tuple_mut(&mut self) -> Option<&mut Vec<TyTupleField>>

Optionally returns mutable references to the inner fields if this is a TyKind::Tuple, otherwise None

pub fn as_tuple(&self) -> Option<&Vec<TyTupleField>>

Optionally returns references to the inner fields if this is a TyKind::Tuple, otherwise None

pub fn into_tuple(self) -> Result<Vec<TyTupleField>, Self>

Returns the inner fields if this is a TyKind::Tuple, otherwise returns back the enum in the Err case of the result

pub fn is_array(&self) -> bool

Returns true if this is a TyKind::Array, otherwise false

pub fn as_array_mut(&mut self) -> Option<&mut Box<Ty>>

Optionally returns mutable references to the inner fields if this is a TyKind::Array, otherwise None

pub fn as_array(&self) -> Option<&Box<Ty>>

Optionally returns references to the inner fields if this is a TyKind::Array, otherwise None

pub fn into_array(self) -> Result<Box<Ty>, Self>

Returns the inner fields if this is a TyKind::Array, otherwise returns back the enum in the Err case of the result

pub fn is_function(&self) -> bool

Returns true if this is a TyKind::Function, otherwise false

pub fn as_function_mut(&mut self) -> Option<&mut Option<TyFunc>>

Optionally returns mutable references to the inner fields if this is a TyKind::Function, otherwise None

pub fn as_function(&self) -> Option<&Option<TyFunc>>

Optionally returns references to the inner fields if this is a TyKind::Function, otherwise None

pub fn into_function(self) -> Result<Option<TyFunc>, Self>

Returns the inner fields if this is a TyKind::Function, otherwise returns back the enum in the Err case of the result

pub fn is_any(&self) -> bool

Returns true if this is a TyKind::Any, otherwise false

pub fn is_difference(&self) -> bool

Returns true if this is a TyKind::Difference, otherwise false

pub fn as_difference_mut(&mut self) -> Option<(&mut Box<Ty>, &mut Box<Ty>)>

Optionally returns mutable references to the inner fields if this is a TyKind::Difference, otherwise None

pub fn as_difference(&self) -> Option<(&Box<Ty>, &Box<Ty>)>

Optionally returns references to the inner fields if this is a TyKind::Difference, otherwise None

pub fn into_difference(self) -> Result<(Box<Ty>, Box<Ty>), Self>

Returns the inner fields if this is a TyKind::Difference, otherwise returns back the enum in the Err case of the result

pub fn is_generic_arg(&self) -> bool

Returns true if this is a TyKind::GenericArg, otherwise false

pub fn as_generic_arg_mut(&mut self) -> Option<&mut (usize, String)>

Optionally returns mutable references to the inner fields if this is a TyKind::GenericArg, otherwise None

pub fn as_generic_arg(&self) -> Option<&(usize, String)>

Optionally returns references to the inner fields if this is a TyKind::GenericArg, otherwise None

pub fn into_generic_arg(self) -> Result<(usize, String), Self>

Returns the inner fields if this is a TyKind::GenericArg, otherwise returns back the enum in the Err case of the result

impl TyKind

pub fn into_ty(self: TyKind, span: Span) -> Ty

Trait Implementations

impl AsRef<str> for TyKind

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TyKind

fn clone(&self) -> TyKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TyKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TyKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Literal> for TyKind

fn from(value: Literal) -> Self

Converts to this type from the input type.

impl From<PrimitiveSet> for TyKind

fn from(value: PrimitiveSet) -> Self

Converts to this type from the input type.

impl From<TyFunc> for TyKind

fn from(value: TyFunc) -> Self

Converts to this type from the input type.

impl JsonSchema for TyKind

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn always_inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for TyKind

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

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 TyKind