numbat 1.23.0

A statically typed programming language for scientific computations with first class support for physical dimensions and units.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

mod currency;
mod datetime;
mod functions;
mod lists;
mod lookup;
mod macros;
mod math;
mod plot;
mod procedures;
mod strings;

use std::collections::VecDeque;

use crate::interpreter::{RuntimeError, RuntimeErrorKind};
use crate::span::Span;
use crate::typechecker::type_scheme::TypeScheme;
use crate::unit::Unit;
use crate::value::Value;
use crate::vm::{Constant, ExecutionContext};

type ControlFlow = std::ops::ControlFlow<RuntimeErrorKind>;

pub(crate) type ArityRange = std::ops::RangeInclusive<usize>;

type Result<T, E = Box<RuntimeError>> = std::result::Result<T, E>;

pub(crate) struct Arg {
    pub value: Value,
    pub type_: TypeScheme,
    pub span: Span,
}

pub(crate) type Args = VecDeque<Arg>;

/// Context passed to FFI functions, providing access to runtime state.
pub struct FfiContext<'a, 'b> {
    pub ctx: &'a mut ExecutionContext<'b>,
    constants: &'a [Constant],
}

impl<'a, 'b> FfiContext<'a, 'b> {
    pub fn new(ctx: &'a mut ExecutionContext<'b>, constants: &'a [Constant]) -> Self {
        Self { ctx, constants }
    }

    /// Look up a unit by name from the constants table.
    pub fn lookup_unit(&self, name: &str) -> Option<Unit> {
        self.ctx
            .unit_name_to_constant_idx
            .get(name)
            .and_then(|&idx| self.constants.get(idx as usize))
            .and_then(|c| match c {
                Constant::Unit(u) => Some(u.clone()),
                _ => None,
            })
    }
}

/// FFI function signature: (ffi_context, args, return_type) -> Result
type FfiFunctionFn = fn(&mut FfiContext, Args, &TypeScheme) -> Result<Value, Box<RuntimeErrorKind>>;

pub(crate) enum Callable {
    Function(FfiFunctionFn),
    Procedure(fn(&mut ExecutionContext, Args) -> ControlFlow),
}

pub(crate) struct ForeignFunction {
    pub(crate) arity: ArityRange,
    pub(crate) callable: Callable,
}

pub(crate) use functions::functions;
pub(crate) use procedures::procedures;