Enum LogosValue 

pub enum LogosValue {
    Int(i64),
    BigInt(Arc<BigInt>),
    Rational(Arc<Rational>),
    Float(f64),
    Decimal(Arc<Decimal>),
    Bool(bool),
    Text(Arc<str>),
    Nothing,
    List(Arc<Vec<LogosValue>>),
    Tuple(Arc<Vec<LogosValue>>),
    Algebraic(Arc<Algebraic>),
    ExactReal(Arc<ExactReal>),
    Hyperreal(Arc<HyperValue>),
    Hypernatural(Arc<NaturalValue>),
    Ordinal(Arc<Ordinal>),
    Depends(Arc<DependsValue<LogosValue>>),
    Converging(Arc<Converging<LogosValue>>),
    Other(Arc<dyn OtherValue>),
}

A value of a compiled program where the exact extension reaches. See the module documentation.

Variants

Int(i64)

BigInt(Arc<BigInt>)

An integer outside i64; never one that fits.

Rational(Arc<Rational>)

A rational that is not whole.

Float(f64)

Decimal(Arc<Decimal>)

Bool(bool)

Text(Arc<str>)

Nothing

List(Arc<Vec<LogosValue>>)

Tuple(Arc<Vec<LogosValue>>)

Algebraic(Arc<Algebraic>)

ExactReal(Arc<ExactReal>)

Hyperreal(Arc<HyperValue>)

Hypernatural(Arc<NaturalValue>)

Ordinal(Arc<Ordinal>)

Depends(Arc<DependsValue<LogosValue>>)

Converging(Arc<Converging<LogosValue>>)

Other(Arc<dyn OtherValue>)

A value of a kind the exact types do not mix with — a date, a span of time, a moment — held as its own compiled value, which prints, compares and combines as the interpreter’s does.

Implementations

impl LogosValue

pub fn from_bigint(b: BigInt) -> LogosValue

An integer in its smallest form.

pub fn from_rational(r: Rational) -> LogosValue

A rational in its smallest form: an integer when it is whole.

pub fn text(t: &str) -> LogosValue

Text.

pub fn list(items: Vec<LogosValue>) -> LogosValue

A list.

pub fn other(v: impl OtherValue) -> LogosValue

A value of a kind outside the exact tower.

pub fn other_as<T: OtherValue>(&self) -> Option<&T>

The compiled value of a kind outside the tower this holds, when it holds one of that kind.

pub fn infinitesimal( name: &str, modulus: i64, allowed: &[i64], ) -> Result<LogosValue, String>

The program’s infinitesimal named name, its reciprocal’s residues modulo modulus limited to allowed.

pub fn type_name(&self) -> &str

The value’s type as the language names it.

pub fn display_string(&self) -> String

How the value prints.

pub fn decided_truth(&self) -> Result<bool, String>

The truth a condition reads: a residue-dependent answer, or a provisional one no proof settled, is refused with the sentence every tier gives.

pub fn add(&self, o: &LogosValue) -> Result<LogosValue, String>

a + b.

pub fn sub(&self, o: &LogosValue) -> Result<LogosValue, String>

a − b.

pub fn mul(&self, o: &LogosValue) -> Result<LogosValue, String>

a × b.

pub fn div(&self, o: &LogosValue) -> Result<LogosValue, String>

The polymorphic /: two integers truncate, a rational divides exactly, a float divides as a float, the exact types divide in their field.

pub fn exact_div(&self, o: &LogosValue) -> Result<LogosValue, String>

/ in an exact context: every integer and rational divides exactly; a float defers to /.

pub fn floor_div(&self, o: &LogosValue) -> Result<LogosValue, String>

Floor division.

pub fn rem(&self, o: &LogosValue) -> Result<LogosValue, String>

The remainder of two integers, its sign the dividend’s.

pub fn pow(&self, o: &LogosValue) -> Result<LogosValue, String>

base ^ exponent.

pub fn relation(&self, rel: Rel, o: &LogosValue) -> Result<LogosValue, String>

a rel b: a Bool, or a residue-dependent one where the answer depends on ⌈1/dt⌉.

pub fn values_equal(&self, o: &LogosValue) -> bool

The language’s equality: exact across numeric types, structural on lists and tuples.

pub fn not(&self) -> Result<LogosValue, String>

not v, lifted over residue branches and through provisional values.

pub fn bit_and(&self, o: &LogosValue) -> Result<LogosValue, String>

a & b: bitwise on integers, logical on booleans, and a non-negative big integer under a low mask 2^k - 1 leaves its low k bits.

pub fn bit_or(&self, o: &LogosValue) -> Result<LogosValue, String>

a | b.

pub fn bit_xor(&self, o: &LogosValue) -> Result<LogosValue, String>

a ^ b.

pub fn shl(&self, o: &LogosValue) -> Result<LogosValue, String>

a << b, the count taken modulo the width.

pub fn shr(&self, o: &LogosValue) -> Result<LogosValue, String>

a >> b, the count taken modulo the width.

pub fn approx_eq(&self, o: &LogosValue) -> Result<LogosValue, String>

a is approximately b, on the two values as floats.

pub fn seq_concat(&self, o: &LogosValue) -> Result<LogosValue, String>

a followed by b: the items of two sequences, in order.

pub fn abs(&self) -> Result<LogosValue, String>

The builtin abs: exact on integers (promoting |i64::MIN|), rationals and decimals.

pub fn sqrt(&self) -> Result<LogosValue, String>

The builtin sqrt, a float.

pub fn min(&self, o: &LogosValue) -> Result<LogosValue, String>

The builtin min.

pub fn max(&self, o: &LogosValue) -> Result<LogosValue, String>

The builtin max.

pub fn power(&self, o: &LogosValue) -> Result<LogosValue, String>

The builtin pow: an integer power is exact, a negative one a float.

pub fn length_of(&self) -> Result<i64, String>

length of self: a list’s or a tuple’s item count, a text’s byte count.

pub fn contains_value(&self, value: &LogosValue) -> Result<bool, String>

self contains value: an equal item of a list, a substring of a text.

pub fn items(&self) -> Result<Vec<LogosValue>, String>

The values a Repeat over self binds, taken once before the loop runs: a list’s items, a text’s characters.

pub fn push_value(&mut self, value: LogosValue) -> Result<(), String>

Push value to self.

pub fn set_item( &mut self, index: &LogosValue, value: LogosValue, ) -> Result<(), String>

Set item index of self to value.

pub fn pop_value(&mut self) -> Result<LogosValue, String>

Pop from self: the last item, or nothing from an empty list.

pub fn item(&self, index: &LogosValue) -> Result<LogosValue, String>

item index of self: the 1-based item of a list or a tuple, the character of a text.

pub fn slice( &self, start: &LogosValue, end: &LogosValue, ) -> Result<LogosValue, String>

items start through end of self: the 1-based, inclusive run of a list’s items (crate::logos_slice_range); one that reaches outside the list is empty.

pub fn integer_at(&self, past_word: &str, fraction: &str) -> Result<i64, String>

The machine integer this is where the language takes one: refused with past_word for an integer past i64, with fraction for a rational that is not whole, and by its type for any other value.

pub fn into_real(self) -> f64

The real an operator over a real answers.

pub fn floor(&self) -> Result<LogosValue, String>

The language’s floor.

pub fn ceil(&self) -> Result<LogosValue, String>

The language’s ceil.

pub fn round(&self) -> Result<LogosValue, String>

The language’s round.

impl LogosValue

pub fn defined_real( kind: &str, base: i64, name: &str, f: impl Fn(i64) -> LogosValue + Send + Sync + 'static, ) -> LogosValue

The real number f defines by its digits in base or its approximations (kind, as logicaffeine_base::exact_real::Definition::named reads it), name being how the program spells f.

pub fn define_real( kind: &str, base: i64, name: &str, f: impl Fn(i64) -> Result<LogosValue, String> + Send + Sync + 'static, ) -> Result<LogosValue, String>

LogosValue::defined_real for a function that may refuse an answer, refused itself when kind and base name no definition.

pub fn sendable(&self) -> Result<(), String>

Ok when the value may cross to a task, Err with the interpreter’s sentence when it holds a real number a function of the program defines, which stays with the program.

Trait Implementations

impl Clone for LogosValue

fn clone(&self) -> LogosValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogosValue

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

Formats the value using the given formatter.

impl Default for LogosValue

An unset slot of an exact type, as the interpreter starts one: nothing.

fn default() -> Self

Returns the “default value” for a type.

impl Display for LogosValue

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

Formats the value using the given formatter.

impl From<&str> for LogosValue

fn from(t: &str) -> Self

Converts to this type from the input type.

impl From<()> for LogosValue

fn from(_: ()) -> Self

Converts to this type from the input type.

impl From<LogosDate> for LogosValue

fn from(d: LogosDate) -> Self

Converts to this type from the input type.

impl From<LogosDecimal> for LogosValue

fn from(d: LogosDecimal) -> Self

Converts to this type from the input type.

impl From<LogosInt> for LogosValue

fn from(n: LogosInt) -> Self

Converts to this type from the input type.

impl From<LogosMoment> for LogosValue

fn from(m: LogosMoment) -> Self

Converts to this type from the input type.

impl From<LogosRational> for LogosValue

fn from(r: LogosRational) -> Self

Converts to this type from the input type.

impl<T: Clone + Into<LogosValue>> From<LogosSeq<T>> for LogosValue

fn from(items: LogosSeq<T>) -> Self

Converts to this type from the input type.

impl From<LogosSpan> for LogosValue

fn from(s: LogosSpan) -> Self

Converts to this type from the input type.

impl From<LogosTime> for LogosValue

fn from(t: LogosTime) -> Self

Converts to this type from the input type.

impl From<String> for LogosValue

fn from(t: String) -> Self

Converts to this type from the input type.

impl<T: Into<LogosValue>> From<Vec<T>> for LogosValue

fn from(items: Vec<T>) -> Self

Converts to this type from the input type.

impl From<bool> for LogosValue

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<f64> for LogosValue

fn from(f: f64) -> Self

Converts to this type from the input type.

impl From<i128> for LogosValue

fn from(n: i128) -> Self

Converts to this type from the input type.

impl From<i16> for LogosValue

fn from(n: i16) -> Self

Converts to this type from the input type.

impl From<i32> for LogosValue

fn from(n: i32) -> Self

Converts to this type from the input type.

impl From<i64> for LogosValue

fn from(n: i64) -> Self

Converts to this type from the input type.

impl From<i8> for LogosValue

fn from(n: i8) -> Self

Converts to this type from the input type.

impl From<u128> for LogosValue

fn from(n: u128) -> Self

Converts to this type from the input type.

impl From<u16> for LogosValue

fn from(n: u16) -> Self

Converts to this type from the input type.

impl From<u32> for LogosValue

fn from(n: u32) -> Self

Converts to this type from the input type.

impl From<u64> for LogosValue

fn from(n: u64) -> Self

Converts to this type from the input type.

impl From<u8> for LogosValue

fn from(n: u8) -> Self

Converts to this type from the input type.

impl From<usize> for LogosValue

fn from(n: usize) -> Self

Converts to this type from the input type.

impl LogosIndex<LogosValue> for LogosValue

type Output = LogosValue

The type of element returned by indexing.

fn logos_get(&self, index: LogosValue) -> LogosValue

Get the element at the given index.

impl LogosIndex<i64> for LogosValue

type Output = LogosValue

The type of element returned by indexing.

fn logos_get(&self, index: i64) -> LogosValue

Get the element at the given index.

impl PartialEq for LogosValue

fn eq(&self, o: &Self) -> 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 TowerValue for LogosValue

fn exact(&self) -> Option<ExactRef<'_, Self>>

The value as one of the exact types, or None for any other value.

fn standard_rational(&self) -> Option<Rational>

An integer, rational, decimal or finite float as the rational it denotes exactly.

fn integer(&self) -> Option<BigInt>

An Int or big integer.

fn exact_rational(&self) -> Option<Rational>

An integer or a rational: a number held exactly, never a float or a decimal.

fn is_standard_number(&self) -> bool

An integer, rational, decimal or float: its own standard part.

fn text(&self) -> Option<&str>

A Text value’s characters.

fn type_name(&self) -> String

The value’s type as the language names it.

fn display_string(&self) -> String

How the value prints.

fn values_equal(&self, other: &Self) -> bool

The language’s equality on two values.

fn is_nothing(&self) -> bool

Whether the value is nothing.

fn from_rational(r: Rational) -> Self

A rational in its smallest form: an Int when it fits, a big integer, else a rational.

fn from_bigint(b: BigInt) -> Self

An integer in its smallest form.

fn boolean(b: bool) -> Self

fn nothing() -> Self

fn algebraic(a: Algebraic) -> Self

fn exact_real(x: ExactReal) -> Self

fn hyper(h: HyperValue) -> Self

fn natural(n: NaturalValue) -> Self

fn ordinal(o: Ordinal) -> Self

fn depends(d: DependsValue<Self>) -> Self

fn converging(c: Converging<Self>) -> Self

impl Truthy for LogosValue

fn truthy(&self) -> bool

impl ValueAlgebra for LogosValue

fn add(a: Self, b: Self) -> Result<Self, String>

fn subtract(a: Self, b: Self) -> Result<Self, String>

fn multiply(a: Self, b: Self) -> Result<Self, String>

fn exact_divide(a: Self, b: Self) -> Result<Self, String>

/ in an exact context: field division, integers included.

fn modulo(a: Self, b: Self) -> Result<Self, String>

The language’s %.

fn power(a: Self, b: Self) -> Result<Self, String>

The language’s **.

fn holds(rel: Rel, a: &Self, b: &Self) -> Result<bool, String>

Whether a rel b holds, decided: an answer that depends on the residue, or a provisional one, is the refusal of the branch.

fn floor(v: Self) -> Result<Self, String>

The language’s floor.

fn ceil(v: Self) -> Result<Self, String>

The language’s ceiling.

fn list(values: Vec<Self>) -> Self

fn shape(&self) -> Shape<Self>