Any attempt to use two generic constants of the same type gets denied by the compiler.

Specifically, I’m trying to convert between generic variants of type Foo as follows.

  1 struct Foo<const X: isize> {
  2     n: isize,
  3 }
  4 
  5 impl<const A: isize, const B: isize> std::convert::From<Foo<B>> for Foo<A> {
  6     fn from(o: Foo<B>) -> Self {
  7         // arbitrary operation with A and B into constant
  8         const want: isize = A & B;
  9 
 10         return Self { n: want };
 11     }
 12 }

Access to both generics constants (A and B) gets denied with error E0401.

error[E0401]: can't use generic parameters from outer item
 --> trait.rs:8:29
  |
5 | impl<const A: isize, const B: isize> std::convert::From<Foo<B>> for Foo<A> {
  |            - const parameter from outer item
...
8 |         const want: isize = A & B;
  |                             ^ use of generic parameter from outer item

error[E0401]: can't use generic parameters from outer item
 --> trait.rs:8:33
  |
5 | impl<const A: isize, const B: isize> std::convert::From<Foo<B>> for Foo<A> {
  |                            - const parameter from outer item
...
8 |         const want: isize = A & B;
  |                                 ^ use of generic parameter from outer item

Rust allows exposure of the generic value.

  1 struct Foo<const X: isize> {
  2     n: isize,
  3 }
  4 
  5 impl<const X: isize> Foo<X> {
  6     const EXPOSE: isize = X;
  7 }
  8 
  9 impl<const A: isize, const B: isize> std::convert::From<Foo<B>> for Foo<A> {
 10     fn from(o: Foo<B>) -> Self {
 11         return Self { n: Foo::<A>::EXPOSE & Foo::<B>::EXPOSE };
 12     }
 13 }

The compiler explainer for E0119 provides no alternative.

error[E0119]: conflicting implementations of trait `From<Foo<_>>` for type `Foo<_>`
 --> expose.rs:9:1
  |
9 | impl<const A: isize, const B: isize> std::convert::From<Foo<B>> for Foo<A> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: conflicting implementation in crate `core`:
          - impl<T> From<T> for T;

A function would be fine too. The only important requirements is a const result of both generic const values.