Trait for enums convertible to isize - rust

Question

I have several enums. Each of them has numeric tags and can be converted to integer (isize). I have a trait that all of them define. But instances of that trait are not convertible to integer any more, because the compiler can't prove all implementations are actually parameterless enums.
Is there any trait that would mean a type is a parameterless enum or that it is convertible to integer (by any means) that I could use as constraint in the generics that need to get the numeric value?
To be more specific, here is a code-sample (also on play):
enum Foo {
a = 1,
b = 2,
c = 3,
}
enum Bar {
d = 4,
e = 5,
f = 6,
}
trait Process : std::marker::MarkerTrait {
fn process(v: isize) -> String;
}
impl Process for Foo {
fn process(v: isize) -> String { format!("foo{}", v) }
}
impl Process for Bar {
fn process(v: isize) -> String { format!("bar{}", v) }
}
// just for sake of argument; something more complex in reality, of course
fn extern_call(v: isize) -> isize { 2 * v + 211 }
fn process<T: Process>(v: T) -> String {
T::process(extern_call(v as isize))
}
fn main() {
println!("a: {}", process(Foo::a));
}
Obviously the problem is in process, v as isize fails to compile with
error: non-scalar cast: T as isize
So I would like to do something like
process<T: Process + scalar>
or
process<T: Process + ToPrimitive>
or something that would tell the compiler that only types that can be cast to isize are permitted, but I don't know what that could be.

Answer 1

Add a method to your trait that coerces it to a isize. Then the compiler can verify that the objects meet the required criteria:
enum Foo {
A = 1,
B = 2,
C = 3,
}
enum Bar {
D = 4,
E = 5,
F = 6,
}
trait Process: {
fn as_isize(self) -> isize;
fn process(v: isize) -> String;
}
impl Process for Foo {
fn as_isize(self) -> isize { self as isize }
fn process(v: isize) -> String { format!("foo{}", v) }
}
impl Process for Bar {
fn as_isize(self) -> isize { self as isize }
fn process(v: isize) -> String { format!("bar{}", v) }
}
// just for sake of argument; something more complex in reality, of course
fn extern_call(v: isize) -> isize { 2 * v + 211 }
fn process<T: Process>(v: T) -> String {
T::process(extern_call(v.as_isize()))
}
fn main() {
println!("a: {}", process(Foo::A));
}
FYI, MarkerTrait isn't needed here (and is un-idiomatic):
MarkerTrait is intended to be used as the supertrait for traits that don't have any methods