Introduce Standard Operator Traits in Core

Oct 13, 2025 by magicalceylontours.com 31 views

Problem Statement

Currently, Moonbit's operator implementations (e.g., +, -, *) are bound directly to concrete types via methods like Int::op_add and Array[T]::op_add. While this works for basic usage, it brings much trouble for library developers wanting to write generic code that requires operator constraints.

Example Use Case

A third-party library author wanting to create a generic sum function currently cannot express:

fn sum[T: ???](a: T, b: T) -> T { a + b }

There's no standard trait to constrain T to types supporting +. This forces every library author to reinvent their own Add trait:

trait MyCustomAdd {
  fn op_add(Self, Self) -> Self
}

impl MyCustomAdd for Double with op_add(self, other) { self + other }
impl MyCustomAdd for Int with op_add(self, other) { self + other }
impl MyCustomAdd for Int64 with op_add(self, other) { self + other }
impl MyCustomAdd for UInt with op_add(self, other) { self + other }
impl MyCustomAdd for UInt64 with op_add(self, other) { self + other }

fn sum[T: MyCustomAdd](a: T, b: T) -> T { a + b }

fn main {
	let _ = sum(1, 2)
	let _ = sum(1.0, 2.0)
	let _ = sum(3L, 5L)
	let _ = sum(4U, 6U)
	let _ = sum(1UL, 9UL)
}

This fragmentation harms ecosystem interoperability and forces duplicate effort.

Successful Precedents

Rust's approach in std::ops demonstrates the value of standardized operator traits:

use std::ops::Add;

fn generic_add<T: Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

Proposed Solution

Introduce Standard Operator Traits in Core:

trait Add { add(Self, Self) -> Self }
trait Sub { sub(Self, Self) -> Self }
trait Mul { mul(Self, Self) -> Self }
trait Div { div(Self, Self) -> Self }
// ... plus Rem, Mod, etc.

Refactor Existing Operator Implementations to Use These Traits:

// Before: fn Object::op_add(...)

// After:
impl Add for Object with add(self, other) { ... }

Key Benefits

Ecosystem Consistency: Libraries can rely on standard interfaces instead of fragmented custom traits

Generic Programming: Enables clean operator-constrained generics:

fn vector_add[T: Add](a: Vector[T], b: Vector[T]) -> Vector[T] {
  // element-wise a + b
}

Backward Compatibility: Existing a + b syntax continues working unchanged
Extensibility: Users can implement traits for custom types (e.g., ComplexNumber + operator)

Implementation Plan

I'm happy to prototype the implementation if the concept aligns with Moonbit's design goals. The implementation will involve:

Creating the standard operator traits in the Core library
Refactoring existing operator implementations to use these traits
Testing the new implementation to ensure backward compatibility and correctness

Conclusion

Q: What is the purpose of introducing operator traits in Moonbit's Core Library?

A: The primary goal is to provide a standardized way for library developers to write generic code that requires operator constraints. This will help to reduce fragmentation and promote ecosystem consistency.

Q: How will introducing operator traits affect existing code?

A: Existing code that uses operator methods (e.g., Int::op_add) will continue to work unchanged. The new operator traits will be used to implement these methods, ensuring backward compatibility.

Q: What are the benefits of using operator traits?

A: The benefits include:

Ecosystem consistency: Libraries can rely on standard interfaces instead of fragmented custom traits
Generic programming: Enables clean operator-constrained generics
Backward compatibility: Existing a + b syntax continues working unchanged
Extensibility: Users can implement traits for custom types (e.g., ComplexNumber + operator)

Q: How will the new operator traits be implemented?

A: The implementation will involve creating the standard operator traits in the Core library and refactoring existing operator implementations to use these traits. Testing will be performed to ensure backward compatibility and correctness.

Q: What are the potential challenges of introducing operator traits?

A: Some potential challenges include:

Ensuring backward compatibility with existing code
Refactoring existing operator implementations to use the new traits
Testing the new implementation to ensure correctness

Q: How will the introduction of operator traits affect the Moonbit ecosystem?

A: The introduction of operator traits is expected to have a positive impact on the Moonbit ecosystem by:

Reducing fragmentation and promoting ecosystem consistency
Enabling more generic and reusable code
Improving the overall quality and maintainability of the ecosystem

Q: Can users implement custom operator traits for their own types?

A: Yes, users can implement custom operator traits for their own types, allowing for more flexibility and extensibility.

Q: What is the expected timeline for implementing the operator traits?

A: The timeline for implementing the operator traits will depend on the complexity of the implementation and the availability of resources. However, it is expected to be a relatively short-term effort.

Q: How can users provide feedback and suggestions on the operator traits?

A: Users can provide feedback and suggestions by submitting issues or pull requests on the Moonbit repository. The development team will review and consider all feedback and suggestions.

Q: What is the next step in implementing the operator traits?

A: The next step is to create a prototype implementation of the operator traits and test it to ensure correctness and backward compatibility. This will involve creating a set of test cases to cover various scenarios and edge cases.

Q: How will the operator traits be documented and maintained?

A: The operator traits will be documented in the Moonbit documentation and maintained by the development team. Users can also contribute to the documentation and maintenance efforts by submitting issues or pull requests.