mirror of
https://github.com/google/comprehensive-rust.git
synced 2025-05-15 23:26:48 +02:00
136 lines
3.5 KiB
Rust
136 lines
3.5 KiB
Rust
// Copyright 2023 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#![allow(dead_code)]
|
|
// ANCHOR: solution
|
|
// ANCHOR: Operation
|
|
/// An operation to perform on two subexpressions.
|
|
#[derive(Debug)]
|
|
enum Operation {
|
|
Add,
|
|
Sub,
|
|
Mul,
|
|
Div,
|
|
}
|
|
// ANCHOR_END: Operation
|
|
|
|
// ANCHOR: Expression
|
|
/// An expression, in tree form.
|
|
#[derive(Debug)]
|
|
enum Expression {
|
|
/// An operation on two subexpressions.
|
|
Op { op: Operation, left: Box<Expression>, right: Box<Expression> },
|
|
|
|
/// A literal value
|
|
Value(i64),
|
|
}
|
|
// ANCHOR_END: Expression
|
|
|
|
// ANCHOR: eval
|
|
fn eval(e: Expression) -> Result<i64, String> {
|
|
// ANCHOR_END: eval
|
|
match e {
|
|
Expression::Op { op, left, right } => {
|
|
let left = match eval(*left) {
|
|
Ok(v) => v,
|
|
Err(e) => return Err(e),
|
|
};
|
|
let right = match eval(*right) {
|
|
Ok(v) => v,
|
|
Err(e) => return Err(e),
|
|
};
|
|
Ok(match op {
|
|
Operation::Add => left + right,
|
|
Operation::Sub => left - right,
|
|
Operation::Mul => left * right,
|
|
Operation::Div => {
|
|
if right == 0 {
|
|
return Err(String::from("division by zero"));
|
|
} else {
|
|
left / right
|
|
}
|
|
}
|
|
})
|
|
}
|
|
Expression::Value(v) => Ok(v),
|
|
}
|
|
}
|
|
|
|
// ANCHOR: tests
|
|
#[test]
|
|
fn test_value() {
|
|
assert_eq!(eval(Expression::Value(19)), Ok(19));
|
|
}
|
|
|
|
#[test]
|
|
fn test_sum() {
|
|
assert_eq!(
|
|
eval(Expression::Op {
|
|
op: Operation::Add,
|
|
left: Box::new(Expression::Value(10)),
|
|
right: Box::new(Expression::Value(20)),
|
|
}),
|
|
Ok(30)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_recursion() {
|
|
let term1 = Expression::Op {
|
|
op: Operation::Mul,
|
|
left: Box::new(Expression::Value(10)),
|
|
right: Box::new(Expression::Value(9)),
|
|
};
|
|
let term2 = Expression::Op {
|
|
op: Operation::Mul,
|
|
left: Box::new(Expression::Op {
|
|
op: Operation::Sub,
|
|
left: Box::new(Expression::Value(3)),
|
|
right: Box::new(Expression::Value(4)),
|
|
}),
|
|
right: Box::new(Expression::Value(5)),
|
|
};
|
|
assert_eq!(
|
|
eval(Expression::Op {
|
|
op: Operation::Add,
|
|
left: Box::new(term1),
|
|
right: Box::new(term2),
|
|
}),
|
|
Ok(85)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_error() {
|
|
assert_eq!(
|
|
eval(Expression::Op {
|
|
op: Operation::Div,
|
|
left: Box::new(Expression::Value(99)),
|
|
right: Box::new(Expression::Value(0)),
|
|
}),
|
|
Err(String::from("division by zero"))
|
|
);
|
|
}
|
|
// ANCHOR_END: tests
|
|
|
|
fn main() {
|
|
let expr = Expression::Op {
|
|
op: Operation::Sub,
|
|
left: Box::new(Expression::Value(20)),
|
|
right: Box::new(Expression::Value(10)),
|
|
};
|
|
println!("expr: {:?}", expr);
|
|
println!("result: {:?}", eval(expr));
|
|
}
|