Make sure more protocols are implemented and documented

Author: udoprog

crates/rune/src/modules/cmp.rs

@@ -1,8 +1,10 @@
 //! The `std::cmp` module.
 
 use core::cmp::Ordering;
+use core::fmt::{self, Write};
 
 use crate as rune;
+use crate::no_std::prelude::*;
 use crate::runtime::{Protocol, Value, VmResult};
 use crate::{ContextError, Module};
 
@@ -16,16 +18,17 @@ pub fn module() -> Result<Module, ContextError> {
             "",
             "# Examples",
             "",
-            "```",
+            "```rune",
             "use std::cmp::Ordering;",
+            "use std::ops::cmp;",
             "",
-            "let result = 1.cmp(2);",
+            "let result = cmp(1, 2);",
             "assert_eq!(Ordering::Less, result);",
             "",
-            "let result = 1.cmp(1);",
+            "let result = cmp(1, 1);",
             "assert_eq!(Ordering::Equal, result);",
             "",
-            "let result = 2.cmp(1);",
+            "let result = cmp(2, 1);",
             "assert_eq!(Ordering::Greater, result);",
             "```",
         ]);
@@ -52,6 +55,7 @@ pub fn module() -> Result<Module, ContextError> {
         lhs == rhs
     })?;
     m.associated_function(Protocol::EQ, |lhs: Ordering, rhs: Ordering| lhs == rhs)?;
+    m.function_meta(ordering_string_debug)?;
     m.function_meta(min)?;
     m.function_meta(max)?;
     Ok(m)
@@ -100,3 +104,17 @@ fn min(v1: Value, v2: Value) -> VmResult<Value> {
         Ordering::Greater => v2,
     })
 }
+
+/// Debug format [`Ordering`].
+///
+/// # Examples
+///
+/// ```rune
+/// use std::cmp::Ordering;
+///
+/// assert_eq!(format!("{:?}", Ordering::Less), "Less");
+/// ```
+#[rune::function(instance, protocol = STRING_DEBUG)]
+fn ordering_string_debug(this: Ordering, s: &mut String) -> fmt::Result {
+    write!(s, "{:?}", this)
+}

crates/rune/src/modules/f64.rs

@@ -1,8 +1,10 @@
 //! The `std::f64` module.
 
+use core::cmp::Ordering;
 use core::num::ParseFloatError;
 
 use crate as rune;
+use crate::runtime::{VmErrorKind, VmResult};
 use crate::{ContextError, Module};
 
 /// Install the core package into the given functions namespace.
@@ -25,6 +27,10 @@ pub fn module() -> Result<Module, ContextError> {
     #[cfg(feature = "std")]
     m.function_meta(powi)?;
     m.function_meta(to_integer)?;
+    m.function_meta(partial_eq)?;
+    m.function_meta(eq)?;
+    m.function_meta(partial_cmp)?;
+    m.function_meta(cmp)?;
 
     m.constant(["EPSILON"], f64::EPSILON)?;
     m.constant(["MIN"], f64::MIN)?;
@@ -254,3 +260,88 @@ fn powf(this: f64, other: f64) -> f64 {
 fn powi(this: f64, other: i32) -> f64 {
     this.powi(other)
 }
+
+/// Test two floats for partial equality.
+///
+/// # Examples
+///
+/// ```rune
+/// assert!(5.0 == 5.0);
+/// assert!(5.0 != 10.0);
+/// assert!(10.0 != 5.0);
+/// assert!(10.0 != f64::NAN);
+/// assert!(f64::NAN != f64::NAN);
+/// ```
+#[rune::function(instance, protocol = PARTIAL_EQ)]
+#[inline]
+fn partial_eq(this: f64, rhs: f64) -> bool {
+    this.eq(&rhs)
+}
+
+/// Test two floats for total equality.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::ops::eq;
+///
+/// assert_eq!(eq(5.0, 5.0), true);
+/// assert_eq!(eq(5.0, 10.0), false);
+/// assert_eq!(eq(10.0, 5.0), false);
+/// ```
+#[rune::function(instance, protocol = EQ)]
+#[inline]
+fn eq(this: f64, rhs: f64) -> VmResult<bool> {
+    let Some(ordering) = this.partial_cmp(&rhs) else {
+        return VmResult::err(VmErrorKind::IllegalFloatComparison {
+            lhs: this,
+            rhs,
+        })
+    };
+
+    VmResult::Ok(matches!(ordering, Ordering::Equal))
+}
+
+/// Perform a partial ordered comparison between two floats.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::cmp::Ordering;
+/// use std::ops::partial_cmp;
+///
+/// assert_eq!(partial_cmp(5.0, 10.0), Some(Ordering::Less));
+/// assert_eq!(partial_cmp(10.0, 5.0), Some(Ordering::Greater));
+/// assert_eq!(partial_cmp(5.0, 5.0), Some(Ordering::Equal));
+/// assert_eq!(partial_cmp(5.0, f64::NAN), None);
+/// ```
+#[rune::function(instance, protocol = PARTIAL_CMP)]
+#[inline]
+fn partial_cmp(this: f64, rhs: f64) -> Option<Ordering> {
+    this.partial_cmp(&rhs)
+}
+
+/// Perform a partial ordered comparison between two floats.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::cmp::Ordering;
+/// use std::ops::cmp;
+///
+/// assert_eq!(cmp(5.0, 10.0), Ordering::Less);
+/// assert_eq!(cmp(10.0, 5.0), Ordering::Greater);
+/// assert_eq!(cmp(5.0, 5.0), Ordering::Equal);
+/// ```
+#[rune::function(instance, protocol = CMP)]
+#[inline]
+fn cmp(this: f64, rhs: f64) -> VmResult<Ordering> {
+    let Some(ordering) = this.partial_cmp(&rhs) else {
+        return VmResult::err(VmErrorKind::IllegalFloatComparison {
+            lhs: this,
+            rhs,
+        })
+    };
+
+    VmResult::Ok(ordering)
+}

crates/rune/src/modules/i64.rs

@@ -13,7 +13,6 @@ pub fn module() -> Result<Module, ContextError> {
     let mut module = Module::with_crate_item("std", ["i64"]);
 
     module.function(["parse"], parse)?;
-    module.function_meta(cmp)?;
     module.function_meta(to_float)?;
 
     module.function_meta(max)?;
@@ -43,6 +42,10 @@ pub fn module() -> Result<Module, ContextError> {
     module.function_meta(is_positive)?;
     module.function_meta(is_negative)?;
 
+    module.function_meta(partial_eq)?;
+    module.function_meta(eq)?;
+    module.function_meta(partial_cmp)?;
+    module.function_meta(cmp)?;
     module.function_meta(to_string)?;
 
     module.constant(["MIN"], i64::MIN)?.docs([
@@ -85,26 +88,6 @@ fn parse(s: &str) -> Result<i64, ParseIntError> {
     str::parse::<i64>(s)
 }
 
-/// This method returns an Ordering between self and other.
-///
-/// By convention, `self.cmp(other)` returns the ordering matching the
-/// expression `self <operator> other` if true.
-///
-/// # Examples
-///
-/// ```rune
-/// use std::cmp::Ordering;
-///
-/// assert_eq!(5.cmp(10), Ordering::Less);
-/// assert_eq!(10.cmp(5), Ordering::Greater);
-/// assert_eq!(5.cmp(5), Ordering::Equal);
-/// ```
-#[rune::function(instance)]
-#[inline]
-fn cmp(this: i64, rhs: i64) -> Ordering {
-    this.cmp(&rhs)
-}
-
 /// Convert an `int` to a `float`.
 ///
 /// # Examples
@@ -533,6 +516,76 @@ fn is_negative(this: i64) -> bool {
     i64::is_negative(this)
 }
 
+/// Test two integers for partial equality.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::ops::partial_eq;
+///
+/// assert_eq!(partial_eq(5, 5), true);
+/// assert_eq!(partial_eq(5, 10), false);
+/// assert_eq!(partial_eq(10, 5), false);
+/// ```
+#[rune::function(instance, protocol = PARTIAL_EQ)]
+#[inline]
+fn partial_eq(this: i64, rhs: i64) -> bool {
+    this.eq(&rhs)
+}
+
+/// Test two integers for total equality.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::ops::eq;
+///
+/// assert_eq!(eq(5, 5), true);
+/// assert_eq!(eq(5, 10), false);
+/// assert_eq!(eq(10, 5), false);
+/// ```
+#[rune::function(instance, protocol = EQ)]
+#[inline]
+fn eq(this: i64, rhs: i64) -> bool {
+    this.eq(&rhs)
+}
+
+/// Perform a partial ordered comparison between two integers.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::cmp::Ordering;
+/// use std::ops::partial_cmp;
+///
+/// assert_eq!(partial_cmp(5, 10), Some(Ordering::Less));
+/// assert_eq!(partial_cmp(10, 5), Some(Ordering::Greater));
+/// assert_eq!(partial_cmp(5, 5), Some(Ordering::Equal));
+/// ```
+#[rune::function(instance, protocol = PARTIAL_CMP)]
+#[inline]
+fn partial_cmp(this: i64, rhs: i64) -> Option<Ordering> {
+    this.partial_cmp(&rhs)
+}
+
+/// Perform a partial ordered comparison between two integers.
+///
+/// # Examples
+///
+/// ```rune
+/// use std::cmp::Ordering;
+/// use std::ops::cmp;
+///
+/// assert_eq!(cmp(5, 10), Ordering::Less);
+/// assert_eq!(cmp(10, 5), Ordering::Greater);
+/// assert_eq!(cmp(5, 5), Ordering::Equal);
+/// ```
+#[rune::function(instance, protocol = CMP)]
+#[inline]
+fn cmp(this: i64, rhs: i64) -> Ordering {
+    this.cmp(&rhs)
+}
+
 /// Returns the number as a string.
 ///
 /// # Examples

crates/rune/src/modules/object.rs

@@ -5,9 +5,7 @@ use core::cmp::Ordering;
 use crate::no_std::prelude::*;
 
 use crate as rune;
-use crate::runtime::{
-    EnvProtocolCaller, FromValue, Iterator, Object, Protocol, Ref, Value, VmResult,
-};
+use crate::runtime::{EnvProtocolCaller, Iterator, Object, Protocol, Value, VmResult};
 use crate::{ContextError, Module};
 
 /// Construct the `std::object` module.
@@ -30,10 +28,10 @@ pub fn module() -> Result<Module, ContextError> {
     m.function_meta(keys)?;
     m.function_meta(values)?;
     m.associated_function(Protocol::INTO_ITER, Object::rune_iter)?;
-    m.associated_function(Protocol::PARTIAL_EQ, partial_eq)?;
-    m.associated_function(Protocol::EQ, eq)?;
-    m.associated_function(Protocol::PARTIAL_CMP, partial_cmp)?;
-    m.associated_function(Protocol::CMP, cmp)?;
+    m.function_meta(partial_eq)?;
+    m.function_meta(eq)?;
+    m.function_meta(partial_cmp)?;
+    m.function_meta(cmp)?;
     Ok(m)
 }
 
@@ -126,40 +124,22 @@ fn values(object: &Object) -> Iterator {
     Iterator::from_double_ended("std::object::Values", iter)
 }
 
+#[rune::function(instance, protocol = PARTIAL_EQ)]
 fn partial_eq(this: &Object, other: Value) -> VmResult<bool> {
-    let mut other = vm_try!(other.into_iter());
-
-    for (k1, v1) in this.iter() {
-        let Some(value) = vm_try!(other.next()) else {
-            return VmResult::Ok(false);
-        };
-
-        let (k2, v2) = vm_try!(<(Ref<String>, Value)>::from_value(value));
-
-        if k1 != &*k2 {
-            return VmResult::Ok(false);
-        }
-
-        if !vm_try!(Value::partial_eq(v1, &v2)) {
-            return VmResult::Ok(false);
-        }
-    }
-
-    if vm_try!(other.next()).is_some() {
-        return VmResult::Ok(false);
-    }
-
-    VmResult::Ok(true)
+    Object::partial_eq_with(this, other, &mut EnvProtocolCaller)
 }
 
+#[rune::function(instance, protocol = EQ)]
 fn eq(this: &Object, other: &Object) -> VmResult<bool> {
-    Object::eq_with(this, other, &mut EnvProtocolCaller)
+    Object::eq_with(this, other, Value::eq_with, &mut EnvProtocolCaller)
 }
 
+#[rune::function(instance, protocol = PARTIAL_CMP)]
 fn partial_cmp(this: &Object, other: &Object) -> VmResult<Option<Ordering>> {
     Object::partial_cmp_with(this, other, &mut EnvProtocolCaller)
 }
 
+#[rune::function(instance, protocol = CMP)]
 fn cmp(this: &Object, other: &Object) -> VmResult<Ordering> {
     Object::cmp_with(this, other, &mut EnvProtocolCaller)
 }