Chain functions

I want to chain functions, but let them follow a section,
example

 sum(2,3);
 sum(2,3).subtract(1);
 sum(2,3).subtract(1).pow(2);
 sum(2,3).subtract(1).pow(2).divede(2);

Here is my proof of concept

With this it works, but how can I improve it?

pub fn sum(a: u32, b: u32) -> Number {
    Number { result: a + b }
}

#[derive(Debug)]
pub struct Number {
    pub result: u32,
}
impl Number {
    pub fn subtract(&self, rhs: u32) -> Pow {
        Pow {
            result: self.result - rhs,
        }
    }
}

#[derive(Debug)]
pub struct Subtract {
    pub result: u32,
}
impl Subtract {
    pub fn subtract(&self, rhs: u32) -> Self {
        Self {
            result: self.result - rhs,
        }
    }
}

#[derive(Debug)]
pub struct Pow {
    pub result: u32,
}
impl Pow {
    pub fn pow(&self, rhs: u32) -> Divide {
        Divide {
            result: self.result.pow(rhs)
        }
    }
}

#[derive(Debug)]
pub struct Divide {
    pub result: u32,
}
impl Divide {
    pub fn divide(&self, rhs: u32) -> Self {
        Self {
            result: self.result / rhs,
        }
    }
}

fn main() {
    let opr = sum(2, 3).subtract(1).pow(2).divide(2);

    println!("opr: {:?}", opr.result)
}

Here is the working example

What are you trying to achieve here? Having such a large number of types can be quite intimidating for users.