640 lines
21 KiB
Rust
640 lines
21 KiB
Rust
/*!
|
|
* Box Operator Implementations - Trait-Based Operator Overloading
|
|
*
|
|
* This module implements the new trait-based operator system for basic Box types.
|
|
* It provides implementations of NyashAdd, NyashSub, etc. for IntegerBox, StringBox,
|
|
* and other fundamental types.
|
|
*
|
|
* Based on AI consultation decision (2025-08-10): Rust-style traits with
|
|
* static/dynamic hybrid dispatch for optimal performance.
|
|
*/
|
|
|
|
use crate::box_trait::{BoolBox, IntegerBox, NyashBox, StringBox};
|
|
use crate::boxes::FloatBox;
|
|
use crate::operator_traits::{
|
|
DynamicAdd, DynamicDiv, DynamicMul, DynamicSub, NyashAdd, NyashDiv, NyashMul, NyashSub,
|
|
OperatorError,
|
|
};
|
|
|
|
// Small helpers to reduce duplication in dynamic operators
|
|
#[inline]
|
|
fn concat_result(left: &dyn NyashBox, right: &dyn NyashBox) -> Box<dyn NyashBox> {
|
|
let l = left.to_string_box();
|
|
let r = right.to_string_box();
|
|
Box::new(StringBox::new(format!("{}{}", l.value, r.value)))
|
|
}
|
|
|
|
#[inline]
|
|
fn can_repeat(times: i64) -> bool {
|
|
(0..=10_000).contains(×)
|
|
}
|
|
|
|
// ===== Static numeric operators (macro-generated) =====
|
|
macro_rules! impl_static_numeric_ops {
|
|
($ty:ty, $zero:expr) => {
|
|
impl NyashAdd<$ty> for $ty {
|
|
type Output = $ty;
|
|
fn add(self, rhs: $ty) -> Self::Output {
|
|
< $ty >::new(self.value + rhs.value)
|
|
}
|
|
}
|
|
|
|
impl NyashSub<$ty> for $ty {
|
|
type Output = $ty;
|
|
fn sub(self, rhs: $ty) -> Self::Output {
|
|
< $ty >::new(self.value - rhs.value)
|
|
}
|
|
}
|
|
|
|
impl NyashMul<$ty> for $ty {
|
|
type Output = $ty;
|
|
fn mul(self, rhs: $ty) -> Self::Output {
|
|
< $ty >::new(self.value * rhs.value)
|
|
}
|
|
}
|
|
|
|
impl NyashDiv<$ty> for $ty {
|
|
type Output = Result<$ty, OperatorError>;
|
|
fn div(self, rhs: $ty) -> Self::Output {
|
|
if rhs.value == $zero {
|
|
Err(OperatorError::DivisionByZero)
|
|
} else {
|
|
Ok(< $ty >::new(self.value / rhs.value))
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_static_numeric_ops!(IntegerBox, 0);
|
|
|
|
/// Dynamic dispatch implementation for IntegerBox
|
|
impl DynamicAdd for IntegerBox {
|
|
fn try_add(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// IntegerBox + IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(IntegerBox::new(self.value + other_int.value)));
|
|
}
|
|
|
|
// IntegerBox + FloatBox -> FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(
|
|
self.value as f64 + other_float.value,
|
|
)));
|
|
}
|
|
|
|
// Fallback: Convert both to strings and concatenate (existing AddBox behavior)
|
|
Some(concat_result(self, other))
|
|
}
|
|
|
|
fn can_add_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox" | "FloatBox" | "StringBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicSub for IntegerBox {
|
|
fn try_sub(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// IntegerBox - IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(IntegerBox::new(self.value - other_int.value)));
|
|
}
|
|
|
|
// IntegerBox - FloatBox -> FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(
|
|
self.value as f64 - other_float.value,
|
|
)));
|
|
}
|
|
|
|
None // Subtraction not supported for other types
|
|
}
|
|
|
|
fn can_sub_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox" | "FloatBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicMul for IntegerBox {
|
|
fn try_mul(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// IntegerBox * IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(IntegerBox::new(self.value * other_int.value)));
|
|
}
|
|
|
|
// IntegerBox * FloatBox -> FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(
|
|
self.value as f64 * other_float.value,
|
|
)));
|
|
}
|
|
|
|
// IntegerBox * StringBox -> Repeated string
|
|
if let Some(other_str) = other.as_any().downcast_ref::<StringBox>() {
|
|
if can_repeat(self.value) {
|
|
let repeated = other_str.value.repeat(self.value as usize);
|
|
return Some(Box::new(StringBox::new(repeated)));
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_mul_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox" | "FloatBox" | "StringBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicDiv for IntegerBox {
|
|
fn try_div(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// IntegerBox / IntegerBox -> FloatBox (for precision)
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
if other_int.value == 0 {
|
|
return None; // Division by zero
|
|
}
|
|
return Some(Box::new(FloatBox::new(
|
|
self.value as f64 / other_int.value as f64,
|
|
)));
|
|
}
|
|
|
|
// IntegerBox / FloatBox -> FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
if other_float.value == 0.0 {
|
|
return None; // Division by zero
|
|
}
|
|
return Some(Box::new(FloatBox::new(
|
|
self.value as f64 / other_float.value,
|
|
)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_div_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox" | "FloatBox")
|
|
}
|
|
}
|
|
|
|
impl_static_numeric_ops!(FloatBox, 0.0);
|
|
|
|
// ===== FloatBox Dynamic Operator Implementations =====
|
|
|
|
impl DynamicAdd for FloatBox {
|
|
fn try_add(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// FloatBox + FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value + other_float.value)));
|
|
}
|
|
|
|
// FloatBox + IntegerBox -> FloatBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value + other_int.value as f64)));
|
|
}
|
|
|
|
// Fallback: Convert both to strings and concatenate
|
|
Some(concat_result(self, other))
|
|
}
|
|
|
|
fn can_add_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "FloatBox" | "IntegerBox" | "StringBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicSub for FloatBox {
|
|
fn try_sub(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// FloatBox - FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value - other_float.value)));
|
|
}
|
|
|
|
// FloatBox - IntegerBox -> FloatBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value - other_int.value as f64)));
|
|
}
|
|
|
|
None // Subtraction not supported for other types
|
|
}
|
|
|
|
fn can_sub_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "FloatBox" | "IntegerBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicMul for FloatBox {
|
|
fn try_mul(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// FloatBox * FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value * other_float.value)));
|
|
}
|
|
|
|
// FloatBox * IntegerBox -> FloatBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
return Some(Box::new(FloatBox::new(self.value * other_int.value as f64)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_mul_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "FloatBox" | "IntegerBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicDiv for FloatBox {
|
|
fn try_div(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// FloatBox / FloatBox
|
|
if let Some(other_float) = other.as_any().downcast_ref::<FloatBox>() {
|
|
if other_float.value == 0.0 {
|
|
return None; // Division by zero
|
|
}
|
|
return Some(Box::new(FloatBox::new(self.value / other_float.value)));
|
|
}
|
|
|
|
// FloatBox / IntegerBox -> FloatBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
if other_int.value == 0 {
|
|
return None; // Division by zero
|
|
}
|
|
return Some(Box::new(FloatBox::new(self.value / other_int.value as f64)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_div_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "FloatBox" | "IntegerBox")
|
|
}
|
|
}
|
|
|
|
// ===== StringBox Operator Implementations =====
|
|
|
|
/// StringBox + StringBox -> StringBox (concatenation)
|
|
impl NyashAdd<StringBox> for StringBox {
|
|
type Output = StringBox;
|
|
|
|
fn add(self, rhs: StringBox) -> Self::Output {
|
|
StringBox::new(format!("{}{}", self.value, rhs.value))
|
|
}
|
|
}
|
|
|
|
/// StringBox * IntegerBox -> StringBox (repetition)
|
|
impl NyashMul<IntegerBox> for StringBox {
|
|
type Output = StringBox;
|
|
|
|
fn mul(self, rhs: IntegerBox) -> Self::Output {
|
|
if rhs.value >= 0 && rhs.value <= 10000 {
|
|
// Safety limit
|
|
StringBox::new(self.value.repeat(rhs.value as usize))
|
|
} else {
|
|
StringBox::new(String::new()) // Empty string for invalid repetition
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Dynamic dispatch implementation for StringBox
|
|
impl DynamicAdd for StringBox {
|
|
fn try_add(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// StringBox + StringBox
|
|
if let Some(other_str) = other.as_any().downcast_ref::<StringBox>() {
|
|
return Some(Box::new(StringBox::new(format!(
|
|
"{}{}",
|
|
self.value, other_str.value
|
|
))));
|
|
}
|
|
|
|
// StringBox + any other type -> Convert to string and concatenate
|
|
Some(concat_result(self, other))
|
|
}
|
|
|
|
fn can_add_with(&self, _other_type: &str) -> bool {
|
|
true // StringBox can concatenate with anything via to_string_box()
|
|
}
|
|
}
|
|
|
|
impl DynamicSub for StringBox {
|
|
fn try_sub(&self, _other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
None // Subtraction not defined for strings
|
|
}
|
|
|
|
fn can_sub_with(&self, _other_type: &str) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
impl DynamicMul for StringBox {
|
|
fn try_mul(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// StringBox * IntegerBox -> Repeated string
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
if can_repeat(other_int.value) {
|
|
let repeated = self.value.repeat(other_int.value as usize);
|
|
return Some(Box::new(StringBox::new(repeated)));
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_mul_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicDiv for StringBox {
|
|
fn try_div(&self, _other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
None // Division not defined for strings
|
|
}
|
|
|
|
fn can_div_with(&self, _other_type: &str) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
// ===== BoolBox Operator Implementations =====
|
|
|
|
/// BoolBox + BoolBox -> IntegerBox (logical OR as addition)
|
|
impl NyashAdd<BoolBox> for BoolBox {
|
|
type Output = IntegerBox;
|
|
|
|
fn add(self, rhs: BoolBox) -> Self::Output {
|
|
let result = (self.value as i64) + (rhs.value as i64);
|
|
IntegerBox::new(result)
|
|
}
|
|
}
|
|
|
|
impl DynamicAdd for BoolBox {
|
|
fn try_add(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// BoolBox + BoolBox
|
|
if let Some(other_bool) = other.as_any().downcast_ref::<BoolBox>() {
|
|
let result = (self.value as i64) + (other_bool.value as i64);
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
// BoolBox + IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
let result = (self.value as i64) + other_int.value;
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
// Fallback to string concatenation
|
|
let left_str = self.to_string_box();
|
|
let right_str = other.to_string_box();
|
|
Some(Box::new(StringBox::new(format!(
|
|
"{}{}",
|
|
left_str.value, right_str.value
|
|
))))
|
|
}
|
|
|
|
fn can_add_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "BoolBox" | "IntegerBox" | "StringBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicSub for BoolBox {
|
|
fn try_sub(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// BoolBox - BoolBox
|
|
if let Some(other_bool) = other.as_any().downcast_ref::<BoolBox>() {
|
|
let result = (self.value as i64) - (other_bool.value as i64);
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
// BoolBox - IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
let result = (self.value as i64) - other_int.value;
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_sub_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "BoolBox" | "IntegerBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicMul for BoolBox {
|
|
fn try_mul(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// BoolBox * BoolBox -> logical AND
|
|
if let Some(other_bool) = other.as_any().downcast_ref::<BoolBox>() {
|
|
let result = (self.value as i64) * (other_bool.value as i64);
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
// BoolBox * IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
let result = (self.value as i64) * other_int.value;
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_mul_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "BoolBox" | "IntegerBox")
|
|
}
|
|
}
|
|
|
|
impl DynamicDiv for BoolBox {
|
|
fn try_div(&self, other: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
// BoolBox / IntegerBox
|
|
if let Some(other_int) = other.as_any().downcast_ref::<IntegerBox>() {
|
|
if other_int.value == 0 {
|
|
return None; // Division by zero
|
|
}
|
|
let result = (self.value as i64) / other_int.value;
|
|
return Some(Box::new(IntegerBox::new(result)));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
fn can_div_with(&self, other_type: &str) -> bool {
|
|
matches!(other_type, "IntegerBox")
|
|
}
|
|
}
|
|
|
|
// ===== High-level Operator Resolution =====
|
|
|
|
/// High-level operator resolution that tries static dispatch first,
|
|
/// then falls back to dynamic dispatch
|
|
pub struct OperatorResolver;
|
|
|
|
impl OperatorResolver {
|
|
#[inline]
|
|
fn try_dyn_left_add(left: &dyn NyashBox, right: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
if let Some(int_box) = left.as_any().downcast_ref::<crate::box_trait::IntegerBox>() {
|
|
if let Some(result) = int_box.try_add(right) { return Some(result); }
|
|
}
|
|
if let Some(str_box) = left.as_any().downcast_ref::<crate::box_trait::StringBox>() {
|
|
if let Some(result) = str_box.try_add(right) { return Some(result); }
|
|
}
|
|
if let Some(float_box) = left.as_any().downcast_ref::<crate::boxes::math_box::FloatBox>() {
|
|
if let Some(result) = float_box.try_add(right) { return Some(result); }
|
|
}
|
|
if let Some(bool_box) = left.as_any().downcast_ref::<crate::box_trait::BoolBox>() {
|
|
if let Some(result) = bool_box.try_add(right) { return Some(result); }
|
|
}
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn try_dyn_left_sub(left: &dyn NyashBox, right: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
if let Some(int_box) = left.as_any().downcast_ref::<crate::box_trait::IntegerBox>() {
|
|
if let Some(result) = int_box.try_sub(right) { return Some(result); }
|
|
}
|
|
if let Some(float_box) = left.as_any().downcast_ref::<crate::boxes::math_box::FloatBox>() {
|
|
if let Some(result) = float_box.try_sub(right) { return Some(result); }
|
|
}
|
|
if let Some(bool_box) = left.as_any().downcast_ref::<crate::box_trait::BoolBox>() {
|
|
if let Some(result) = bool_box.try_sub(right) { return Some(result); }
|
|
}
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn try_dyn_left_mul(left: &dyn NyashBox, right: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
if let Some(int_box) = left.as_any().downcast_ref::<crate::box_trait::IntegerBox>() {
|
|
if let Some(result) = int_box.try_mul(right) { return Some(result); }
|
|
}
|
|
if let Some(str_box) = left.as_any().downcast_ref::<crate::box_trait::StringBox>() {
|
|
if let Some(result) = str_box.try_mul(right) { return Some(result); }
|
|
}
|
|
if let Some(float_box) = left.as_any().downcast_ref::<crate::boxes::math_box::FloatBox>() {
|
|
if let Some(result) = float_box.try_mul(right) { return Some(result); }
|
|
}
|
|
if let Some(bool_box) = left.as_any().downcast_ref::<crate::box_trait::BoolBox>() {
|
|
if let Some(result) = bool_box.try_mul(right) { return Some(result); }
|
|
}
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn try_dyn_left_div(left: &dyn NyashBox, right: &dyn NyashBox) -> Option<Box<dyn NyashBox>> {
|
|
if let Some(int_box) = left.as_any().downcast_ref::<crate::box_trait::IntegerBox>() {
|
|
return int_box.try_div(right);
|
|
}
|
|
if let Some(float_box) = left.as_any().downcast_ref::<crate::boxes::math_box::FloatBox>() {
|
|
return float_box.try_div(right);
|
|
}
|
|
if let Some(bool_box) = left.as_any().downcast_ref::<crate::box_trait::BoolBox>() {
|
|
return bool_box.try_div(right);
|
|
}
|
|
None
|
|
}
|
|
/// Resolve addition operation with hybrid dispatch
|
|
pub fn resolve_add(
|
|
left: &dyn NyashBox,
|
|
right: &dyn NyashBox,
|
|
) -> Result<Box<dyn NyashBox>, OperatorError> {
|
|
// Try to cast to concrete types first and use their DynamicAdd implementation
|
|
// This approach uses the concrete types rather than trait objects
|
|
|
|
if let Some(result) = Self::try_dyn_left_add(left, right) { return Ok(result); }
|
|
|
|
Err(OperatorError::UnsupportedOperation {
|
|
operator: "+".to_string(),
|
|
left_type: left.type_name().to_string(),
|
|
right_type: right.type_name().to_string(),
|
|
})
|
|
}
|
|
|
|
/// Resolve subtraction operation with hybrid dispatch
|
|
pub fn resolve_sub(
|
|
left: &dyn NyashBox,
|
|
right: &dyn NyashBox,
|
|
) -> Result<Box<dyn NyashBox>, OperatorError> {
|
|
if let Some(result) = Self::try_dyn_left_sub(left, right) { return Ok(result); }
|
|
|
|
Err(OperatorError::UnsupportedOperation {
|
|
operator: "-".to_string(),
|
|
left_type: left.type_name().to_string(),
|
|
right_type: right.type_name().to_string(),
|
|
})
|
|
}
|
|
|
|
/// Resolve multiplication operation with hybrid dispatch
|
|
pub fn resolve_mul(
|
|
left: &dyn NyashBox,
|
|
right: &dyn NyashBox,
|
|
) -> Result<Box<dyn NyashBox>, OperatorError> {
|
|
if let Some(result) = Self::try_dyn_left_mul(left, right) { return Ok(result); }
|
|
|
|
Err(OperatorError::UnsupportedOperation {
|
|
operator: "*".to_string(),
|
|
left_type: left.type_name().to_string(),
|
|
right_type: right.type_name().to_string(),
|
|
})
|
|
}
|
|
|
|
/// Resolve division operation with hybrid dispatch
|
|
pub fn resolve_div(
|
|
left: &dyn NyashBox,
|
|
right: &dyn NyashBox,
|
|
) -> Result<Box<dyn NyashBox>, OperatorError> {
|
|
if let Some(result) = Self::try_dyn_left_div(left, right) { return Ok(result); }
|
|
|
|
Err(OperatorError::UnsupportedOperation {
|
|
operator: "/".to_string(),
|
|
left_type: left.type_name().to_string(),
|
|
right_type: right.type_name().to_string(),
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_integer_addition() {
|
|
let a = IntegerBox::new(5);
|
|
let b = IntegerBox::new(3);
|
|
let result = a.add(b);
|
|
assert_eq!(result.value, 8);
|
|
}
|
|
|
|
#[test]
|
|
fn test_string_concatenation() {
|
|
let a = StringBox::new("Hello");
|
|
let b = StringBox::new(" World");
|
|
let result = a.add(b);
|
|
assert_eq!(result.value, "Hello World");
|
|
}
|
|
|
|
#[test]
|
|
fn test_string_repetition() {
|
|
let s = StringBox::new("Hi");
|
|
let n = IntegerBox::new(3);
|
|
let result = s.mul(n);
|
|
assert_eq!(result.value, "HiHiHi");
|
|
}
|
|
|
|
#[test]
|
|
fn test_dynamic_addition() {
|
|
let a = IntegerBox::new(10);
|
|
let b = StringBox::new("20");
|
|
|
|
// Test dynamic dispatch
|
|
let result = a.try_add(&b).unwrap();
|
|
let result_str = result.to_string_box();
|
|
assert_eq!(result_str.value, "1020"); // String concatenation fallback
|
|
}
|
|
|
|
#[test]
|
|
fn test_boolean_arithmetic() {
|
|
let a = BoolBox::new(true);
|
|
let b = BoolBox::new(false);
|
|
let result = a.add(b);
|
|
assert_eq!(result.value, 1); // true + false = 1 + 0 = 1
|
|
}
|
|
|
|
#[test]
|
|
fn test_can_add_with() {
|
|
let int_box = IntegerBox::new(42);
|
|
assert!(int_box.can_add_with("IntegerBox"));
|
|
assert!(int_box.can_add_with("StringBox"));
|
|
|
|
let str_box = StringBox::new("test");
|
|
assert!(str_box.can_add_with("IntegerBox"));
|
|
assert!(str_box.can_add_with("StringBox"));
|
|
}
|
|
}
|