Solution

1. ```
   /// An operation to perform on two subexpressions.
   ```
2. ```
   #[derive(Debug)]
   ```
3. ```
   enum Operation {
   ```
4. ```
       Add,
   ```
5. ```
       Sub,
   ```
6. ```
       Mul,
   ```
7. ```
       Div,
   ```
8. ```
   }
   ```

10. ```
    /// An expression, in tree form.
    ```
11. ```
    #[derive(Debug)]
    ```
12. ```
    enum Expression {
    ```
13. ```
        /// An operation on two subexpressions.
    ```
14. ```
        Op { op: Operation, left: Box<Expression>, right: Box<Expression> },
    ```

16. ```
        /// A literal value
    ```
17. ```
        Value(i64),
    ```
18. ```
    }
    ```

20. ```
    fn eval(e: Expression) -> Result<i64, String> {
    ```
21. ```
        match e {
    ```
22. ```
            Expression::Op { op, left, right } => {
    ```
23. ```
                let left = match eval(*left) {
    ```
24. ```
                    Ok(v) => v,
    ```
25. ```
                    Err(e) => return Err(e),
    ```
26. ```
                };
    ```
27. ```
                let right = match eval(*right) {
    ```
28. ```
                    Ok(v) => v,
    ```
29. ```
                    Err(e) => return Err(e),
    ```
30. ```
                };
    ```
31. ```
                Ok(match op {
    ```
32. ```
                    Operation::Add => left + right,
    ```
33. ```
                    Operation::Sub => left - right,
    ```
34. ```
                    Operation::Mul => left * right,
    ```
35. ```
                    Operation::Div => {
    ```
36. ```
                        if right == 0 {
    ```
37. ```
                            return Err(String::from("division by zero"));
    ```
38. ```
                        } else {
    ```
39. ```
                            left / right
    ```
40. ```
                        }
    ```
41. ```
                    }
    ```
42. ```
                })
    ```
43. ```
            }
    ```
44. ```
            Expression::Value(v) => Ok(v),
    ```
45. ```
        }
    ```
46. ```
    }
    ```

48. ```
    #[test]
    ```
49. ```
    fn test_value() {
    ```
50. ```
        assert_eq!(eval(Expression::Value(19)), Ok(19));
    ```
51. ```
    }
    ```

53. ```
    #[test]
    ```
54. ```
    fn test_sum() {
    ```
55. ```
        assert_eq!(
    ```
56. ```
            eval(Expression::Op {
    ```
57. ```
                op: Operation::Add,
    ```
58. ```
                left: Box::new(Expression::Value(10)),
    ```
59. ```
                right: Box::new(Expression::Value(20)),
    ```
60. ```
            }),
    ```
61. ```
            Ok(30)
    ```
62. ```
        );
    ```
63. ```
    }
    ```

65. ```
    #[test]
    ```
66. ```
    fn test_recursion() {
    ```
67. ```
        let term1 = Expression::Op {
    ```
68. ```
            op: Operation::Mul,
    ```
69. ```
            left: Box::new(Expression::Value(10)),
    ```
70. ```
            right: Box::new(Expression::Value(9)),
    ```
71. ```
        };
    ```
72. ```
        let term2 = Expression::Op {
    ```
73. ```
            op: Operation::Mul,
    ```
74. ```
            left: Box::new(Expression::Op {
    ```
75. ```
                op: Operation::Sub,
    ```
76. ```
                left: Box::new(Expression::Value(3)),
    ```
77. ```
                right: Box::new(Expression::Value(4)),
    ```
78. ```
            }),
    ```
79. ```
            right: Box::new(Expression::Value(5)),
    ```
80. ```
        };
    ```
81. ```
        assert_eq!(
    ```
82. ```
            eval(Expression::Op {
    ```
83. ```
                op: Operation::Add,
    ```
84. ```
                left: Box::new(term1),
    ```
85. ```
                right: Box::new(term2),
    ```
86. ```
            }),
    ```
87. ```
            Ok(85)
    ```
88. ```
        );
    ```
89. ```
    }
    ```

91. ```
    #[test]
    ```
92. ```
    fn test_zeros() {
    ```
93. ```
        assert_eq!(
    ```
94. ```
            eval(Expression::Op {
    ```
95. ```
                op: Operation::Add,
    ```
96. ```
                left: Box::new(Expression::Value(0)),
    ```
97. ```
                right: Box::new(Expression::Value(0))
    ```
98. ```
            }),
    ```
99. ```
            Ok(0)
    ```
100. ```
         );
     ```
101. ```
         assert_eq!(
     ```
102. ```
             eval(Expression::Op {
     ```
103. ```
                 op: Operation::Mul,
     ```
104. ```
                 left: Box::new(Expression::Value(0)),
     ```
105. ```
                 right: Box::new(Expression::Value(0))
     ```
106. ```
             }),
     ```
107. ```
             Ok(0)
     ```
108. ```
         );
     ```
109. ```
         assert_eq!(
     ```
110. ```
             eval(Expression::Op {
     ```
111. ```
                 op: Operation::Sub,
     ```
112. ```
                 left: Box::new(Expression::Value(0)),
     ```
113. ```
                 right: Box::new(Expression::Value(0))
     ```
114. ```
             }),
     ```
115. ```
             Ok(0)
     ```
116. ```
         );
     ```
117. ```
     }
     ```

119. ```
     #[test]
     ```
120. ```
     fn test_error() {
     ```
121. ```
         assert_eq!(
     ```
122. ```
             eval(Expression::Op {
     ```
123. ```
                 op: Operation::Div,
     ```
124. ```
                 left: Box::new(Expression::Value(99)),
     ```
125. ```
                 right: Box::new(Expression::Value(0)),
     ```
126. ```
             }),
     ```
127. ```
             Err(String::from("division by zero"))
     ```
128. ```
         );
     ```
129. ```
     }
     ```

131. ```
     fn main() {
     ```
132. ```
         let expr = Expression::Op {
     ```
133. ```
             op: Operation::Sub,
     ```
134. ```
             left: Box::new(Expression::Value(20)),
     ```
135. ```
             right: Box::new(Expression::Value(10)),
     ```
136. ```
         };
     ```
137. ```
         println!("expr: {expr:?}");
     ```
138. ```
         println!("result: {:?}", eval(expr));
     ```
139. ```
     }
     ```