ksl 0.1.30

//! # ksl::builtin
//!
//! Defines the constants and functions built into KSL
//! and the associated evaluation functions.

mod anl;
mod ano;
mod bimath;
mod bit;
mod block;
mod channel;
mod chars;
mod consume;
mod delete;
mod do_;
mod eq;
mod filter;
mod find;
mod fs;
mod fun;
mod get;
mod get_type;
mod glt;
mod has;
mod head;
mod if_;
mod index;
mod input;
mod is;
mod json;
mod keys;
mod length;
mod let_;
mod list;
mod load;
mod map;
mod math;
mod module;
mod multi;
mod not;
mod object;
mod parse_number;
mod pend;
mod plugin;
mod print;
mod range;
mod read;
mod reduce;
mod regex;
mod reverse;
mod set;
mod shell;
mod sleep;
mod split_by;
mod string_case;
mod substring;
mod tail;
mod thread;
mod time;
mod to_string;
mod trim;
mod try_;
mod use_;
mod while_;
mod write;

use crate::{Environment, value::Value};

/// KSL file extension.
const FILE_EXT: &str = "ksl";
/// Literal value corresponding to the boolean true in Atom.
pub static TRUE_SYMBOL: std::sync::LazyLock<Value> = std::sync::LazyLock::new(|| Value::Atom(std::sync::Arc::from("t")));
/// Literal value corresponding to the boolean false in Atom.
pub static FALSE_SYMBOL: std::sync::LazyLock<Value> = std::sync::LazyLock::new(|| Value::Atom(std::sync::Arc::from("f")));
/// Literal value corresponding to the ok tag in Atom.
pub static OK_SYMBOL: std::sync::LazyLock<Value> = std::sync::LazyLock::new(|| Value::Atom(std::sync::Arc::from("ok")));
/// Literal value corresponding to the error tag in Atom.
pub static ERR_SYMBOL: std::sync::LazyLock<Value> = std::sync::LazyLock::new(|| Value::Atom(std::sync::Arc::from("err")));
/// Command line arguments in environment as key's literal value.
pub static ENV_ARGS_ENV: std::sync::LazyLock<std::sync::Arc<str>> =
    std::sync::LazyLock::new(|| std::sync::Arc::from("ENV_ARGS"));
/// Literal value of the KSL_PATH environment variable.
pub const KSL_PATH_ENV: &str = "KSL_PATH";
pub(crate) static DEFAULT_KSL_PATH: std::sync::LazyLock<std::sync::Arc<str>> =
    std::sync::LazyLock::new(|| std::sync::Arc::from("~/.local/share/ksl"));
/// Imported module path list in environment as key's literal value.
pub static MODULE_PATH_ENV: std::sync::LazyLock<std::sync::Arc<str>> =
    std::sync::LazyLock::new(|| std::sync::Arc::from("MODULE_PATH"));
/// Module name in environment as key's literal value.
pub static MODULE_NAME_ENV: std::sync::LazyLock<std::sync::Arc<str>> =
    std::sync::LazyLock::new(|| std::sync::Arc::from("MODULE_NAME"));
/// List of built-in functions.
pub const BUILTIN_FUNCTIONS: [&str; 142] = [
    "Abs",
    "Add",
    "All",
    "And",
    "Any",
    "Append",
    "ArcCos",
    "ArcSin",
    "ArcTan",
    "ArcTan2",
    "Band",
    "Block",
    "Bor",
    "Bxor",
    "Cd",
    "Ceiling",
    "Chars",
    "Chn",
    "Concat",
    "Cond",
    "Consume",
    "Cos",
    "Cosh",
    "Delete",
    "Div",
    "Do",
    "Drop",
    "DropReceiver",
    "DropSender",
    "Eq",
    "Evial",
    "Exit",
    "Exp",
    "FileMeta",
    "Filter",
    "Find",
    "Floor",
    "FromJSON",
    "Fstr",
    "Fun",
    "Get",
    "GetChar",
    "GetDate",
    "GetEnv",
    "GetTime",
    "GetType",
    "Glob",
    "Greater",
    "Has",
    "Head",
    "If",
    "Index",
    "Input",
    "Insert",
    "IsAtom",
    "IsBuiltin",
    "IsInteger",
    "IsLambda",
    "IsList",
    "IsMember",
    "IsNativeObject",
    "IsNumber",
    "IsObject",
    "IsPlugin",
    "IsString",
    "IsThread",
    "IsUnit",
    "Keys",
    "Length",
    "Less",
    "Let",
    "Ln",
    "Load",
    "Lowercase",
    "Many",
    "Map",
    "Max",
    "Min",
    "Mkdir",
    "Mod",
    "Module",
    "Mul",
    "NDiv",
    "Neg",
    "Not",
    "Object",
    "OpenChannel",
    "Or",
    "PadLeft",
    "PadRight",
    "ParseNumber",
    "Plugin",
    "Power",
    "Prepend",
    "Print",
    "Pwd",
    "Quot",
    "Range",
    "Read",
    "ReCapture",
    "ReceiveValue",
    "Reduce",
    "Rem",
    "ReMatch",
    "Remove",
    "Reverse",
    "Rm",
    "Round",
    "RunShell",
    "SendValue",
    "Set",
    "SetEnv",
    "ShiftL",
    "ShiftR",
    "Sin",
    "Sinh",
    "Sleep",
    "SlideBy",
    "SplitBy",
    "Sqrt",
    "Sub",
    "SubString",
    "Tail",
    "Take",
    "Tan",
    "Tanh",
    "Thread",
    "Timeit",
    "ToJSON",
    "ToString",
    "Trim",
    "Trunc",
    "Try",
    "Unit",
    "Update",
    "Uppercase",
    "Use",
    "While",
    "Write",
    "WriteTerm",
    "Zip",
    "ZipWith",
];

#[derive(Debug)]
enum MathFunctionType {
    Abs,
    ArcCos,
    ArcSin,
    ArcTan,
    Ceiling,
    Cos,
    Cosh,
    Exp,
    Floor,
    Ln,
    Neg,
    Round,
    Sin,
    Sinh,
    Sqrt,
    Tan,
    Tanh,
    Trunc,
}

#[derive(Debug)]
enum BiMathType {
    ArcTan2,
    Div,
    Max,
    Min,
    Mod,
    NDiv,
    Power,
    Quot,
    Rem,
    Sub,
}

#[derive(Debug)]
enum MultiFunctionType {
    Add,
    Concat,
    Mul,
}

#[derive(Debug)]
enum ValueType {
    Atom,
    Builtin,
    Integer,
    Lambda,
    List,
    NativeObject,
    Number,
    Object,
    Plugin,
    String,
    Thread,
    Unit,
}

/// Evaluate built-in functions.
pub(crate) fn eval_builtin(symbol: &str, args: &[Value], env: Environment) -> Result<Value, std::sync::Arc<str>> {
    match symbol {
        "Abs" => math::builtin(args, MathFunctionType::Abs, env),
        "Add" => multi::builtin(args, MultiFunctionType::Add, env),
        "All" => anl::builtin(args, false, env),
        "And" => ano::builtin(args, true, env),
        "Any" => anl::builtin(args, true, env),
        "Append" => pend::builtin(args, false, env),
        "ArcCos" => math::builtin(args, MathFunctionType::ArcCos, env),
        "ArcSin" => math::builtin(args, MathFunctionType::ArcSin, env),
        "ArcTan" => math::builtin(args, MathFunctionType::ArcTan, env),
        "ArcTan2" => bimath::builtin(args, BiMathType::ArcTan2, env),
        "Band" => bit::band(args, env),
        "Block" => block::builtin(args, env),
        "Bor" => bit::bor(args, env),
        "Bxor" => bit::bxor(args, env),
        "Cd" => fs::cd(args, env),
        "Ceiling" => math::builtin(args, MathFunctionType::Ceiling, env),
        "Chars" => chars::builtin(args, env),
        "Chn" => regex::chn(args, env),
        "Concat" => multi::builtin(args, MultiFunctionType::Concat, env),
        "Cond" => list::cond(args, env),
        "Consume" => consume::builtin(args, env),
        "Cos" => math::builtin(args, MathFunctionType::Cos, env),
        "Cosh" => math::builtin(args, MathFunctionType::Cosh, env),
        "Delete" => delete::builtin(args, env),
        "Div" => bimath::builtin(args, BiMathType::Div, env),
        "Do" => do_::builtin(args, env),
        "Drop" => list::drop(args, env),
        "DropReceiver" => channel::drop_receiver(args, env),
        "DropSender" => channel::drop_sender(args, env),
        "Eq" => eq::builtin(args, env),
        "Evial" => shell::evial(args, env),
        "Exit" => shell::exit(args, env),
        "Exp" => math::builtin(args, MathFunctionType::Exp, env),
        "FileMeta" => fs::file_meta(args, env),
        "Filter" => filter::builtin(args, env),
        "Find" => find::builtin(args, env),
        "Floor" => math::builtin(args, MathFunctionType::Floor, env),
        "FromJSON" => json::from_json(args, env),
        "Fstr" => regex::fstr(args, env),
        "Fun" => fun::builtin(args, env),
        "Get" => get::builtin(args, env),
        "GetChar" => shell::get_char(args, env),
        "GetDate" => time::get_date(args, env),
        "GetEnv" => shell::get_env(args, env),
        "GetTime" => time::get_time(args, env),
        "GetType" => get_type::builtin(args, env),
        "Glob" => fs::glob(args, env),
        "Greater" => glt::builtin(args, true, env),
        "Has" => has::builtin(args, env),
        "Head" => head::builtin(args, env),
        "If" => if_::builtin(args, env),
        "Index" => index::builtin(args, env),
        "Input" => input::builtin(args, env),
        "Insert" => list::insert(args, env),
        "IsAtom" => is::builtin(args, ValueType::Atom, env),
        "IsBuiltin" => is::builtin(args, ValueType::Builtin, env),
        "IsInteger" => is::builtin(args, ValueType::Integer, env),
        "IsLambda" => is::builtin(args, ValueType::Lambda, env),
        "IsList" => is::builtin(args, ValueType::List, env),
        "IsMember" => list::is_member(args, env),
        "IsNumber" => is::builtin(args, ValueType::Number, env),
        "IsObject" => is::builtin(args, ValueType::Object, env),
        "IsPlugin" => is::builtin(args, ValueType::Plugin, env),
        "IsNativeObject" => is::builtin(args, ValueType::NativeObject, env),
        "IsString" => is::builtin(args, ValueType::String, env),
        "IsThread" => is::builtin(args, ValueType::Thread, env),
        "IsUnit" => is::builtin(args, ValueType::Unit, env),
        "Keys" => keys::builtin(args, env),
        "Length" => length::builtin(args, env),
        "Less" => glt::builtin(args, false, env),
        "Let" => let_::builtin(args, false, env),
        "Ln" => math::builtin(args, MathFunctionType::Ln, env),
        "Load" => load::builtin(args, env),
        "Lowercase" => string_case::builtin(args, false, env),
        "Many" => range::many(args, env),
        "Map" => map::builtin(args, env),
        "Max" => bimath::builtin(args, BiMathType::Max, env),
        "Min" => bimath::builtin(args, BiMathType::Min, env),
        "Mkdir" => fs::mkdir(args, env),
        "Mod" => bimath::builtin(args, BiMathType::Mod, env),
        "Module" => module::builtin(args, env),
        "Mul" => multi::builtin(args, MultiFunctionType::Mul, env),
        "NDiv" => bimath::builtin(args, BiMathType::NDiv, env),
        "Neg" => math::builtin(args, MathFunctionType::Neg, env),
        "Not" => not::builtin(args, env),
        "Object" => object::builtin(args, env),
        "OpenChannel" => channel::open_channel(args, env),
        "Or" => ano::builtin(args, false, env),
        "PadLeft" => list::pad_left(args, env),
        "PadRight" => list::pad_right(args, env),
        "ParseNumber" => parse_number::builtin(args, env),
        "Plugin" => plugin::builtin(args, env),
        "Power" => bimath::builtin(args, BiMathType::Power, env),
        "Prepend" => pend::builtin(args, true, env),
        "Print" => print::builtin(args, env),
        "Pwd" => fs::pwd(args, env),
        "Quot" => bimath::builtin(args, BiMathType::Quot, env),
        "Range" => range::builtin(args, env),
        "Read" => read::builtin(args, env),
        "ReCapture" => regex::re_capture(args, env),
        "ReceiveValue" => channel::receive_value(args, env),
        "Reduce" => reduce::builtin(args, env),
        "Rem" => bimath::builtin(args, BiMathType::Rem, env),
        "ReMatch" => regex::re_match(args, env),
        "Remove" => list::remove(args, env),
        "Reverse" => reverse::builtin(args, env),
        "Rm" => fs::rm(args, env),
        "Round" => math::builtin(args, MathFunctionType::Round, env),
        "RunShell" => shell::run_shell(args, env),
        "SendValue" => channel::send_value(args, env),
        "Set" => set::builtin(args, env),
        "SetEnv" => shell::set_env(args, env),
        "ShiftL" => bit::shift_l(args, env),
        "ShiftR" => bit::shift_r(args, env),
        "Sin" => math::builtin(args, MathFunctionType::Sin, env),
        "Sinh" => math::builtin(args, MathFunctionType::Sinh, env),
        "Sleep" => sleep::builtin(args, env),
        "SlideBy" => list::slide_by(args, env),
        "SplitBy" => split_by::builtin(args, env),
        "Sqrt" => math::builtin(args, MathFunctionType::Sqrt, env),
        "Sub" => bimath::builtin(args, BiMathType::Sub, env),
        "SubString" => substring::builtin(args, env),
        "Tail" => tail::builtin(args, env),
        "Take" => list::take(args, env),
        "Tan" => math::builtin(args, MathFunctionType::Tan, env),
        "Tanh" => math::builtin(args, MathFunctionType::Tanh, env),
        "Thread" => thread::builtin(args, env),
        "Timeit" => time::time_it(args, env),
        "ToJSON" => json::to_json(args, env),
        "ToString" => to_string::builtin(args, env),
        "Trim" => trim::builtin(args, env),
        "Trunc" => math::builtin(args, MathFunctionType::Trunc, env),
        "Try" => try_::builtin(args, env),
        "Unit" => {
            // Unit.
            if args.is_empty() {
                Ok(Value::Unit)
            } else {
                Err(std::sync::Arc::from(format!(
                    concat!(
                        "Error[ksl::builtin::Object]: ",
                        "Expected no parameters, but {} were passed."
                    ),
                    args.len()
                )))
            }
        }
        "Update" => let_::builtin(args, true, env),
        "Uppercase" => string_case::builtin(args, true, env),
        "Use" => use_::builtin(args, env),
        "While" => while_::builtin(args, env),
        "Write" => write::builtin(args, env),
        "WriteTerm" => shell::write_term(args, env),
        "Zip" => list::zip(args, env),
        "ZipWith" => list::zip_with(args, env),
        builtin_name => Err(std::sync::Arc::from(format!(
            concat!(
                "Error[ksl::builtin::eval_builtin]: ",
                "Function `{}` is not implemented yet."
            ),
            builtin_name
        ))),
    }
}