Switch to using 2 & 3 arg hypot

Author: teor2345

.github/workflows/check.yml

@@ -53,8 +53,8 @@ jobs:
       - name: Run all Rust binaries
         # If we ever add more than two binaries, detect them all automatically
         run: |
-          cargo run --bin cpp-pow-overload
-          cargo run --bin rust-pow-overload
+          cargo run --bin cpp-hypot-overload
+          cargo run --bin rust-hypot-overload
 
   clippy-rust:
     name: 4. Clippy lints on Rust crates

Cargo.lock

@@ -1,10 +1,10 @@
 [workspace]
 resolver = "3"
 members = [
-    "cpp-pow-overload",
+    "cpp-hypot-overload",
 ]
 default-members = [
-    "cpp-pow-overload",
+    "cpp-hypot-overload",
 ]
 
 [workspace.package]

Cargo.toml

@@ -12,5 +12,5 @@ git clone https://github.com/rustfoundation/overloading-examples
 cd overloading-examples
 rustup override set nightly
 cargo run
-cargo run --bin rust-pow-overload
+cargo run --bin rust-hypot-overload
 ```

README.md

@@ -1,7 +1,7 @@
 # Modify the workspace Cargo.toml instead of this file (if possible)
 [package]
-name = "cpp-pow-overload"
-default-run = "cpp-pow-overload"
+name = "cpp-hypot-overload"
+default-run = "cpp-hypot-overload"
 
 version.workspace = true
 authors.workspace = true

cpp-pow-overload/Cargo.toml cpp-hypot-overload/Cargo.tomlcpp-pow-overload/Cargo.toml renamed to cpp-hypot-overload/Cargo.toml

@@ -0,0 +1,5 @@
+fn main() {
+    cpp_build::Config::new()
+        .flag("-std=c++17")
+        .build("src/bin/cpp-hypot-overload.rs");
+}

cpp-hypot-overload/build.rs

@@ -0,0 +1,87 @@
+//! Example of calling overloaded C++ arithmetic functions from Rust.
+
+#![feature(splat, tuple_trait)]
+#![expect(incomplete_features)]
+
+use cpp::cpp;
+use std::ffi::{c_double, c_int};
+use std::marker::Tuple;
+
+cpp! {{
+    #include <cmath>
+}}
+
+/// The arguments of an overloaded C++ `hypot` function.
+trait HypotArgs: Tuple {
+    type Output;
+    fn call_hypot(self) -> Self::Output;
+}
+
+/// Calls the overloaded C++ `std::hypot` function with the given arguments.
+fn hypot<Args: HypotArgs>(#[splat] args: Args) -> <Args as HypotArgs>::Output {
+    args.call_hypot()
+}
+
+impl HypotArgs for (c_double, c_double) {
+    type Output = c_double;
+
+    fn call_hypot(self) -> c_double {
+        let (x, y) = self;
+        unsafe {
+            cpp!([x as "double", y as "double"] -> c_double as "double" {
+                return std::hypot(x, y);
+            })
+        }
+    }
+}
+
+impl HypotArgs for (c_double, c_double, c_double) {
+    type Output = c_double;
+
+    fn call_hypot(self) -> c_double {
+        let (x, y, z) = self;
+        unsafe {
+            cpp!([x as "double", y as "double", z as "double"] -> c_double as "double" {
+                return std::hypot(x, y, z);
+            })
+        }
+    }
+}
+
+impl HypotArgs for (c_int, c_int) {
+    type Output = c_double;
+
+    fn call_hypot(self) -> c_double {
+        let (x, y) = self;
+        unsafe {
+            cpp!([x as "int", y as "int"] -> c_double as "double" {
+                // C++ instantiates the `std::hypot<int, int>` template, which casts to `double`
+                // before calling `std::hypot(double, double)`.
+                return std::hypot(x, y);
+            })
+        }
+    }
+}
+
+impl HypotArgs for (c_int, c_int, c_int) {
+    type Output = c_double;
+
+    fn call_hypot(self) -> c_double {
+        let (x, y, z) = self;
+        unsafe {
+            cpp!([x as "int", y as "int", z as "int"] -> c_double as "double" {
+                // C++ instantiates the `std::hypot<int, int, int>` template, which casts to
+                // `double` before calling `std::hypot(double, double, double)`.
+                return std::hypot(x, y, z);
+            })
+        }
+    }
+}
+
+fn main() {
+    // Rust doesn't have c_* literal type specifiers.
+    println!("|(3, 4)|    double = {}", hypot(3.0_f64, 4.0_f64));
+    println!("|(2, 3, 6)| double = {}", hypot(2.0_f64, 3.0_f64, 6.0_f64));
+    println!("|(3, 4)|    int    = {}", hypot(3_i32, 4_i32));
+    println!("|(2, 3, 6)| int    = {}", hypot(2_i32, 3_i32, 6_i32));
+}

cpp-hypot-overload/src/bin/cpp-hypot-overload.rs

@@ -0,0 +1,61 @@
+//! Example of Rust arithmetic via overloaded functions.
+
+#![feature(splat, tuple_trait)]
+#![expect(incomplete_features)]
+
+use std::marker::Tuple;
+
+/// The arguments of an overloaded Rust `hypot` function.
+trait HypotArgs: Tuple {
+    type Output;
+    fn call_hypot(self) -> Self::Output;
+}
+
+/// Calls the overloaded Rust `hypot` function with the given arguments.
+fn hypot<Args: HypotArgs>(#[splat] args: Args) -> <Args as HypotArgs>::Output {
+    args.call_hypot()
+}
+
+impl HypotArgs for (f64, f64) {
+    type Output = f64;
+
+    fn call_hypot(self) -> f64 {
+        let (x, y) = self;
+        x.hypot(y)
+    }
+}
+
+impl HypotArgs for (f64, f64, f64) {
+    type Output = f64;
+
+    fn call_hypot(self) -> f64 {
+        let (x, y, z) = self;
+        // Rust std doesn't have a `hypot(x, y, z)` implementation.
+        f64::sqrt(x.powi(2) + y.powi(2) + z.powi(2))
+    }
+}
+
+impl HypotArgs for (i32, i32) {
+    type Output = f64;
+
+    fn call_hypot(self) -> f64 {
+        let (x, y) = self;
+        f64::from(x).hypot(f64::from(y))
+    }
+}
+
+impl HypotArgs for (i32, i32, i32) {
+    type Output = f64;
+
+    fn call_hypot(self) -> f64 {
+        let (x, y, z) = self;
+        f64::sqrt(f64::from(x).powi(2) + f64::from(y).powi(2) + f64::from(z).powi(2))
+    }
+}
+
+fn main() {
+    println!("|(3, 4)|    f64 = {}", hypot(3.0_f64, 4.0_f64));
+    println!("|(2, 3, 6)| f64 = {}", hypot(2.0_f64, 3.0_f64, 6.0_f64));
+    println!("|(3, 4)|    i32 = {}", hypot(3_i32, 4_i32));
+    println!("|(2, 3, 6)| i32 = {}", hypot(2_i32, 3_i32, 6_i32));
+}