Archived
Will Anderson
114 lines
3.5 KiB
Rust
114 lines
3.5 KiB
Rust
//! Engram language standard library.
|
|
//!
|
|
//! This crate defines function signatures for the built-in standard library
|
|
//! modules. Each module registers its functions into a [`TypeEnv`] so the
|
|
//! type checker can resolve calls to stdlib functions without an explicit
|
|
//! import.
|
|
//!
|
|
//! # Auto-imported modules
|
|
//! - `std::array` — array operations
|
|
//! - `std::string` — string operations
|
|
//! - `std::result` — Result<T, E> operations
|
|
//! - `std::optional`— T? operations
|
|
//! - `std::math` — numeric operations
|
|
//! - `std::map` — Map<K, V> operations
|
|
//! - `std::engram` — Engram graph operations
|
|
|
|
pub mod array;
|
|
pub mod engram;
|
|
pub mod map;
|
|
pub mod math;
|
|
pub mod optional;
|
|
pub mod result;
|
|
pub mod string;
|
|
|
|
use el_types::{Type, TypeEnv};
|
|
|
|
/// Register all automatically-imported stdlib modules into the given environment.
|
|
///
|
|
/// Call this from `TypeEnv::with_builtins()` or at the start of type checking.
|
|
pub fn register_builtins(env: &mut TypeEnv) {
|
|
array::register(env);
|
|
string::register(env);
|
|
result::register(env);
|
|
optional::register(env);
|
|
math::register(env);
|
|
map::register(env);
|
|
engram::register(env);
|
|
}
|
|
|
|
/// Helper: build a simple function type.
|
|
pub(crate) fn fn_type(params: Vec<Type>, ret: Type) -> Type {
|
|
Type::Fn { params, return_type: Box::new(ret) }
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use el_types::TypeEnv;
|
|
|
|
fn stdlib_env() -> TypeEnv {
|
|
let mut env = TypeEnv::with_builtins();
|
|
register_builtins(&mut env);
|
|
env
|
|
}
|
|
|
|
#[test]
|
|
fn test_array_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("array_map").is_some(), "array_map should be registered");
|
|
assert!(env.lookup_fn("array_filter").is_some());
|
|
assert!(env.lookup_fn("array_length").is_some());
|
|
assert!(env.lookup_fn("array_push").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_string_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("string_len").is_some());
|
|
assert!(env.lookup_fn("string_trim").is_some());
|
|
assert!(env.lookup_fn("string_split").is_some());
|
|
assert!(env.lookup_fn("string_contains").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_math_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("math_abs").is_some());
|
|
assert!(env.lookup_fn("math_max").is_some());
|
|
assert!(env.lookup_fn("math_min").is_some());
|
|
assert!(env.lookup_fn("math_sqrt").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_result_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("result_unwrap_or").is_some());
|
|
assert!(env.lookup_fn("result_ok").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_optional_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("optional_unwrap_or").is_some());
|
|
assert!(env.lookup_fn("optional_is_some").is_some());
|
|
assert!(env.lookup_fn("optional_is_none").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_map_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("map_get").is_some());
|
|
assert!(env.lookup_fn("map_set").is_some());
|
|
assert!(env.lookup_fn("map_remove").is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_engram_functions_registered() {
|
|
let env = stdlib_env();
|
|
assert!(env.lookup_fn("engram_activate").is_some());
|
|
assert!(env.lookup_fn("engram_relate").is_some());
|
|
assert!(env.lookup_fn("engram_neighbors").is_some());
|
|
}
|
|
}
|