Add a fourth approach to the rust version of the Bob problem

exercises/practice/bob/.articles/performance/code/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "code"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+
+[[bin]]
+name = "code"
+path = "main.rs"

exercises/practice/bob/.articles/performance/code/main.rs

@@ -6,6 +6,7 @@ fn main() {
     println!("Hello, world!");
 }
 
+// Reply using match
 pub fn reply_match(msg: &str) -> &str {
     let message = msg.trim_end();
     if message.is_empty() {
@@ -24,6 +25,7 @@ pub fn reply_match(msg: &str) -> &str {
     }
 }
 
+// Reply using if chain
 pub fn reply_if_chain(msg: &str) -> &str {
     let message = msg.trim_end();
     if message.is_empty() {
@@ -47,6 +49,7 @@ pub fn reply_if_chain(msg: &str) -> &str {
     "Whatever."
 }
 
+// Reply using array
 const ANSWERS: &'static [&'static str] = &[
     "Whatever.",
     "Sure.",
@@ -71,20 +74,132 @@ pub fn reply_array(msg: &str) -> &str {
     ANSWERS[is_questioning + is_yelling]
 }
 
+// Reply using state machine
+enum State {
+    Initial,
+    HasQuestionMark,
+    NoQuestionMarkUpperCase,
+    NoQuestionMarkUndefined,
+    QuestionMarkUpperCase,
+    QuestionMarkUndefined,
+}
+
+const FINE_BE_THAT_WAY: &str = "Fine. Be that way!";
+const WHATEVER: &str = "Whatever.";
+const SURE: &str = "Sure.";
+const CHILL_OUT: &str = "Whoa, chill out!";
+const CALM_DOWN: &str = "Calm down, I know what I'm doing!";
+
+pub fn reply_state_machine(message: &str) -> &str {
+    let message = message.trim();
+    if message.is_empty() {
+        return FINE_BE_THAT_WAY;
+    }
+    let mut state = State::Initial;
+    for c in message.chars().rev() {
+        match state {
+            State::Initial => {
+                state = if c == '?' {
+                    State::HasQuestionMark
+                } else {
+                    if c.is_lowercase() {
+                        return WHATEVER;
+                    }
+                    if c.is_uppercase() {
+                        State::NoQuestionMarkUpperCase
+                    } else {
+                        State::NoQuestionMarkUndefined
+                    }
+                };
+            }
+            State::HasQuestionMark => {
+                state = if c.is_uppercase() {
+                    State::QuestionMarkUpperCase
+                } else {
+                    State::QuestionMarkUndefined
+                };
+            }
+            State::NoQuestionMarkUpperCase => {
+                if c.is_lowercase() {
+                    return WHATEVER;
+                }
+            }
+            State::NoQuestionMarkUndefined => {
+                if c.is_lowercase() {
+                    return WHATEVER;
+                }
+                if c.is_uppercase() {
+                    state = State::NoQuestionMarkUpperCase;
+                }
+            }
+            State::QuestionMarkUpperCase => {
+                if c.is_lowercase() {
+                    return SURE;
+                }
+            }
+            State::QuestionMarkUndefined => {
+                if c.is_lowercase() {
+                    return SURE;
+                }
+                if c.is_uppercase() {
+                    state = State::QuestionMarkUpperCase;
+                }
+            }
+        }
+    }
+    match state {
+        State::HasQuestionMark | State::QuestionMarkUndefined => SURE,
+        State::NoQuestionMarkUpperCase => CHILL_OUT,
+        State::NoQuestionMarkUndefined => WHATEVER,
+        State::QuestionMarkUpperCase => CALM_DOWN,
+        _ => panic!("Unexpected final state"),
+    }
+}
+
 #[bench]
 /// multiple line question for match
 fn multiple_line_question_match(b: &mut Bencher) {
-    b.iter(|| reply_match("\rDoes this cryogenic chamber make me look fat?\rNo."));
+    b.iter(|| {
+        reply_match("\rDoes this cryogenic chamber make me look fat?\rNo.");
+        reply_match("  ");
+        reply_match("Does this cryogenic chamber make me look fat?");
+        reply_match("WHAT'S GOING ON?");
+        reply_match("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
+    });
 }
 
 #[bench]
 /// multiple line question for if statements
 fn multiple_line_question_if(b: &mut Bencher) {
-    b.iter(|| reply_if_chain("\rDoes this cryogenic chamber make me look fat?\rNo."));
+    b.iter(|| {
+        reply_if_chain("\rDoes this cryogenic chamber make me look fat?\rNo.");
+        reply_if_chain("  ");
+        reply_if_chain("Does this cryogenic chamber make me look fat?");
+        reply_if_chain("WHAT'S GOING ON?");
+        reply_if_chain("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
+    });
 }
 
 #[bench]
 /// multiple line question for answer array
 fn multiple_line_question_array(b: &mut Bencher) {
-    b.iter(|| reply_array("\rDoes this cryogenic chamber make me look fat?\rNo."));
+    b.iter(|| {
+        reply_array("\rDoes this cryogenic chamber make me look fat?\rNo.");
+        reply_array("  ");
+        reply_array("Does this cryogenic chamber make me look fat?");
+        reply_array("WHAT'S GOING ON?");
+        reply_array("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
+    });
+}
+
+#[bench]
+/// multiple line question for state machine
+fn multiple_line_question_state_machine(b: &mut Bencher) {
+    b.iter(|| {
+        reply_state_machine("\rDoes this cryogenic chamber make me look fat?\rNo.");
+        reply_state_machine("  ");
+        reply_state_machine("Does this cryogenic chamber make me look fat?");
+        reply_state_machine("WHAT'S GOING ON?");
+        reply_state_machine("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!");
+    });
 }

exercises/practice/bob/.articles/performance/content.md

@@ -7,19 +7,21 @@ The [approaches page][approaches] lists two idiomatic approaches to this exercis
 1. [Using `if` statements][approach-if].
 2. [Using `match` on a `tuple`][approach-match].
 
-For our performance investigation, we'll also include a third approach that [uses an answer array][approach-answer-array].
+For our performance investigation, we'll also include a third approach that [uses an answer array][approach-answer-array] and
+a fourth that uses a state machine.
 
 ## Benchmarks
 
 To benchmark the approaches, we wrote a [small benchmark application][benchmark-application].
 
 ```
-test multiple_line_question_match  ... bench:          96 ns/iter (+/- 17)
-test multiple_line_question_if     ... bench:          97 ns/iter (+/- 12)
-test multiple_line_question_array  ... bench:         100 ns/iter (+/- 2)
+test multiple_line_question_array         ... bench:         175.80 ns/iter (+/- 5.91)
+test multiple_line_question_if            ... bench:         157.26 ns/iter (+/- 8.69)
+test multiple_line_question_match         ... bench:         152.95 ns/iter (+/- 5.79)
+test multiple_line_question_state_machine ... bench:          89.17 ns/iter (+/- 9.65)
 ```
 
-All three approaches are close in performance, but the `if` statements and `match` approaches may be considered to be more idiomatic.
+All four approaches are close in performance, but the `if` statements and `match` approaches may be considered to be more idiomatic. The state machine approach is the fastest because it loops through the characters of the message only once.
 
 [approaches]: https://exercism.org/tracks/rust/exercises/bob/approaches
 [approach-if]: https://exercism.org/tracks/rust/exercises/bob/approaches/if-statements