Enum dyon::Type

pub enum Type {
    Unreachable,
    Void,
    Any,
    Bool,
    F64,
    Vec4,
    Mat4,
    Str,
    Link,
    Array(Box<Type>),
    Object,
    Option(Box<Type>),
    Result(Box<Type>),
    Secret(Box<Type>),
    Thread(Box<Type>),
    In(Box<Type>),
    AdHoc(Arc<String>, Box<Type>),
    Closure(Box<Dfn>),
}

Stores a Dyon type.

Variants

Unreachable

Whether a statement is never reached.

Void

A no-type.

Any

Any type.

Bool

Boolean type.

F64

F64 type.

Vec4

4D vector type.

Mat4

4D matrix type.

Str

String/text type.

Link

Link type.

Array(Box<Type>)

Array type.

Object

Object type.

Option(Box<Type>)

Option type.

Result(Box<Type>)

Result type.

Secret(Box<Type>)

Secret type.

Thread(Box<Type>)

Thread handle type.

In(Box<Type>)

In-type.

AdHoc(Arc<String>, Box<Type>)

Ad-hoc type.

Closure(Box<Dfn>)

Closure type.

Implementations

impl Type

pub fn all_ext( args: Vec<Type>, ret: Type ) -> (Vec<Arc<String>>, Vec<Type>, Type)

Returns an extension quantified over ad-hoc types.

For example, (vec4, vec4) -> vec4 becomes all T { (T vec4, T vec4) -> T vec4 }.

pub fn description(&self) -> String

Returns description of the type.

pub fn array() -> Type

Returns an array type with an any as inner type.

pub fn object() -> Type

Returns an object type.

pub fn option() -> Type

Returns an Option type with an any as inner type.

pub fn result() -> Type

Returns a Result type with an any as inner type.

pub fn thread() -> Type

Returns a thread handle type with an any as inner type.

pub fn in_ty() -> Type

Returns an in-type with an any as inner type.

pub fn bind_ty_vars( &self, refine: &Type, names: &[Arc<String>], ty_vars: &mut Vec<Option<Arc<String>>> ) -> Result<Type, String>

Binds refinement type variables.

Returns the type argument to compare to.

pub fn insert_var(&mut self, name: &Arc<String>, val: &Arc<String>)

Inserts variable name, replacing ad-hoc type name.

pub fn insert_none_var(&mut self, name: &Arc<String>)

Inserts a none ad-hoc variable.

pub fn ambiguous(&self, refine: &Type) -> bool

Returns true if a type to be refined is ambiguous relative to this type (directional check).

For example, the type ad-hoc type Foo str is ambiguous with type str. If more was known about the str type with further refinement, then it might turn out to be Bar str, which triggers a collision.

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

Returns true if the type can be a closure, false otherwise.

pub fn goes_with(&self, other: &Type) -> bool

Returns true if a type goes with another type (directional check).

• bool (argument) goes with sec[bool] (value)
• f64 (argument) goes with sec[f64] (value)

The opposite is not true, since sec contains extra information.

pub fn add_assign(&self, other: &Type) -> bool

Infers type from the += operator.

pub fn from_meta_data( node: &str, convert: Convert<'_>, ignored: &mut Vec<Range> ) -> Result<(Range, Type), ()>

Converts meta data into a type.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy 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 PartialEq<Type> for Type

fn eq(&self, other: &Type) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Type