102 lines
2.4 KiB
Rust
102 lines
2.4 KiB
Rust
use super::{Value, VariableType};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct FunctionSignature {
|
|
pub name: String,
|
|
pub parameters: Vec<VariableType>,
|
|
}
|
|
|
|
impl FunctionSignature {
|
|
pub fn new<T: Into<String>>(name: T, params: Vec<VariableType>) -> FunctionSignature {
|
|
FunctionSignature {
|
|
name: name.into(),
|
|
parameters: params,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for FunctionSignature {
|
|
fn eq(&self, other: &FunctionSignature) -> bool {
|
|
if self.name == other.name && self.parameters.len() == other.parameters.len() {
|
|
let mut found_difference = false;
|
|
for (idx, t) in self.parameters.iter().enumerate() {
|
|
if other.parameters[idx] != *t {
|
|
found_difference = true;
|
|
}
|
|
}
|
|
!found_difference
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<BuiltinFunctionDef> for FunctionSignature {
|
|
fn from(from: BuiltinFunctionDef) -> FunctionSignature {
|
|
from.signature
|
|
}
|
|
}
|
|
|
|
pub enum FunctionDef {
|
|
Builtin(BuiltinFunctionDef),
|
|
}
|
|
|
|
impl FunctionDef {
|
|
fn get_signature(&self) -> &FunctionSignature {
|
|
match self {
|
|
FunctionDef::Builtin(func) => &func.signature,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for FunctionDef {
|
|
fn eq(&self, other: &FunctionDef) -> bool {
|
|
self.get_signature() == other.get_signature()
|
|
}
|
|
}
|
|
|
|
impl PartialEq<FunctionSignature> for FunctionDef {
|
|
fn eq(&self, other: &FunctionSignature) -> bool {
|
|
self.get_signature() == other
|
|
}
|
|
}
|
|
|
|
pub struct BuiltinFunctionDef {
|
|
pub signature: FunctionSignature,
|
|
pub function: Box<dyn Fn(Vec<Value>)>,
|
|
}
|
|
|
|
impl BuiltinFunctionDef {
|
|
pub fn new<T: Into<String>>(
|
|
name: T,
|
|
parameters: Vec<VariableType>,
|
|
func: Box<dyn Fn(Vec<Value>)>,
|
|
) -> BuiltinFunctionDef {
|
|
BuiltinFunctionDef {
|
|
signature: FunctionSignature {
|
|
name: name.into(),
|
|
parameters,
|
|
},
|
|
function: func,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct BuiltinFunctions(pub Vec<BuiltinFunctionDef>);
|
|
|
|
impl BuiltinFunctions {
|
|
pub fn signatures(&self) -> Vec<FunctionSignature> {
|
|
let mut signatures = Vec::new();
|
|
for func in &self.0 {
|
|
signatures.push(func.signature.clone());
|
|
}
|
|
signatures
|
|
}
|
|
}
|
|
|
|
impl From<BuiltinFunctions> for Vec<BuiltinFunctionDef> {
|
|
fn from(builtin: BuiltinFunctions) -> Self {
|
|
builtin.0
|
|
}
|
|
}
|