Enum over::types::Type

pub enum Type {
    Any,
    Null,
    Bool,
    Int,
    Frac,
    Char,
    Str,
    Arr(Box<Type>),
    Tup(Vec<Type>),
    Obj,
}

Enum of possible types for Values.

Variants

Any

A type used to indicate an empty Arr.

Null

Null value.

Bool

A boolean type.

Int

A signed integer type.

Frac

A fractional type.

Char

A character type.

Str

A string type.

Arr(Box<Type>)

An array type, containing the type of its sub-elements.

Tup(Vec<Type>)

A tuple type, containing the types of its sub-elements.

Obj

An object type.

Methods

impl Type

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

Returns true if this type is strictly the same as other. Usually you want to use eq() instead.

fn has_any(&self) -> bool

Returns true if this Type contains Any.

fn most_specific(type1: &Type, type2: &Type) -> Option<(Type, bool)>

Returns a type with the most specificity that can be applied to the two input types as well as true if the returned type is not maximally specific, that is, it contains Any. If no single type can be applied to both input types (e.g. the types are Str and Int), returns None.

Examples

use over::types::Type;
use over::types::Type::*;
use over::value::Value;

let val1: Value = tup!(arr![], arr![2]).into();
let val2: Value = tup!(arr!['c'], arr![]).into();

let (specific_type, has_any) =
    Type::most_specific(&val1.get_type(), &val2.get_type()).unwrap();

assert_eq!(specific_type, Tup(vec![Arr(Box::new(Char)), Arr(Box::new(Int))]));
assert!(!has_any);

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, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for Type

Two types are considered equal if one of them is Any or they have the same variant. In the case of Arr and Tup, the inner types are recursively checked for equality.

fn eq(&self, other: &Self) -> 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 !=.

impl Eq for Type

impl Display for Type

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

Formats the value using the given formatter.