引数に基づいてRust関数またはトレイトメソッドの戻り値の型を計算することは可能ですか？

boost::math::tools::promote_argsRustと同様のことを達成できますか？慣用的なC ++ 11タイプのプロモーションも参照してください。

具体的には、引数に基づいて関数またはトレイトメソッドの戻り値の型を計算し、戻り値の型が引数の1つと同じ型であることを確認することは可能ですか？

次の場合を考えてみましょう。私には2つの構造体があります：

#[derive(Debug, Clone, Copy)]
struct MySimpleType(f64);

#[derive(Debug, Clone, Copy)]
struct MyComplexType(f64, f64);

特性MySimpleTypeをMyComplexType介してどこに昇格することができますFrom。

impl From<MySimpleType> for MyComplexType {
    fn from(src: MySimpleType) -> MyComplexType {
        let MySimpleType(x1) = src;
        MyComplexType(x1, 0.0)
    }
 }

私はタイプの二つの引数を取る関数書きたいMySimpleTypeかをMyComplexTypeし、型の値を返すMySimpleTypeすべての引数がのように入力された場合MySimpleType、それ以外の機能は、型の値を返す必要がありますMyComplexType。Add<Output=Self>両方のタイプに実装したとすると、次のようなことができます。

trait Foo<S, T> {
    fn foo(s: S, t: T) -> Self;
}

impl<S, T, O> Foo<S, T> for O
    where O: From<S> + From<T> + Add<Output = Self>
{
    fn foo(s: S, t: T) -> Self {
        let s: O = From::from(s);
        let t: O = From::from(t);
        s + t
    }
}

しかし、その後、コンパイラはそれが分かっていないOのいずれかであるべきSか、Tと私はほとんどのメソッド呼び出しに注釈を付ける必要があります。

私の2番目の試みは、わずかに異なる特性を使用して、2つの実装を作成することです。

trait Foo<S, T> {
    fn foo(s: S, t: T) -> Self;
}

impl Foo<MySimpleType, MySimpleType> for MySimpleType {
    fn foo(s: MySimpleType, t: MySimpleType) -> Self {
        s + t
    }
}

impl<S, T> Foo<S, T> for MyComplexType
    where MyComplexType: From<S> + From<T>
{
    fn foo(s: S, t: T) -> Self {
        let s: MyComplexType = From::from(s);
        let t: MyComplexType = From::from(t);
        s + t
    }
}

しかし、繰り返しになりますが、コンパイラはの戻り値の型を把握できません。

Foo::foo(MySimpleType(1.0), MySimpleType(1.0))

3番目の試行は、に似たものstd::ops::{Add, Mul, ...}です。関連する型を使用し、引数型の可能な組み合わせごとに特定の実装を記述します

trait Foo<T> {
    type Output;
    fn foo(self, t: T) -> Self::Output;
}

impl<T: Add<Output=T>> Foo<T> for T {
    type Output = Self;
    fn foo(self, t: T) -> Self::Output {
        self + t
    }
}

impl Foo<MySimpleType> for MyComplexType {
    type Output = Self;
    fn foo(self, t: MySimpleType) -> Self::Output {
        let t: Self = From::from(t);
        self + t
    }
}

impl Foo<MyComplexType> for MySimpleType {
    type Output = MyComplexType;
    fn foo(self, t: MyComplexType) -> Self::Output {
        let s: MyComplexType = From::from(self);
        s + t
    }
}

これは、n引数を持つ関数が必要になるまでは最善の解決策のようです。それなら、2^n - n + 1 implステートメントを書かなければならないからです。もちろん、2つ以上のタイプを検討すると、これはさらに悪化します。

===

編集：

私のコードでは、複数のネストされた関数呼び出しがあり、単純型の関数の評価は複雑型の場合は安価で高価であるため、不要な型の昇格は避けたいと思います。@MatthieuMを使用する。の提案された解決策では、これは達成されていません。次の例を検討してください

#![feature(core_intrinsics)]

use std::ops::Add;

trait Promote<Target> {
    fn promote(self) -> Target;
}

impl<T> Promote<T> for T {
    fn promote(self) -> T {
        self
    }
}

impl Promote<u64> for u32 {
    fn promote(self) -> u64 {
        self as u64
    }
}

fn foo<Result, Left, Right>(left: Left, right: Right) -> Result
    where Left: Promote<Result>,
        Right: Promote<Result>,
        Result: Add<Output = Result>
{
    println!("============\nFoo called");
    println!("Left: {}", unsafe { std::intrinsics::type_name::<Left>() });
    println!("Right: {}",
            unsafe { std::intrinsics::type_name::<Right>() });
    println!("Result: {}",
            unsafe { std::intrinsics::type_name::<Result>() });
    left.promote() + right.promote()
}

fn bar<Result, Left, Right>(left: Left, right: Right) -> Result
    where Left: Promote<Result>,
        Right: Promote<Result>,
        Result: Add<Output = Result>
{
    left.promote() + right.promote()
}

fn baz<Result, A, B, C, D>(a: A, b: B, c: C, d: D) -> Result
    where A: Promote<Result>,
        B: Promote<Result>,
        C: Promote<Result>,
        D: Promote<Result>,
        Result: Add<Output = Result>
{
    let lhs = foo(a, b).promote();
    let rhs = bar(c, d).promote();
    lhs + rhs
}

fn main() {
    let one = baz(1u32, 1u32, 1u64, 1u32);
    println!("{}", one);
}