Enum Type 

pub enum Type {
    Single(Cow<'static, str>),
    Value(Box<Type>),
    Alias(Box<Type>),
    Tuple(Vec<Type>),
    Table(BTreeMap<Index, Type>),
    Union(Vec<Type>),
    Array(Box<Type>),
    Map(Box<Type>, Box<Type>),
    Function {
        params: Vec<Param>,
        returns: Vec<Return>,
    },
    Enum(Vec<Type>),
    Class(Box<TypedClass>),
}

Representation of a lua type for a rust type

Variants

Single(Cow<'static, str>)

Represents a single type. i.e. string, number, 0, "literal", Example, etc…

Example

--- @type string
--- @type number
--- @type 0
--- @type "literal"
--- @type Example

Value(Box<Type>)

Represents a typed value

Example

--- @type {type}
value = nil

Alias(Box<Type>)

Represents a type alias

Example

--- @alias MyType {type}

Tuple(Vec<Type>)

Represents a tuple type

Example

--- @type [number, integer, string]

Table(BTreeMap<Index, Type>)

Represents a table literal

Example

--- @type { name: string, age: integer, height: number }

Union(Vec<Type>)

Represents a type union

Example

--- @type string | number | "literal" | Example

Array(Box<Type>)

Represents an array of a single type

Example

--- @type string[]

Map(Box<Type>, Box<Type>)

Represents a table with set key types and value types

Example

--- @type { [string]: boolean }

Function

Represents a function with it’s parameters and return types

Example

--- @type fun(self: any, name: string): string

Fields

params: Vec<Param>

returns: Vec<Return>

Enum(Vec<Type>)

References a enum type.

In this instance it acts like a union since that is the closest relation between rust enums and a lua type

Example

--- @alias {name} {type}
---  | {type}
---  | {type}
---  | {type}

Class(Box<TypedClass>)

Represents a class type

Example

--- @class {name}
--- @field name string
--- @field age integer
--- @field height number

Implementations

impl Type

pub const fn is_single(&self) -> bool

Returns true if the enum is Type::Single otherwise false

pub const fn is_value(&self) -> bool

Returns true if the enum is Type::Value otherwise false

pub const fn is_alias(&self) -> bool

Returns true if the enum is Type::Alias otherwise false

pub const fn is_tuple(&self) -> bool

Returns true if the enum is Type::Tuple otherwise false

pub const fn is_table(&self) -> bool

Returns true if the enum is Type::Table otherwise false

pub const fn is_union(&self) -> bool

Returns true if the enum is Type::Union otherwise false

pub const fn is_array(&self) -> bool

Returns true if the enum is Type::Array otherwise false

pub const fn is_map(&self) -> bool

Returns true if the enum is Type::Map otherwise false

pub const fn is_function(&self) -> bool

Returns true if the enum is Type::Function otherwise false

pub const fn is_enum(&self) -> bool

Returns true if the enum is Type::Enum otherwise false

pub const fn is_class(&self) -> bool

Returns true if the enum is Type::Class otherwise false

impl Type

pub fn literal<T: IntoLuaTypeLiteral>(value: T) -> Self

Create a lua type literal from a rust value. i.e. 3, true, etc…

pub fn named(value: impl Into<Cow<'static, str>>) -> Self

Create a reference to a name of another defined type.

Example

--- @class Example

--- @type Example
example = nil

use mlua_extras::typed::Type;

// This reference the type named `Example`
Type::named("Example");

pub fn string() -> Self

Create a lua builtin string type

pub fn integer() -> Self

Create a lua builtin integer type

pub fn number() -> Self

Create a lua builtin number type

pub fn boolean() -> Self

Create a lua builtin boolean type

pub fn nil() -> Self

Create a lua builtin nil type

pub fn any() -> Self

Create a lua builtin any type

pub fn lightuserdata() -> Self

Create a lua builtin lightuserdata type

pub fn thread() -> Self

Create a lua builtin thread type

pub fn enum(types: impl IntoIterator<Item = Type>) -> Self

Create an enum type. This is equal to an alias

pub fn alias(ty: Type) -> Self

Create a type that is an alias. i.e. --- @alias {name} string

pub fn array(ty: Type) -> Self

Create a type that is an array. i.e. { [integer]: type }

pub fn map(key: Type, value: Type) -> Self

Create a type that is an array. i.e. { [integer]: type }

pub fn union(types: impl IntoIterator<Item = Type>) -> Self

Create a type that is a union. i.e. string | integer | nil

pub fn tuple(types: impl IntoIterator<Item = Type>) -> Self

create a type that is a tuple. i.e. { [1]: type, [2]: type }

pub fn class(class: TypedClass) -> Self

create a type that is a class. i.e. --- @class {name}

pub fn function<Params: TypedMultiValue, Response: TypedMultiValue>( params: Vec<(String, String)>, returns: Vec<String>, ) -> Self

create a type that is a function. i.e. fun(self): number

pub fn table(items: impl IntoIterator<Item = (Index, Type)>) -> Self

A table that has defined entries.

If the goal is a map like syntax use Type::Map or Type::map instead

Trait Implementations

impl AsRef<str> for Type

fn as_ref(&self) -> &str

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

impl<T: Into<Type>> BitOr<T> for Type

Allows to union types

Example

use mlua_extras::typed::Type;

Type::string() | Type::nil();

type Output = Type

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

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<const N: usize> From<[Type; N]> for Type

fn from(value: [Type; N]) -> Self

Converts to this type from the input type.

impl<T: IntoLuaTypeLiteral> From<T> for Type

fn from(value: T) -> Self

Converts to this type from the input type.

impl From<Type> for Param

fn from(value: Type) -> Self

Converts to this type from the input type.

impl From<TypedClassBuilder> for Type

fn from(value: TypedClassBuilder) -> Self

Converts to this type from the input 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 Ord for Type

fn cmp(&self, other: &Type) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn partial_cmp(&self, other: &Type) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Type

impl StructuralPartialEq for Type