Enum Root 

pub enum Root {
    Ty(Arc<String>),
    Str(Arc<String>),
    F64(f64),
    Bool(bool),
    Avatar(Box<(Self, Self)>),
    Tup(Vec<Self>),
    Struct {
        name: Box<Self>,
        fields: Vec<Self>,
    },
    Enum {
        name: Box<Self>,
        variants: Vec<Self>,
    },
    Instance {
        class: usize,
        data: Option<Box<Self>>,
    },
    InstanceTy {
        ty: Box<Self>,
        data: Option<Box<Self>>,
    },
}

Root knowledge structure.

Variants

Ty(Arc<String>)

A type.

Str(Arc<String>)

A string value.

F64(f64)

An f64 value.

Bool(bool)

A boolean value.

Avatar(Box<(Self, Self)>)

Describes an avatar, e.g. Option<.T>, where Option is the avatar and .T is the core.

Tup(Vec<Self>)

Describes a tuple of variable number of items.

Struct

Describes a struct.

Fields

name: Box<Self>

Name of struct.

fields: Vec<Self>

Fields of struct.

Enum

Describes an enum.

Fields

name: Box<Self>

Name of enum.

variants: Vec<Self>

Variants of enum.

Instance

Instance with type reference.

Fields

class: usize

A index referencing the type of instance.

data: Option<Box<Self>>

Data of instance, if any.

InstanceTy

Instance with explicit type.

Fields

ty: Box<Self>

The explicit type of instance.

data: Option<Box<Self>>

Data of instance, if any.

Implementations

impl Root

pub fn ty_self() -> Root

The Self type.

pub fn ty_arc() -> Root

The Arc type.

pub fn ty_string() -> Root

The String type.

pub fn ty_f64() -> Root

The f64 type.

pub fn ty_bool() -> Root

The bool type.

pub fn ty_box() -> Root

The Box type.

pub fn ty_usize() -> Root

The usize type.

pub fn ty_option() -> Root

The Option type.

pub fn ty_vec() -> Root

The Vec type.

Trait Implementations

impl Debug for Root

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

Formats the value using the given formatter.

impl Display for Root

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

Formats the value using the given formatter.

impl PartialEq for Root

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