exercises

builder.rs (5712B)

---

 use crate::{TokenFactory, token::Token};
 
 /// This struct represents our final, immutable expression
 #[derive(Clone)]
 pub struct Expression<F: TokenFactory> {
     tokens: Vec<Token<F::Number, F::Operator>>,
     factory: F,
 }
 
 impl<F: TokenFactory> Expression<F> {
     /// Defining builder on Expression rather than calling ExpressionBuilder::new
     /// directly follows Rust convention: the type you're building provides the
     /// entry point to its builder, this makes the API discoverable
     pub fn builder(factory: F) -> ExpressionBuilder<F> {
         ExpressionBuilder::new(factory)
     }
 
     pub fn evaluate(&self) -> Result<F::Number, String> {
         todo!()
     }
 
     /// Prototype Pattern
     pub fn quadratic_template(factory: F) -> Result<ExpressionBuilder<F>, String> {
         Expression::builder(factory)
             .number("1")?
             .operator("*")?
             .variable("x")
             .operator("^")?
             .number("2")?
             .operator("+")?
             .number("0")?
             .operator("*")?
             .variable("x")
             .operator("+")?
             .number("0")
     }
 
     /// Another Prototype Pattern
     pub fn set_coefficient(&self, a: i64, b: f64) -> Result<(), String> {
         todo!()
     }
 }
 
 #[derive(Clone)]
 pub struct SubExpression<F: TokenFactory> {
     pub tokens: Vec<Token<F::Number, F::Operator>>,
     factory: F,
 }
 
 impl<F: TokenFactory> SubExpression<F> {
     pub fn new(tokens: Vec<Token<F::Number, F::Operator>>, factory: F) -> Self {
         Self { tokens, factory }
     }
 
     // Insert this subexpression into a larger expression
     pub fn insert_into(self, builder: ExpressionBuilder<F>) -> ExpressionBuilder<F> {
         builder.extend(self.tokens)
     }
 }
 
 /// This struct manages the construction process
 pub struct ExpressionBuilder<F: TokenFactory> {
     tokens: Vec<Token<F::Number, F::Operator>>,
     factory: F,
     paren_count: i32,
 }
 
 /// Implement the builder construction methods
 /// Each method takes ownership of self and then returns it after modification
 /// This enables method chaining while preventing accidental reuse of partially
 /// built expressions
 impl<F: TokenFactory> ExpressionBuilder<F> {
     pub fn new(factory: F) -> Self {
         Self {
             tokens: Vec::new(),
             factory,
             paren_count: 0,
         }
     }
 
     // This is to support inserting subexpression into a larger expression
     pub fn extend(mut self, tokens: Vec<Token<F::Number, F::Operator>>) -> ExpressionBuilder<F> {
         todo!()
     }
 
     // Add a number to the expression
     pub fn number(mut self, value: &str) -> Result<Self, String> {
         let num = self.factory.create_number(value)?;
         self.tokens.push(Token::Number(num));
         Ok(self)
     }
 
     // Add an operator
     pub fn operator(mut self, op: &str) -> Result<Self, String> {
         let op = self.factory.create_operator(op)?;
         self.tokens.push(Token::Operator(op));
         Ok(self)
     }
 
     // Add a variable
     pub fn variable(mut self, name: &str) -> Self {
         self.tokens.push(Token::Variable(name.to_string()));
         self
     }
 
     // Open a parenthesis group
     pub fn open_paren(mut self) -> Self {
         self.tokens.push(Token::OpenParen);
         self.paren_count += 1;
         self
     }
 
     // Close a parenthesis group
     // The guard error prevents invalid expression from being built
     pub fn close_paren(mut self) -> Result<Self, String> {
         if self.paren_count <= 0 {
             return Err("Unmatched closing parenthesis".to_string());
         }
         self.tokens.push(Token::CloseParen);
         self.paren_count -= 1;
         Ok(self)
     }
 
     /// Specialized Builder Pattern
     /// Function-application Pattern
     pub fn function(mut self, func: &str, arg: &str) -> Result<Self, String> {
         let func_op = self.factory.create_operator(func)?;
         let arg_num = self.factory.create_number(arg)?;
 
         self.tokens.push(Token::Operator(func_op));
         self.tokens.push(Token::Number(arg_num));
 
         Ok(self)
     }
 
     /// Specialized Builder Pattern
     /// Constructs a complete binary expression in one call
     pub fn binary_op(mut self, left: &str, op: &str, right: &str) -> Result<Self, String> {
         let left_num = self.factory.create_number(left)?;
         let op_token = self.factory.create_operator(op)?;
         let right_num = self.factory.create_number(right)?;
 
         self.tokens.extend([
             Token::Number(left_num),
             Token::Operator(op_token),
             Token::Number(right_num),
         ]);
 
         Ok(self)
     }
 
     // Build the final expression
     // This method consumes the build, by taking self by value, ensuring no
     // further modifications can be made after building
     pub fn build(self) -> Result<Expression<F>, String> {
         if self.paren_count != 0 {
             return Err("Unmatched parenthesis".to_string());
         }
 
         if self.tokens.is_empty() {
             return Err("Empty expression".to_string());
         }
 
         // Validate expression structure
         self.validate_expression()?;
 
         Ok(Expression {
             tokens: self.tokens,
             factory: self.factory,
         })
     }
 
     fn validate_expression(&self) -> Result<(), String> {
         use Token::*;
 
         // No consecutive operators
         for window in self.tokens.windows(2) {
             match (&window[0], &window[1]) {
                 (Operator(_), Operator(_)) => {
                     return Err("Consecutive operators".to_string());
                 }
                 _ => continue,
             }
         }
 
         // More validation rules...
         Ok(())
     }
 }