What counts as a conflicting implementation? - rust

Question

In the following code:
enum Either<A, B> { Left(A), Right(B) }
use Either::{Left, Right};
impl<A, B> From<A> for Either<A, B> {
fn from(a: A) -> Self {
Left(a)
}
}
impl<A, B> From<B> for Either<A, B> {
fn from(b: B) -> Self {
Right(b)
}
}
I'm getting the following error: "conflicting implementations of trait std::convert::From<_> for type Either<_, _>". I do not understand how the implementation of From<A> and From<B> for Either<A, B> is conflicting.
I saw an example in the standard library docs where they're doing almost exactly what I'm doing but it works there:
use std::fs;
use std::io;
use std::num;
enum CliError {
IoError(io::Error),
ParseError(num::ParseIntError),
}
impl From<io::Error> for CliError {
fn from(error: io::Error) -> Self {
CliError::IoError(error)
}
}
impl From<num::ParseIntError> for CliError {
fn from(error: num::ParseIntError) -> Self {
CliError::ParseError(error)
}
}
Please can someone explain? Thanks.

Answer 1

In your original code:
enum Either<A, B> { Left(A), Right(B) }
use Either::{Left, Right};
impl<A, B> From<A> for Either<A, B> {
fn from(a: A) -> Self {
Left(a)
}
}
impl<A, B> From<B> for Either<A, B> {
fn from(b: B) -> Self {
Right(b)
}
}
You implement the From trait for Either<A, B> twice for From bound by the same traits A and B. Which is likely causing your issue where From is implemented multiple times. I cannot confirm that since the issue is not reproducible from the provided code. Using the code provided directly throws errors stating that A and B are undefined.
Combining the original and functional code together; we can provide definitions to the types. However, the following code will still fail due to improper bounding. In this case, the trait bounds are bound by a structure:
use std::{io, num};
enum Either<A, B> { Left(A), Right(B) }
use Either::{Left, Right};
impl<A: io::Error, B: num::ParseIntError> From<A> for Either<A, B> {
fn from(a: A) -> Self {
Left(a)
}
}
impl<A: io::Error, B: num::ParseIntError> From<B> for Either<A, B> {
fn from(b: B) -> Self {
Right(b)
}
}
Will result in the following error:
error[E0404]: expected trait, found struct `num::ParseIntError`
To make a functional version, the trait bounds should be removed. Resulting in something like the following which will compile without errors:
use std::{io, num};
enum Either<A, B> { Left(A), Right(B) }
type A = io::Error;
type B = num::ParseIntError;
use Either::{Left, Right};
impl From<A> for Either<A, B> {
fn from(a: A) -> Self {
Left(a)
}
}
impl From<B> for Either<A, B> {
fn from(b: B) -> Self {
Right(b)
}
}
From will only be usable on the type parameter it is implemented on and does not require the trait bounds.
You can find more information on trait bounds here: https://doc.rust-lang.org/reference/trait-bounds.html
You can find more information on type parameters here: https://doc.rust-lang.org/reference/types/parameters.html
You can find the documentation for the From trait here: https://doc.rust-lang.org/std/convert/trait.From.html