Literals in Trait methods implementing generics

I'm trying to learn Generics and Traits in Rust and using the num crate to write generic code.
I get the following compiler error

6 |         return self.gt(0)
  |                     -- ^ expected type parameter `T`, found integer

on this code block.

use num::{Integer, zero};

trait CanCompareGreater<T: Integer> {
    fn gt(&self, other: T) -> bool;
    fn is_positive(&self) -> bool {
        return self.gt(0)
    }
}

struct MyNumber {
    num: i32,
}

impl CanCompareGreater<i32> for MyNumber
{
    fn gt(&self, other: i32) -> bool {
        self.num > other
    }
}

fn main() {
    let n = MyNumber {num: 5};
    println!("{}", n.is_positive());
}

If I use num::zero it works correctly.
But that restricts it to symbols defined in the num crate. I want it to work with any integer literal in the trait methods.
How would I go about doing it ?

I've tried 0 as Integer which doesn't compile 0 as i32 etc

Update: drewtato's answer is probably better than mine, as it provides a solution based on num::NumCast (a trait I wasn't familiar with). A word of caution though: one needs to be aware that for out-of-range values T::from() would return None. We are not talking about the specific value in MyNumber's instance num field, but the value passed as a parameter to T::from(...).

I'll keep my answer below, as it might still be helpful in understanding why the OP's example didn't work.

Let's first take a look at this example (which has nothing to do with generics or the num crate:

fn abc(a: i32) {
    println!("Called abc with {a}");
}

fn main() { 
    let b = 23 as i16;
    abc(b);
}

The compiler emits the following error:

error[E0308]: mismatched types
 --> src/main.rs:7:9
  |
7 |     abc(b);
  |     --- ^ expected `i32`, found `i16`

In CanCompareGreater::is_positive() you are trying to call the method gt by passing some specific value of a specific type (such as i32) where a generic T: Integer is expected. That cannot be compiled, because T's type might happen to be different from the type of the specific value you are trying to pass, and then you'd get in a situation similar to the above example.

Literal numbers have their own inference going on that's separate from generic inference. This inference can't escape the function or depend on generics, so you can't use it here. You also can't use as since that is also not connected to generic inference. But there's the NumCast trait that mimics as.

use num::{Integer, NumCast};

trait CanCompareGreater<T: Integer + NumCast> {
    fn gt(&self, other: T) -> bool;
    fn is_positive(&self) -> bool {
        return self.gt(T::from(4).unwrap())
    }
}

There's also num_traits::AsPrimitive which is closer to as since it is infallible.