Enum Value

pub enum Value {
    Empty,
    Int(isize),
    Float(f64),
    Bool(bool),
    Char(char),
    String(Interned<'static, str>),
    Ref(Place),
    Slice(Place, usize),
    Array(Box<[ConValue]>),
    Tuple(Box<[ConValue]>),
    Struct(Box<(Interned<'static, str>, HashMap<Interned<'static, str>, ConValue>)>),
    TupleStruct(Box<(&'static str, Box<[ConValue]>)>),
    Module(Box<HashMap<Interned<'static, str>, Option<ConValue>>>),
    Quote(Box<Expr>),
    Function(Rc<Function>),
    Closure(Rc<Closure>),
    Builtin(&'static Builtin),
}

A Conlang value stores data in the interpreter

Variants

Empty

The empty/unit () type

Int(isize)

An integer

Float(f64)

A floating point number

Bool(bool)

A boolean

Char(char)

A unicode character

String(Interned<'static, str>)

A string

Ref(Place)

A reference

Slice(Place, usize)

A reference to an array

Array(Box<[ConValue]>)

An Array

Tuple(Box<[ConValue]>)

A tuple

Struct(Box<(Interned<'static, str>, HashMap<Interned<'static, str>, ConValue>)>)

A value of a product type

TupleStruct(Box<(&'static str, Box<[ConValue]>)>)

A value of a product type with anonymous members

Module(Box<HashMap<Interned<'static, str>, Option<ConValue>>>)

An entire namespace

Quote(Box<Expr>)

A quoted expression

Function(Rc<Function>)

A callable thing

Closure(Rc<Closure>)

A closure, capturing by reference

Builtin(&'static Builtin)

A built-in function

Implementations

impl ConValue

pub fn truthy(&self) -> Result<bool, Error>

Gets whether the current value is true or false

pub fn TupleStruct( name: Interned<'static, str>, values: Box<[ConValue]>, ) -> ConValue

pub fn Struct( name: Interned<'static, str>, values: HashMap<Interned<'static, str>, ConValue>, ) -> ConValue

pub fn index( &self, index: &ConValue, env: &Environment, ) -> Result<ConValue, Error>

pub fn lt(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn lt_eq(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn eq(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn neq(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn gt_eq(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn gt(&self, other: &ConValue) -> Result<ConValue, Error>

TODO: Remove when functions are implemented: Desugar into function calls

pub fn add_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn bitand_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn bitor_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn bitxor_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn div_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn mul_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn rem_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn shl_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn shr_assign(&mut self, other: ConValue) -> Result<(), Error>

pub fn sub_assign(&mut self, other: ConValue) -> Result<(), Error>

Trait Implementations

impl Add for ConValue

fn add(self, rhs: ConValue) -> <ConValue as Add>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the + operator.

impl BitAnd for ConValue

fn bitand(self, rhs: ConValue) -> <ConValue as BitAnd>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the & operator.

impl BitOr for ConValue

fn bitor(self, rhs: ConValue) -> <ConValue as BitOr>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the | operator.

impl BitXor for ConValue

fn bitxor(self, rhs: ConValue) -> <ConValue as BitXor>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the ^ operator.

impl Callable for ConValue

fn name(&self) -> Interned<'static, str>

Returns the common name of this identifier.

fn call( &self, interpreter: &mut Environment, args: &[ConValue], ) -> Result<ConValue, Error>

Calls this Callable in the provided Environment, with ConValue args
The Callable is responsible for checking the argument count and validating types

impl Clone for ConValue

fn clone(&self) -> ConValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConValue

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

Formats the value using the given formatter.

impl Default for ConValue

fn default() -> ConValue

Returns the “default value” for a type.

impl Display for ConValue

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

Formats the value using the given formatter.

impl Div for ConValue

fn div(self, rhs: ConValue) -> <ConValue as Div>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the / operator.

impl From<&[ConValue]> for ConValue

fn from(value: &[ConValue]) -> ConValue

Converts to this type from the input type.

impl From<&'static Builtin> for ConValue

fn from(value: &'static Builtin) -> ConValue

Converts to this type from the input type.

impl From<&Interned<'static, str>> for ConValue

fn from(value: &Interned<'static, str>) -> ConValue

Converts to this type from the input type.

impl From<&str> for ConValue

fn from(value: &str) -> ConValue

Converts to this type from the input type.

impl From<()> for ConValue

fn from(_: ()) -> ConValue

Converts to this type from the input type.

impl From<Expr> for ConValue

fn from(value: Expr) -> ConValue

Converts to this type from the input type.

impl From<Function> for ConValue

fn from(value: Function) -> ConValue

Converts to this type from the input type.

impl From<Interned<'static, str>> for ConValue

fn from(value: Interned<'static, str>) -> ConValue

Converts to this type from the input type.

impl From<Rc<str>> for ConValue

fn from(value: Rc<str>) -> ConValue

Converts to this type from the input type.

impl From<String> for ConValue

fn from(value: String) -> ConValue

Converts to this type from the input type.

impl From<Vec<ConValue>> for ConValue

fn from(value: Vec<ConValue>) -> ConValue

Converts to this type from the input type.

impl From<bool> for ConValue

fn from(value: bool) -> ConValue

Converts to this type from the input type.

impl From<char> for ConValue

fn from(value: char) -> ConValue

Converts to this type from the input type.

impl From<f64> for ConValue

fn from(value: f64) -> ConValue

Converts to this type from the input type.

impl From<isize> for ConValue

fn from(value: isize) -> ConValue

Converts to this type from the input type.

impl Mul for ConValue

fn mul(self, rhs: ConValue) -> <ConValue as Mul>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the * operator.

impl Rem for ConValue

fn rem(self, rhs: ConValue) -> <ConValue as Rem>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the % operator.

impl Shl for ConValue

fn shl(self, rhs: ConValue) -> <ConValue as Shl>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the << operator.

impl Shr for ConValue

fn shr(self, rhs: ConValue) -> <ConValue as Shr>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the >> operator.

impl Sub for ConValue

fn sub(self, rhs: ConValue) -> <ConValue as Sub>::Output

TODO: Desugar operators into function calls

type Output = Result<ConValue, Error>

The resulting type after applying the - operator.