From cf4edc0c77498862d3be3a2781473d8d243963a6 Mon Sep 17 00:00:00 2001
From: Peter Tseng <pht24@cornell.edu>
Date: Sun, 3 Jul 2016 14:04:19 -0700
Subject: [PATCH 1/2] parallel-letter-frequency: Use &str with lifetime, not
 String

The previous version had a comment that explained a need for copying the
`&str` into `Strings`, but this can be avoided.

The disadvantage is now that this function can *only* be invoked with
`&'static str`, which means that it can't (for example) accept arbitrary
user input as part of a command-line program. So it works for our style
of testing (all our tests do indeed use `&'static str`) but is
unrealistic code.
---
 exercises/parallel-letter-frequency/example.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/exercises/parallel-letter-frequency/example.rs b/exercises/parallel-letter-frequency/example.rs
index 3897a89a8..3a57afc39 100644
--- a/exercises/parallel-letter-frequency/example.rs
+++ b/exercises/parallel-letter-frequency/example.rs
@@ -5,20 +5,18 @@ use std::sync::mpsc::channel;
 
 /// Compute the frequency of each letter (technically of each unicode codepoint) using the given
 /// number of worker threads.
-pub fn frequency(texts: &[&str], num_workers: usize) -> HashMap<char, usize> {
+pub fn frequency(texts: &[&'static str], num_workers: usize) -> HashMap<char, usize> {
     assert!(num_workers > 0);
     let part_size_floor = texts.len() / num_workers;
     let rem = texts.len() % num_workers;
     let part_size = if rem > 0 { part_size_floor + 1 } else { part_size_floor };
-    let mut parts: Vec<Vec<String>> = Vec::with_capacity(part_size);
+    let mut parts: Vec<Vec<&str>> = Vec::with_capacity(part_size);
     for _ in 0 .. num_workers {
         parts.push(Vec::with_capacity(part_size));
     }
     let mut i = 0;
-    for line in texts.iter() {
-        // We'll need to clone those strings in order to satisfy some lifetime guarantees. Basically
-        // it's hard for the system to be sure that the threads spawned don't outlive the strings.
-        parts[i].push(line.to_string());
+    for &line in texts.iter() {
+        parts[i].push(line);
         i = (i + 1) % num_workers;
     }
 
@@ -41,7 +39,7 @@ pub fn frequency(texts: &[&str], num_workers: usize) -> HashMap<char, usize> {
     results
 }
 
-fn count(lines: Vec<String>) -> HashMap<char, usize> {
+fn count(lines: Vec<&str>) -> HashMap<char, usize> {
     let mut results: HashMap<char, usize> = HashMap::new();
     for line in lines.iter() {
         for c in line.chars() {

From 8fe6c5bcb988557cb41fe58970001ef9380ffc93 Mon Sep 17 00:00:00 2001
From: Peter Tseng <pht24@cornell.edu>
Date: Thu, 5 Jan 2017 10:20:49 -0800
Subject: [PATCH 2/2] DO NOT MERGE: This fails to compile

This is meant to demonstrate why `&'static str` of #239 is very
restrictive.
---
 .../tests/parallel-letter-frequency.rs                     | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/exercises/parallel-letter-frequency/tests/parallel-letter-frequency.rs b/exercises/parallel-letter-frequency/tests/parallel-letter-frequency.rs
index 87cb7827f..612a8de9e 100644
--- a/exercises/parallel-letter-frequency/tests/parallel-letter-frequency.rs
+++ b/exercises/parallel-letter-frequency/tests/parallel-letter-frequency.rs
@@ -40,6 +40,13 @@ fn test_no_texts() {
     assert_eq!(frequency::frequency(&[], 4), HashMap::new());
 }
 
+#[test]
+#[ignore]
+fn test_hello_world() {
+    let hi = format!("Hello, {}!", "world");
+    frequency::frequency(&[&hi], 4);
+}
+
 #[test]
 #[ignore]
 fn test_one_letter() {