Rustでi32とu32を区別するためにUnsigedを型境界に使おうとするとconflictしてると怒られる

Question

やりたいこと

UnsigedなやつとSignedなやつで関数のふるまいを変えたい

ソースコード

use std::{ops::Mul, process::Output};
use num::{Signed, Unsigned};

struct Sample<T>(T);
// Unsigedなprimitive型に対する計算(負の場合を考慮しない)
impl<T> Mul<u32> for Sample<T> {
    type Output = Self;
    fn mul(self, rhs: u32) -> Self::Output {
        todo!()
    }
}
// Signedなprimitive型に対する計算(負の場合も実装する)
impl<S:Signed + 'static + Copy,T> Mul<S> for Sample<T> {
    type Output = Self;
    fn mul(self, rhs: S) -> Self::Output {
        todo!()
    }
}

エラー

conflicting implementations of trait `std::ops::Mul<u32>` for type `Sample<_>`
upstream crates may add a new impl of trait `num::Signed` for type `u32` in future versions

Comments

[tatsuya6502]

こんにちは。いまある情報だけですと、エラーの原因も解決方法もわかりません。

質問に以下の情報を追記していただけないでしょうか？

- エラーメッセージ
- Negトレイトの定義
- 何かクレートを使用しているなら、その情報。（AsPrimitive, WrappingMul, Unsignedトレイトはnum-traitsクレートのものを使っているのですか？）
- もしAsPrimitive, WrappingMul, Unsignedトレイトは自分で定義したものなら、それらの定義

[hidekiti]

コメントありがとうございます。
すべてのtraitはnum-traitsクレートのものを使ってます。
Unsigedはi32は実装することはなく、u32はSignedを実装することがないことが人間にはわかりますが、コンパイラはわからないので、型境界にUnsignedをつけた型TについてのMul<T>の実装と、i32についてのMul<i32>の実装がコンフリクトするんです。
これをうまくコンフリクトさせずに分けて実装できる、択一型(e.g. Unsignedを実装したらSignedは実装できないし、逆も成り立つ)みたいな型境界はないんですかね。ないとしたら符号付き整数型と符号なし整数型で実装を分けるにはすべての型について実装するしかないですかね。

[退会済みユーザー]

まずは、tatsuya6502さんの質問にちゃんと応えましょう（念の為、回答者が偉いから従えとかいうことではなく、至極妥当な確認事項だからです）．
あと、u32にstd::ops::Negは実装されていないので、その2つの実装がコンフリクトするとは思えません．できれば、ソースコードもあまり省略せずに貼ってほしいです．塩梅が難しいかもしれませんが、不足しているよりは過剰な方が回答しやすいです．

[hidekiti]

上のソースコードは変更してしまって手元になくなってしまいました。ごめんなさい。
ご指摘にのようにu32はNegを現状実装していませんが、コンパイラはu32がいつかNegを実装するかもしれないから潜在的にconflictしてるよと怒ってきます。これに対処する方法をご存じないですか？

[hidekiti]

tsutuya6502さんのご指摘のようにSignedなものとUnsigedなものの区別は型境界ではできなさそうなので、実装単位を分けることで対処しようかなと思います。

[退会済みユーザー]

潜在的なconflictという概念があるんですね．それは知らなかったので、勉強になりました．

unstableな機能としては、negative implsというのがありますが、unstableなので、nightlyでないとコンパイルできなくなりますし、あまりおすすめはしません．
https://doc.rust-lang.org/beta/unstable-book/language-features/negative-impls.html

Answer 1

前提

ご質問のコードに、省略されているDecimal構造体やuse文を追加してみましたが、エラーは再現できませんでした。そこで、質問の追記依頼の欄にあるコメントを頼りに、以下のようにコードを変更したところ、それらしいエラーが出ました。

• impl Mul<u32> for Decimal<u32>をimpl Mul<i32> for Decimal<i32>に変更

当方でエラーを再現できたコードは以下のとおりです。このコードを元に回答します。

// Cargo.toml
//
// [dependencies]
// num-traits = "0.2"

use std::ops::{Mul, Neg};
use num_traits::{AsPrimitive, ToPrimitive, Unsigned, WrappingMul};

struct Decimal<T>(T);

impl Mul<i32> for Decimal<i32> {
    type Output = Self;
    fn mul(self, rhs: u32) -> Self::Output {
        Decimal(self.0.wrapping_mul(rhs.to_i32().unwrap()))
    }
}

impl<S, T> Mul<S> for Decimal<T>
where
    S: 'static + Neg<Output = S> + Copy,
    T: AsPrimitive<S> + WrappingMul + Unsigned,
{
    type Output = Self;
    fn mul(self, rhs: S) -> Self::Output {
        // コンパイルエラーになるためコメントアウト
        // error[E0308]: mismatched types:
        //     expected type parameter `S`, found type `{integer}`
        // if rhs < 0 {
        //     // error[E0369]: cannot multiply `Decimal<T>` by `u32`
        //     // error[E0605]: non-primitive cast: `S` as `u32`
        //     -(self * rhs as u32)
        // } else {
        //     self * rhs as u32
        // }
        todo!()
    }
}

また、エラーメッセージは以下のとおりです。

error[E0119]: conflicting implementations of trait `Mul<i32>` for type `Decimal<i32>`
   |
18 |   impl Mul<i32> for Decimal<i32> {
   |   ------------------------------ first implementation here
...
33 | / impl<S, T> Mul<S> for Decimal<T>
34 | | where
35 | |     S: 'static + Neg<Output = S> + PartialOrd + Copy,
36 | |     T: AsPrimitive<S> + WrappingMul + Unsigned,
...  |
51 | |     }
52 | | }
   | |_^ conflicting implementation for `Decimal<i32>`
   |
   = note: upstream crates may add a new impl of trait `num_traits::Unsigned` for type `i32` in future versions

質問の回答

質問の追記依頼の欄のコメントより

Unsigedはi32は実装することはなく、u32はSignedを実装することがないことが人間にはわかりますが、コンパイラはわからないので、型境界にUnsignedをつけた型TについてのMul<T>の実装と、i32についてのMul<i32>の実装がコンフリクトするんです。
これをうまくコンフリクトさせずに分けて実装できる、択一型(e.g. Unsignedを実装したらSignedは実装できないし、逆も成り立つ)みたいな型境界はないんですかね。

現時点のRustでは択一型を定義したり、否定のようなトレイト境界をつけることはできないと思います。そのためDecimal<i32>とDecimal<T: Unsigned>がコンフリクトするのは避けられません。

回避方法ですが、Decimal<T>を以下の2つの型に分けるのはどうでしょうか？

struct UnsignedDecimal<T: Unsigned>(T);
struct SignedDecimal<T: Signed>(T);

これを用いると以下のようなコードになり、コンフリクトを回避できます。

use std::ops::{Mul, Neg};
use num_traits::{AsPrimitive, Signed, ToPrimitive, Unsigned, WrappingMul};

struct UnsignedDecimal<T: Unsigned>(T);
struct SignedDecimal<T: Signed>(T);

impl Mul<i32> for SignedDecimal<i32> {
    type Output = Self;
    fn mul(self, rhs: i32) -> Self::Output {
        SignedDecimal(self.0.wrapping_mul(rhs.to_i32().unwrap()))
    }
}

impl<S, T> Mul<S> for UnsignedDecimal<T>
where
    S: 'static + Neg<Output = S> + Copy,
    T: AsPrimitive<S> + WrappingMul + Unsigned,
{
    type Output = Self;
    fn mul(self, rhs: S) -> Self::Output {
        todo!()
    }
}

Comments

[hidekiti]

回答ありがとうございます。
やはり型推論で分けるのは今はできないということなんですね。
unsigned_mulトレイトとかを作ってそれを使う方針でしてみようかな
と思います。