How can a function be generic over a struct and uints in Rust, using methods defined for both?

So I have a struct S defined

struct S {
  pub inner_state: [u8; N],
}

with some methods that implement rotating a bit between set bounds (i.e. I can rotate bits for the last 5 bits, which I need to do.)
I also have a bunch of function like

pub fn compute_stuff(state: OtherStruct<S>) {
  do_bit_wise_operations!();
}

Now, since the struct S implements all the methods that are used inside these functions, I would like to make these function generics over T, where T can be either an uint or the struct S.

I tried changing the function signature to

pub fn compute_stuff<T>(state: OtherStruct<T>)
where T: std::ops::BitAnd<Output = T> + [...]
{
  do_bit_wise_operations!();
}

but I get to a road block. I use the leading_zeros() method that does exist for the struct S, but I can't seem to find how I should tell the compiler that it exists. Also, this get kinda long to write, is there a way to alias this specific T?
I also tried creating a trait BitOperations and impl it for S and the uints, but I don't really understand how it could help me solve this problem.

Creating a trait does work. First, create the trait. Since you want it to augment the behavior of an existing trait, you can make it a subtrait of BitAnd.

use std::ops::BitAnd;

pub trait BitOps: BitAnd<Output = Self> + Sized {
    fn leading_zeros(self) -> u32;
}

Sized is necessary since it takes self by value.

Then you can implement the trait for your types.

// Implemented for a primitive (a macro is useful to do this for many primitives)
impl BitOps for i32 {
    fn leading_zeros(self) -> u32 {
        self.leading_zeros()
    }
}

impl BitAnd for S {
    type Output = Self;
    
    fn bitand(mut self, other: Self) -> Self {
        for (a, b) in self.inner_state.iter_mut().zip(other.inner_state) {
            *a = *a & b;
        }
        self
    }
}

// Implemented for S
impl BitOps for S {
    fn leading_zeros(self) -> u32 {
        let mut zeros = 0;
        for byte in self.inner_state {
            if byte == 0 {
                zeros += 8;
            } else {
                zeros += byte.leading_zeros();
                break;
            }
        }
        zeros
    }
}

And then you can use it.

pub fn compute_stuff<T>(state: T) where T: BitOps + Copy {
    let _leading_zeros = state.leading_zeros();
    let _bit_and = state & state;
}

This is how the num-traits library works, but with more traits and types. It doesn't have any traits that are this specific, but PrimInt is a subtrait of BitAnd and could be useful if you want to expand your functionality.