```
pub trait BitManipT {
fn bit_set(&mut self, lhs: usize, rhs: usize, v: Self);
fn bit_get(&self, lhs: usize, rhs: usize) -> Self;
}
impl BitManipT for u8 {
#[inline(always)]
fn bit_set(&mut self, lhs: usize, rhs: usize, v: u8) {
let rhs_side = *self >> rhs;
let lhs_side = (*self << (8 - lhs)) >> (8 - lhs);
*self = (rhs_side << rhs) + (v << lhs) + lhs_side;}
#[inline(always)]
fn bit_get(&self, lhs: usize, rhs: usize) -> u8 {
(self << (8 - rhs)) >> (8 - rhs + lhs)}}
impl BitManipT for u16 {
#[inline(always)]
fn bit_set(&mut self, lhs: usize, rhs: usize, v: u16) {
let rhs_side = *self >> rhs;
let lhs_side = (*self << (16 - lhs)) >> (16 - lhs);
*self = (rhs_side << rhs) + (v << lhs) + lhs_side;}
#[inline(always)]
fn bit_get(&self, lhs: usize, rhs: usize) -> u16 {
(self << (16 - rhs)) >> (16 - rhs + lhs)}}
impl BitManipT for u32 {
#[inline(always)]
fn bit_set(&mut self, lhs: usize, rhs: usize, v: u32) {
let rhs_side = *self >> rhs;
let lhs_side = (*self << (32 - lhs)) >> (32 - lhs);
*self = (rhs_side << rhs) + (v << lhs) + lhs_side;}
#[inline(always)]
fn bit_get(&self, lhs: usize, rhs: usize) -> u32 {
(self << (32 - rhs)) >> (32 - rhs + lhs)}}
impl BitManipT for u64 {
#[inline(always)]
fn bit_set(&mut self, lhs: usize, rhs: usize, v: u64) {
let rhs_side = *self >> rhs;
let lhs_side = (*self << (64 - lhs)) >> (64 - lhs);
*self = (rhs_side << rhs) + (v << lhs) + lhs_side;}
#[inline(always)]
fn bit_get(&self, lhs: usize, rhs: usize) -> u64 {
(self << (64 - rhs)) >> (64 - rhs + lhs)}}
```

Motivated by original post at Get last k bits of a uN - #5 by newpavlov .

Looking for critical feedback.