diff --git a/listings/ch20-web-server/listing-20-01/Cargo.toml b/listings/ch20-web-server/listing-20-01/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-01/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-01/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-01/src/main.rs b/listings/ch20-web-server/listing-20-01/src/main.rs
index d868c3ec1..5279e73f3 100644
--- a/listings/ch20-web-server/listing-20-01/src/main.rs
+++ b/listings/ch20-web-server/listing-20-01/src/main.rs
@@ -6,6 +6,7 @@ fn main() {
     for stream in listener.incoming() {
         let stream = stream.unwrap();
 
+        // 接続が確立しました!
         println!("Connection established!");
     }
 }
diff --git a/listings/ch20-web-server/listing-20-02/Cargo.toml b/listings/ch20-web-server/listing-20-02/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-02/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-02/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-02/src/main.rs b/listings/ch20-web-server/listing-20-02/src/main.rs
index 2e68f2f74..7240c73c7 100644
--- a/listings/ch20-web-server/listing-20-02/src/main.rs
+++ b/listings/ch20-web-server/listing-20-02/src/main.rs
@@ -1,6 +1,7 @@
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
+use std::{
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
@@ -13,9 +14,12 @@ fn main() {
 }
 
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
+    let buf_reader = BufReader::new(&mut stream);
+    let http_request: Vec<_> = buf_reader
+        .lines()
+        .map(|result| result.unwrap())
+        .take_while(|line| !line.is_empty())
+        .collect();
 
-    stream.read(&mut buffer).unwrap();
-
-    println!("Request: {}", String::from_utf8_lossy(&buffer[..]));
+    println!("Request: {:#?}", http_request);
 }
diff --git a/listings/ch20-web-server/listing-20-03/Cargo.toml b/listings/ch20-web-server/listing-20-03/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-03/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-03/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-03/src/main.rs b/listings/ch20-web-server/listing-20-03/src/main.rs
index afa579a45..c72d4a9c6 100644
--- a/listings/ch20-web-server/listing-20-03/src/main.rs
+++ b/listings/ch20-web-server/listing-20-03/src/main.rs
@@ -1,6 +1,7 @@
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
+use std::{
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
@@ -14,13 +15,15 @@ fn main() {
 
 // ANCHOR: here
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-
-    stream.read(&mut buffer).unwrap();
+    let buf_reader = BufReader::new(&mut stream);
+    let http_request: Vec<_> = buf_reader
+        .lines()
+        .map(|result| result.unwrap())
+        .take_while(|line| !line.is_empty())
+        .collect();
 
     let response = "HTTP/1.1 200 OK\r\n\r\n";
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
 }
 // ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-04/src/main.rs b/listings/ch20-web-server/listing-20-04/src/main.rs
deleted file mode 100644
index 818eac97e..000000000
--- a/listings/ch20-web-server/listing-20-04/src/main.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        handle_connection(stream);
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-
-    stream.read(&mut buffer).unwrap();
-
-    let response = "HTTP/1.1 200 OK\r\n\r\n";
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-05/Cargo.toml b/listings/ch20-web-server/listing-20-05/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-05/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-05/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-05/hello.html b/listings/ch20-web-server/listing-20-05/hello.html
index fe442d6b9..a80a862cf 100644
--- a/listings/ch20-web-server/listing-20-05/hello.html
+++ b/listings/ch20-web-server/listing-20-05/hello.html
@@ -5,7 +5,9 @@
     <title>Hello!</title>
   </head>
   <body>
+    <!-- <h1>こんにちは!</h1> -->
     <h1>Hello!</h1>
+    <!-- <p>Rustからやあ</p> -->
     <p>Hi from Rust</p>
   </body>
 </html>
diff --git a/listings/ch20-web-server/listing-20-05/src/main.rs b/listings/ch20-web-server/listing-20-05/src/main.rs
index d20417c44..d4b78b640 100644
--- a/listings/ch20-web-server/listing-20-05/src/main.rs
+++ b/listings/ch20-web-server/listing-20-05/src/main.rs
@@ -1,12 +1,12 @@
 // ANCHOR: here
-use std::fs;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 // --snip--
 
 // ANCHOR_END: here
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
 
@@ -19,18 +19,20 @@ fn main() {
 
 // ANCHOR: here
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
+    let buf_reader = BufReader::new(&mut stream);
+    let http_request: Vec<_> = buf_reader
+        .lines()
+        .map(|result| result.unwrap())
+        .take_while(|line| !line.is_empty())
+        .collect();
+
+    let status_line = "HTTP/1.1 200 OK";
     let contents = fs::read_to_string("hello.html").unwrap();
+    let length = contents.len();
 
-    let response = format!(
-        "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
-        contents.len(),
-        contents
-    );
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
 }
 // ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-06/Cargo.toml b/listings/ch20-web-server/listing-20-06/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-06/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-06/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-06/src/main.rs b/listings/ch20-web-server/listing-20-06/src/main.rs
index 835324422..fa5f0d502 100644
--- a/listings/ch20-web-server/listing-20-06/src/main.rs
+++ b/listings/ch20-web-server/listing-20-06/src/main.rs
@@ -1,7 +1,8 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
@@ -12,28 +13,25 @@ fn main() {
         handle_connection(stream);
     }
 }
-
 // ANCHOR: here
 // --snip--
 
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
 
-    if buffer.starts_with(get) {
+    if request_line == "GET / HTTP/1.1" {
+        let status_line = "HTTP/1.1 200 OK";
         let contents = fs::read_to_string("hello.html").unwrap();
+        let length = contents.len();
 
         let response = format!(
-            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
-            contents.len(),
-            contents
+            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
         );
 
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
+        stream.write_all(response.as_bytes()).unwrap();
     } else {
+    	// 何か別の要求
         // some other request
     }
 }
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/404.html b/listings/ch20-web-server/listing-20-07/404.html
similarity index 61%
rename from listings/ch20-web-server/no-listing-07-define-message-enum/404.html
rename to listings/ch20-web-server/listing-20-07/404.html
index 88d8e9152..7feea11b8 100644
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/404.html
+++ b/listings/ch20-web-server/listing-20-07/404.html
@@ -5,7 +5,9 @@
     <title>Hello!</title>
   </head>
   <body>
+    <!-- <h1>おっと！</h1> -->
     <h1>Oops!</h1>
+    <!-- <p>すみませんが、何を要求しているのか分かりません。</p> -->
     <p>Sorry, I don't know what you're asking for.</p>
   </body>
 </html>
diff --git a/listings/ch20-web-server/listing-20-07/Cargo.toml b/listings/ch20-web-server/listing-20-07/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-07/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-07/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-07/src/main.rs b/listings/ch20-web-server/listing-20-07/src/main.rs
index 4d8e51286..a14b7d538 100644
--- a/listings/ch20-web-server/listing-20-07/src/main.rs
+++ b/listings/ch20-web-server/listing-20-07/src/main.rs
@@ -1,7 +1,8 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
@@ -14,32 +15,31 @@ fn main() {
 }
 
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
 
-    let get = b"GET / HTTP/1.1\r\n";
-
-    if buffer.starts_with(get) {
+    if request_line == "GET / HTTP/1.1" {
+        let status_line = "HTTP/1.1 200 OK";
         let contents = fs::read_to_string("hello.html").unwrap();
+        let length = contents.len();
 
         let response = format!(
-            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
-            contents.len(),
-            contents
+            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
         );
 
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
+        stream.write_all(response.as_bytes()).unwrap();
     // ANCHOR: here
     // --snip--
     } else {
-        let status_line = "HTTP/1.1 404 NOT FOUND\r\n\r\n";
+        let status_line = "HTTP/1.1 404 NOT FOUND";
         let contents = fs::read_to_string("404.html").unwrap();
+        let length = contents.len();
 
-        let response = format!("{}{}", status_line, contents);
+        let response = format!(
+            "{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
+        );
 
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
+        stream.write_all(response.as_bytes()).unwrap();
     }
     // ANCHOR_END: here
 }
diff --git a/listings/ch20-web-server/listing-20-08/Cargo.lock b/listings/ch20-web-server/listing-20-08/Cargo.lock
deleted file mode 100644
index f2d069f46..000000000
--- a/listings/ch20-web-server/listing-20-08/Cargo.lock
+++ /dev/null
@@ -1,6 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "hello"
-version = "0.1.0"
-
diff --git a/listings/ch20-web-server/listing-20-08/Cargo.toml b/listings/ch20-web-server/listing-20-08/Cargo.toml
deleted file mode 100644
index 78dfe6ebc..000000000
--- a/listings/ch20-web-server/listing-20-08/Cargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "hello"
-version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
-
-[dependencies]
diff --git a/listings/ch20-web-server/listing-20-08/hello.html b/listings/ch20-web-server/listing-20-08/hello.html
deleted file mode 100644
index fe442d6b9..000000000
--- a/listings/ch20-web-server/listing-20-08/hello.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Hello!</title>
-  </head>
-  <body>
-    <h1>Hello!</h1>
-    <p>Hi from Rust</p>
-  </body>
-</html>
diff --git a/listings/ch20-web-server/listing-20-08/src/main.rs b/listings/ch20-web-server/listing-20-08/src/main.rs
deleted file mode 100644
index ef905fa27..000000000
--- a/listings/ch20-web-server/listing-20-08/src/main.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        handle_connection(stream);
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-
-    if buffer.starts_with(get) {
-        let contents = fs::read_to_string("hello.html").unwrap();
-
-        let response = format!(
-            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
-            contents.len(),
-            contents
-        );
-
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
-    } else {
-        let status_line = "HTTP/1.1 404 NOT FOUND\r\n\r\n";
-        let contents = fs::read_to_string("404.html").unwrap();
-
-        let response = format!("{}{}", status_line, contents);
-
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
-    }
-}
diff --git a/listings/ch20-web-server/listing-20-09/Cargo.toml b/listings/ch20-web-server/listing-20-09/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-09/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-09/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-09/src/main.rs b/listings/ch20-web-server/listing-20-09/src/main.rs
index 8fdfd076a..ffc51e803 100644
--- a/listings/ch20-web-server/listing-20-09/src/main.rs
+++ b/listings/ch20-web-server/listing-20-09/src/main.rs
@@ -1,7 +1,8 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+};
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
@@ -12,31 +13,28 @@ fn main() {
         handle_connection(stream);
     }
 }
-
 // ANCHOR: here
 // --snip--
 
 fn handle_connection(mut stream: TcpStream) {
     // --snip--
-
     // ANCHOR_END: here
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
     // ANCHOR: here
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
+
+    let (status_line, filename) = if request_line == "GET / HTTP/1.1" {
+        ("HTTP/1.1 200 OK", "hello.html")
     } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+        ("HTTP/1.1 404 NOT FOUND", "404.html")
     };
 
     let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
 
-    let response = format!("{}{}", status_line, contents);
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
 }
 // ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-10/Cargo.toml b/listings/ch20-web-server/listing-20-10/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-10/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-10/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-10/src/main.rs b/listings/ch20-web-server/listing-20-10/src/main.rs
index 257d47a79..5a18b45c0 100644
--- a/listings/ch20-web-server/listing-20-10/src/main.rs
+++ b/listings/ch20-web-server/listing-20-10/src/main.rs
@@ -1,10 +1,11 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
 // ANCHOR: here
-use std::thread;
-use std::time::Duration;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
 // --snip--
 // ANCHOR_END: here
 
@@ -23,31 +24,29 @@ fn handle_connection(mut stream: TcpStream) {
     // --snip--
 
     // ANCHOR_END: here
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
 
     // ANCHOR: here
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
     };
 
     // --snip--
     // ANCHOR_END: here
 
     let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
 
-    let response = format!("{}{}", status_line, contents);
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
     // ANCHOR: here
 }
 // ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-11/Cargo.toml b/listings/ch20-web-server/listing-20-11/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-11/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-11/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-11/src/main.rs b/listings/ch20-web-server/listing-20-11/src/main.rs
index d1087e212..1181357b0 100644
--- a/listings/ch20-web-server/listing-20-11/src/main.rs
+++ b/listings/ch20-web-server/listing-20-11/src/main.rs
@@ -1,9 +1,10 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
 
 // ANCHOR: here
 fn main() {
@@ -20,25 +21,23 @@ fn main() {
 // ANCHOR_END: here
 
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
     };
 
     let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
 
-    let response = format!("{}{}", status_line, contents);
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
 }
diff --git a/listings/ch20-web-server/listing-20-12/Cargo.toml b/listings/ch20-web-server/listing-20-12/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-12/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-12/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-12/output.txt b/listings/ch20-web-server/listing-20-12/output.txt
index 3a798ef12..ca6a7bb93 100644
--- a/listings/ch20-web-server/listing-20-12/output.txt
+++ b/listings/ch20-web-server/listing-20-12/output.txt
@@ -1,14 +1,11 @@
 $ cargo check
     Checking hello v0.1.0 (file:///projects/hello)
-error[E0433]: failed to resolve: use of undeclared type or module `ThreadPool`
-  --> src/main.rs:10:16
+error[E0433]: failed to resolve: use of undeclared type `ThreadPool`
+(エラー: 解決に失敗しました。未定義の型`ThreadPool`を使用しています)
+  --> src/main.rs:11:16
    |
-10 |     let pool = ThreadPool::new(4);
-   |                ^^^^^^^^^^ use of undeclared type or module `ThreadPool`
-
-error: aborting due to previous error
+11 |     let pool = ThreadPool::new(4);
+   |                ^^^^^^^^^^ use of undeclared type `ThreadPool`
 
 For more information about this error, try `rustc --explain E0433`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (bin "hello") due to 1 previous error
diff --git a/listings/ch20-web-server/listing-20-12/src/main.rs b/listings/ch20-web-server/listing-20-12/src/main.rs
index 72c5b9a83..21b9a80f1 100644
--- a/listings/ch20-web-server/listing-20-12/src/main.rs
+++ b/listings/ch20-web-server/listing-20-12/src/main.rs
@@ -1,9 +1,10 @@
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
 
 // ANCHOR: here
 fn main() {
@@ -21,25 +22,23 @@ fn main() {
 // ANCHOR_END: here
 
 fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
     };
 
     let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
 
-    let response = format!("{}{}", status_line, contents);
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
 
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
 }
diff --git a/listings/ch20-web-server/listing-20-13/Cargo.toml b/listings/ch20-web-server/listing-20-13/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-13/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-13/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-13/src/bin/main.rs b/listings/ch20-web-server/listing-20-13/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-13/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-13/src/lib.rs b/listings/ch20-web-server/listing-20-13/src/lib.rs
index ffa3c6a25..5e34a8c7d 100644
--- a/listings/ch20-web-server/listing-20-13/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-13/src/lib.rs
@@ -2,6 +2,14 @@ pub struct ThreadPool;
 
 // ANCHOR: here
 impl ThreadPool {
+    /// 新しいThreadPoolを生成する。
+    ///
+    /// sizeがプールのスレッド数です。
+    ///
+    /// # パニック
+    ///
+    /// sizeが0なら、`new`関数はパニックします。
+    ///
     /// Create a new ThreadPool.
     ///
     /// The size is the number of threads in the pool.
@@ -17,7 +25,6 @@ impl ThreadPool {
 
     // --snip--
     // ANCHOR_END: here
-
     pub fn execute<F>(&self, f: F)
     where
         F: FnOnce() + Send + 'static,
@@ -26,5 +33,3 @@ impl ThreadPool {
     // ANCHOR: here
 }
 // ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-13/src/main.rs b/listings/ch20-web-server/listing-20-13/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-13/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-14/Cargo.toml b/listings/ch20-web-server/listing-20-14/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-14/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-14/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-14/src/bin/main.rs b/listings/ch20-web-server/listing-20-14/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-14/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-14/src/lib.rs b/listings/ch20-web-server/listing-20-14/src/lib.rs
index 509a62e1f..400ff8f79 100644
--- a/listings/ch20-web-server/listing-20-14/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-14/src/lib.rs
@@ -22,12 +22,12 @@ impl ThreadPool {
         let mut threads = Vec::with_capacity(size);
 
         for _ in 0..size {
+            // スレッドを作成してベクタに格納する
             // create some threads and store them in the vector
         }
 
         ThreadPool { threads }
     }
-
     // --snip--
     // ANCHOR_END: here
 
diff --git a/listings/ch20-web-server/listing-20-14/src/main.rs b/listings/ch20-web-server/listing-20-14/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-14/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-15/Cargo.toml b/listings/ch20-web-server/listing-20-15/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-15/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-15/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-15/src/lib.rs b/listings/ch20-web-server/listing-20-15/src/lib.rs
index d2ad3ca17..80a6eeeb3 100644
--- a/listings/ch20-web-server/listing-20-15/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-15/src/lib.rs
@@ -51,5 +51,3 @@ impl Worker {
     }
 }
 // ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-15/src/main.rs b/listings/ch20-web-server/listing-20-15/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-15/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-16/Cargo.toml b/listings/ch20-web-server/listing-20-16/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-16/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-16/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-16/src/bin/main.rs b/listings/ch20-web-server/listing-20-16/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-16/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-16/src/lib.rs b/listings/ch20-web-server/listing-20-16/src/lib.rs
index 28b374eed..411c1d003 100644
--- a/listings/ch20-web-server/listing-20-16/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-16/src/lib.rs
@@ -1,7 +1,5 @@
-use std::thread;
 // ANCHOR: here
-// --snip--
-use std::sync::mpsc;
+use std::{sync::mpsc, thread};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -58,5 +56,3 @@ impl Worker {
         Worker { id, thread }
     }
 }
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-16/src/main.rs b/listings/ch20-web-server/listing-20-16/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-16/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-17/Cargo.toml b/listings/ch20-web-server/listing-20-17/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-17/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-17/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-17/output.txt b/listings/ch20-web-server/listing-20-17/output.txt
index f9749e121..cd06ca1b6 100644
--- a/listings/ch20-web-server/listing-20-17/output.txt
+++ b/listings/ch20-web-server/listing-20-17/output.txt
@@ -1,17 +1,21 @@
 $ cargo check
     Checking hello v0.1.0 (file:///projects/hello)
 error[E0382]: use of moved value: `receiver`
-  --> src/lib.rs:27:42
+  --> src/lib.rs:26:42
    |
-22 |         let (sender, receiver) = mpsc::channel();
+21 |         let (sender, receiver) = mpsc::channel();
    |                      -------- move occurs because `receiver` has type `std::sync::mpsc::Receiver<Job>`, which does not implement the `Copy` trait
 ...
-27 |             workers.push(Worker::new(id, receiver));
+25 |         for id in 0..size {
+   |         ----------------- inside of this loop
+26 |             workers.push(Worker::new(id, receiver));
    |                                          ^^^^^^^^ value moved here, in previous iteration of loop
-
-error: aborting due to previous error
+   |
+note: consider changing this parameter type in method `new` to borrow instead if owning the value isn't necessary
+  --> src/lib.rs:47:33
+   |
+47 |     fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {
+   |        --- in this method       ^^^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
 
 For more information about this error, try `rustc --explain E0382`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (lib) due to 1 previous error
diff --git a/listings/ch20-web-server/listing-20-17/src/bin/main.rs b/listings/ch20-web-server/listing-20-17/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-17/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-17/src/lib.rs b/listings/ch20-web-server/listing-20-17/src/lib.rs
index f3ce7d06e..d764879e5 100644
--- a/listings/ch20-web-server/listing-20-17/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-17/src/lib.rs
@@ -1,5 +1,4 @@
-use std::sync::mpsc;
-use std::thread;
+use std::{sync::mpsc, thread};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
diff --git a/listings/ch20-web-server/listing-20-17/src/main.rs b/listings/ch20-web-server/listing-20-17/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-17/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-18/Cargo.toml b/listings/ch20-web-server/listing-20-18/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-18/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-18/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-18/src/bin/main.rs b/listings/ch20-web-server/listing-20-18/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-18/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-18/src/lib.rs b/listings/ch20-web-server/listing-20-18/src/lib.rs
index d47eef869..4bff8acad 100644
--- a/listings/ch20-web-server/listing-20-18/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-18/src/lib.rs
@@ -1,8 +1,8 @@
-use std::sync::mpsc;
-use std::thread;
 // ANCHOR: here
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 // --snip--
 
 // ANCHOR_END: here
@@ -74,5 +74,3 @@ impl Worker {
     }
 }
 // ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-18/src/main.rs b/listings/ch20-web-server/listing-20-18/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-18/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-19/Cargo.toml b/listings/ch20-web-server/listing-20-19/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-19/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-19/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-19/src/bin/main.rs b/listings/ch20-web-server/listing-20-19/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-19/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-19/src/lib.rs b/listings/ch20-web-server/listing-20-19/src/lib.rs
index bf8127b8e..aeb1facd6 100644
--- a/listings/ch20-web-server/listing-20-19/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-19/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -67,5 +67,3 @@ impl Worker {
         Worker { id, thread }
     }
 }
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-19/src/main.rs b/listings/ch20-web-server/listing-20-19/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-19/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-20/Cargo.toml b/listings/ch20-web-server/listing-20-20/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-20/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-20/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-20/src/bin/main.rs b/listings/ch20-web-server/listing-20-20/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-20/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-20/src/lib.rs b/listings/ch20-web-server/listing-20-20/src/lib.rs
index 5fdc32e8b..a8ffecabe 100644
--- a/listings/ch20-web-server/listing-20-20/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-20/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -57,7 +57,8 @@ impl Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv().unwrap();
 
-            println!("Worker {} got a job; executing.", id);
+            // ワーカー{id}は仕事を得ました; 実行します。
+            println!("Worker {id} got a job; executing.");
 
             job();
         });
diff --git a/listings/ch20-web-server/listing-20-20/src/main.rs b/listings/ch20-web-server/listing-20-20/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-20/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-21/Cargo.toml b/listings/ch20-web-server/listing-20-21/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-21/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-21/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-21/src/bin/main.rs b/listings/ch20-web-server/listing-20-21/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-21/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-21/src/lib.rs b/listings/ch20-web-server/listing-20-21/src/lib.rs
index 6bde52488..17b37e77b 100644
--- a/listings/ch20-web-server/listing-20-21/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-21/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -55,7 +55,7 @@ impl Worker {
     fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
         let thread = thread::spawn(move || {
             while let Ok(job) = receiver.lock().unwrap().recv() {
-                println!("Worker {} got a job; executing.", id);
+                println!("Worker {id} got a job; executing.");
 
                 job();
             }
diff --git a/listings/ch20-web-server/listing-20-21/src/main.rs b/listings/ch20-web-server/listing-20-21/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-21/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-22/Cargo.toml b/listings/ch20-web-server/listing-20-22/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-22/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-22/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-22/output.txt b/listings/ch20-web-server/listing-20-22/output.txt
index f5dd1ba13..35588617d 100644
--- a/listings/ch20-web-server/listing-20-22/output.txt
+++ b/listings/ch20-web-server/listing-20-22/output.txt
@@ -4,11 +4,12 @@ error[E0507]: cannot move out of `worker.thread` which is behind a mutable refer
   --> src/lib.rs:52:13
    |
 52 |             worker.thread.join().unwrap();
-   |             ^^^^^^^^^^^^^ move occurs because `worker.thread` has type `std::thread::JoinHandle<()>`, which does not implement the `Copy` trait
-
-error: aborting due to previous error
+   |             ^^^^^^^^^^^^^ ------ `worker.thread` moved due to this method call
+   |             |
+   |             move occurs because `worker.thread` has type `JoinHandle<()>`, which does not implement the `Copy` trait
+   |
+note: `JoinHandle::<T>::join` takes ownership of the receiver `self`, which moves `worker.thread`
+  --> /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/std/src/thread/mod.rs:1649:17
 
 For more information about this error, try `rustc --explain E0507`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (lib) due to 1 previous error
diff --git a/listings/ch20-web-server/listing-20-22/src/bin/main.rs b/listings/ch20-web-server/listing-20-22/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-22/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-22/src/lib.rs b/listings/ch20-web-server/listing-20-22/src/lib.rs
index 824257898..cb3141810 100644
--- a/listings/ch20-web-server/listing-20-22/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-22/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -48,6 +48,7 @@ impl ThreadPool {
 impl Drop for ThreadPool {
     fn drop(&mut self) {
         for worker in &mut self.workers {
+            // ワーカー{}を終了します
             println!("Shutting down worker {}", worker.id);
 
             worker.thread.join().unwrap();
@@ -66,7 +67,7 @@ impl Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv().unwrap();
 
-            println!("Worker {} got a job; executing.", id);
+            println!("Worker {id} got a job; executing.");
 
             job();
         });
diff --git a/listings/ch20-web-server/listing-20-22/src/main.rs b/listings/ch20-web-server/listing-20-22/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-22/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-23/Cargo.toml b/listings/ch20-web-server/listing-20-23/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-23/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-23/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-23/src/bin/main.rs b/listings/ch20-web-server/listing-20-23/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-23/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-23/src/lib.rs b/listings/ch20-web-server/listing-20-23/src/lib.rs
index 6ccaee73f..eea339b02 100644
--- a/listings/ch20-web-server/listing-20-23/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-23/src/lib.rs
@@ -1,28 +1,20 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 // ANCHOR: here
 pub struct ThreadPool {
     workers: Vec<Worker>,
-    sender: mpsc::Sender<Message>,
+    sender: Option<mpsc::Sender<Job>>,
 }
-
 // --snip--
-
 // ANCHOR_END: here
-type Job = Box<dyn FnOnce() + Send + 'static>;
 
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
+type Job = Box<dyn FnOnce() + Send + 'static>;
 
 // ANCHOR: here
 impl ThreadPool {
-    // --snip--
-
     // ANCHOR_END: here
     /// Create a new ThreadPool.
     ///
@@ -31,7 +23,11 @@ impl ThreadPool {
     /// # Panics
     ///
     /// The `new` function will panic if the size is zero.
+    // ANCHOR: here
     pub fn new(size: usize) -> ThreadPool {
+        // --snip--
+
+        // ANCHOR_END: here
         assert!(size > 0);
 
         let (sender, receiver) = mpsc::channel();
@@ -44,25 +40,27 @@ impl ThreadPool {
             workers.push(Worker::new(id, Arc::clone(&receiver)));
         }
 
-        ThreadPool { workers, sender }
+        // ANCHOR: here
+        ThreadPool {
+            workers,
+            sender: Some(sender),
+        }
     }
 
-    // ANCHOR: here
     pub fn execute<F>(&self, f: F)
     where
         F: FnOnce() + Send + 'static,
     {
         let job = Box::new(f);
 
-        self.sender.send(Message::NewJob(job)).unwrap();
+        self.sender.as_ref().unwrap().send(job).unwrap();
     }
 }
 
-// --snip--
-
-// ANCHOR_END: here
 impl Drop for ThreadPool {
     fn drop(&mut self) {
+        drop(self.sender.take());
+
         for worker in &mut self.workers {
             println!("Shutting down worker {}", worker.id);
 
@@ -72,30 +70,21 @@ impl Drop for ThreadPool {
         }
     }
 }
+// ANCHOR_END: here
 
 struct Worker {
     id: usize,
     thread: Option<thread::JoinHandle<()>>,
 }
 
-// ANCHOR: here
 impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
+    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
         let thread = thread::spawn(move || loop {
-            let message = receiver.lock().unwrap().recv().unwrap();
-
-            match message {
-                Message::NewJob(job) => {
-                    println!("Worker {} got a job; executing.", id);
+            let job = receiver.lock().unwrap().recv().unwrap();
 
-                    job();
-                }
-                Message::Terminate => {
-                    println!("Worker {} was told to terminate.", id);
+            println!("Worker {id} got a job; executing.");
 
-                    break;
-                }
-            }
+            job();
         });
 
         Worker {
@@ -104,4 +93,3 @@ impl Worker {
         }
     }
 }
-// ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-23/src/main.rs b/listings/ch20-web-server/listing-20-23/src/main.rs
new file mode 100644
index 000000000..b6aa046d1
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-23/src/main.rs
@@ -0,0 +1,45 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming().take(2) {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+
+    println!("Shutting down.");
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-24/Cargo.toml b/listings/ch20-web-server/listing-20-24/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-24/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-24/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-24/src/bin/main.rs b/listings/ch20-web-server/listing-20-24/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/listing-20-24/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-24/src/lib.rs b/listings/ch20-web-server/listing-20-24/src/lib.rs
index 747bff2b1..162ba1b13 100644
--- a/listings/ch20-web-server/listing-20-24/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-24/src/lib.rs
@@ -1,20 +1,15 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
-    sender: mpsc::Sender<Message>,
+    sender: Option<mpsc::Sender<Job>>,
 }
 
 type Job = Box<dyn FnOnce() + Send + 'static>;
 
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
-
 impl ThreadPool {
     /// Create a new ThreadPool.
     ///
@@ -36,7 +31,10 @@ impl ThreadPool {
             workers.push(Worker::new(id, Arc::clone(&receiver)));
         }
 
-        ThreadPool { workers, sender }
+        ThreadPool {
+            workers,
+            sender: Some(sender),
+        }
     }
 
     pub fn execute<F>(&self, f: F)
@@ -45,20 +43,13 @@ impl ThreadPool {
     {
         let job = Box::new(f);
 
-        self.sender.send(Message::NewJob(job)).unwrap();
+        self.sender.as_ref().unwrap().send(job).unwrap();
     }
 }
 
-// ANCHOR: here
 impl Drop for ThreadPool {
     fn drop(&mut self) {
-        println!("Sending terminate message to all workers.");
-
-        for _ in &self.workers {
-            self.sender.send(Message::Terminate).unwrap();
-        }
-
-        println!("Shutting down all workers.");
+        drop(self.sender.take());
 
         for worker in &mut self.workers {
             println!("Shutting down worker {}", worker.id);
@@ -69,27 +60,27 @@ impl Drop for ThreadPool {
         }
     }
 }
-// ANCHOR_END: here
 
 struct Worker {
     id: usize,
     thread: Option<thread::JoinHandle<()>>,
 }
 
+// ANCHOR: here
 impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
+    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
         let thread = thread::spawn(move || loop {
-            let message = receiver.lock().unwrap().recv().unwrap();
+            let message = receiver.lock().unwrap().recv();
 
             match message {
-                Message::NewJob(job) => {
-                    println!("Worker {} got a job; executing.", id);
+                Ok(job) => {
+                    println!("Worker {id} got a job; executing.");
 
                     job();
                 }
-                Message::Terminate => {
-                    println!("Worker {} was told to terminate.", id);
-
+                Err(_) => {
+                    // ワーカー{id}は切断されました; 停止します。
+                    println!("Worker {id} disconnected; shutting down.");
                     break;
                 }
             }
@@ -101,3 +92,4 @@ impl Worker {
         }
     }
 }
+// ANCHOR_END: here
diff --git a/listings/ch20-web-server/listing-20-24/src/main.rs b/listings/ch20-web-server/listing-20-24/src/main.rs
new file mode 100644
index 000000000..b6aa046d1
--- /dev/null
+++ b/listings/ch20-web-server/listing-20-24/src/main.rs
@@ -0,0 +1,45 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming().take(2) {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+
+    println!("Shutting down.");
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/listing-20-25/Cargo.toml b/listings/ch20-web-server/listing-20-25/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-25/Cargo.toml
+++ b/listings/ch20-web-server/listing-20-25/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-25/src/lib.rs b/listings/ch20-web-server/listing-20-25/src/lib.rs
index 424eac8e4..54c0489ab 100644
--- a/listings/ch20-web-server/listing-20-25/src/lib.rs
+++ b/listings/ch20-web-server/listing-20-25/src/lib.rs
@@ -1,21 +1,15 @@
-// ANCHOR: here
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
-    sender: mpsc::Sender<Message>,
+    sender: Option<mpsc::Sender<Job>>,
 }
 
 type Job = Box<dyn FnOnce() + Send + 'static>;
 
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
-
 impl ThreadPool {
     /// Create a new ThreadPool.
     ///
@@ -37,7 +31,10 @@ impl ThreadPool {
             workers.push(Worker::new(id, Arc::clone(&receiver)));
         }
 
-        ThreadPool { workers, sender }
+        ThreadPool {
+            workers,
+            sender: Some(sender),
+        }
     }
 
     pub fn execute<F>(&self, f: F)
@@ -46,19 +43,13 @@ impl ThreadPool {
     {
         let job = Box::new(f);
 
-        self.sender.send(Message::NewJob(job)).unwrap();
+        self.sender.as_ref().unwrap().send(job).unwrap();
     }
 }
 
 impl Drop for ThreadPool {
     fn drop(&mut self) {
-        println!("Sending terminate message to all workers.");
-
-        for _ in &self.workers {
-            self.sender.send(Message::Terminate).unwrap();
-        }
-
-        println!("Shutting down all workers.");
+        drop(self.sender.take());
 
         for worker in &mut self.workers {
             println!("Shutting down worker {}", worker.id);
@@ -76,19 +67,18 @@ struct Worker {
 }
 
 impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
+    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
         let thread = thread::spawn(move || loop {
-            let message = receiver.lock().unwrap().recv().unwrap();
+            let message = receiver.lock().unwrap().recv();
 
             match message {
-                Message::NewJob(job) => {
-                    println!("Worker {} got a job; executing.", id);
+                Ok(job) => {
+                    println!("Worker {id} got a job; executing.");
 
                     job();
                 }
-                Message::Terminate => {
-                    println!("Worker {} was told to terminate.", id);
-
+                Err(_) => {
+                    println!("Worker {id} disconnected; shutting down.");
                     break;
                 }
             }
@@ -100,6 +90,3 @@ impl Worker {
         }
     }
 }
-// ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-25/src/bin/main.rs b/listings/ch20-web-server/listing-20-25/src/main.rs
similarity index 74%
rename from listings/ch20-web-server/listing-20-25/src/bin/main.rs
rename to listings/ch20-web-server/listing-20-25/src/main.rs
index 22534d2f4..a649ff103 100644
--- a/listings/ch20-web-server/listing-20-25/src/bin/main.rs
+++ b/listings/ch20-web-server/listing-20-25/src/main.rs
@@ -1,4 +1,3 @@
-// ANCHOR: all
 use hello::ThreadPool;
 use std::fs;
 use std::io::prelude::*;
@@ -32,19 +31,23 @@ fn handle_connection(mut stream: TcpStream) {
     let sleep = b"GET /sleep HTTP/1.1\r\n";
 
     let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
+        ("HTTP/1.1 200 OK", "hello.html")
     } else if buffer.starts_with(sleep) {
         thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
+        ("HTTP/1.1 200 OK", "hello.html")
     } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+        ("HTTP/1.1 404 NOT FOUND", "404.html")
     };
 
     let contents = fs::read_to_string(filename).unwrap();
 
-    let response = format!("{}{}", status_line, contents);
+    let response = format!(
+        "{}\r\nContent-Length: {}\r\n\r\n{}",
+        status_line,
+        contents.len(),
+        contents
+    );
 
-    stream.write(response.as_bytes()).unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
     stream.flush().unwrap();
 }
-// ANCHOR_END: all
diff --git a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/Cargo.toml b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/output.txt b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/output.txt
index 0161c7b2c..953b01d15 100644
--- a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/output.txt
+++ b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/output.txt
@@ -1,14 +1,11 @@
 $ cargo check
     Checking hello v0.1.0 (file:///projects/hello)
-error[E0599]: no function or associated item named `new` found for type `hello::ThreadPool` in the current scope
-  --> src/bin/main.rs:11:28
+error[E0599]: no function or associated item named `new` found for struct `ThreadPool` in the current scope
+(エラー: 現在のスコープで構造体`ThreadPool`の関数または関連アイテムに`new`というものが見つかりません)
+  --> src/main.rs:12:28
    |
-11 |     let pool = ThreadPool::new(4);
-   |                            ^^^ function or associated item not found in `hello::ThreadPool`
-
-error: aborting due to previous error
+12 |     let pool = ThreadPool::new(4);
+   |                            ^^^ function or associated item not found in `ThreadPool`
 
 For more information about this error, try `rustc --explain E0599`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (bin "hello") due to 1 previous error
diff --git a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/bin/main.rs b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/bin/main.rs
deleted file mode 100644
index 8df1b17ee..000000000
--- a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/bin/main.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// ANCHOR: here
-use hello::ThreadPool;
-// ANCHOR_END: here
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/main.rs b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/main.rs
new file mode 100644
index 000000000..f7b42167f
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/main.rs
@@ -0,0 +1,45 @@
+// ANCHOR: here
+use hello::ThreadPool;
+// ANCHOR_END: here
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/Cargo.toml b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/output.txt b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/output.txt
index c808b8986..667041862 100644
--- a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/output.txt
+++ b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/output.txt
@@ -1,14 +1,10 @@
 $ cargo check
     Checking hello v0.1.0 (file:///projects/hello)
-error[E0599]: no method named `execute` found for type `hello::ThreadPool` in the current scope
-  --> src/bin/main.rs:16:14
+error[E0599]: no method named `execute` found for struct `ThreadPool` in the current scope
+  --> src/main.rs:17:14
    |
-16 |         pool.execute(|| {
-   |              ^^^^^^^ method not found in `hello::ThreadPool`
-
-error: aborting due to previous error
+17 |         pool.execute(|| {
+   |         -----^^^^^^^ method not found in `ThreadPool`
 
 For more information about this error, try `rustc --explain E0599`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (bin "hello") due to 1 previous error
diff --git a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/bin/main.rs b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/lib.rs b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/lib.rs
index 3ff5ad497..f0e1890bb 100644
--- a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/lib.rs
@@ -1,4 +1,3 @@
-// ANCHOR: here
 pub struct ThreadPool;
 
 impl ThreadPool {
@@ -6,6 +5,3 @@ impl ThreadPool {
         ThreadPool
     }
 }
-// ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/main.rs b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-03-define-execute/Cargo.toml b/listings/ch20-web-server/no-listing-03-define-execute/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-03-define-execute/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-03-define-execute/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-03-define-execute/src/bin/main.rs b/listings/ch20-web-server/no-listing-03-define-execute/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-03-define-execute/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-03-define-execute/src/lib.rs b/listings/ch20-web-server/no-listing-03-define-execute/src/lib.rs
index 44e0ebd72..1321ab873 100644
--- a/listings/ch20-web-server/no-listing-03-define-execute/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-03-define-execute/src/lib.rs
@@ -16,5 +16,3 @@ impl ThreadPool {
     }
 }
 // ANCHOR_END: here
-
-fn main() {}
diff --git a/listings/ch20-web-server/no-listing-03-define-execute/src/main.rs b/listings/ch20-web-server/no-listing-03-define-execute/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-03-define-execute/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-04-update-worker-definition/Cargo.toml b/listings/ch20-web-server/no-listing-04-update-worker-definition/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-04-update-worker-definition/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-04-update-worker-definition/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-04-update-worker-definition/output.txt b/listings/ch20-web-server/no-listing-04-update-worker-definition/output.txt
index 91907cf79..4a622de7f 100644
--- a/listings/ch20-web-server/no-listing-04-update-worker-definition/output.txt
+++ b/listings/ch20-web-server/no-listing-04-update-worker-definition/output.txt
@@ -1,27 +1,31 @@
 $ cargo check
     Checking hello v0.1.0 (file:///projects/hello)
-error[E0599]: no method named `join` found for type `std::option::Option<std::thread::JoinHandle<()>>` in the current scope
+error[E0599]: no method named `join` found for enum `Option` in the current scope
   --> src/lib.rs:52:27
    |
 52 |             worker.thread.join().unwrap();
-   |                           ^^^^ method not found in `std::option::Option<std::thread::JoinHandle<()>>`
+   |                           ^^^^ method not found in `Option<JoinHandle<()>>`
+   |
+note: the method `join` exists on the type `JoinHandle<()>`
+  --> /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/std/src/thread/mod.rs:1649:5
+help: consider using `Option::expect` to unwrap the `JoinHandle<()>` value, panicking if the value is an `Option::None`
+   |
+52 |             worker.thread.expect("REASON").join().unwrap();
+   |                          +++++++++++++++++
 
 error[E0308]: mismatched types
   --> src/lib.rs:72:22
    |
 72 |         Worker { id, thread }
-   |                      ^^^^^^
-   |                      |
-   |                      expected enum `std::option::Option`, found struct `std::thread::JoinHandle`
-   |                      help: try using a variant of the expected enum: `Some(thread)`
+   |                      ^^^^^^ expected `Option<JoinHandle<()>>`, found `JoinHandle<_>`
    |
-   = note: expected enum `std::option::Option<std::thread::JoinHandle<()>>`
-            found struct `std::thread::JoinHandle<_>`
-
-error: aborting due to 2 previous errors
+   = note: expected enum `Option<JoinHandle<()>>`
+            found struct `JoinHandle<_>`
+help: try wrapping the expression in `Some`
+   |
+72 |         Worker { id, thread: Some(thread) }
+   |                      +++++++++++++      +
 
 Some errors have detailed explanations: E0308, E0599.
 For more information about an error, try `rustc --explain E0308`.
-error: could not compile `hello`.
-
-To learn more, run the command again with --verbose.
+error: could not compile `hello` (lib) due to 2 previous errors
diff --git a/listings/ch20-web-server/no-listing-04-update-worker-definition/src/bin/main.rs b/listings/ch20-web-server/no-listing-04-update-worker-definition/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-04-update-worker-definition/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-04-update-worker-definition/src/lib.rs b/listings/ch20-web-server/no-listing-04-update-worker-definition/src/lib.rs
index 1098330b3..6ef710a26 100644
--- a/listings/ch20-web-server/no-listing-04-update-worker-definition/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-04-update-worker-definition/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -66,7 +66,7 @@ impl Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv().unwrap();
 
-            println!("Worker {} got a job; executing.", id);
+            println!("Worker {id} got a job; executing.");
 
             job();
         });
diff --git a/listings/ch20-web-server/no-listing-04-update-worker-definition/src/main.rs b/listings/ch20-web-server/no-listing-04-update-worker-definition/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-04-update-worker-definition/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-05-fix-worker-new/Cargo.toml b/listings/ch20-web-server/no-listing-05-fix-worker-new/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-05-fix-worker-new/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-05-fix-worker-new/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-05-fix-worker-new/src/bin/main.rs b/listings/ch20-web-server/no-listing-05-fix-worker-new/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-05-fix-worker-new/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-05-fix-worker-new/src/lib.rs b/listings/ch20-web-server/no-listing-05-fix-worker-new/src/lib.rs
index 6bef23a16..ede3750a1 100644
--- a/listings/ch20-web-server/no-listing-05-fix-worker-new/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-05-fix-worker-new/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -68,7 +68,7 @@ impl Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv().unwrap();
 
-            println!("Worker {} got a job; executing.", id);
+            println!("Worker {id} got a job; executing.");
 
             job();
         });
diff --git a/listings/ch20-web-server/no-listing-05-fix-worker-new/src/main.rs b/listings/ch20-web-server/no-listing-05-fix-worker-new/src/main.rs
new file mode 100644
index 000000000..79efb28a2
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-05-fix-worker-new/src/main.rs
@@ -0,0 +1,43 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/Cargo.toml b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/bin/main.rs b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/lib.rs b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/lib.rs
index d5b38a635..b795ea53b 100644
--- a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/lib.rs
@@ -1,7 +1,7 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
@@ -68,7 +68,7 @@ impl Worker {
         let thread = thread::spawn(move || loop {
             let job = receiver.lock().unwrap().recv().unwrap();
 
-            println!("Worker {} got a job; executing.", id);
+            println!("Worker {id} got a job; executing.");
 
             job();
         });
diff --git a/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/main.rs b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/main.rs
new file mode 100644
index 000000000..b6aa046d1
--- /dev/null
+++ b/listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/main.rs
@@ -0,0 +1,45 @@
+use hello::ThreadPool;
+use std::{
+    fs,
+    io::{prelude::*, BufReader},
+    net::{TcpListener, TcpStream},
+    thread,
+    time::Duration,
+};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
+    let pool = ThreadPool::new(4);
+
+    for stream in listener.incoming().take(2) {
+        let stream = stream.unwrap();
+
+        pool.execute(|| {
+            handle_connection(stream);
+        });
+    }
+
+    println!("Shutting down.");
+}
+
+fn handle_connection(mut stream: TcpStream) {
+    let buf_reader = BufReader::new(&mut stream);
+    let request_line = buf_reader.lines().next().unwrap().unwrap();
+
+    let (status_line, filename) = match &request_line[..] {
+        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"),
+        "GET /sleep HTTP/1.1" => {
+            thread::sleep(Duration::from_secs(5));
+            ("HTTP/1.1 200 OK", "hello.html")
+        }
+        _ => ("HTTP/1.1 404 NOT FOUND", "404.html"),
+    };
+
+    let contents = fs::read_to_string(filename).unwrap();
+    let length = contents.len();
+
+    let response =
+        format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
+
+    stream.write_all(response.as_bytes()).unwrap();
+}
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.lock b/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.lock
deleted file mode 100644
index f2d069f46..000000000
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.lock
+++ /dev/null
@@ -1,6 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "hello"
-version = "0.1.0"
-
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.toml b/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.toml
deleted file mode 100644
index 78dfe6ebc..000000000
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/Cargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "hello"
-version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
-
-[dependencies]
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/hello.html b/listings/ch20-web-server/no-listing-07-define-message-enum/hello.html
deleted file mode 100644
index fe442d6b9..000000000
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/hello.html
+++ /dev/null
@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Hello!</title>
-  </head>
-  <body>
-    <h1>Hello!</h1>
-    <p>Hi from Rust</p>
-  </body>
-</html>
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/src/bin/main.rs b/listings/ch20-web-server/no-listing-07-define-message-enum/src/bin/main.rs
deleted file mode 100644
index 9d6a9c154..000000000
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/src/bin/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use hello::ThreadPool;
-use std::fs;
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let contents = fs::read_to_string(filename).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
diff --git a/listings/ch20-web-server/listing-20-08/404.html b/listings/ch20-web-server/no-listing-07-final-code/404.html
similarity index 100%
rename from listings/ch20-web-server/listing-20-08/404.html
rename to listings/ch20-web-server/no-listing-07-final-code/404.html
diff --git a/listings/ch20-web-server/listing-20-04/Cargo.lock b/listings/ch20-web-server/no-listing-07-final-code/Cargo.lock
similarity index 100%
rename from listings/ch20-web-server/listing-20-04/Cargo.lock
rename to listings/ch20-web-server/no-listing-07-final-code/Cargo.lock
diff --git a/listings/ch20-web-server/listing-20-04/Cargo.toml b/listings/ch20-web-server/no-listing-07-final-code/Cargo.toml
similarity index 50%
rename from listings/ch20-web-server/listing-20-04/Cargo.toml
rename to listings/ch20-web-server/no-listing-07-final-code/Cargo.toml
index 78dfe6ebc..fe619478a 100644
--- a/listings/ch20-web-server/listing-20-04/Cargo.toml
+++ b/listings/ch20-web-server/no-listing-07-final-code/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "hello"
 version = "0.1.0"
-authors = ["Your Name <you@example.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
diff --git a/listings/ch20-web-server/listing-20-04/hello.html b/listings/ch20-web-server/no-listing-07-final-code/hello.html
similarity index 100%
rename from listings/ch20-web-server/listing-20-04/hello.html
rename to listings/ch20-web-server/no-listing-07-final-code/hello.html
diff --git a/listings/ch20-web-server/no-listing-07-define-message-enum/src/lib.rs b/listings/ch20-web-server/no-listing-07-final-code/src/lib.rs
similarity index 67%
rename from listings/ch20-web-server/no-listing-07-define-message-enum/src/lib.rs
rename to listings/ch20-web-server/no-listing-07-final-code/src/lib.rs
index ed1913b29..54c0489ab 100644
--- a/listings/ch20-web-server/no-listing-07-define-message-enum/src/lib.rs
+++ b/listings/ch20-web-server/no-listing-07-final-code/src/lib.rs
@@ -1,22 +1,15 @@
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    thread,
+};
 
 pub struct ThreadPool {
     workers: Vec<Worker>,
-    sender: mpsc::Sender<Job>,
+    sender: Option<mpsc::Sender<Job>>,
 }
 
 type Job = Box<dyn FnOnce() + Send + 'static>;
 
-// ANCHOR: here
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
-// ANCHOR_END: here
-
 impl ThreadPool {
     /// Create a new ThreadPool.
     ///
@@ -38,7 +31,10 @@ impl ThreadPool {
             workers.push(Worker::new(id, Arc::clone(&receiver)));
         }
 
-        ThreadPool { workers, sender }
+        ThreadPool {
+            workers,
+            sender: Some(sender),
+        }
     }
 
     pub fn execute<F>(&self, f: F)
@@ -47,12 +43,14 @@ impl ThreadPool {
     {
         let job = Box::new(f);
 
-        self.sender.send(job).unwrap();
+        self.sender.as_ref().unwrap().send(job).unwrap();
     }
 }
 
 impl Drop for ThreadPool {
     fn drop(&mut self) {
+        drop(self.sender.take());
+
         for worker in &mut self.workers {
             println!("Shutting down worker {}", worker.id);
 
@@ -71,11 +69,19 @@ struct Worker {
 impl Worker {
     fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
         let thread = thread::spawn(move || loop {
-            let job = receiver.lock().unwrap().recv().unwrap();
-
-            println!("Worker {} got a job; executing.", id);
-
-            job();
+            let message = receiver.lock().unwrap().recv();
+
+            match message {
+                Ok(job) => {
+                    println!("Worker {id} got a job; executing.");
+
+                    job();
+                }
+                Err(_) => {
+                    println!("Worker {id} disconnected; shutting down.");
+                    break;
+                }
+            }
         });
 
         Worker {
@@ -84,5 +90,3 @@ impl Worker {
         }
     }
 }
-
-fn main() {}
diff --git a/listings/ch20-web-server/listing-20-15/src/bin/main.rs b/listings/ch20-web-server/no-listing-07-final-code/src/main.rs
similarity index 66%
rename from listings/ch20-web-server/listing-20-15/src/bin/main.rs
rename to listings/ch20-web-server/no-listing-07-final-code/src/main.rs
index 9d6a9c154..cbd235512 100644
--- a/listings/ch20-web-server/listing-20-15/src/bin/main.rs
+++ b/listings/ch20-web-server/no-listing-07-final-code/src/main.rs
@@ -10,13 +10,16 @@ fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
     let pool = ThreadPool::new(4);
 
-    for stream in listener.incoming() {
+    for stream in listener.incoming().take(2) {
         let stream = stream.unwrap();
 
         pool.execute(|| {
             handle_connection(stream);
         });
     }
+
+    // 終了します。
+    println!("Shutting down.");
 }
 
 fn handle_connection(mut stream: TcpStream) {
@@ -27,18 +30,23 @@ fn handle_connection(mut stream: TcpStream) {
     let sleep = b"GET /sleep HTTP/1.1\r\n";
 
     let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
+        ("HTTP/1.1 200 OK", "hello.html")
     } else if buffer.starts_with(sleep) {
         thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
+        ("HTTP/1.1 200 OK", "hello.html")
     } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
+        ("HTTP/1.1 404 NOT FOUND", "404.html")
     };
 
     let contents = fs::read_to_string(filename).unwrap();
 
-    let response = format!("{}{}", status_line, contents);
+    let response = format!(
+        "{}\r\nContent-Length: {}\r\n\r\n{}",
+        status_line,
+        contents.len(),
+        contents
+    );
 
-    stream.write(response.as_bytes()).unwrap();
+    stream.write_all(response.as_bytes()).unwrap();
     stream.flush().unwrap();
 }
diff --git a/src/ch20-00-final-project-a-web-server.md b/src/ch20-00-final-project-a-web-server.md
index 424f99a73..f9c8bc979 100644
--- a/src/ch20-00-final-project-a-web-server.md
+++ b/src/ch20-00-final-project-a-web-server.md
@@ -30,7 +30,7 @@ Figure 20-1 in a web browser.
 <span class="caption">図20-1: 最後の共有されたプロジェクト</span>
 
 <!--
-Here is the plan to build the web server:
+Here is our plan for building the web server:
 -->
 
 こちらがWebサーバを構築するプランです:
@@ -50,27 +50,25 @@ Here is the plan to build the web server:
 5. スレッドプールでサーバのスループットを強化する。
 
 <!--
-But before we get started, we should mention one detail: the method we’ll use
-won’t be the best way to build a web server with Rust. A number of
-production-ready crates are available on *https://crates.io/* that provide more
-complete web server and thread pool implementations than we’ll build.
+Before we get started, we should mention one detail: the method we’ll use won’t
+be the best way to build a web server with Rust. Community members have
+published a number of production-ready crates available on
+[crates.io](https://crates.io/) that provide more complete web server and
+thread pool implementations than we’ll build. However, our intention in this
+chapter is to help you learn, not to take the easy route. Because Rust is a
+systems programming language, we can choose the level of abstraction we want to
+work with and can go to a lower level than is possible or practical in other
+languages. We’ll therefore write the basic HTTP server and thread pool manually
+so you can learn the general ideas and techniques behind the crates you might
+use in the future.
 -->
 
-ですが、取り掛かる前に、ある小さな事実に触れなければなりません:
+取り掛かる前に、ある小さな事実に触れなければなりません:
 わたしたちがこれから行うやり方は、RustでWebサーバを構築する最善の方法ではないだろうということです。
 これから構築するよりもより完全なWebサーバとスレッドプールの実装を提供する製品利用可能な多くのクレートが、
-*https://crates.io/* で利用可能なのです。
-
-<!--
-However, our intention in this chapter is to help you learn, not to take the
-easy route. Because Rust is a systems programming language, we can choose the
-level of abstraction we want to work with and can go to a lower level than is
-possible or practical in other languages. We’ll write the basic HTTP server and
-thread pool manually so you can learn the general ideas and techniques behind
-the crates you might use in the future.
--->
-
+[crates.io](https://crates.io/)から利用できるように、コミュニティメンバたちによって公開されています。
 しかしながら、この章での意図は、学習を手助けすることであり、簡単なやり方を選ぶことではありません。
 Rustはシステムプログラミング言語なので、取りかかる抽象度を選ぶことができ、
-他の言語で可能だったり実践的だったりするよりも低レベルまで行くことができます。一般的な考えと将来使う可能性のあるクレートの背後にある技術を学べるように、
+他の言語で可能だったり実践的だったりするよりも低レベルまで行くことができます。
+そのため、一般的な考えと将来使う可能性のあるクレートの背後にある技術を学べるように、
 手動で基本的なHTTPサーバとスレッドプールを書きます。
diff --git a/src/ch20-01-single-threaded.md b/src/ch20-01-single-threaded.md
index b01fd42da..dfbdae5fb 100644
--- a/src/ch20-01-single-threaded.md
+++ b/src/ch20-01-single-threaded.md
@@ -15,12 +15,11 @@ a brief overview will give you the information you need.
 これらのプロトコルの詳細は、この本の範疇を超えていますが、さっと眺めることで必要な情報が得られるでしょう。
 
 <!--
-The two main protocols involved in web servers are the *Hypertext Transfer
-Protocol* *(HTTP)* and the *Transmission Control Protocol* *(TCP)*. Both
-protocols are *request-response* protocols, meaning a *client* initiates
-requests and a *server* listens to the requests and provides a response to the
-client. The contents of those requests and responses are defined by the
-protocols.
+The two main protocols involved in web servers are *Hypertext Transfer
+Protocol* *(HTTP)* and *Transmission Control Protocol* *(TCP)*. Both protocols
+are *request-response* protocols, meaning a *client* initiates requests and a
+*server* listens to the requests and provides a response to the client. The
+contents of those requests and responses are defined by the protocols.
 -->
 
 主に2つのプロトコルがWebサーバに関係し、*Hypertext Transfer Protocol* *(HTTP)*(`注釈`: ハイパーテキスト転送プロトコル)と、
@@ -58,20 +57,20 @@ this. Let’s make a new project in the usual fashion:
 WebサーバはTCP接続をリッスンするので、そこが最初に取り掛かる部分になります。標準ライブラリは、
 `std::net`というこれを行うモジュールを用意しています。通常通り、新しいプロジェクトを作りましょう:
 
-```text
-$ cargo new hello --bin
+```console
+$ cargo new hello
      Created binary (application) `hello` project
 $ cd hello
 ```
 
 <!--
 Now enter the code in Listing 20-1 in *src/main.rs* to start. This code will
-listen at the address `127.0.0.1:7878` for incoming TCP streams. When it gets
-an incoming stream, it will print `Connection established!`.
+listen at the local address `127.0.0.1:7878` for incoming TCP streams. When it
+gets an incoming stream, it will print `Connection established!`.
 -->
 
 さて、リスト20-1のコードを*src/main.rs*に入力して始めてください。このコードは、
-TCPストリームを受信するため`127.0.0.1:7878`というアドレスをリッスンします。
+TCPストリームを受信するため`127.0.0.1:7878`というローカルアドレスをリッスンします。
 入力ストリームを得ると、`Connection established!`と出力します。
 
 <!--
@@ -81,18 +80,7 @@ TCPストリームを受信するため`127.0.0.1:7878`というアドレスを
 <span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,no_run
-use std::net::TcpListener;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        // 接続が確立しました
-        println!("Connection established!");
-    }
-}
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-01/src/main.rs}}
 ```
 
 <!--
@@ -107,41 +95,44 @@ Using `TcpListener`, we can listen for TCP connections at the address
 `127.0.0.1:7878`. In the address, the section before the colon is an IP address
 representing your computer (this is the same on every computer and doesn’t
 represent the authors’ computer specifically), and `7878` is the port. We’ve
-chosen this port for two reasons: HTTP is normally accepted on this port, and
-7878 is “rust” typed on a telephone.
+chosen this port for two reasons: HTTP isn’t normally accepted on this port so
+our server is unlikely to conflict with any other web server you might have
+running on your machine, and 7878 is *rust* typed on a telephone.
 -->
 
 `TcpListener`により、アドレス`127.0.0.1:7878`でTCP接続をリッスンできます。アドレス内で、
 コロンの前の区域は、自分のコンピュータを表すIPアドレスで(これはどんなコンピュータでも同じで、
 特に著者のコンピュータを表すわけではありません)、`7878`はポートです。このポートを選択した理由は2つあります:
-HTTPは通常このポートで受け付けられることと、7878は電話で“rust”と入力されるからです。
+HTTPは通常このポートで受け付けられることがないので、私たちのサーバはおそらく、
+あなたのマシンで実行中かもしれない他のwebサーバと混線しないだろうということと、
+7878は電話で*rust*と入力されるからです。
 
 <!--
 The `bind` function in this scenario works like the `new` function in that it
-will return a new `TcpListener` instance. The reason the function is called
-`bind` is that in networking, connecting to a port to listen to is known as
-“binding to a port.”
+will return a new `TcpListener` instance. The function is called `bind`
+because, in networking, connecting to a port to listen to is known as “binding
+to a port.”
 -->
 
 この筋書きでの`bind`関数は、新しい`TcpListener`インスタンスを返すという点で`new`関数のような働きをします。
-この関数が`bind`と呼ばれている理由は、ネットワークにおいて、リッスンすべきポートに接続することは、
+この関数は`bind`と呼ばれます。ネットワークにおいて、リッスンすべきポートに接続することは、
 「ポートに束縛する」(binding to a port)こととして知られているからです。
 
 <!--
-The `bind` function returns a `Result<T, E>`, which indicates that binding
-might fail. For example, connecting to port 80 requires administrator
-privileges (nonadministrators can listen only on ports higher than 1024), so if
-we tried to connect to port 80 without being an administrator, binding wouldn’t
-work. As another example, binding wouldn’t work if we ran two instances of our
-program and so had two programs listening to the same port. Because we’re
-writing a basic server just for learning purposes, we won’t worry about
-handling these kinds of errors; instead, we use `unwrap` to stop the program if
-errors happen.
+The `bind` function returns a `Result<T, E>`, which indicates that it’s
+possible for binding to fail. For example, connecting to port 80 requires
+administrator privileges (nonadministrators can listen only on ports higher
+than 1023), so if we tried to connect to port 80 without being an
+administrator, binding wouldn’t work. Binding also wouldn’t work, for example,
+if we ran two instances of our program and so had two programs listening to the
+same port. Because we’re writing a basic server just for learning purposes, we
+won’t worry about handling these kinds of errors; instead, we use `unwrap` to
+stop the program if errors happen.
 -->
 
 `bind`関数は`Result<T, E>`を返し、束縛が失敗することもあることを示しています。例えば、
-ポート80に接続するには管理者権限が必要なので(管理者以外はポート1024以上しかリッスンできません)管理者にならずにポート80に接続を試みたら、
-束縛はうまくいかないでしょう。また、別の例として自分のプログラムを2つ同時に立ち上げて2つのプログラムが同じポートをリッスンしたら、
+ポート80に接続するには管理者権限が必要なので(管理者以外は1023より大きい番号のポートしかリッスンできません)管理者にならずにポート80に接続を試みたら、
+束縛はうまくいかないでしょう。また例えば、自分のプログラムを2つ同時に立ち上げて2つのプログラムが同じポートをリッスンする場合も、
 束縛は機能しないでしょう。学習目的のためだけに基本的なサーバを記述しているので、この種のエラーを扱う心配はしません;
 その代わり、`unwrap`を使用してエラーが発生したら、プログラムを停止します。
 
@@ -151,16 +142,17 @@ sequence of streams (more specifically, streams of type `TcpStream`). A single
 *stream* represents an open connection between the client and the server. A
 *connection* is the name for the full request and response process in which a
 client connects to the server, the server generates a response, and the server
-closes the connection. As such, `TcpStream` will read from itself to see what
-the client sent and then allow us to write our response to the stream. Overall,
-this `for` loop will process each connection in turn and produce a series of
-streams for us to handle.
+closes the connection. As such, we will read from the `TcpStream` to see what
+the client sent and then write our response to the stream to send data back to
+the client. Overall, this `for` loop will process each connection in turn and
+produce a series of streams for us to handle.
 -->
 
 `TcpListener`の`incoming`メソッドは、一連のストリームを与えるイテレータを返します(具体的には、型`TcpStream`のストリーム)。
 単独の*ストリーム*がクライアント・サーバ間の開かれた接続を表します。*接続*(connection)は、
 クライアントがサーバに接続し、サーバがレスポンスを生成し、サーバが接続を閉じるというリクエストとレスポンス全体の過程の名前です。
-そのため、`TcpStream`は自身を読み取って、クライアントが送信したことを確認し、それからレスポンスをストリームに記述させてくれます。
+そのため、`TcpStream`から読み取ってクライアントが送信した内容を確認し、
+それからレスポンスをストリームに書き込んでクライアントにデータを返信します。
 総括すると、この`for`ループは各接続を順番に処理し、我々が扱えるように一連のストリームを生成します。
 
 <!--
@@ -230,13 +222,14 @@ factor is that we’ve successfully gotten a handle to a TCP connection!
 
 <!--
 Remember to stop the program by pressing <span class="keystroke">ctrl-c</span>
-when you’re done running a particular version of the code. Then restart `cargo
-run` after you’ve made each set of code changes to make sure you’re running the
-newest code.
+when you’re done running a particular version of the code. Then restart the
+program by invoking the `cargo run` command after you’ve made each set of code
+changes to make sure you’re running the newest code.
 -->
 
 特定のバージョンのコードを走らせ終わった時に<span class="keystroke">ctrl-c</span>を押して、
-プログラムを止めることを忘れないでください。そして、一連のコード変更を行った後に`cargo run`を再起動し、
+プログラムを止めることを忘れないでください。そして、一連のコード変更を行った後に、
+`cargo run`コマンドを実行することでプログラムを再起動し、
 最新のコードを実行していることを確かめてください。
 
 <!--
@@ -265,27 +258,7 @@ look like Listing 20-2.
 <span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,no_run
-use std::io::prelude::*;
-use std::net::TcpStream;
-use std::net::TcpListener;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        handle_connection(stream);
-    }
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-
-    stream.read(&mut buffer).unwrap();
-
-    println!("Request: {}", String::from_utf8_lossy(&buffer[..]));
-}
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-02/src/main.rs}}
 ```
 
 <!--
@@ -296,59 +269,68 @@ the data</span>
 <span class="caption">リスト20-2: `TcpStream`から読み取り、データを出力する</span>
 
 <!--
-We bring `std::io::prelude` into scope to get access to certain traits that let
-us read from and write to the stream. In the `for` loop in the `main` function,
-instead of printing a message that says we made a connection, we now call the
-new `handle_connection` function and pass the `stream` to it.
+We bring `std::io::prelude` and `std::io::BufReader` into scope to get access
+to traits and types that let us read from and write to the stream. In the `for`
+loop in the `main` function, instead of printing a message that says we made a
+connection, we now call the new `handle_connection` function and pass the
+`stream` to it.
 -->
 
-`std::io::prelude`をスコープに導入して、ストリームから読み書きさせてくれる特定のトレイトにアクセスできるようにしています。
+`std::io::prelude`と`std::io::BufReader`をスコープに導入して、
+ストリームから読み書きさせてくれるトレイトと型にアクセスできるようにしています。
 `main`関数内の`for`ループで、接続を確立したというメッセージを出力する代わりに、今では、
 新しい`handle_connection`関数を呼び出し、`stream`を渡しています。
 
 <!--
-In the `handle_connection` function, we’ve made the `stream` parameter mutable.
-The reason is that the `TcpStream` instance keeps track of what data it returns
-to us internally. It might read more data than we asked for and save that data
-for the next time we ask for data. It therefore needs to be `mut` because its
-internal state might change; usually, we think of “reading” as not needing
-mutation, but in this case we need the `mut` keyword.
+In the `handle_connection` function, we create a new `BufReader` instance that
+wraps a mutable reference to the `stream`. `BufReader` adds buffering by
+managing calls to the `std::io::Read` trait methods for us.
 -->
 
-`handle_connection`関数において、`stream`引数を可変にしました。理由は、
-`TcpStream`インスタンスが内部で返すデータを追いかけているからです。要求した以上のデータを読み取り、
-次回データを要求した時のためにそのデータを保存する可能性があります。故に、内部の状態が変化する可能性があるので、
-`mut`にする必要があるのです; 普通、「読み取り」に可変化は必要ないと考えてしまいますが、この場合、`mut`キーワードが必要です。
+`handle_connection`関数では、`stream`への可変参照をラップする、新しい`BufReader`インスタンスを作成しています。
+`BufReader`は、`std::io::Read`トレイトメソッドへの呼び出しを管理することで、バッファリング機能を追加します。
 
 <!--
-Next, we need to actually read from the stream. We do this in two steps: first,
-we declare a `buffer` on the stack to hold the data that is read in. We’ve made
-the buffer 1024 bytes in size, which is big enough to hold the data of a basic
-request and sufficient for our purposes in this chapter. If we wanted to handle
-requests of an arbitrary size, buffer management would need to be more
-complicated; we’ll keep it simple for now. We pass the buffer to `stream.read`,
-which will read bytes from the `TcpStream` and put them in the buffer.
+We create a variable named `http_request` to collect the lines of the request
+the browser sends to our server. We indicate that we want to collect these
+lines in a vector by adding the `Vec<_>` type annotation.
 -->
 
-次に、実際にストリームから読み取る必要があります。これを2つの手順で行います: まず、
-スタックに読み取ったデータを保持する`buffer`を宣言します。バッファーのサイズは1024バイトにしました。
-これは、基本的なリクエストには十分な大きさでこの章の目的には必要十分です。任意のサイズのリクエストを扱いたければ、
-バッファーの管理はもっと複雑にする必要があります; 今は、単純に保っておきます。このバッファーを`stream.read`に渡し、
-これが`TcpStream`からバイトを読み取ってバッファーに置きます。
+ブラウザがサーバに送信したリクエストの各行を集めるために、`http_request`という名前の変数を作成しています。
+`Vec<_>`型注釈を追加することで、これらの行をベクタに集めたいということを示します。
 
 <!--
-Second, we convert the bytes in the buffer to a string and print that string.
-The `String::from_utf8_lossy` function takes a `&[u8]` and produces a `String`
-from it. The “lossy” part of the name indicates the behavior of this function
-when it sees an invalid UTF-8 sequence: it will replace the invalid sequence
-with `�`, the `U+FFFD REPLACEMENT CHARACTER`. You might see replacement
-characters for characters in the buffer that aren’t filled by request data.
+`BufReader` implements the `std::io::BufRead` trait, which provides the `lines`
+method. The `lines` method returns an iterator of `Result<String,
+std::io::Error>` by splitting the stream of data whenever it sees a newline
+byte. To get each `String`, we map and `unwrap` each `Result`. The `Result`
+might be an error if the data isn’t valid UTF-8 or if there was a problem
+reading from the stream. Again, a production program should handle these errors
+more gracefully, but we’re choosing to stop the program in the error case for
+simplicity.
 -->
 
-2番目にバッファーのバイトを文字列に変換し、その文字列を出力します。`String::from_utf8_lossy`関数は、
-`&[u8]`を取り、`String`を生成します。名前の“lossy”の箇所は、無効なUTF-8シーケンスを目の当たりにした際のこの関数の振る舞いを示唆しています:
-無効なシーケンスを`�`、`U+FFFD REPLACEMENT CHARACTER`で置き換えます。
-リクエストデータによって埋められなかったバッファーの部分(`訳注` バッファーとして1024バイトの領域を用意しているが、リクエストデータは1024バイト存在しないことがほとんどなので変数 `buffer` の後ろ部分が埋められないまま放置されることを意図していると思われる) は、置換文字が表示される場合があります。
+`BufReader`は`std::io::BufRead`トレイトを実装しており、これは`lines`メソッドを提供しています。
+`lines`メソッドは、改行バイトを見つけたらそこでデータのストリームを分割することで、
+`Result<String, std::io::Error>`からなるイテレータを返します。
+各`String`を得るために、`map`して各`Result`を`unwrap`します。
+データが妥当なUTF-8でない場合や、ストリームからの読み込みに問題があった場合などは、
+`Result`はエラーになる場合があります。繰り返しになりますが、
+実運用のプログラムではこれらのエラーをより丁寧に処理するべきですが、
+ここでは簡潔性のために、エラーの場合にはプログラムを停止することを選択しています。
+
+<!--
+The browser signals the end of an HTTP request by sending two newline
+characters in a row, so to get one request from the stream, we take lines until
+we get a line that is the empty string. Once we’ve collected the lines into the
+vector, we’re printing them out using pretty debug formatting so we can take a
+look at the instructions the web browser is sending to our server.
+-->
+
+ブラウザは2個の改行文字列を連続で送信することでHTTPリクエストの終わりを伝えるてくるので、
+ストリームから1リクエストを取得するためには、空文字列である行が得られるまで行を取得します。
+行をベクタに集めたら、それらをprettyデバッグフォーマットを使用して出力していますので、
+webブラウザが私たちのサーバに送信している指示を確認することができます。
 
 <!--
 Let’s try this code! Start the program and make a request in a web browser
@@ -359,33 +341,40 @@ program’s output in the terminal will now look similar to this:
 このコードを試しましょう！プログラムを開始してWebブラウザで再度リクエストを送ってください。ブラウザではそれでも、
 エラーページが得られるでしょうが、端末のプログラムの出力はこんな感じになっていることに注目してください:
 
-```text
+```console
 $ cargo run
    Compiling hello v0.1.0 (file:///projects/hello)
-    Finished dev [unoptimized + debuginfo] target(s) in 0.42 secs
+    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
      Running `target/debug/hello`
-Request: GET / HTTP/1.1
-Host: 127.0.0.1:7878
-User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101
-Firefox/52.0
-Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
-Accept-Language: en-US,en;q=0.5
-Accept-Encoding: gzip, deflate
-Connection: keep-alive
-Upgrade-Insecure-Requests: 1
-������������������������������������
+Request: [
+    "GET / HTTP/1.1",
+    "Host: 127.0.0.1:7878",
+    "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:99.0) Gecko/20100101 Firefox/99.0",
+    "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language: en-US,en;q=0.5",
+    "Accept-Encoding: gzip, deflate, br",
+    "DNT: 1",
+    "Connection: keep-alive",
+    "Upgrade-Insecure-Requests: 1",
+    "Sec-Fetch-Dest: document",
+    "Sec-Fetch-Mode: navigate",
+    "Sec-Fetch-Site: none",
+    "Sec-Fetch-User: ?1",
+    "Cache-Control: max-age=0",
+]
 ```
 
 <!--
 Depending on your browser, you might get slightly different output. Now that
 we’re printing the request data, we can see why we get multiple connections
-from one browser request by looking at the path after `Request: GET`. If the
-repeated connections are all requesting */*, we know the browser is trying to
-fetch */* repeatedly because it’s not getting a response from our program.
+from one browser request by looking at the path after `GET` in the first line
+of the request. If the repeated connections are all requesting */*, we know the
+browser is trying to fetch */* repeatedly because it’s not getting a response
+from our program.
 -->
 
 ブラウザによって、少し異なる出力になる可能性があります。今やリクエストデータを出力しているので、
-`Request: GET`の後のパスを見ることで1回のブラウザリクエストから複数の接続が得られる理由が確認できます。
+リクエストの最初の行の`GET`の後のパスを見ることで1回のブラウザリクエストから複数の接続が得られる理由が確認できます。
 繰り返される接続が全て */* を要求しているなら、ブラウザは、我々のプログラムからレスポンスが得られないので、
 繰り返し */* をフェッチしようとしていることがわかります。
 
@@ -418,12 +407,13 @@ message-body
 The first line is the *request line* that holds information about what the
 client is requesting. The first part of the request line indicates the *method*
 being used, such as `GET` or `POST`, which describes how the client is making
-this request. Our client used a `GET` request.
+this request. Our client used a `GET` request, which means it is asking for
+information.
 -->
 
 1行目は、クライアントが要求しているものがなんなのかについての情報を保持するリクエスト行です。
 リクエスト行の最初の部分は使用されている`GET`や`POST`などの*メソッド*を示し、これは、どのようにクライアントがこの要求を行なっているかを記述します。
-クライアントは`GET`リクエストを使用しました。
+クライアントは`GET`リクエストを使用しており、これは情報を求めていることを意味します。
 
 <!--
 The next part of the request line is */*, which indicates the *Uniform Resource
@@ -489,11 +479,12 @@ Now that we know what the browser is asking for, let’s send back some data!
 ### レスポンスを記述する
 
 <!--
-Now we’ll implement sending data in response to a client request. Responses
-have the following format:
+We’re going to implement sending data in response to a client request.
+Responses have the following format:
 -->
 
-さて、クライアントのリクエストに対する返答としてデータの送信を実装します。レスポンスは、以下のようなフォーマットです:
+クライアントのリクエストに対する返答としてデータの送信を実装します。
+レスポンスは、以下のようなフォーマットです:
 
 ```text
 HTTP-Version Status-Code Reason-Phrase CRLF
@@ -541,19 +532,8 @@ Listing 20-3.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-
-    stream.read(&mut buffer).unwrap();
-
-    let response = "HTTP/1.1 200 OK\r\n\r\n";
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-03/src/main.rs:here}}
 ```
 
 <!--
@@ -566,38 +546,30 @@ the stream</span>
 <!--
 The first new line defines the `response` variable that holds the success
 message’s data. Then we call `as_bytes` on our `response` to convert the string
-data to bytes. The `write` method on `stream` takes a `&[u8]` and sends those
-bytes directly down the connection.
+data to bytes. The `write_all` method on `stream` takes a `&[u8]` and sends
+those bytes directly down the connection. Because the `write_all` operation
+could fail, we use `unwrap` on any error result as before. Again, in a real
+application you would add error handling here.
 -->
 
 新しい最初の行に成功したメッセージのデータを保持する`response`変数を定義しています。そして、
-`response`に対して`as_bytes`を呼び出し、文字列データをバイトに変換します。`stream`の`write`メソッドは、
+`response`に対して`as_bytes`を呼び出し、文字列データをバイトに変換します。`stream`の`write_all`メソッドは、
 `&[u8]`を取り、接続に直接そのバイトを送信します。
-
-<!--
-Because the `write` operation could fail, we use `unwrap` on any error result
-as before. Again, in a real application you would add error handling here.
-Finally, `flush` will wait and prevent the program from continuing until all
-the bytes are written to the connection; `TcpStream` contains an internal
-buffer to minimize calls to the underlying operating system.
--->
-
-`write`処理は失敗することもあるので、以前のようにエラーの結果には`unwrap`を使用します。
-今回も、実際のアプリでは、エラー処理をここに追加するでしょう。最後に`flush`は待機し、
-バイトが全て接続に書き込まれるまでプログラムが継続するのを防ぎます; `TcpStream`は内部にバッファーを保持して、
-元となるOSへの呼び出しを最小化します。
+`write_all`処理は失敗することもあるので、以前のようにエラーの結果には`unwrap`を使用します。
+今回も、実際のアプリでは、エラー処理をここに追加するでしょう。
 
 <!--
 With these changes, let’s run our code and make a request. We’re no longer
 printing any data to the terminal, so we won’t see any output other than the
 output from Cargo. When you load *127.0.0.1:7878* in a web browser, you should
-get a blank page instead of an error. You’ve just hand-coded an HTTP request
-and response!
+get a blank page instead of an error. You’ve just hand-coded receiving an HTTP
+request and sending a response!
 -->
 
 これらの変更とともに、コードを実行し、リクエストをしましょう。最早、端末にどんなデータも出力していないので、
 Cargoからの出力以外には何も出力はありません。Webブラウザで*127.0.0.1:7878*をロードすると、
-エラーではなく空のページが得られるはずです。HTTPリクエストとレスポンスを手で実装したばかりなのです！
+エラーではなく空のページが得られるはずです。
+HTTPリクエストの受信とレスポンスの送信を手で実装することができました！
 
 <!--
 ### Returning Real HTML
@@ -607,7 +579,7 @@ Cargoからの出力以外には何も出力はありません。Webブラウザ
 
 <!--
 Let’s implement the functionality for returning more than a blank page. Create
-a new file, *hello.html*, in the root of your project directory, not in the
+the new file *hello.html* in the root of your project directory, not in the
 *src* directory. You can input any HTML you want; Listing 20-4 shows one
 possibility.
 -->
@@ -623,23 +595,7 @@ possibility.
 <span class="filename">ファイル名: hello.html</span>
 
 ```html
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Hello!</title>
-  </head>
-  <body>
-<!--
-やあ！
--->
-    <h1>Hello!</h1>
-<!--
-Rustからやあ
--->
-    <p>Hi from Rust</p>
-  </body>
-</html>
+{{#include ../listings/ch20-web-server/listing-20-05/hello.html}}
 ```
 
 <!--
@@ -665,26 +621,8 @@ and send it.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-use std::fs::File;
-// --snip--
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let mut file = File::open("hello.html").unwrap();
-
-    let mut contents = String::new();
-    file.read_to_string(&mut contents).unwrap();
-
-    let response = format!("HTTP/1.1 200 OK\r\n\r\n{}", contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-05/src/main.rs:here}}
 ```
 
 <!--
@@ -695,21 +633,26 @@ body of the response</span>
 <span class="caption">リスト20-5: レスポンスの本体として*hello.html*の中身を送る</span>
 
 <!--
-We’ve added a line at the top to bring the standard library’s `File` into
-scope. The code for opening a file and reading the contents should look
-familiar; we used it in Chapter 12 when we read the contents of a file for our
-I/O project in Listing 12-4.
+We’ve added `fs` to the `use` statement to bring the standard library’s
+filesystem module into scope. The code for reading the contents of a file to a
+string should look familiar; we used it in Chapter 12 when we read the contents
+of a file for our I/O project in Listing 12-4.
 -->
 
-先頭に行を追加して標準ライブラリの`File`をスコープに導入しました。ファイルを開き、中身を読み込むコードは、
-馴染みがあるはずです; リスト12-4でI/Oプロジェクト用にファイルの中身を読み込んだ時に第12章で使用しましたね。
+`use`文に`fs`を追加して、標準ライブラリのファイルシステムモジュールをスコープに導入しました。
+ファイルの中身を文字列として読み込むコードは、馴染みがあるはずです;
+リスト12-4でI/Oプロジェクト用にファイルの中身を読み込んだ時に第12章で使用しましたね。
 
 <!--
 Next, we use `format!` to add the file’s contents as the body of the success
-response.
+response. To ensure a valid HTTP response, we add the `Content-Length` header
+which is set to the size of our response body, in this case the size of
+`hello.html`.
 -->
 
 次に`format!`でファイルの中身を成功したレスポンスの本体として追記しています。
+妥当なHTTPレスポンスであることを保証するために、`Content-Length`ヘッダを追加し、
+私たちのレスポンスボディのサイズに設定します。この場合は`hello.html`のサイズです。
 
 <!--
 Run this code with `cargo run` and load *127.0.0.1:7878* in your browser; you
@@ -720,17 +663,19 @@ should see your HTML rendered!
 HTMLが描画されるのが確認できるはずです！
 
 <!--
-Currently, we’re ignoring the request data in `buffer` and just sending back
-the contents of the HTML file unconditionally. That means if you try requesting
-*127.0.0.1:7878/something-else* in your browser, you’ll still get back this
-same HTML response. Our server is very limited and is not what most web servers
-do. We want to customize our responses depending on the request and only send
-back the HTML file for a well-formed request to */*.
+Currently, we’re ignoring the request data in `http_request` and just sending
+back the contents of the HTML file unconditionally. That means if you try
+requesting *127.0.0.1:7878/something-else* in your browser, you’ll still get
+back this same HTML response. At the moment, our server is very limited and
+does not do what most web servers do. We want to customize our responses
+depending on the request and only send back the HTML file for a well-formed
+request to */*.
 -->
 
-現時点では、`buffer`内のリクエストデータは無視し、無条件でHTMLファイルの中身を送り返しているだけです。
+現時点では、`http_request`内のリクエストデータは無視し、無条件でHTMLファイルの中身を送り返しているだけです。
 これはつまり、ブラウザで*127.0.0.1:7878/something-else*をリクエストしても、
-この同じHTMLレスポンスが得られるということです。我々のサーバはかなり限定的で、多くのWebサーバとは異なっています。
+この同じHTMLレスポンスが得られるということです。現時点では、我々のサーバはかなり限定的で、
+多くのWebサーバが行うことを行っていません。
 リクエストに基づいてレスポンスをカスタマイズし、*/* への合法なリクエストに対してのみHTMLファイルを送り返したいです。
 
 <!--
@@ -761,75 +706,58 @@ received against what we know a request for */* looks like and adds `if` and
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-# use std::fs::File;
-// --snip--
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-
-    if buffer.starts_with(get) {
-        let mut file = File::open("hello.html").unwrap();
-
-        let mut contents = String::new();
-        file.read_to_string(&mut contents).unwrap();
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-06/src/main.rs:here}}
+```
 
-        let response = format!("HTTP/1.1 200 OK\r\n\r\n{}", contents);
+<!--
+<span class="caption">Listing 20-6: Handling requests to */* differently from
+other requests</span>
+-->
 
-        stream.write(response.as_bytes()).unwrap();
-        stream.flush().unwrap();
-    } else {
-        // 何か他の要求
-        // some other request
-    }
-}
-```
+<span class="caption">リスト20-6: */* へのリクエストを他のリクエストとは異なる形で扱う</span>
 
 <!--
-<span class="caption">Listing 20-6: Matching the request and handling requests
-to */* differently than other requests</span>
+We’re only going to be looking at the first line of the HTTP request, so rather
+than reading the entire request into a vector, we’re calling `next` to get the
+first item from the iterator. The first `unwrap` takes care of the `Option` and
+stops the program if the iterator has no items. The second `unwrap` handles the
+`Result` and has the same effect as the `unwrap` that was in the `map` added in
+Listing 20-2.
 -->
 
-<span class="caption">リスト20-6: リクエストをマッチさせ、*/* へのリクエストを他のリクエストとは異なる形で扱う</span>
+HTTPリクエストの最初の行しか見ないので、リクエスト全体をベクタに読むのではなく、
+`next`を呼んでイテレータから最初の要素を取得しています。
+最初の`unwrap`は`Option`を処理するもので、イテレータに要素が無い場合はプログラムを停止します。
+2番目の`unwrap`は`Result`を処理するもので、リスト20-2で追加された`map`の中にあった`unwrap`と同じ効果を持ちます。
 
 <!--
-First, we hardcode the data corresponding to the */* request into the `get`
-variable. Because we’re reading raw bytes into the buffer, we transform `get`
-into a byte string by adding the `b""` byte string syntax at the start of the
-content data. Then we check whether `buffer` starts with the bytes in `get`. If
-it does, it means we’ve received a well-formed request to */*, which is the
-success case we’ll handle in the `if` block that returns the contents of our
+Next, we check the `request_line` to see if it equals the request line of a GET
+request to the */* path. If it does, the `if` block returns the contents of our
 HTML file.
 -->
 
-まず、*/* リクエストに対応するデータを`get`変数にハードコードしています。生のバイトをバッファーに読み込んでいるので、
-`b""`バイト文字列記法を中身のデータの先頭に追記することで、`get`をバイト文字列に変換しています。
-そして、`buffer`が`get`のバイトから始まっているか確認します。もしそうなら、*/* への合法なリクエストを受け取ったことを意味し、
-これが、HTMLファイルの中身を返す`if`ブロックで扱う成功した場合になります。
+次に、`request_line`を確認して、*/* パスへのGETリクエストのリクエスト行と等しいか確認します。
+もしそうなら、`if`ブロックはHTMLファイルの中身を返します。
 
 <!--
-If `buffer` does *not* start with the bytes in `get`, it means we’ve received
-some other request. We’ll add code to the `else` block in a moment to respond
-to all other requests.
+If the `request_line` does *not* equal the GET request to the */* path, it
+means we’ve received some other request. We’ll add code to the `else` block in
+a moment to respond to all other requests.
 -->
 
-`buffer`が`get`のバイトで始まら*ない*のなら、何か他のリクエストを受け取ったことになります。
+`request_line`が */* パスへのGETリクエストと等しく*ない*のなら、何か他のリクエストを受け取ったことになります。
 この後すぐ、`else`ブロックに他のリクエストに対応するコードを追加します。
 
 <!--
 Run this code now and request *127.0.0.1:7878*; you should get the HTML in
 *hello.html*. If you make any other request, such as
-*127.0.0.1:7878/something-else*, you’ll get a connection error like you
+*127.0.0.1:7878/something-else*, you’ll get a connection error like those you
 saw when running the code in Listing 20-1 and Listing 20-2.
 -->
 
 さあ、このコードを走らせて*127.0.0.1:7878*を要求してください; *hello.html*のHTMLが得られるはずです。
-*127.0.0.1:7878/something-else*などの他のリクエストを行うと、リスト20-1や20-2のコードを走らせた時に見かけた接続エラーになるでしょう。
+*127.0.0.1:7878/something-else*などの他のリクエストを行うと、リスト20-1や20-2のコードを走らせた時に見かけたような接続エラーになるでしょう。
 
 <!--
 Now let’s add the code in Listing 20-7 to the `else` block to return a response
@@ -848,27 +776,8 @@ indicating the response to the end user.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-# use std::fs::File;
-# fn handle_connection(mut stream: TcpStream) {
-# if true {
-// --snip--
-
-} else {
-    let status_line = "HTTP/1.1 404 NOT FOUND\r\n\r\n";
-    let mut file = File::open("404.html").unwrap();
-    let mut contents = String::new();
-
-    file.read_to_string(&mut contents).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
-# }
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-07/src/main.rs:here}}
 ```
 
 <!--
@@ -879,15 +788,15 @@ error page if anything other than */* was requested</span>
 <span class="caption">リスト20-7: */* 以外の何かが要求されたら、ステータスコード404とエラーページで応答する</span>
 
 <!--
-Here, our response has a status line with status code 404 and the reason
-phrase `NOT FOUND`. We’re still not returning headers, and the body of the
-response will be the HTML in the file *404.html*. You’ll need to create a
-*404.html* file next to *hello.html* for the error page; again feel free to use
-any HTML you want or use the example HTML in Listing 20-8.
+Here, our response has a status line with status code 404 and the reason phrase
+`NOT FOUND`. The body of the response will be the HTML in the file *404.html*.
+You’ll need to create a *404.html* file next to *hello.html* for the error
+page; again feel free to use any HTML you want or use the example HTML in
+Listing 20-8.
 -->
 
 ここでは、レスポンスにはステータスコード404と理由フレーズ`NOT FOUND`のステータス行があります。
-それでもヘッダは返さず、レスポンスの本体は、ファイル*404.html*のHTMLになります。エラーページのために、
+レスポンスの本体は、ファイル*404.html*のHTMLになります。エラーページのために、
 *hello.html*の隣に*404.html*ファイルを作成する必要があります; 今回も、ご自由にお好きなHTMLにしたり、
 リスト20-8の例のHTMLを使用したりしてください。
 
@@ -898,23 +807,7 @@ any HTML you want or use the example HTML in Listing 20-8.
 <span class="filename">ファイル名: 404.html</span>
 
 ```html
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <title>Hello!</title>
-  </head>
-  <body>
-<!--
-ああ！
--->
-    <h1>Oops!</h1>
-<!--
-すいません。要求しているものが理解できません
--->
-    <p>Sorry, I don't know what you're asking for.</p>
-  </body>
-</html>
+{{#include ../listings/ch20-web-server/listing-20-07/404.html}}
 ```
 
 <!--
@@ -925,8 +818,8 @@ with any 404 response</span>
 <span class="caption">リスト20-8: あらゆる404レスポンスでページが送り返す中身のサンプル</span>
 
 <!--
-With these changes, run your server again. Requesting *127.0.0.1:7878*
-should return the contents of *hello.html*, and any other request, like
+With these changes, run your server again. Requesting *127.0.0.1:7878* should
+return the contents of *hello.html*, and any other request, like
 *127.0.0.1:7878/foo*, should return the error HTML from *404.html*.
 -->
 
@@ -961,35 +854,8 @@ the large `if` and `else` blocks.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-# use std::fs::File;
-// --snip--
-
-fn handle_connection(mut stream: TcpStream) {
-#     let mut buffer = [0; 1024];
-#     stream.read(&mut buffer).unwrap();
-#
-#     let get = b"GET / HTTP/1.1\r\n";
-    // --snip--
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    let mut file = File::open(filename).unwrap();
-    let mut contents = String::new();
-
-    file.read_to_string(&mut contents).unwrap();
-
-    let response = format!("{}{}", status_line, contents);
-
-    stream.write(response.as_bytes()).unwrap();
-    stream.flush().unwrap();
-}
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-09/src/main.rs:here}}
 ```
 
 <!--
@@ -1035,7 +901,7 @@ requests with a 404 response.
 <!--
 Currently, our server runs in a single thread, meaning it can only serve one
 request at a time. Let’s examine how that can be a problem by simulating some
-slow requests. Then we'll fix it so our server can handle multiple requests at
+slow requests. Then we’ll fix it so our server can handle multiple requests at
 once.
 -->
 
diff --git a/src/ch20-02-multithreaded.md b/src/ch20-02-multithreaded.md
index 50ec24ef5..948f9d511 100644
--- a/src/ch20-02-multithreaded.md
+++ b/src/ch20-02-multithreaded.md
@@ -42,53 +42,40 @@ for 5 seconds before responding.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust
-use std::thread;
-use std::time::Duration;
-# use std::io::prelude::*;
-# use std::net::TcpStream;
-# use std::fs::File;
-// --snip--
-
-fn handle_connection(mut stream: TcpStream) {
-#     let mut buffer = [0; 1024];
-#     stream.read(&mut buffer).unwrap();
-    // --snip--
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-    // --snip--
-}
+```rust,no_run
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-10/src/main.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-10: Simulating a slow request by recognizing
-*/sleep* and sleeping for 5 seconds</span>
+<span class="caption">Listing 20-10: Simulating a slow request by sleeping for
+5 seconds</span>
+-->
+
+<span class="caption">リスト20-10: 5秒間スリープすることで遅いリクエストをシミュレーションする</span>
+
+<!--
+We switched from `if` to `match` now that we have three cases. We need to
+explicitly match on a slice of `request_line` to pattern match against the
+string literal values; `match` doesn’t do automatic referencing and
+dereferencing like the equality method does.
 -->
 
-<span class="caption">リスト20-10: */sleep*を認識して5秒間スリープすることで遅いリクエストをシミュレーションする</span>
+3通りの場合分けを持つようになったので、`if`から`match`に切り替えました。
+文字列リテラル値を使ってパターンマッチするには、`request_line`のスライスにマッチすることを明示する必要があります;
+`match`は、等値性メソッドが行うような自動的な参照および参照外しを行いません。
 
 <!--
-This code is a bit messy, but it’s good enough for simulation purposes. We
-created a second request `sleep`, whose data our server recognizes. We added an
-`else if` after the `if` block to check for the request to */sleep*. When that
-request is received, the server will sleep for 5 seconds before rendering the
-successful HTML page.
+The first arm is the same as the `if` block from Listing 20-9. The second arm
+matches a request to */sleep*. When that request is received, the server will
+sleep for 5 seconds before rendering the successful HTML page. The third arm is
+the same as the `else` block from Listing 20-9.
+
 -->
 
-このコードはちょっと汚いですが、シミュレーション目的には十分です。2番目のリクエスト`sleep`を作成し、
-そのデータをサーバは認識します。`if`ブロックの後に`else if`を追加し、*/sleep*へのリクエストを確認しています。
+最初のアームは、リスト20-9の`if`ブロックと同じです。
+2番目のアームは、*/sleep* へのリクエストにマッチします。
 そのリクエストが受け付けられると、サーバは成功のHTMLページを描画する前に5秒間スリープします。
+3番目のアームは、リスト20-9の`else`ブロックと同じです。
 
 <!--
 You can see how primitive our server is: real libraries would handle the
@@ -99,24 +86,23 @@ recognition of multiple requests in a much less verbose way!
 
 <!--
 Start the server using `cargo run`. Then open two browser windows: one for
-*http://localhost:7878/* and the other for *http://localhost:7878/sleep*. If
+*http://127.0.0.1:7878/* and the other for *http://127.0.0.1:7878/sleep*. If
 you enter the */* URI a few times, as before, you’ll see it respond quickly.
-But if you enter */sleep*, and then load */*, you’ll see that */* waits until
+But if you enter */sleep* and then load */*, you’ll see that */* waits until
 `sleep` has slept for its full 5 seconds before loading.
 -->
 
 `cargo run`でサーバを開始してください。それから2つブラウザのウインドウを開いてください: 1つは、
-*http://localhost:7878/* 用、そしてもう1つは*http://localhost:7878/sleep* 用です。
+*http://127.0.0.1:7878/* 用、そしてもう1つは*http://127.0.0.1:7878/sleep* 用です。
 以前のように */* URIを数回入力したら、素早く応答するでしょう。しかし、*/sleep*を入力し、それから */* をロードしたら、
 `sleep`がロードする前にきっかり5秒スリープし終わるまで、*/* は待機するのを目撃するでしょう。
 
 <!--
-There are multiple ways we could change how our web server works to avoid
-having more requests back up behind a slow request; the one we’ll implement is
-a thread pool.
+There are multiple techniques we could use to avoid requests backing up behind
+a slow request; the one we’ll implement is a thread pool.
 -->
 
-より多くのリクエストが遅いリクエストの背後に回ってしまうのを回避するようWebサーバが動く方法を変える方法は複数あります;
+遅いリクエストの後ろにリクエストが積み重なってしまうのを回避するための技術は、複数あります;
 これから実装するのは、スレッドプールです。
 
 <!--
@@ -156,34 +142,36 @@ the processing of requests to a halt.
 大混乱を招くことができてしまうでしょう。
 
 <!--
-Rather than spawning unlimited threads, we’ll have a fixed number of threads
-waiting in the pool. As requests come in, they’ll be sent to the pool for
+Rather than spawning unlimited threads, then, we’ll have a fixed number of
+threads waiting in the pool. Requests that come in are sent to the pool for
 processing. The pool will maintain a queue of incoming requests. Each of the
 threads in the pool will pop off a request from this queue, handle the request,
-and then ask the queue for another request. With this design, we can process
-`N` requests concurrently, where `N` is the number of threads. If each thread
-is responding to a long-running request, subsequent requests can still back up
-in the queue, but we’ve increased the number of long-running requests we can
-handle before reaching that point.
+and then ask the queue for another request. With this design, we can process up
+to `N` requests concurrently, where `N` is the number of threads. If each
+thread is responding to a long-running request, subsequent requests can still
+back up in the queue, but we’ve increased the number of long-running requests
+we can handle before reaching that point.
 -->
 
-無制限にスレッドを大量生産するのではなく、プールに固定された数のスレッドを待機させます。リクエストが来る度に、
-処理するためにプールに送られます。プールは、やって来るリクエストのキューを管理します。
+無制限にスレッドを大量生産するのではなく、プールに固定された数のスレッドを待機させます。
+やってきたリクエストは、処理するためにプールに送られます。プールは、やって来るリクエストのキューを管理します。
 プールの各スレッドがこのキューからリクエストを取り出し、リクエストを処理し、そして、別のリクエストをキューに要求します。
-この設計により、`N`リクエストを並行して処理でき、ここで`N`はスレッド数です。各スレッドが実行に時間のかかるリクエストに応答していたら、
+この設計により、`N`個までのリクエストを並行して処理でき、ここで`N`はスレッド数です。各スレッドが実行に時間のかかるリクエストに応答していたら、
 続くリクエストはそれでも、キュー内で待機させられてしまうこともありますが、その地点に到達する前に扱える時間のかかるリクエスト数を増加させました。
 
 <!--
 This technique is just one of many ways to improve the throughput of a web
-server. Other options you might explore are the fork/join model and the
-single-threaded async I/O model. If you’re interested in this topic, you can
-read more about other solutions and try to implement them in Rust; with a
-low-level language like Rust, all of these options are possible.
+server. Other options you might explore are the *fork/join model*, the
+*single-threaded async I/O model*, or the *multi-threaded async I/O model*. If
+you’re interested in this topic, you can read more about other solutions and
+try to implement them; with a low-level language like Rust, all of these
+options are possible.
 -->
 
 このテクニックは、Webサーバのスループットを向上させる多くの方法の1つに過ぎません。探究する可能性のある他の選択肢は、
-fork/joinモデルと、シングルスレッドの非同期I/Oモデルです。この話題にご興味があれば、他の解決策についてもっと読み、
-Rustで実装を試みることができます; Rustのような低レベル言語であれば、これらの選択肢全部が可能なのです。
+*fork/joinモデル*、*シングルスレッドの非同期I/Oモデル*、または*マルチスレッドの非同期I/Oモデル*です。
+この話題に興味があれば、他の解決策についてもっと読み、実装してみるのもよいでしょう;
+Rustのような低レベル言語であれば、これらの選択肢全部が可能なのです。
 
 <!--
 Before we begin implementing a thread pool, let’s talk about what using the
@@ -202,29 +190,40 @@ designing the public API.
 Similar to how we used test-driven development in the project in Chapter 12,
 we’ll use compiler-driven development here. We’ll write the code that calls the
 functions we want, and then we’ll look at errors from the compiler to determine
-what we should change next to get the code to work.
+what we should change next to get the code to work. Before we do that, however,
+we’ll explore the technique we’re not going to use as a starting point.
 -->
 
 第12章のプロジェクトでTDDを使用したように、ここではCompiler Driven Development(コンパイラ駆動開発)を使用します。
 欲しい関数を呼び出すコードを書き、それからコンパイラの出すエラーを見てコードが動くように次に何を変更すべきかを決定します。
+ですがその前に開始点として、使用しない技法について探索してみましょう。
 
+<!-- Old headings. Do not remove or links may break. -->
 <!--
-#### Code Structure If We Could Spawn a Thread for Each Request
+<a id="code-structure-if-we-could-spawn-a-thread-for-each-request"></a>
 -->
 
-#### 各リクエストに対してスレッドを立ち上げられる場合のコードの構造
+<!--
+#### Spawning a Thread for Each Request
+-->
+
+#### 各リクエストに対してスレッドを立ち上げる
 
 <!--
 First, let’s explore how our code might look if it did create a new thread for
 every connection. As mentioned earlier, this isn’t our final plan due to the
 problems with potentially spawning an unlimited number of threads, but it is a
-starting point. Listing 20-11 shows the changes to make to `main` to spawn a
-new thread to handle each stream within the `for` loop.
+starting point to get a working multithreaded server first. Then we’ll add the
+thread pool as an improvement, and contrasting the two solutions will be
+easier. Listing 20-11 shows the changes to make to `main` to spawn a new thread
+to handle each stream within the `for` loop.
 -->
 
 まず、全接続に対して新しいスレッドを確かに生成した場合にコードがどんな見た目になるかを探究しましょう。
 先ほど述べたように、無制限にスレッドを大量生産する可能性があるという問題のため、これは最終的な計画ではありませんが、
-開始点です。リスト20-11は、新しいスレッドを立ち上げて`for`ループ内で各ストリームを扱うために`main`に行う変更を示しています。
+まず機能するマルチスレッドサーバを得るための開始点です。
+その後、改善としてスレッドプールを追加します。そうすることで、2つの解決策の対比がより簡単になるでしょう。
+リスト20-11は、新しいスレッドを立ち上げて`for`ループ内で各ストリームを扱うために`main`に行う変更を示しています。
 
 <!--
 <span class="filename">Filename: src/main.rs</span>
@@ -233,23 +232,7 @@ new thread to handle each stream within the `for` loop.
 <span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,no_run
-# use std::thread;
-# use std::io::prelude::*;
-# use std::net::TcpListener;
-# use std::net::TcpStream;
-#
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        thread::spawn(|| {
-            handle_connection(stream);
-        });
-    }
-}
-# fn handle_connection(mut stream: TcpStream) {}
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-11/src/main.rs:here}}
 ```
 
 <!--
@@ -263,8 +246,8 @@ stream</span>
 As you learned in Chapter 16, `thread::spawn` will create a new thread and then
 run the code in the closure in the new thread. If you run this code and load
 */sleep* in your browser, then */* in two more browser tabs, you’ll indeed see
-that the requests to */* don’t have to wait for */sleep* to finish. But as we
-mentioned, this will eventually overwhelm the system because you'd making
+that the requests to */* don’t have to wait for */sleep* to finish. However, as
+we mentioned, this will eventually overwhelm the system because you’d be making
 new threads without any limit.
 -->
 
@@ -273,11 +256,16 @@ new threads without any limit.
 確かに */* へのリクエストは、*/sleep*が完了するのを待機しなくても済むことがわかるでしょう。
 ですが、前述したように、無制限にスレッドを生成することになるので、これは最終的にシステムを参らせてしまうでしょう。
 
+<!-- Old headings. Do not remove or links may break. -->
+<!--
+<a id="creating-a-similar-interface-for-a-finite-number-of-threads"></a>
+-->
+
 <!--
-#### Creating a Similar Interface for a Finite Number of Threads
+#### Creating a Finite Number of Threads
 -->
 
-#### 有限数のスレッド用に似たインターフェイスを作成する
+#### 有限個のスレッドを作成する
 
 <!--
 We want our thread pool to work in a similar, familiar way so switching from
@@ -296,31 +284,8 @@ struct we want to use instead of `thread::spawn`.
 
 <span class="filename">ファイル名: src/main.rs</span>
 
-```rust,no_run
-# use std::thread;
-# use std::io::prelude::*;
-# use std::net::TcpListener;
-# use std::net::TcpStream;
-# struct ThreadPool;
-# impl ThreadPool {
-#    fn new(size: u32) -> ThreadPool { ThreadPool }
-#    fn execute<F>(&self, f: F)
-#        where F: FnOnce() + Send + 'static {}
-# }
-#
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming() {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-}
-# fn handle_connection(mut stream: TcpStream) {}
+```rust,ignore,does_not_compile
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-12/src/main.rs:here}}
 ```
 
 <!--
@@ -344,11 +309,16 @@ compile, but we’ll try so the compiler can guide us in how to fix it.
 これはクロージャを取り、実行するためにプール内のスレッドに与えます。このコードはまだコンパイルできませんが、
 コンパイラがどう修正したらいいかガイドできるように試してみます。
 
+<!-- Old headings. Do not remove or links may break. -->
+<!--
+<a id="building-the-threadpool-struct-using-compiler-driven-development"></a>
+-->
+
 <!--
-#### Building the `ThreadPool` Struct Using Compiler Driven Development
+#### Building `ThreadPool` Using Compiler Driven Development
 -->
 
-#### コンパイラ駆動開発で`ThreadPool`構造体を構築する
+#### コンパイラ駆動開発で`ThreadPool`を構築する
 
 <!--
 Make the changes in Listing 20-12 to *src/main.rs*, and then let’s use the
@@ -359,18 +329,8 @@ error we get:
 リスト20-12の変更を*src/main.rs*に行い、それから開発を駆動するために`cargo check`からのコンパイラエラーを活用しましょう。
 こちらが得られる最初のエラーです:
 
-```text
-$ cargo check
-   Compiling hello v0.1.0 (file:///projects/hello)
-error[E0433]: failed to resolve. Use of undeclared type or module `ThreadPool`
-(エラー: 解決に失敗しました。未定義の型またはモジュール`ThreadPool`を使用しています)
-  --> src\main.rs:10:16
-   |
-10 |     let pool = ThreadPool::new(4);
-   |                ^^^^^^^^^^^^^^^ Use of undeclared type or module
-   `ThreadPool`
-
-error: aborting due to previous error
+```console
+{{#include ../listings/ch20-web-server/listing-20-12/output.txt}}
 ```
 
 <!--
@@ -401,33 +361,26 @@ definition of a `ThreadPool` struct that we can have for now:
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-pub struct ThreadPool;
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/lib.rs}}
 ```
 
 <!--
-Then create a new directory, *src/bin*, and move the binary crate rooted in
-*src/main.rs* into *src/bin/main.rs*. Doing so will make the library crate the
-primary crate in the *hello* directory; we can still run the binary in
-*src/bin/main.rs* using `cargo run`. After moving the *main.rs* file, edit it
-to bring the library crate in and bring `ThreadPool` into scope by adding the
-following code to the top of *src/bin/main.rs*:
+Then edit *main.rs* file to bring `ThreadPool` into scope from the library
+crate by adding the following code to the top of *src/main.rs*:
 -->
 
-それから新しいディレクトリ、*src/bin*を作成し、*src/main.rs*に根付くバイナリクレートを*src/bin/main.rs*に移動してください。
-そうすると、ライブラリクレートが*hello*ディレクトリ内で主要クレートになります; それでも、
-`cargo run`で*src/bin/main.rs*のバイナリを実行することはできます。*main.rs*ファイルを移動後、
-編集してライブラリクレートを持ち込み、以下のコードを*src/bin/main.rs*の先頭に追記して`ThreadPool`をスコープに導入してください:
+それから*main.rs*ファイルを編集し、以下のコードを*src/main.rs*の先頭に追記して、
+ライブラリクレートから`ThreadPool`をスコープに導入してください:
 
 <!--
-<span class="filename">Filename: src/bin/main.rs</span>
+<span class="filename">Filename: src/main.rs</span>
 -->
 
-<span class="filename">ファイル名: src/bin/main.rs</span>
+<span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,ignore
-extern crate hello;
-use hello::ThreadPool;
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-01-define-threadpool-struct/src/main.rs:here}}
 ```
 
 <!--
@@ -437,17 +390,8 @@ we need to address:
 
 このコードはまだ動きませんが、再度それを確認して扱う必要のある次のエラーを手に入れましょう:
 
-```text
-$ cargo check
-   Compiling hello v0.1.0 (file:///projects/hello)
-error[E0599]: no function or associated item named `new` found for type
-`hello::ThreadPool` in the current scope
-(エラー: 現在のスコープで型`hello::ThreadPool`の関数または関連アイテムに`new`というものが見つかりません)
- --> src/bin/main.rs:13:16
-   |
-13 |     let pool = ThreadPool::new(4);
-   |                ^^^^^^^^^^^^^^^ function or associated item not found in
-   `hello::ThreadPool`
+```console
+{{#include ../listings/ch20-web-server/no-listing-01-define-threadpool-struct/output.txt}}
 ```
 
 <!--
@@ -468,25 +412,20 @@ characteristics:
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-pub struct ThreadPool;
-
-impl ThreadPool {
-    pub fn new(size: usize) -> ThreadPool {
-        ThreadPool
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-02-impl-threadpool-new/src/lib.rs}}
 ```
 
 <!--
 We chose `usize` as the type of the `size` parameter, because we know that a
 negative number of threads doesn’t make any sense. We also know we’ll use this
 4 as the number of elements in a collection of threads, which is what the
-`usize` type is for, as discussed in the “Integer Types” section of Chapter 3.
+`usize` type is for, as discussed in the [“Integer Types”][integer-types]
+section of Chapter 3.
 -->
 
 `size`引数の型として、`usize`を選択しました。何故なら、マイナスのスレッド数は、何も筋が通らないことを知っているからです。
-また、この4をスレッドのコレクションの要素数として使用し、第3章の「整数型」節で議論したように、これは`usize`のあるべき姿であることも知っています。
+また、この4をスレッドのコレクションの要素数として使用し、第3章の[「整数型」][integer-types]節で議論したように、これは`usize`のあるべき姿であることも知っています。
 
 <!--
 Let’s check the code again:
@@ -494,53 +433,37 @@ Let’s check the code again:
 
 コードを再度確認しましょう:
 
-```text
-$ cargo check
-   Compiling hello v0.1.0 (file:///projects/hello)
-warning: unused variable: `size`
-(警告: 未使用の変数: `size`)
- --> src/lib.rs:4:16
-  |
-4 |     pub fn new(size: usize) -> ThreadPool {
-  |                ^^^^
-  |
-  = note: #[warn(unused_variables)] on by default
-  = note: to avoid this warning, consider using `_size` instead
-
-error[E0599]: no method named `execute` found for type `hello::ThreadPool` in the current scope
-  --> src/bin/main.rs:18:14
-   |
-18 |         pool.execute(|| {
-   |              ^^^^^^^
+```console
+{{#include ../listings/ch20-web-server/no-listing-02-impl-threadpool-new/output.txt}}
 ```
 
 <!--
-Now we get a warning and an error. Ignoring the warning for a moment, the error
-occurs because we don’t have an `execute` method on `ThreadPool`. Recall from
-the “Creating a Similar Interface for a Finite Number of Threads” section that
-we decided our thread pool should have an interface similar to `thread::spawn`.
-In addition, we’ll implement the `execute` function so it takes the closure
-it’s given and gives it to an idle thread in the pool to run.
+Now the error occurs because we don’t have an `execute` method on `ThreadPool`.
+Recall from the [“Creating a Finite Number of
+Threads”](#creating-a-finite-number-of-threads) section that we
+decided our thread pool should have an interface similar to `thread::spawn`. In
+addition, we’ll implement the `execute` function so it takes the closure it’s
+given and gives it to an idle thread in the pool to run.
 -->
 
-今度は、警告とエラーが出ました。一時的に警告は無視して、`ThreadPool`に`execute`メソッドがないためにエラーが発生しました。
-「有限数のスレッド用に似たインターフェイスを作成する」節で我々のスレッドプールは、
+今度は、`ThreadPool`に`execute`メソッドがないためにエラーが発生しました。
+[「有限個のスレッドを作成する」](#有限個のスレッドを作成する)節で我々のスレッドプールは、
 `thread::spawn`と似たインターフェイスにするべきと決定したことを思い出してください。
 さらに、`execute`関数を実装するので、与えられたクロージャを取り、実行するようにプールの待機中のスレッドに渡します。
 
 <!--
 We’ll define the `execute` method on `ThreadPool` to take a closure as a
-parameter. Recall from the “Storing Closures Using Generic Parameters and the
-`Fn` Traits” section in Chapter 13 that we can take closures as parameters with
-three different traits: `Fn`, `FnMut`, and `FnOnce`. We need to decide which
-kind of closure to use here. We know we’ll end up doing something similar to
-the standard library `thread::spawn` implementation, so we can look at what
-bounds the signature of `thread::spawn` has on its parameter. The documentation
-shows us the following:
+parameter. Recall from the [“Moving Captured Values Out of the Closure and the
+`Fn` Traits”][fn-traits] section in Chapter 13 that we can take
+closures as parameters with three different traits: `Fn`, `FnMut`, and
+`FnOnce`. We need to decide which kind of closure to use here. We know we’ll
+end up doing something similar to the standard library `thread::spawn`
+implementation, so we can look at what bounds the signature of `thread::spawn`
+has on its parameter. The documentation shows us the following:
 -->
 
 `ThreadPool`に`execute`メソッドをクロージャを引数として受け取るように定義します。
-第13章の「ジェネリック引数と`Fn`トレイトを使用してクロージャを保存する」節から、
+第13章の[「キャプチャされた値のクロージャからのムーブと、`Fn`系トレイト」][fn-traits]節から、
 3つの異なるトレイトでクロージャを引数として取ることができることを思い出してください: `Fn`、`FnMut`、`FnOnce`です。
 ここでは、どの種類のクロージャを使用するか決定する必要があります。最終的には、
 標準ライブラリの`thread::spawn`実装に似たことをすることがわかっているので、
@@ -549,8 +472,9 @@ shows us the following:
 ```rust,ignore
 pub fn spawn<F, T>(f: F) -> JoinHandle<T>
     where
-        F: FnOnce() -> T + Send + 'static,
-        T: Send + 'static
+        F: FnOnce() -> T,
+        F: Send + 'static,
+        T: Send + 'static,
 ```
 
 <!--
@@ -586,28 +510,18 @@ the thread will take to execute. Let’s create an `execute` method on
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-# pub struct ThreadPool;
-impl ThreadPool {
-    // --snip--
-
-    pub fn execute<F>(&self, f: F)
-        where
-            F: FnOnce() + Send + 'static
-    {
-
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-03-define-execute/src/lib.rs:here}}
 ```
 
 <!--
 We still use the `()` after `FnOnce` because this `FnOnce` represents a closure
-that takes no parameters and doesn’t return a value. Just like function
+that takes no parameters and returns the unit type `()`. Just like function
 definitions, the return type can be omitted from the signature, but even if we
 have no parameters, we still need the parentheses.
 -->
 
-それでも、`FnOnce`の後に`()`を使用しています。この`FnOnce`は引数を取らず、値も返さないクロージャを表すからです。
+それでも、`FnOnce`の後に`()`を使用しています。この`FnOnce`は引数を取らず、ユニット型`()`を返すクロージャを表すからです。
 関数定義同様に、戻り値の型はシグニチャから省略できますが、引数がなくても、カッコは必要です。
 
 <!--
@@ -618,35 +532,18 @@ nothing, but we’re trying only to make our code compile. Let’s check it agai
 またもや、これが`execute`メソッドの最も単純な実装です: 何もしませんが、
 コードがコンパイルできるようにしようとしているだけです。再確認しましょう:
 
-```text
-$ cargo check
-   Compiling hello v0.1.0 (file:///projects/hello)
-warning: unused variable: `size`
- --> src/lib.rs:4:16
-  |
-4 |     pub fn new(size: usize) -> ThreadPool {
-  |                ^^^^
-  |
-  = note: #[warn(unused_variables)] on by default
-  = note: to avoid this warning, consider using `_size` instead
-
-warning: unused variable: `f`
- --> src/lib.rs:8:30
-  |
-8 |     pub fn execute<F>(&self, f: F)
-  |                              ^
-  |
-  = note: to avoid this warning, consider using `_f` instead
+```console
+{{#include ../listings/ch20-web-server/no-listing-03-define-execute/output.txt}}
 ```
 
 <!--
-We’re receiving only warnings now, which means it compiles! But note that if
-you try `cargo run` and make a request in the browser, you’ll see the errors in
-the browser that we saw at the beginning of the chapter. Our library isn’t
-actually calling the closure passed to `execute` yet!
+It compiles! But note that if you try `cargo run` and make a request in the
+browser, you’ll see the errors in the browser that we saw at the beginning of
+the chapter. Our library isn’t actually calling the closure passed to `execute`
+yet!
 -->
 
-これで警告を受け取るだけになり、コンパイルできるようになりました！しかし、`cargo run`を試して、
+コンパイルできました！しかし、`cargo run`を試して、
 ブラウザでリクエストを行うと、章の冒頭で見かけたエラーがブラウザに現れることに注意してください。
 ライブラリは、まだ実際に`execute`に渡されたクロージャを呼び出していないのです！
 
@@ -671,18 +568,17 @@ actually calling the closure passed to `execute` yet!
 #### `new`でスレッド数を検査する
 
 <!--
-We’ll continue to get warnings because we aren’t doing anything with the
-parameters to `new` and `execute`. Let’s implement the bodies of these
-functions with the behavior we want. To start, let’s think about `new`. Earlier
-we chose an unsigned type for the `size` parameter, because a pool with a
-negative number of threads makes no sense. However, a pool with zero threads
-also makes no sense, yet zero is a perfectly valid `usize`. We’ll add code to
-check that `size` is greater than zero before we return a `ThreadPool` instance
-and have the program panic if it receives a zero by using the `assert!` macro,
-as shown in Listing 20-13.
+We aren’t doing anything with the parameters to `new` and `execute`. Let’s
+implement the bodies of these functions with the behavior we want. To start,
+let’s think about `new`. Earlier we chose an unsigned type for the `size`
+parameter, because a pool with a negative number of threads makes no sense.
+However, a pool with zero threads also makes no sense, yet zero is a perfectly
+valid `usize`. We’ll add code to check that `size` is greater than zero before
+we return a `ThreadPool` instance and have the program panic if it receives a
+zero by using the `assert!` macro, as shown in Listing 20-13.
 -->
 
-`new`と`execute`の引数で何もしていないので、警告が出続けます。欲しい振る舞いでこれらの関数の本体を実装しましょう。
+`new`と`execute`への引数は、何にも使用していません。欲しい振る舞いでこれらの関数の本体を実装しましょう。
 まずはじめに、`new`を考えましょう。先刻、`size`引数に非負整数型を選択しました。負のスレッド数のプールは、
 全く道理が通らないからです。しかしながら、0スレッドのプールも全く意味がわかりませんが、0も完全に合法な`usize`です。
 `ThreadPool`インスタンスを返す前に`size`が0よりも大きいことを確認するコードを追加し、リスト20-13に示したように、
@@ -694,32 +590,8 @@ as shown in Listing 20-13.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-# pub struct ThreadPool;
-impl ThreadPool {
-    /// 新しいThreadPoolを生成する。
-    ///
-    /// sizeがプールのスレッド数です。
-    ///
-    /// # パニック
-    ///
-    /// sizeが0なら、`new`関数はパニックします。
-    ///
-    /// Create a new ThreadPool.
-    ///
-    /// The size is the number of threads in the pool.
-    ///
-    /// # Panics
-    ///
-    /// The `new` function will panic if the size is zero.
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        ThreadPool
-    }
-
-    // --snip--
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-13/src/lib.rs:here}}
 ```
 
 <!--
@@ -734,33 +606,33 @@ impl ThreadPool {
 -->
 
 <!--
-We’ve added some documentation for our `ThreadPool` with doc comments. Note
-that we followed good documentation practices by adding a section that calls
-out the situations in which our function can panic, as discussed in Chapter 14.
-Try running `cargo doc --open` and clicking the `ThreadPool` struct to see what
-the generated docs for `new` look like!
+We’ve also added some documentation for our `ThreadPool` with doc comments.
+Note that we followed good documentation practices by adding a section that
+calls out the situations in which our function can panic, as discussed in
+Chapter 14. Try running `cargo doc --open` and clicking the `ThreadPool` struct
+to see what the generated docs for `new` look like!
 -->
 
-doc commentで`ThreadPool`にドキュメンテーションを追加しました。第14章で議論したように、
+doc commentで`ThreadPool`にドキュメンテーションも追加しました。第14章で議論したように、
 関数がパニックすることもある場面を声高に叫ぶセクションを追加することで、
 いいドキュメンテーションの実践に<ruby>倣<rp>(</rp><rt>なら</rt><rp>)</rp></ruby>っていることに注意してください。
 試しに`cargo doc --open`を実行し、`ThreadPool`構造体をクリックして、`new`の生成されるドキュメンテーションがどんな見た目か確かめてください！
 
 <!--
-Instead of adding the `assert!` macro as we’ve done here, we could make `new`
-return a `Result` like we did with `Config::new` in the I/O project in Listing
-12-9. But we’ve decided in this case that trying to create a thread pool
-without any threads should be an unrecoverable error. If you’re feeling
-ambitious, try to write a version of `new` with the following signature to
-compare both versions:
+Instead of adding the `assert!` macro as we’ve done here, we could change `new`
+into `build` and return a `Result` like we did with `Config::build` in the I/O
+project in Listing 12-9. But we’ve decided in this case that trying to create a
+thread pool without any threads should be an unrecoverable error. If you’re
+feeling ambitious, try to write a function named `build` with the following
+signature to compare with the `new` function:
 -->
 
-ここでしたように`assert!`マクロを追加する代わりに、リスト12-9のI/Oプロジェクトの`Config::new`のように、
-`new`に`Result`を返させることもできるでしょう。しかし、今回の場合、スレッドなしでスレッドプールを作成しようとするのは、
-回復不能なエラーであるべきと決定しました。野心を感じるのなら、以下のシグニチャの`new`も書いてみて、両者を比較してみてください:
+ここでしたように`assert!`マクロを追加する代わりに、リスト12-9のI/Oプロジェクトの`Config::build`のように、
+`new`を`build`に変更し、`Result`を返させることもできるでしょう。しかし、今回の場合、スレッドなしでスレッドプールを作成しようとするのは、
+回復不能なエラーであるべきと決定しました。野心を感じるのなら、以下のシグニチャを持つ`build`関数を書いてみて、`new`関数と比較してみてください:
 
 ```rust,ignore
-pub fn new(size: usize) -> Result<ThreadPool, PoolCreationError> {
+pub fn build(size: usize) -> Result<ThreadPool, PoolCreationError> {
 ```
 
 <!--
@@ -772,8 +644,8 @@ pub fn new(size: usize) -> Result<ThreadPool, PoolCreationError> {
 <!--
 Now that we have a way to know we have a valid number of threads to store in
 the pool, we can create those threads and store them in the `ThreadPool` struct
-before returning it. But how do we “store” a thread? Let’s take another look at
-the `thread::spawn` signature:
+before returning the struct. But how do we “store” a thread? Let’s take another
+look at the `thread::spawn` signature:
 -->
 
 今や、プールに格納する合法なスレッド数を知る方法ができたので、`ThreadPool`構造体を返す前にスレッドを作成して格納できます。
@@ -782,8 +654,9 @@ the `thread::spawn` signature:
 ```rust,ignore
 pub fn spawn<F, T>(f: F) -> JoinHandle<T>
     where
-        F: FnOnce() -> T + Send + 'static,
-        T: Send + 'static
+        F: FnOnce() -> T,
+        F: Send + 'static,
+        T: Send + 'static,
 ```
 
 <!--
@@ -815,32 +688,8 @@ returned a `ThreadPool` instance containing them.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-use std::thread;
-
-pub struct ThreadPool {
-    threads: Vec<thread::JoinHandle<()>>,
-}
-
-impl ThreadPool {
-    // --snip--
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let mut threads = Vec::with_capacity(size);
-
-        for _ in 0..size {
-            // スレッドを生成してベクタに格納する
-            // create some threads and store them in the vector
-        }
-
-        ThreadPool {
-            threads
-        }
-    }
-
-    // --snip--
-}
+```rust,ignore,not_desired_behavior
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-14/src/lib.rs:here}}
 ```
 
 <!--
@@ -861,26 +710,24 @@ using `thread::JoinHandle` as the type of the items in the vector in
 
 <!--
 Once a valid size is received, our `ThreadPool` creates a new vector that can
-hold `size` items. We haven’t used the `with_capacity` function in this book
-yet, which performs the same task as `Vec::new` but with an important
-difference: it preallocates space in the vector. Because we know we need to
-store `size` elements in the vector, doing this allocation up front is slightly
-more efficient than using `Vec::new`, which resizes itself as elements are
-inserted.
+hold `size` items. The `with_capacity` function performs the same task as
+`Vec::new` but with an important difference: it preallocates space in the
+vector. Because we know we need to store `size` elements in the vector, doing
+this allocation up front is slightly more efficient than using `Vec::new`,
+which resizes itself as elements are inserted.
 -->
 
 一旦、合法なサイズを受け取ったら、`ThreadPool`は`size`個の要素を保持できる新しいベクタを生成します。
-この本ではまだ、`with_capacity`関数を使用したことがありませんが、これは`Vec::new`と同じ作業をしつつ、
-重要な違いがあります: ベクタに予めスペースを確保しておくのです。ベクタに`size`個の要素を格納する必要があることはわかっているので、
+`with_capacity`関数は`Vec::new`と同じ作業をしますが、重要な違いがあります:
+ベクタに予めスペースを確保しておくのです。ベクタに`size`個の要素を格納する必要があることはわかっているので、
 このメモリ確保を前もってしておくと、`Vec::new`よりも少しだけ効率的になります。`Vec::new`は、
 要素が挿入されるにつれて、自身のサイズを変更します。
 
 <!--
-When you run `cargo check` again, you’ll get a few more warnings, but it should
-succeed.
+When you run `cargo check` again, it should succeed.
 -->
 
-再び`cargo check`を実行すると、もういくつか警告が出るものの、成功するはずです。
+再び`cargo check`を実行すると、成功するはずです。
 
 <!--
 #### A `Worker` Struct Responsible for Sending Code from the `ThreadPool` to a Thread
@@ -908,14 +755,17 @@ implement it manually.
 <!--
 We’ll implement this behavior by introducing a new data structure between the
 `ThreadPool` and the threads that will manage this new behavior. We’ll call
-this data structure `Worker`, which is a common term in pooling
-implementations. Think of people working in the kitchen at a restaurant: the
-workers wait until orders come in from customers, and then they’re responsible
-for taking those orders and filling them.
+this data structure *Worker*, which is a common term in pooling
+implementations. The Worker picks up code that needs to be run and runs the
+code in the Worker’s thread. Think of people working in the kitchen at a
+restaurant: the workers wait until orders come in from customers, and then
+they’re responsible for taking those orders and fulfilling them.
 -->
 
 この新しい振る舞いを管理するスレッドと`ThreadPool`間に新しいデータ構造を導入することでこの振る舞いを実装します。
-このデータ構造を`Worker`と呼び、プール実装では一般的な用語です。レストランのキッチンで働く人々を思い浮かべてください:
+このデータ構造を*ワーカー*と呼び、プール実装では一般的な用語です。
+ワーカーは実行する必要のあるコードを受け取り、ワーカーのスレッドでそのコードを実行します。
+レストランのキッチンで働く人々を思い浮かべてください:
 労働者は、お客さんからオーダーが来るまで待機し、それからそれらのオーダーを取り、満たすことに責任を負います。
 
 <!--
@@ -933,22 +783,22 @@ the different workers in the pool when logging or debugging.
 各ワーカーに`id`も付与します。
 
 <!--
-Let’s make the following changes to what happens when we create a `ThreadPool`.
-We’ll implement the code that sends the closure to the thread after we have
-`Worker` set up in this way:
+Here is the new process that will happen when we create a `ThreadPool`. We’ll
+implement the code that sends the closure to the thread after we have `Worker`
+set up in this way:
 -->
 
-`ThreadPool`を生成する際に発生することに以下の変更を加えましょう。このように`Worker`をセットアップした後に、
-スレッドにクロージャを送信するコードを実装します:
+`ThreadPool`を作成する際に発生する新しいプロセスは、以下のようになります。
+このように`Worker`をセットアップした後に、スレッドにクロージャを送信するコードを実装します:
 
 <!--
 1. Define a `Worker` struct that holds an `id` and a `JoinHandle<()>`.
 2. Change `ThreadPool` to hold a vector of `Worker` instances.
 3. Define a `Worker::new` function that takes an `id` number and returns a
-`Worker` instance that holds the `id` and a thread spawned with an empty
-closure.
+   `Worker` instance that holds the `id` and a thread spawned with an empty
+   closure.
 4. In `ThreadPool::new`, use the `for` loop counter to generate an `id`, create
-a new `Worker` with that `id`, and store the worker in the vector.
+   a new `Worker` with that `id`, and store the worker in the vector.
 -->
 
 1. `id`と`JoinHandle<()>`を保持する`Worker`構造体を定義する。
@@ -975,46 +825,8 @@ Ready? Here is Listing 20-15 with one way to make the preceding modifications.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-use std::thread;
-
-pub struct ThreadPool {
-    workers: Vec<Worker>,
-}
-
-impl ThreadPool {
-    // --snip--
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let mut workers = Vec::with_capacity(size);
-
-        for id in 0..size {
-            workers.push(Worker::new(id));
-        }
-
-        ThreadPool {
-            workers
-        }
-    }
-    // --snip--
-}
-
-struct Worker {
-    id: usize,
-    thread: thread::JoinHandle<()>,
-}
-
-impl Worker {
-    fn new(id: usize) -> Worker {
-        let thread = thread::spawn(|| {});
-
-        Worker {
-            id,
-            thread,
-        }
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-15/src/lib.rs:here}}
 ```
 
 <!--
@@ -1036,17 +848,32 @@ instances. We use the counter in the `for` loop as an argument to
 それぞれの新しい`Worker`を`workers`というベクタに格納します。
 
 <!--
-External code (like our server in *src/bin/main.rs*) doesn’t need to know the
+External code (like our server in *src/main.rs*) doesn’t need to know the
 implementation details regarding using a `Worker` struct within `ThreadPool`,
 so we make the `Worker` struct and its `new` function private. The
 `Worker::new` function uses the `id` we give it and stores a `JoinHandle<()>`
 instance that is created by spawning a new thread using an empty closure.
 -->
 
-外部のコード(*src/bin/main.rs*のサーバなど)は、`ThreadPool`内で`Worker`構造体を使用していることに関する実装の詳細を知る必要はないので、
+外部のコード(*src/main.rs*のサーバなど)は、`ThreadPool`内で`Worker`構造体を使用していることに関する実装の詳細を知る必要はないので、
 `Worker`構造体とその`new`関数は非公開にしています。`Worker::new`関数は与えた`id`を使用し、
 空のクロージャを使って新しいスレッドを立ち上げることで生成される`JoinHandle<()>`インスタンスを格納します。
 
+<!--
+> Note: If the operating system can’t create a thread because there aren’t
+> enough system resources, `thread::spawn` will panic. That will cause our
+> whole server to panic, even though the creation of some threads might
+> succeed. For simplicity’s sake, this behavior is fine, but in a production
+> thread pool implementation, you’d likely want to use
+> [`std::thread::Builder`][builder] and its
+> [`spawn`][builder-spawn] method that returns `Result` instead.
+-->
+
+> 注釈: 十分なシステムリソースが無いためにOSがスレッドを作成できない場合、`thread::spawn`はパニックするでしょう。
+> これは、一部のスレッドが作成に成功したとしても、サーバ全体のパニックを引き起こすでしょう。
+> 簡潔性を優先してこの挙動はまあよしとしますが、実運用のスレッドプール実装では、
+> [`std::thread::Builder`][builder]と、パニックするのではなく`Result`を返す[`spawn`][builder-spawn]メソッドを使用するのがよいでしょう。
+
 <!--
 This code will compile and will store the number of `Worker` instances we
 specified as an argument to `ThreadPool::new`. But we’re *still* not processing
@@ -1063,62 +890,60 @@ the closure that we get in `execute`. Let’s look at how to do that next.
 #### チャンネル経由でスレッドにリクエストを送信する
 
 <!--
-Now we’ll tackle the problem that the closures given to `thread::spawn` do
+The next problem we’ll tackle is that the closures given to `thread::spawn` do
 absolutely nothing. Currently, we get the closure we want to execute in the
 `execute` method. But we need to give `thread::spawn` a closure to run when we
 create each `Worker` during the creation of the `ThreadPool`.
 -->
 
-さて、`thread::spawn`に与えられたクロージャが全く何もしないという問題に取り組みましょう。現在、
+次に取り組む問題は、`thread::spawn`に与えられたクロージャが全く何もしない問題です。現在、
 `execute`メソッドで実行したいクロージャを得ています。ですが、`ThreadPool`の生成中、`Worker`それぞれを生成する際に、
 実行するクロージャを`thread::spawn`に与える必要があります。
 
 <!--
-We want the `Worker` structs that we just created to fetch code to run from a
-queue held in the `ThreadPool` and send that code to its thread to run.
+We want the `Worker` structs that we just created to fetch the code to run from
+a queue held in the `ThreadPool` and send that code to its thread to run.
 -->
 
 作ったばかりの`Worker`構造体に`ThreadPool`が保持するキューから実行するコードをフェッチして、
 そのコードをスレッドが実行できるように送信してほしいです。
 
 <!--
-In Chapter 16, you learned about *channels*—a simple way to communicate between
-two threads—that would be perfect for this use case. We’ll use a channel to
-function as the queue of jobs, and `execute` will send a job from the
-`ThreadPool` to the `Worker` instances, which will send the job to its thread.
-Here is the plan:
+The channels we learned about in Chapter 16—a simple way to communicate between
+two threads—would be perfect for this use case. We’ll use a channel to function
+as the queue of jobs, and `execute` will send a job from the `ThreadPool` to
+the `Worker` instances, which will send the job to its thread. Here is the plan:
 -->
 
-第16章でこのユースケースにぴったりであろう*チャンネル*(2スレッド間コミュニケーションをとる単純な方法)について学びました。
+第16章で学んだチャンネル—2スレッド間コミュニケーションをとる単純な方法—は、このユースケースにぴったりでしょう。
 チャンネルをキューの仕事として機能させ、`execute`は`ThreadPool`から`Worker`インスタンスに仕事を送り、
 これが仕事をスレッドに送信します。こちらが計画です:
 
 <!--
-1. The `ThreadPool` will create a channel and hold on to the sending side of
-the channel.
-2. Each `Worker` will hold on to the receiving side of the channel.
+1. The `ThreadPool` will create a channel and hold on to the sender.
+2. Each `Worker` will hold on to the receiver.
 3. We’ll create a new `Job` struct that will hold the closures we want to send
-down the channel.
-4. The `execute` method will send the job it wants to execute down the sending
-side of the channel.
-5. In its thread, the `Worker` will loop over its receiving side of the channel
-and execute the closures of any jobs it receives.
+   down the channel.
+4. The `execute` method will send the job it wants to execute through the
+   sender.
+5. In its thread, the `Worker` will loop over its receiver and execute the
+   closures of any jobs it receives.
 -->
 
-1. `ThreadPool`はチャンネルを生成し、チャンネルの送信側に就く。
-2. `Worker`それぞれは、チャンネルの受信側に就く。
+1. `ThreadPool`はチャンネルを生成し、チャンネルの送信機に就く。
+2. `Worker`それぞれは、チャンネルの受信機に就く。
 3. チャンネルに送信したいクロージャを保持する新しい`Job`構造体を生成する。
-4. `execute`メソッドは、実行したい仕事をチャンネルの送信側に送信する。
-5. スレッド内で、`Worker`はチャンネルの受信側をループし、受け取ったあらゆる仕事のクロージャを実行する。
+4. `execute`メソッドは、実行したい仕事をチャンネルの送信機を通して送信する。
+5. スレッド内で、`Worker`はチャンネルの受信機をループし、受け取ったあらゆる仕事のクロージャを実行する。
 
 <!--
-Let’s start by creating a channel in `ThreadPool::new` and holding the sending
-side in the `ThreadPool` instance, as shown in Listing 20-16. The `Job` struct
+Let’s start by creating a channel in `ThreadPool::new` and holding the sender
+in the `ThreadPool` instance, as shown in Listing 20-16. The `Job` struct
 doesn’t hold anything for now but will be the type of item we’re sending down
 the channel.
 -->
 
-`ThreadPool::new`内でチャンネルを生成し、`ThreadPool`インスタンスに送信側を保持することから始めましょう。リスト20-16のようにですね。
+`ThreadPool::new`内でチャンネルを生成し、`ThreadPool`インスタンスに送信機を保持することから始めましょう。リスト20-16のようにですね。
 今の所、`Job`構造体は何も保持しませんが、チャンネルに送信する種類の要素になります。
 
 <!--
@@ -1127,80 +952,34 @@ the channel.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-# use std::thread;
-// --snip--
-use std::sync::mpsc;
-
-pub struct ThreadPool {
-    workers: Vec<Worker>,
-    sender: mpsc::Sender<Job>,
-}
-
-struct Job;
-
-impl ThreadPool {
-    // --snip--
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let (sender, receiver) = mpsc::channel();
-
-        let mut workers = Vec::with_capacity(size);
-
-        for id in 0..size {
-            workers.push(Worker::new(id));
-        }
-
-        ThreadPool {
-            workers,
-            sender,
-        }
-    }
-    // --snip--
-}
-#
-# struct Worker {
-#     id: usize,
-#     thread: thread::JoinHandle<()>,
-# }
-#
-# impl Worker {
-#     fn new(id: usize) -> Worker {
-#         let thread = thread::spawn(|| {});
-#
-#         Worker {
-#             id,
-#             thread,
-#         }
-#     }
-# }
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-16/src/lib.rs:here}}
 ```
 
 <!--
 <span class="caption">Listing 20-16: Modifying `ThreadPool` to store the
-sending end of a channel that sends `Job` instances</span>
+sender of a channel that transmits `Job` instances</span>
 -->
 
-<span class="caption">リスト20-18: `ThreadPool`を変更して`Job`インスタンスを送信するチャンネルの送信側を格納する</span>
+<span class="caption">リスト20-18: `ThreadPool`を変更して`Job`インスタンスを転送するチャンネルの送信機を格納する</span>
 
 <!--
 In `ThreadPool::new`, we create our new channel and have the pool hold the
-sending end. This will successfully compile, still with warnings.
+sender. This will successfully compile.
 -->
 
-`ThreadPool::new`内で新しいチャンネルを生成し、プールに送信側を保持させています。これはコンパイルに成功しますが、
-まだ警告があります。
+`ThreadPool::new`内で新しいチャンネルを生成し、プールに送信機を保持させています。
+これはコンパイルに成功します。
 
 <!--
-Let’s try passing a receiving end of the channel into each worker as the thread
-pool creates them. We know we want to use the receiving end in the
-thread that the workers spawn, so we’ll reference the `receiver` parameter in
-the closure. The code in Listing 20-17 won’t quite compile yet.
+Let’s try passing a receiver of the channel into each worker as the thread pool
+creates the channel. We know we want to use the receiver in the thread that the
+workers spawn, so we’ll reference the `receiver` parameter in the closure. The
+code in Listing 20-17 won’t quite compile yet.
 -->
 
-スレッドプールがワーカーを生成する際に各ワーカーにチャンネルの受信側を試しに渡してみましょう。
-受信側はワーカーが大量生産するスレッド内で使用したいことがわかっているので、クロージャ内で`receiver`引数を参照します。
+スレッドプールがチャンネルを生成する際に、各ワーカーにチャンネルの受信機を渡してみましょう。
+受信機はワーカーが大量生産するスレッド内で使用したいことがわかっているので、クロージャ内で`receiver`引数を参照します。
 リスト20-17のコードはまだ完璧にはコンパイルできません。
 
 <!--
@@ -1209,57 +988,22 @@ the closure. The code in Listing 20-17 won’t quite compile yet.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-impl ThreadPool {
-    // --snip--
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let (sender, receiver) = mpsc::channel();
-
-        let mut workers = Vec::with_capacity(size);
-
-        for id in 0..size {
-            workers.push(Worker::new(id, receiver));
-        }
-
-        ThreadPool {
-            workers,
-            sender,
-        }
-    }
-    // --snip--
-}
-
-// --snip--
-
-impl Worker {
-    fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {
-        let thread = thread::spawn(|| {
-            receiver;
-        });
-
-        Worker {
-            id,
-            thread,
-        }
-    }
-}
+```rust,ignore,does_not_compile
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-17/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-17: Passing the receiving end of the channel
-to the workers</span>
+<span class="caption">Listing 20-17: Passing the receiver to the workers</span>
 -->
 
-<span class="caption">リスト20-17: チャンネルの受信側をワーカーに渡す</span>
+<span class="caption">リスト20-17: チャンネルの受信機をワーカーに渡す</span>
 
 <!--
-We’ve made some small and straightforward changes: we pass the receiving end of
-the channel into `Worker::new`, and then we use it inside the closure.
+We’ve made some small and straightforward changes: we pass the receiver into
+`Worker::new`, and then we use it inside the closure.
 -->
 
-多少些細で単純な変更を行いました: チャンネルの受信側を`Worker::new`に渡し、それからクロージャの内側で使用しています。
+多少些細で単純な変更を行いました: チャンネルの受信機を`Worker::new`に渡し、それからクロージャの内側で使用しています。
 
 <!--
 When we try to check this code, we get this error:
@@ -1267,34 +1011,24 @@ When we try to check this code, we get this error:
 
 このコードのチェックを試みると、このようなエラーが出ます:
 
-```text
-$ cargo check
-   Compiling hello v0.1.0 (file:///projects/hello)
-error[E0382]: use of moved value: `receiver`
-  --> src/lib.rs:27:42
-   |
-27 |             workers.push(Worker::new(id, receiver));
-   |                                          ^^^^^^^^ value moved here in
-   previous iteration of loop
-   |
-   = note: move occurs because `receiver` has type
-   `std::sync::mpsc::Receiver<Job>`, which does not implement the `Copy` trait
+```console
+{{#include ../listings/ch20-web-server/listing-20-17/output.txt}}
 ```
 
 <!--
 The code is trying to pass `receiver` to multiple `Worker` instances. This
 won’t work, as you’ll recall from Chapter 16: the channel implementation that
 Rust provides is multiple *producer*, single *consumer*. This means we can’t
-just clone the consuming end of the channel to fix this code. Even if we could,
-that is not the technique we would want to use; instead, we want to distribute
-the jobs across threads by sharing the single `receiver` among all the workers.
+just clone the consuming end of the channel to fix this code. We also don’t
+want to send a message multiple times to multiple consumers; we want one list
+of messages with multiple workers such that each message gets processed once.
 -->
 
 このコードは、`receiver`を複数の`Worker`インスタンスに渡そうとしています。第16章を思い出すように、これは動作しません:
 Rustが提供するチャンネル実装は、複数の*生成者*、単独の*消費者*です。要するに、
-チャンネルの消費側をクローンするだけでこのコードを修正することはできません。たとえできたとしても、
-使用したいテクニックではありません; 代わりに、全ワーカー間で単独の`receiver`を共有することで、
-スレッド間に仕事を分配したいです。
+チャンネルの消費側をクローンするだけでこのコードを修正することはできません。
+また、メッセージを複数の消費者に複数回送信したくはありません;
+欲しいのは、各メッセージが一度だけ処理されるような、複数のワーカーを備えた、メッセージの単一のリストです。
 
 <!--
 Additionally, taking a job off the channel queue involves mutating the
@@ -1325,78 +1059,25 @@ receiver at a time. Listing 20-18 shows the changes we need to make.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-# use std::thread;
-# use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-// --snip--
-
-# pub struct ThreadPool {
-#     workers: Vec<Worker>,
-#     sender: mpsc::Sender<Job>,
-# }
-# struct Job;
-#
-impl ThreadPool {
-    // --snip--
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let (sender, receiver) = mpsc::channel();
-
-        let receiver = Arc::new(Mutex::new(receiver));
-
-        let mut workers = Vec::with_capacity(size);
-
-        for id in 0..size {
-            workers.push(Worker::new(id, Arc::clone(&receiver)));
-        }
-
-        ThreadPool {
-            workers,
-            sender,
-        }
-    }
-
-    // --snip--
-}
-
-# struct Worker {
-#     id: usize,
-#     thread: thread::JoinHandle<()>,
-# }
-#
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
-        // --snip--
-#         let thread = thread::spawn(|| {
-#            receiver;
-#         });
-#
-#         Worker {
-#             id,
-#             thread,
-#         }
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-18/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-18: Sharing the receiving end of the channel
-among the workers using `Arc` and `Mutex`</span>
+<span class="caption">Listing 20-18: Sharing the receiver among the workers
+using `Arc` and `Mutex`</span>
 -->
 
-<span class="caption">リスト20-18: `Arc`と`Mutex`を使用してワーカー間でチャンネルの受信側を共有する</span>
+<span class="caption">リスト20-18: `Arc`と`Mutex`を使用してワーカー間でチャンネルの受信機を共有する</span>
 
 <!--
-In `ThreadPool::new`, we put the receiving end of the channel in an `Arc` and a
-`Mutex`. For each new worker, we clone the `Arc` to bump the reference count so
-the workers can share ownership of the receiving end.
+In `ThreadPool::new`, we put the receiver in an `Arc` and a `Mutex`. For each
+new worker, we clone the `Arc` to bump the reference count so the workers can
+share ownership of the receiver.
 -->
 
-`ThreadPool::new`で、チャンネルの受信側を`Arc`と`Mutex`に置いています。新しいワーカーそれぞれに対して、
-`Arc`をクローンして参照カウントを跳ね上げているので、ワーカーは受信側の所有権を共有することができます。
+`ThreadPool::new`で、チャンネルの受信機を`Arc`と`Mutex`に置いています。新しいワーカーそれぞれに対して、
+`Arc`をクローンして参照カウントを跳ね上げているので、ワーカーは受信機の所有権を共有することができます。
 
 <!--
 With these changes, the code compiles! We’re getting there!
@@ -1413,14 +1094,16 @@ With these changes, the code compiles! We’re getting there!
 <!--
 Let’s finally implement the `execute` method on `ThreadPool`. We’ll also change
 `Job` from a struct to a type alias for a trait object that holds the type of
-closure that `execute` receives. As discussed in the “Creating Type Synonyms
-with Type Aliases” section of Chapter 19, type aliases allow us to make long
-types shorter. Look at Listing 20-19.
+closure that `execute` receives. As discussed in the [“Creating Type Synonyms
+with Type Aliases”][creating-type-synonyms-with-type-aliases]
+section of Chapter 19, type aliases allow us to make long types shorter for
+ease of use. Look at Listing 20-19.
 -->
 
 最後に`ThreadPool`に`execute`メソッドを実装しましょう。
 `Job`も構造体から`execute`が受け取るクロージャの型を保持するトレイトオブジェクトの型エイリアスに変更します。
-第19章の「型エイリアスで型同義語を生成する」節で議論したように、型エイリアスにより長い型を短くできます。
+第19章の[「型エイリアスで型同義語を生成する」][creating-type-synonyms-with-type-aliases]節で議論したように、
+使いやすさのために、型エイリアスを利用して長い型を短くすることができます。
 リスト20-19をご覧ください。
 
 <!--
@@ -1429,31 +1112,8 @@ types shorter. Look at Listing 20-19.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-// --snip--
-# pub struct ThreadPool {
-#     workers: Vec<Worker>,
-#     sender: mpsc::Sender<Job>,
-# }
-# use std::sync::mpsc;
-# struct Worker {}
-
-type Job = Box<FnOnce() + Send + 'static>;
-
-impl ThreadPool {
-    // --snip--
-
-    pub fn execute<F>(&self, f: F)
-        where
-            F: FnOnce() + Send + 'static
-    {
-        let job = Box::new(f);
-
-        self.sender.send(job).unwrap();
-    }
-}
-
-// --snip--
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-19/src/lib.rs:here}}
 ```
 
 <!--
@@ -1499,28 +1159,8 @@ shown in Listing 20-20 to `Worker::new`.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-// --snip--
-
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
-        let thread = thread::spawn(move || {
-            loop {
-                let job = receiver.lock().unwrap().recv().unwrap();
-
-                // ワーカー{}は仕事を得ました; 実行します
-                println!("Worker {} got a job; executing.", id);
-
-                (*job)();
-            }
-        });
-
-        Worker {
-            id,
-            thread,
-        }
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-20/src/lib.rs:here}}
 ```
 
 <!--
@@ -1549,13 +1189,13 @@ you.
 <!--
 If we get the lock on the mutex, we call `recv` to receive a `Job` from the
 channel. A final `unwrap` moves past any errors here as well, which might occur
-if the thread holding the sending side of the channel has shut down, similar to
-how the `send` method returns `Err` if the receiving side shuts down.
+if the thread holding the sender has shut down, similar to how the `send`
+method returns `Err` if the receiver shuts down.
 -->
 
 ミューテックスのロックを獲得できたら、`recv`を呼び出してチャンネルから`Job`を受け取ります。
-最後の`unwrap`もここであらゆるエラーを超えていき、これはチャンネルの送信側を保持するスレッドが閉じた場合に発生する可能性があり、
-受信側が閉じた場合に`send`メソッドが`Err`を返すのと似ています。
+最後の`unwrap`もここであらゆるエラーを超えていき、これはチャンネルの送信機を保持するスレッドが閉じた場合に発生する可能性があり、
+受信機が閉じた場合に`send`メソッドが`Err`を返すのと似ています。
 
 <!--
 The call to `recv` blocks, so if there is no job yet, the current thread will
@@ -1567,217 +1207,45 @@ wait until a job becomes available. The `Mutex<T>` ensures that only one
 `Mutex<T>`により、ただ1つの`Worker`スレッドのみが一度に仕事の要求を試みることを保証します。
 
 <!--
-Theoretically, this code should compile. Unfortunately, the Rust compiler isn’t
-perfect yet, and we get this error:
--->
-
-理論的には、このコードはコンパイルできるはずです。残念ながら、Rustコンパイラはまだ完全ではなく、
-このようなエラーが出ます:
-
-```text
-error[E0161]: cannot move a value of type std::ops::FnOnce() +
-std::marker::Send: the size of std::ops::FnOnce() + std::marker::Send cannot be
-statically determined
-(エラー: std::ops::FnOnce() + std::marker::Sendの値をムーブできません:
-std::ops::FnOnce() + std::marker::Sendのサイズを静的に決定できません)
-  --> src/lib.rs:63:17
-   |
-63 |                 (*job)();
-   |                 ^^^^^^
-```
-
-<!--
-This error is fairly cryptic because the problem is fairly cryptic. To call a
-`FnOnce` closure that is stored in a `Box<T>` (which is what our `Job` type
-alias is), the closure needs to move itself *out* of the `Box<T>` because the
-closure takes ownership of `self` when we call it. In general, Rust doesn’t
-allow us to move a value out of a `Box<T>` because Rust doesn’t know how big
-the value inside the `Box<T>` will be: recall in Chapter 15 that we used
-`Box<T>` precisely because we had something of an unknown size that we wanted
-to store in a `Box<T>` to get a value of a known size.
--->
-
-問題が非常に謎めいているので、エラーも非常に謎めいています。`Box<T>`に格納された`FnOnce`クロージャを呼び出すためには(`Job`型エイリアスがそう)、
-呼び出す際にクロージャが`self`の所有権を奪うので、
-クロージャは自身を`Box<T>`*から*ムーブする必要があります。一般的に、Rustは`Box<T>`から値をムーブすることを許可しません。
-コンパイラには、`Box<T>`の内側の値がどれほどの大きさなのか見当がつかないからです: 
-第15章で`Box<T>`に格納して既知のサイズの値を得たい未知のサイズの何かがあるために`Box<T>`を正確に使用したことを思い出してください。
-
-<!--
-As you saw in Listing 17-15, we can write methods that use the syntax `self:
-Box<Self>`, which allows the method to take ownership of a `Self` value stored
-in a `Box<T>`. That’s exactly what we want to do here, but unfortunately Rust
-won’t let us: the part of Rust that implements behavior when a closure is
-called isn’t implemented using `self: Box<Self>`. So Rust doesn’t yet
-understand that it could use `self: Box<Self>` in this situation to take
-ownership of the closure and move the closure out of the `Box<T>`.
--->
-
-リスト17-15で見かけたように、記法`self: Box<Self>`を使用するメソッドを書くことができ、
-これにより、メソッドは`Box<T>`に格納された`Self`値の所有権を奪うことができます。
-それがまさしくここで行いたいことですが、残念ながらコンパイラはさせてくれません:
-クロージャが呼び出された際に振る舞いを実装するRustの一部は、`self: Box<Self>`を使用して実装されていないのです。
-故に、コンパイラはまだこの場面において`self: Box<Self>`を使用してクロージャの所有権を奪い、
-クロージャを`Box<T>`からムーブできることを理解していないのです。
-
-<!--
-Rust is still a work in progress with places where the compiler could be
-improved, but in the future, the code in Listing 20-20 should work just fine.
-People just like you are working to fix this and other issues! After you’ve
-finished this book, we would love for you to join in.
--->
-
-Rustはまだコンパイラの改善途上にあり、リスト20-20のコードは、
-将来的にうまく動くようになるべきです。まさしくあなたのような方がこれや他の問題を修正しています！この本を完了したら、
-是非ともあなたにも参加していただきたいです。
-
-<!--
-But for now, let’s work around this problem using a handy trick. We can tell
-Rust explicitly that in this case we can take ownership of the value inside the
-`Box<T>` using `self: Box<Self>`; then, once we have ownership of the closure,
-we can call it. This involves defining a new trait `FnBox` with the method
-`call_box` that will use `self: Box<Self>` in its signature, defining `FnBox`
-for any type that implements `FnOnce()`, changing our type alias to use the new
-trait, and changing `Worker` to use the `call_box` method. These changes are
-shown in Listing 20-21.
--->
-
-ですがとりあえず、手頃なトリックを使ってこの問題を回避しましょう。この場合、`self: Box<Self>`で、
-`Box<T>`の内部の値の所有権を奪うことができることをコンパイラに明示的に教えてあげます;
-そして、一旦クロージャの所有権を得たら、呼び出せます。これには、
-シグニチャに`self: Box<Self>`を使用する`call_box`というメソッドのある新しいトレイト`FnBox`を定義すること、
-`FnOnce()`を実装する任意の型に対して`FnBox`を定義すること、型エイリアスを新しいトレイトを使用するように変更すること、
-`Worker`を`call_box`メソッドを使用するように変更することが関連します。これらの変更は、
-リスト20-21に表示されています。
-
-<!--
-<span class="filename">Filename: src/lib.rs</span>
--->
-
-<span class="filename">ファイル名: src/lib.rs</span>
-
-```rust,ignore
-trait FnBox {
-    fn call_box(self: Box<Self>);
-}
-
-impl<F: FnOnce()> FnBox for F {
-    fn call_box(self: Box<F>) {
-        (*self)()
-    }
-}
-
-type Job = Box<FnBox + Send + 'static>;
-
-// --snip--
-
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
-        let thread = thread::spawn(move || {
-            loop {
-                let job = receiver.lock().unwrap().recv().unwrap();
-
-                println!("Worker {} got a job; executing.", id);
-
-                job.call_box();
-            }
-        });
-
-        Worker {
-            id,
-            thread,
-        }
-    }
-}
-```
-
-<!--
-<span class="caption">Listing 20-21: Adding a new trait `FnBox` to work around
-the current limitations of `Box<FnOnce()>`</span>
--->
-
-<span class="caption">リスト20-21: 新しいトレイト`FnBox`を追加して`Box<FnOnce()>`の現在の制限を回避する</span>
-
-<!--
-First, we create a new trait named `FnBox`. This trait has the one method
-`call_box`, which is similar to the `call` methods on the other `Fn*` traits
-except that it takes `self: Box<Self>` to take ownership of `self` and move the
-value out of the `Box<T>`.
--->
-
-まず、`FnBox`という新しいトレイトを作成します。このトレイトには`call_box`という1つのメソッドがあり、
-これは、`self: Box<Self>`を取って`self`の所有権を奪い、`Box<T>`から値をムーブする点を除いて、
-他の`Fn*`トレイトの`call`メソッドと類似しています。
-
-<!--
-Next, we implement the `FnBox` trait for any type `F` that implements the
-`FnOnce()` trait. Effectively, this means that any `FnOnce()` closures can use
-our `call_box` method. The implementation of `call_box` uses `(*self)()` to
-move the closure out of the `Box<T>` and call the closure.
--->
-
-次に、`FnOnce()`トレイトを実装する任意の型`F`に対して`FnBox`トレイトを実装します。実質的にこれは、
-あらゆる`FnOnce()`クロージャが`call_box`メソッドを使用できることを意味します。`call_box`の実装は、
-`(*self)()`を使用して`Box<T>`からクロージャをムーブし、クロージャを呼び出します。
-
-<!--
-We now need our `Job` type alias to be a `Box` of anything that implements our
-new trait `FnBox`. This will allow us to use `call_box` in `Worker` when we get
-a `Job` value instead of invoking the closure directly. Implementing the
-`FnBox` trait for any `FnOnce()` closure means we don’t have to change anything
-about the actual values we’re sending down the channel. Now Rust is able to
-recognize that what we want to do is fine.
--->
-
-これで`Job`型エイリアスには、新しいトレイトの`FnBox`を実装する何かの`Box`である必要が出てきました。
-これにより、クロージャを直接呼び出す代わりに`Job`値を得た時に`Worker`の`call_box`を使えます。
-任意の`FnOnce()`クロージャに対して`FnBox`トレイトを実装することは、チャンネルに送信する実際の値は何も変えなくてもいいことを意味します。
-もうコンパイラは、我々が行おうとしていることが平気なことであると認識できます。
-
-<!--
-This trick is very sneaky and complicated. Don’t worry if it doesn’t make
-perfect sense; someday, it will be completely unnecessary.
+Our thread pool is now in a working state! Give it a `cargo run` and make some
+requests:
 -->
 
-このトリックは非常にこそこそしていて複雑です。完璧に筋が通らなくても心配しないでください;
-いつの日か、完全に不要になるでしょう。
+これで私たちのスレッドプールは動作する状態になりました！
+`cargo run`して、リクエストを送ってみてください:
 
-<!--
-With the implementation of this trick, our thread pool is in a working state!
-Give it a `cargo run`, and make some requests:
+<!-- manual-regeneration
+cd listings/ch20-web-server/listing-20-20
+cargo run
+make some requests to 127.0.0.1:7878
+Can't automate because the output depends on making requests
 -->
 
-このトリックの実装で、スレッドプールは動く状態になります！`cargo run`を実行し、
-リクエストを行なってください:
-
-```text
+```console
 $ cargo run
    Compiling hello v0.1.0 (file:///projects/hello)
-warning: field is never used: `workers`
+warning: field is never read: `workers`
  --> src/lib.rs:7:5
   |
 7 |     workers: Vec<Worker>,
   |     ^^^^^^^^^^^^^^^^^^^^
   |
-  = note: #[warn(dead_code)] on by default
+  = note: `#[warn(dead_code)]` on by default
 
-warning: field is never used: `id`
-  --> src/lib.rs:61:5
+warning: field is never read: `id`
+  --> src/lib.rs:48:5
    |
-61 |     id: usize,
+48 |     id: usize,
    |     ^^^^^^^^^
-   |
-   = note: #[warn(dead_code)] on by default
 
-warning: field is never used: `thread`
-  --> src/lib.rs:62:5
+warning: field is never read: `thread`
+  --> src/lib.rs:49:5
    |
-62 |     thread: thread::JoinHandle<()>,
+49 |     thread: thread::JoinHandle<()>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: #[warn(dead_code)] on by default
 
-    Finished dev [unoptimized + debuginfo] target(s) in 0.99 secs
+warning: `hello` (lib) generated 3 warnings
+    Finished dev [unoptimized + debuginfo] target(s) in 1.40s
      Running `target/debug/hello`
 Worker 0 got a job; executing.
 Worker 2 got a job; executing.
@@ -1803,12 +1271,23 @@ thread run them.
 サーバが多くのリクエストを受け取っても、システムは過負荷にならないでしょう。*/sleep*にリクエストを行なっても、
 サーバは他のスレッドに実行させることで他のリクエストを提供できるでしょう。
 
+<!--
+> Note: if you open */sleep* in multiple browser windows simultaneously, they
+> might load one at a time in 5 second intervals. Some web browsers execute
+> multiple instances of the same request sequentially for caching reasons. This
+> limitation is not caused by our web server.
+-->
+
+> 注釈: */sleep* を複数のブラウザウィンドウで同時に開くと、5秒間隔でひとつずつロードするかもしれません。
+> webブラウザによっては、キャッシュのために、複数の同一リクエストを逐次的に実行します。
+> この制限は私たちのwebサーバによって引き起こされているものではありません。
+
 <!--
 After learning about the `while let` loop in Chapter 18, you might be wondering
-why we didn’t write the worker thread code as shown in Listing 20-22.
+why we didn’t write the worker thread code as shown in Listing 20-21.
 -->
 
-第18章で`while let`ループを学んだ後で、なぜリスト20-22に示したようにワーカースレッドのコードを記述しなかったのか、
+第18章で`while let`ループを学んだ後で、なぜリスト20-21に示したようにワーカースレッドのコードを記述しなかったのか、
 不思議に思っている可能性があります。
 
 <!--
@@ -1817,33 +1296,16 @@ why we didn’t write the worker thread code as shown in Listing 20-22.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-// --snip--
-
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
-        let thread = thread::spawn(move || {
-            while let Ok(job) = receiver.lock().unwrap().recv() {
-                println!("Worker {} got a job; executing.", id);
-
-                job.call_box();
-            }
-        });
-
-        Worker {
-            id,
-            thread,
-        }
-    }
-}
+```rust,ignore,not_desired_behavior
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-21/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-22: An alternative implementation of
+<span class="caption">Listing 20-21: An alternative implementation of
 `Worker::new` using `while let`</span>
 -->
 
-<span class="caption">リスト20-22: `while let`を使用したもう1つの`Worker::new`の実装</span>
+<span class="caption">リスト20-21: `while let`を使用したもう1つの`Worker::new`の実装</span>
 
 <!--
 This code compiles and runs but doesn’t result in the desired threading
@@ -1853,11 +1315,9 @@ processed. The reason is somewhat subtle: the `Mutex` struct has no public
 the `MutexGuard<T>` within the `LockResult<MutexGuard<T>>` that the `lock`
 method returns. At compile time, the borrow checker can then enforce the rule
 that a resource guarded by a `Mutex` cannot be accessed unless we hold the
-lock. But this implementation can also result in the lock being held longer
-than intended if we don’t think carefully about the lifetime of the
-`MutexGuard<T>`. Because the values in the `while` expression remain in scope
-for the duration of the block, the lock remains held for the duration of the
-call to `job.call_box()`, meaning other workers cannot receive jobs.
+lock. However, this implementation can also result in the lock being held
+longer than intended if we aren’t mindful of the lifetime of the
+`MutexGuard<T>`.
 -->
 
 このコードはコンパイルでき、動きますが、望み通りのスレッドの振る舞いにはなりません:
@@ -1865,19 +1325,39 @@ call to `job.call_box()`, meaning other workers cannot receive jobs.
 `Mutex`構造体には公開の`unlock`メソッドがありません。ロックの所有権が、
 `lock`メソッドが返す`LockResult<MutexGuard<T>>`内の`MutexGuard<T>`のライフタイムに基づくからです。
 コンパイル時には、ロックを保持していない限り、借用チェッカーはそうしたら、`Mutex`に保護されるリソースにはアクセスできないという規則を強制できます。
-しかし、この実装は、`MutexGuard<T>`のライフタイムについて熟考しなければ、
-意図したよりもロックが長い間保持される結果になり得ます。`while`式の値がブロックの間中スコープに残り続けるので、
-ロックは`job.call_box`の呼び出し中保持されたままになり、つまり、他のワーカーが仕事を受け取れなくなるのです。
-
-<!--
-By using `loop` instead and acquiring the lock and a job within the block
-rather than outside it, the `MutexGuard` returned from the `lock` method is
-dropped as soon as the `let job` statement ends. This ensures that the lock is
-held during the call to `recv`, but it is released before the call to
-`job.call_box()`, allowing multiple requests to be serviced concurrently.
--->
-
-代わりに`loop`を使用し、ロックと仕事をブロックの外ではなく、内側で獲得することで、
-`lock`メソッドが返す`MutexGuard`は`let job`文が終わると同時にドロップされます。
-これにより、複数のリクエストを並行で提供し、ロックは`recv`の呼び出しの間は保持されるけれども、
-`job.call_box`の呼び出しの前には解放されることを保証します。
+しかし、この実装は、`MutexGuard<T>`のライフタイムを心に留めなければ、
+意図したよりもロックが長い間保持される結果になり得ます。
+
+<!--
+The code in Listing 20-20 that uses `let job =
+receiver.lock().unwrap().recv().unwrap();` works because with `let`, any
+temporary values used in the expression on the right hand side of the equals
+sign are immediately dropped when the `let` statement ends. However, `while
+let` (and `if let` and `match`) does not drop temporary values until the end of
+the associated block. In Listing 20-21, the lock remains held for the duration
+of the call to `job()`, meaning other workers cannot receive jobs.
+-->
+
+`let job = receiver.lock().unwrap().recv().unwrap();`を使用するリスト20-20のコードは、機能します。
+`let`を使用する場合、等号の右辺の式内で使用される任意の一時値は、`let`文の終わりの直後にドロップされるからです。
+しかしながら、`while let`(と`if let`と`match`)は、関連するブロックの終わりまで一時値をドロップしません。
+リスト20-21では、`job()`への呼び出しの間ロックは保持されたままになり、
+他のワーカーがジョブを受信できないことになります。
+
+<!--
+[creating-type-synonyms-with-type-aliases]:
+ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases
+[integer-types]: ch03-02-data-types.html#integer-types
+[fn-traits]:
+ch13-01-closures.html#moving-captured-values-out-of-the-closure-and-the-fn-traits
+[builder]: ../std/thread/struct.Builder.html
+[builder-spawn]: ../std/thread/struct.Builder.html#method.spawn
+-->
+
+[creating-type-synonyms-with-type-aliases]:
+ch19-04-advanced-types.html#型エイリアスで型同義語を生成する
+[integer-types]: ch03-02-data-types.html#整数型
+[fn-traits]:
+ch13-01-closures.html#キャプチャされた値のクロージャからのムーブとfn系トレイト
+[builder]: https://doc.rust-lang.org/std/thread/struct.Builder.html
+[builder-spawn]: https://doc.rust-lang.org/std/thread/struct.Builder.html#method.spawn
diff --git a/src/ch20-03-graceful-shutdown-and-cleanup.md b/src/ch20-03-graceful-shutdown-and-cleanup.md
index cdadd2c99..75912cb35 100644
--- a/src/ch20-03-graceful-shutdown-and-cleanup.md
+++ b/src/ch20-03-graceful-shutdown-and-cleanup.md
@@ -5,7 +5,7 @@
 ## 正常なシャットダウンと片付け
 
 <!--
-The code in Listing 20-21 is responding to requests asynchronously through the
+The code in Listing 20-20 is responding to requests asynchronously through the
 use of a thread pool, as we intended. We get some warnings about the `workers`,
 `id`, and `thread` fields that we’re not using in a direct way that reminds us
 we’re not cleaning up anything. When we use the less elegant <span
@@ -14,20 +14,21 @@ threads are stopped immediately as well, even if they’re in the middle of
 serving a request.
 -->
 
-リスト20-21のコードは、意図した通り、スレッドプールの使用を通してリクエストに非同期に応答できます。
+リスト20-20のコードは、意図した通り、スレッドプールの使用を通してリクエストに非同期に応答できます。
 直接使用していない`workers`、`id`、`thread`フィールドについて警告が出ます。この警告は、現在のコードは何も片付けていないことを思い出させてくれます。
 優美さに欠ける<span class="keystroke">ctrl-c</span>を使用してメインスレッドを停止させる方法を使用すると、
 リクエストの処理中であっても、他のスレッドも停止します。
 
 <!--
-Now we’ll implement the `Drop` trait to call `join` on each of the threads in
-the pool so they can finish the requests they’re working on before closing.
-Then we’ll implement a way to tell the threads they should stop accepting new
-requests and shut down. To see this code in action, we’ll modify our server to
-accept only two requests before gracefully shutting down its thread pool.
+Next, then, we’ll implement the `Drop` trait to call `join` on each of the
+threads in the pool so they can finish the requests they’re working on before
+closing. Then we’ll implement a way to tell the threads they should stop
+accepting new requests and shut down. To see this code in action, we’ll modify
+our server to accept only two requests before gracefully shutting down its
+thread pool.
 -->
 
-では、閉じる前に取り掛かっているリクエストを完了できるように、プールの各スレッドに対して`join`を呼び出す`Drop`トレイトを実装します。
+では次に、閉じる前に取り掛かっているリクエストを完了できるように、プールの各スレッドに対して`join`を呼び出す`Drop`トレイトを実装します。
 そして、スレッドに新しいリクエストの受付を停止し、終了するように教える方法を実装します。
 このコードが動いているのを確かめるために、サーバを変更して正常にスレッドプールを終了する前に2つしかリクエストを受け付けないようにします。
 
@@ -40,12 +41,12 @@ accept only two requests before gracefully shutting down its thread pool.
 <!--
 Let’s start with implementing `Drop` on our thread pool. When the pool is
 dropped, our threads should all join to make sure they finish their work.
-Listing 20-23 shows a first attempt at a `Drop` implementation; this code won’t
+Listing 20-22 shows a first attempt at a `Drop` implementation; this code won’t
 quite work yet.
 -->
 
 スレッドプールに`Drop`を実装するところから始めましょう。プールがドロップされると、
-スレッドは全てjoinして、作業を完了するのを確かめるべきです。リスト20-23は、`Drop`実装の最初の試みを表示しています;
+スレッドは全てjoinして、作業を完了するのを確かめるべきです。リスト20-22は、`Drop`実装の最初の試みを表示しています;
 このコードはまだ完全には動きません。
 
 <!--
@@ -54,25 +55,16 @@ quite work yet.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-impl Drop for ThreadPool {
-    fn drop(&mut self) {
-        for worker in &mut self.workers {
-            // ワーカー{}を終了します
-            println!("Shutting down worker {}", worker.id);
-
-            worker.thread.join().unwrap();
-        }
-    }
-}
+```rust,ignore,does_not_compile
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-22/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-23: Joining each thread when the thread pool
+<span class="caption">Listing 20-22: Joining each thread when the thread pool
 goes out of scope</span>
 -->
 
-<span class="caption">リスト20-23: スレッドプールがスコープを抜けた時にスレッドをjoinさせる</span>
+<span class="caption">リスト20-22: スレッドプールがスコープを抜けた時にスレッドをjoinさせる</span>
 
 <!--
 First, we loop through each of the thread pool `workers`. We use `&mut` for
@@ -94,12 +86,8 @@ Here is the error we get when we compile this code:
 
 こちらが、このコードをコンパイルする際に出るエラーです:
 
-```text
-error[E0507]: cannot move out of borrowed content
-  --> src/lib.rs:65:13
-   |
-65 |             worker.thread.join().unwrap();
-   |             ^^^^^^ cannot move out of borrowed content
+```console
+{{#include ../listings/ch20-web-server/listing-20-22/output.txt}}
 ```
 
 <!--
@@ -107,11 +95,11 @@ The error tells us we can’t call `join` because we only have a mutable borrow
 of each `worker` and `join` takes ownership of its argument. To solve this
 issue, we need to move the thread out of the `Worker` instance that owns
 `thread` so `join` can consume the thread. We did this in Listing 17-15: if
-`Worker` holds an `Option<thread::JoinHandle<()>` instead, we can call the
+`Worker` holds an `Option<thread::JoinHandle<()>>` instead, we can call the
 `take` method on the `Option` to move the value out of the `Some` variant and
 leave a `None` variant in its place. In other words, a `Worker` that is running
 will have a `Some` variant in `thread`, and when we want to clean up a
-`Worker` we’ll replace `Some` with `None` so the worker doesn’t have a
+`Worker`, we’ll replace `Some` with `None` so the `Worker` doesn’t have a
 thread to run.
 -->
 
@@ -120,7 +108,7 @@ thread to run.
 これをリスト17-15では行いました: `Worker`が代わりに`Option<thread::JoinHandle<()>>`を保持していれば、
 `Option`に対して`take`メソッドを呼び出し、`Some`列挙子から値をムーブし、その場所に`None`列挙子を残すことができます。
 言い換えれば、実行中の`Worker`には`thread`に`Some`列挙子があり、`Worker`を片付けたい時には、
-ワーカーが実行するスレッドがないように`Some`を`None`で置き換えるのです。
+`Worker`が実行するスレッドがないように`Some`を`None`で置き換えるのです。
 
 <!--
 So we know we want to update the definition of `Worker` like this:
@@ -134,12 +122,8 @@ So we know we want to update the definition of `Worker` like this:
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-# use std::thread;
-struct Worker {
-    id: usize,
-    thread: Option<thread::JoinHandle<()>>,
-}
+```rust,ignore,does_not_compile
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-04-update-worker-definition/src/lib.rs:here}}
 ```
 
 <!--
@@ -150,26 +134,8 @@ Checking this code, we get two errors:
 さて、コンパイラを頼りにして他に変更する必要がある箇所を探しましょう。このコードをチェックすると、
 2つのエラーが出ます:
 
-```text
-error[E0599]: no method named `join` found for type
-`std::option::Option<std::thread::JoinHandle<()>>` in the current scope
-  --> src/lib.rs:65:27
-   |
-65 |             worker.thread.join().unwrap();
-   |                           ^^^^
-
-error[E0308]: mismatched types
-  --> src/lib.rs:89:13
-   |
-89 |             thread,
-   |             ^^^^^^
-   |             |
-   |             expected enum `std::option::Option`, found struct
-   `std::thread::JoinHandle`
-   |             help: try using a variant of the expected type: `Some(thread)`
-   |
-   = note: expected type `std::option::Option<std::thread::JoinHandle<()>>`
-              found type `std::thread::JoinHandle<_>`
+```console
+{{#include ../listings/ch20-web-server/no-listing-04-update-worker-definition/output.txt}}
 ```
 
 <!--
@@ -187,17 +153,8 @@ new `Worker`. Make the following changes to fix this error:
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
-        // --snip--
-
-        Worker {
-            id,
-            thread: Some(thread),
-        }
-    }
-}
+```rust,ignore,does_not_compile
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-05-fix-worker-new/src/lib.rs:here}}
 ```
 
 <!--
@@ -215,18 +172,8 @@ The following changes will do so:
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-impl Drop for ThreadPool {
-    fn drop(&mut self) {
-        for worker in &mut self.workers {
-            println!("Shutting down worker {}", worker.id);
-
-            if let Some(thread) = worker.thread.take() {
-                thread.join().unwrap();
-            }
-        }
-    }
-}
+```rust,ignore,not_desired_behavior
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-06-fix-threadpool-drop/src/lib.rs:here}}
 ```
 
 <!--
@@ -249,13 +196,13 @@ cleaned up, so nothing happens in that case.
 ### スレッドに仕事をリッスンするのを止めるよう通知する
 
 <!--
-With all the changes we’ve made, our code compiles without any warnings. But
-the bad news is this code doesn’t function the way we want it to yet. The key
-is the logic in the closures run by the threads of the `Worker` instances: at
-the moment, we call `join`, but that won’t shut down the threads because they
-`loop` forever looking for jobs. If we try to drop our `ThreadPool` with our
-current implementation of `drop`, the main thread will block forever waiting
-for the first thread to finish.
+With all the changes we’ve made, our code compiles without any warnings.
+However, the bad news is this code doesn’t function the way we want it to yet.
+The key is the logic in the closures run by the threads of the `Worker`
+instances: at the moment, we call `join`, but that won’t shut down the threads
+because they `loop` forever looking for jobs. If we try to drop our
+`ThreadPool` with our current implementation of `drop`, the main thread will
+block forever waiting for the first thread to finish.
 -->
 
 これらの変更によって、コードは警告なしでコンパイルできます。ですが悪い知らせは、このコードが期待したようにはまだ機能しないことです。
@@ -264,44 +211,26 @@ for the first thread to finish.
 最初のスレッドが完了するのを待機してメインスレッドは永遠にブロックされるでしょう。
 
 <!--
-To fix this problem, we’ll modify the threads so they listen for either a `Job`
-to run or a signal that they should stop listening and exit the infinite loop.
-Instead of `Job` instances, our channel will send one of these two enum
-variants.
--->
-
-この問題を修正するには、スレッドが、実行すべき`Job`か、リッスンをやめて無限ループを抜ける通知をリッスンするように、
-変更します。`Job`インスタンスの代わりに、チャンネルはこれら2つのenum列挙子の一方を送信します。
-
-<!--
-<span class="filename">Filename: src/lib.rs</span>
--->
-
-<span class="filename">ファイル名: src/lib.rs</span>
-
-```rust
-# struct Job;
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
-```
-
-<!--
-This `Message` enum will either be a `NewJob` variant that holds the `Job` the
-thread should run, or it will be a `Terminate` variant that will cause the
-thread to exit its loop and stop.
+To fix this problem, we’ll need a change in the `ThreadPool` `drop`
+implementation and then a change in the `Worker` loop.
 -->
 
-この`Message` enumはスレッドが実行すべき`Job`を保持する`NewJob`列挙子か、スレッドをループから抜けさせ、
-停止させる`Terminate`列挙子のどちらかになります。
+この問題を修正するためには、`ThreadPool`の`drop`実装に対して変更を加え、
+その後`Worker`ループに対して変更を加える必要があるでしょう。
 
 <!--
-We need to adjust the channel to use values of type `Message` rather than type
-`Job`, as shown in Listing 20-24.
+First, we’ll change the `ThreadPool` `drop` implementation to explicitly drop
+the `sender` before waiting for the threads to finish. Listing 20-23 shows the
+changes to `ThreadPool` to explicitly drop `sender`. We use the same `Option`
+and `take` technique as we did with the thread to be able to move `sender` out
+of `ThreadPool`:
 -->
 
-チャンネルを調整し、型`Job`ではなく、型`Message`を使用するようにする必要があります。リスト20-24のようにですね。
+まず、スレッドが完了するのを待つ前に明示的に`sender`をドロップするように、
+`ThreadPool`の`drop`実装を変更します。リスト20-23は
+明示的に`sender`をドロップするような`ThreadPool`に対する変更を示しています。
+`ThreadPool`から`sender`をムーブできるようにするために、
+スレッドで使ったのと同じ`Option`と`take`のテクニックを使用します:
 
 <!--
 <span class="filename">Filename: src/lib.rs</span>
@@ -309,94 +238,29 @@ We need to adjust the channel to use values of type `Message` rather than type
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-pub struct ThreadPool {
-    workers: Vec<Worker>,
-    sender: mpsc::Sender<Message>,
-}
-
-// --snip--
-
-impl ThreadPool {
-    // --snip--
-
-    pub fn execute<F>(&self, f: F)
-        where
-            F: FnOnce() + Send + 'static
-    {
-        let job = Box::new(f);
-
-        self.sender.send(Message::NewJob(job)).unwrap();
-    }
-}
-
-// --snip--
-
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) ->
-        Worker {
-
-        let thread = thread::spawn(move ||{
-            loop {
-                let message = receiver.lock().unwrap().recv().unwrap();
-
-                match message {
-                    Message::NewJob(job) => {
-                        println!("Worker {} got a job; executing.", id);
-
-                        job.call_box();
-                    },
-                    Message::Terminate => {
-                        // ワーカー{}は停止するよう指示された
-                        println!("Worker {} was told to terminate.", id);
-
-                        break;
-                    },
-                }
-            }
-        });
-
-        Worker {
-            id,
-            thread: Some(thread),
-        }
-    }
-}
+```rust,noplayground,not_desired_behavior
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-23/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-24: Sending and receiving `Message` values and
-exiting the loop if a `Worker` receives `Message::Terminate`</span>
--->
-
-<span class="caption">リスト20-24: `Message`値を送受信し、`Worker`が`Message::Terminate`を受け取ったら、ループを抜ける</span>
-
-<!--
-To incorporate the `Message` enum, we need to change `Job` to `Message` in two
-places: the definition of `ThreadPool` and the signature of `Worker::new`. The
-`execute` method of `ThreadPool` needs to send jobs wrapped in the
-`Message::NewJob` variant. Then, in `Worker::new` where a `Message` is received
-from the channel, the job will be processed if the `NewJob` variant is
-received, and the thread will break out of the loop if the `Terminate` variant
-is received.
+<span class="caption">Listing 20-23: Explicitly drop `sender` before joining
+the worker threads</span>
 -->
 
-`Message` enumを具体化するために、2箇所で`Job`を`Message`に変更する必要があります:
-`ThreadPool`の定義と`Worker::new`のシグニチャです。`ThreadPool`の`execute`メソッドは、
-仕事を`Message::NewJob`列挙子に包んで送信する必要があります。それから、
-`Message`がチャンネルから受け取られる`Worker::new`で、`NewJob`列挙子が受け取られたら、
-仕事が処理され、`Terminate`列挙子が受け取られたら、スレッドはループを抜けます。
+<span class="caption">リスト20-23: ワーカースレッドをjoinする前に明示的に`sender`をドロップする</span>
 
 <!--
-With these changes, the code will compile and continue to function in the same
-way as it did after Listing 20-21. But we’ll get a warning because we aren’t
-creating any messages of the `Terminate` variety. Let’s fix this warning by
-changing our `Drop` implementation to look like Listing 20-25.
+Dropping `sender` closes the channel, which indicates no more messages will be
+sent. When that happens, all the calls to `recv` that the workers do in the
+infinite loop will return an error. In Listing 20-24, we change the `Worker`
+loop to gracefully exit the loop in that case, which means the threads will
+finish when the `ThreadPool` `drop` implementation calls `join` on them.
 -->
 
-これらの変更と共に、コードはコンパイルでき、リスト20-21の後と同じように機能し続けます。ですが、
-`Terminate`のメッセージを何も生成していないので、警告が出るでしょう。
-`Drop`実装をリスト20-25のような見た目に変更してこの警告を修正しましょう。
+`sender`をドロップすると、チャンネルは閉じられ、それ以上メッセージが送られないことを示します。
+これが発生すると、ワーカーが無限ループ内で行うすべての`recv`への呼び出しは失敗し、エラーを返すでしょう。
+リスト20-24では、そのような場合に正常にループを脱出するように`Worker`ループを変更します。
+正常とは、`ThreadPool`の`drop`実装がスレッドに対して`join`を呼び出すときに、スレッドが完了するようにします。
 
 <!--
 <span class="filename">Filename: src/lib.rs</span>
@@ -404,117 +268,41 @@ changing our `Drop` implementation to look like Listing 20-25.
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust,ignore
-impl Drop for ThreadPool {
-    fn drop(&mut self) {
-        println!("Sending terminate message to all workers.");
-
-        for _ in &mut self.workers {
-            self.sender.send(Message::Terminate).unwrap();
-        }
-
-        // 全ワーカーを閉じます
-        println!("Shutting down all workers.");
-
-        for worker in &mut self.workers {
-            // ワーカー{}を閉じます
-            println!("Shutting down worker {}", worker.id);
-
-            if let Some(thread) = worker.thread.take() {
-                thread.join().unwrap();
-            }
-        }
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-24/src/lib.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-25: Sending `Message::Terminate` to the
-workers before calling `join` on each worker thread</span>
--->
-
-<span class="caption">リスト20-25: 各ワーカースレッドに対して`join`を呼び出す前にワーカーに`Message::Terminate`を送信する</span>
-
-<!--
-We’re now iterating over the workers twice: once to send one `Terminate`
-message for each worker and once to call `join` on each worker’s thread. If we
-tried to send a message and `join` immediately in the same loop, we couldn’t
-guarantee that the worker in the current iteration would be the one to get the
-message from the channel.
--->
-
-今では、ワーカーを2回走査しています: 各ワーカーに`Terminate`メッセージを送信するために1回と、
-各ワーカースレッドに`join`を呼び出すために1回です。メッセージ送信と`join`を同じループで即座に行おうとすると、
-現在の繰り返しのワーカーがチャンネルからメッセージを受け取っているものであるか保証できなくなってしまいます。
-
-<!--
-To better understand why we need two separate loops, imagine a scenario with
-two workers. If we used a single loop to iterate through each worker, on the
-first iteration a terminate message would be sent down the channel and `join`
-called on the first worker’s thread. If that first worker was busy processing a
-request at that moment, the second worker would pick up the terminate message
-from the channel and shut down. We would be left waiting on the first worker to
-shut down, but it never would because the second thread picked up the terminate
-message. Deadlock!
--->
-
-2つの個別のループが必要な理由をよりよく理解するために、2つのワーカーがある筋書きを想像してください。
-単独のループで各ワーカーを走査すると、最初の繰り返しでチャンネルに停止メッセージが送信され、
-`join`が最初のワーカースレッドで呼び出されます。その最初のワーカーが現在、リクエストの処理で忙しければ、
-2番目のワーカーがチャンネルから停止メッセージを受け取り、閉じます。最初のワーカーの終了待ちをしたままですが、
-2番目のスレッドが停止メッセージを拾ってしまったので、終了することは絶対にありません。デッドロックです！
-
-<!--
-To prevent this scenario, we first put all of our `Terminate` messages on the
-channel in one loop; then we join on all the threads in another loop. Each
-worker will stop receiving requests on the channel once it gets a terminate
-message. So, we can be sure that if we send the same number of terminate
-messages as there are workers, each worker will receive a terminate message
-before `join` is called on its thread.
+<span class="caption">Listing 20-24: Explicitly break out of the loop when
+`recv` returns an error</span>
 -->
 
-この筋書きを回避するために、1つのループでまず、チャンネルに対して全ての`Terminate`メッセージを送信します;
-そして、別のループで全スレッドのjoinを待ちます。一旦停止メッセージを受け取ったら、各ワーカーはチャンネルからのリクエストの受付をやめます。
-故に、存在するワーカーと同じ数だけ停止メッセージを送れば、`join`がスレッドに対して呼び出される前に、
-停止メッセージを各ワーカーが受け取ると確信できるわけです。
+<span class="caption">リスト20-24: `recv`がエラーを返したときに明示的にループを抜ける</span>
 
 <!--
 To see this code in action, let’s modify `main` to accept only two requests
-before gracefully shutting down the server, as shown in Listing 20-26.
+before gracefully shutting down the server, as shown in Listing 20-25.
 -->
 
 このコードが動いているところを確認するために、`main`を変更してサーバを正常に閉じる前に2つしかリクエストを受け付けないようにしましょう。
-リスト20-26のようにですね。
+リスト20-25のようにですね。
 
 <!--
-<span class="filename">Filename: src/bin/main.rs</span>
+<span class="filename">Filename: src/main.rs</span>
 -->
 
-<span class="filename">ファイル名: src/bin/main.rs</span>
+<span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,ignore
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming().take(2) {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-
-    println!("Shutting down.");
-}
+{{#rustdoc_include ../listings/ch20-web-server/listing-20-25/src/main.rs:here}}
 ```
 
 <!--
-<span class="caption">Listing 20-26: Shut down the server after serving two
+<span class="caption">Listing 20-25: Shut down the server after serving two
 requests by exiting the loop</span>
 -->
 
-<span class="caption">リスト20-26: ループを抜けることで、2つのリクエストを処理した後にサーバを閉じる</span>
+<span class="caption">リスト20-25: ループを抜けることで、2つのリクエストを処理した後にサーバを閉じる</span>
 
 <!--
 You wouldn’t want a real-world web server to shut down after serving only two
@@ -542,21 +330,30 @@ should error, and in your terminal you should see output similar to this:
 `cargo run`でサーバを開始し、3つリクエストを行なってください。3番目のリクエストはエラーになるはずで、
 端末にはこのような出力が目撃できるはずです:
 
-```text
+<!-- manual-regeneration
+cd listings/ch20-web-server/listing-20-25
+cargo run
+curl http://127.0.0.1:7878
+curl http://127.0.0.1:7878
+curl http://127.0.0.1:7878
+third request will error because server will have shut down
+copy output below
+Can't automate because the output depends on making requests
+-->
+
+```console
 $ cargo run
    Compiling hello v0.1.0 (file:///projects/hello)
-    Finished dev [unoptimized + debuginfo] target(s) in 1.0 secs
+    Finished dev [unoptimized + debuginfo] target(s) in 1.0s
      Running `target/debug/hello`
 Worker 0 got a job; executing.
-Worker 3 got a job; executing.
 Shutting down.
-Sending terminate message to all workers.
-Shutting down all workers.
 Shutting down worker 0
-Worker 1 was told to terminate.
-Worker 2 was told to terminate.
-Worker 0 was told to terminate.
-Worker 3 was told to terminate.
+Worker 3 got a job; executing.
+Worker 1 disconnected; shutting down.
+Worker 2 disconnected; shutting down.
+Worker 3 disconnected; shutting down.
+Worker 0 disconnected; shutting down.
 Shutting down worker 1
 Shutting down worker 2
 Shutting down worker 3
@@ -565,34 +362,35 @@ Shutting down worker 3
 <!--
 You might see a different ordering of workers and messages printed. We can see
 how this code works from the messages: workers 0 and 3 got the first two
-requests, and then on the third request, the server stopped accepting
-connections. When the `ThreadPool` goes out of scope at the end of `main`, its
-`Drop` implementation kicks in, and the pool tells all workers to terminate.
-The workers each print a message when they see the terminate message, and then
-the thread pool calls `join` to shut down each worker thread.
+requests. The server stopped accepting connections after the second connection,
+and the `Drop` implementation on `ThreadPool` starts executing before worker 3
+even starts its job. Dropping the `sender` disconnects all the workers and
+tells them to shut down. The workers each print a message when they disconnect,
+and then the thread pool calls `join` to wait for each worker thread to finish.
 -->
 
 ワーカーとメッセージの順番は異なる可能性があります。どうやってこのコードが動くのかメッセージからわかります:
-ワーカー0と3が最初の2つのリクエストを受け付け、そして3番目のリクエストではサーバは接続の受け入れをやめます。
-`main`の最後で`ThreadPool`がスコープを抜ける際、`Drop`実装が割り込み、プールが全ワーカーに停止するよう指示します。
-ワーカーはそれぞれ、停止メッセージを確認した時にメッセージを出力し、それからスレッドプールは各ワーカースレッドを閉じる`join`を呼び出します。
+ワーカー0と3が最初の2つのリクエストを受け付けます。
+2回目の接続の後は、サーバは接続を受け付けるのをやめ、ワーカー3がジョブを開始する前に`ThreadPool`の`Drop`実装が実行を開始します。
+`sender`をドロップするとすべてのワーカーは切断され、それらに停止するように指示します。
+ワーカーはそれぞれ切断された時にメッセージを出力し、それからスレッドプールは各ワーカースレッドが完了するのを待つために`join`を呼び出します。
 
 <!--
 Notice one interesting aspect of this particular execution: the `ThreadPool`
-sent the terminate messages down the channel, and before any worker received
-the messages, we tried to join worker 0. Worker 0 had not yet received the
-terminate message, so the main thread blocked waiting for worker 0 to finish.
-In the meantime, each of the workers received the termination messages. When
-worker 0 finished, the main thread waited for the rest of the workers to
-finish. At that point, they had all received the termination message and were
-able to shut down.
+dropped the `sender`, and before any worker received an error, we tried to join
+worker 0. Worker 0 had not yet gotten an error from `recv`, so the main thread
+blocked waiting for worker 0 to finish. In the meantime, worker 3 received a
+job and then all threads received an error. When worker 0 finished, the main
+thread waited for the rest of the workers to finish. At that point, they had
+all exited their loops and stopped.
 -->
 
-この特定の実行のある面白い側面に注目してください: `ThreadPool`はチャンネルに停止メッセージを送信しますが、
-どのワーカーがそのメッセージを受け取るよりも前に、ワーカー0のjoinを試みています。ワーカー0はまだ停止メッセージを受け取っていなかったので、
-メインスレッドはワーカー0が完了するまで待機してブロックされます。その間に、各ワーカーは停止メッセージを受け取ります。
-ワーカー0が完了したら、メインスレッドは残りのワーカーが完了するのを待機します。その時点で全ワーカーは停止メッセージを受け取った後で、
-閉じることができたのです。
+この特定の実行のある面白い側面に注目してください: `ThreadPool`は`sender`をドロップしますが、
+どのワーカーがそのエラーを受け取るよりも前に、ワーカー0のjoinを試みています。ワーカー0はまだ`recv`からエラーを受け取っていなかったので、
+メインスレッドはワーカー0が完了するまで待機してブロックされます。その間に、ワーカー3はジョブを受け取り、
+その後すべてのスレッドはエラーを受け取ります。
+ワーカー0が完了したら、メインスレッドは残りのワーカーが完了するのを待機します。
+その時点で全ワーカーはループを脱出し、停止したのです。
 
 <!--
 Congrats! We’ve now completed our project; we have a basic web server that uses
@@ -610,64 +408,13 @@ Here’s the full code for reference:
 参考までに、こちらが全コードです:
 
 <!--
-<span class="filename">Filename: src/bin/main.rs</span>
+<span class="filename">Filename: src/main.rs</span>
 -->
 
-<span class="filename">ファイル名: src/bin/main.rs</span>
+<span class="filename">ファイル名: src/main.rs</span>
 
 ```rust,ignore
-extern crate hello;
-use hello::ThreadPool;
-
-use std::io::prelude::*;
-use std::net::TcpListener;
-use std::net::TcpStream;
-use std::fs::File;
-use std::thread;
-use std::time::Duration;
-
-fn main() {
-    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4);
-
-    for stream in listener.incoming().take(2) {
-        let stream = stream.unwrap();
-
-        pool.execute(|| {
-            handle_connection(stream);
-        });
-    }
-
-    // 閉じます
-    println!("Shutting down.");
-}
-
-fn handle_connection(mut stream: TcpStream) {
-    let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
-
-    let get = b"GET / HTTP/1.1\r\n";
-    let sleep = b"GET /sleep HTTP/1.1\r\n";
-
-    let (status_line, filename) = if buffer.starts_with(get) {
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else if buffer.starts_with(sleep) {
-        thread::sleep(Duration::from_secs(5));
-        ("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
-    } else {
-        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
-    };
-
-     let mut file = File::open(filename).unwrap();
-     let mut contents = String::new();
-
-     file.read_to_string(&mut contents).unwrap();
-
-     let response = format!("{}{}", status_line, contents);
-
-     stream.write(response.as_bytes()).unwrap();
-     stream.flush().unwrap();
-}
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-07-final-code/src/main.rs}}
 ```
 
 <!--
@@ -676,125 +423,8 @@ fn handle_connection(mut stream: TcpStream) {
 
 <span class="filename">ファイル名: src/lib.rs</span>
 
-```rust
-use std::thread;
-use std::sync::mpsc;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-enum Message {
-    NewJob(Job),
-    Terminate,
-}
-
-pub struct ThreadPool {
-    workers: Vec<Worker>,
-    sender: mpsc::Sender<Message>,
-}
-
-trait FnBox {
-    fn call_box(self: Box<Self>);
-}
-
-impl<F: FnOnce()> FnBox for F {
-    fn call_box(self: Box<F>) {
-        (*self)()
-    }
-}
-
-type Job = Box<FnBox + Send + 'static>;
-
-impl ThreadPool {
-    /// Create a new ThreadPool.
-    ///
-    /// The size is the number of threads in the pool.
-    ///
-    /// # Panics
-    ///
-    /// The `new` function will panic if the size is zero.
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
-
-        let (sender, receiver) = mpsc::channel();
-
-        let receiver = Arc::new(Mutex::new(receiver));
-
-        let mut workers = Vec::with_capacity(size);
-
-        for id in 0..size {
-            workers.push(Worker::new(id, Arc::clone(&receiver)));
-        }
-
-        ThreadPool {
-            workers,
-            sender,
-        }
-    }
-
-    pub fn execute<F>(&self, f: F)
-        where
-            F: FnOnce() + Send + 'static
-    {
-        let job = Box::new(f);
-
-        self.sender.send(Message::NewJob(job)).unwrap();
-    }
-}
-
-impl Drop for ThreadPool {
-    fn drop(&mut self) {
-        println!("Sending terminate message to all workers.");
-
-        for _ in &mut self.workers {
-            self.sender.send(Message::Terminate).unwrap();
-        }
-
-        println!("Shutting down all workers.");
-
-        for worker in &mut self.workers {
-            println!("Shutting down worker {}", worker.id);
-
-            if let Some(thread) = worker.thread.take() {
-                thread.join().unwrap();
-            }
-        }
-    }
-}
-
-struct Worker {
-    id: usize,
-    thread: Option<thread::JoinHandle<()>>,
-}
-
-impl Worker {
-    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) ->
-        Worker {
-
-        let thread = thread::spawn(move ||{
-            loop {
-                let message = receiver.lock().unwrap().recv().unwrap();
-
-                match message {
-                    Message::NewJob(job) => {
-                        println!("Worker {} got a job; executing.", id);
-
-                        job.call_box();
-                    },
-                    Message::Terminate => {
-                        println!("Worker {} was told to terminate.", id);
-
-                        break;
-                    },
-                }
-            }
-        });
-
-        Worker {
-            id,
-            thread: Some(thread),
-        }
-    }
-}
+```rust,noplayground
+{{#rustdoc_include ../listings/ch20-web-server/no-listing-07-final-code/src/lib.rs}}
 ```
 
 <!--
@@ -809,16 +439,16 @@ some ideas:
 * Add tests of the library’s functionality.
 * Change calls to `unwrap` to more robust error handling.
 * Use `ThreadPool` to perform some task other than serving web requests.
-* Find a thread pool crate on *https://crates.io/* and implement a similar web
-server using the crate instead. Then compare its API and robustness to the
-thread pool we implemented.
+* Find a thread pool crate on [crates.io](https://crates.io/) and implement a
+  similar web server using the crate instead. Then compare its API and
+  robustness to the thread pool we implemented.
 -->
 
 * `ThreadPool`とその公開メソッドにもっとドキュメンテーションを追加する。
 * ライブラリの機能のテストを追加する。
 * `unwrap`の呼び出しをもっと頑健なエラー処理に変更する。
 * `ThreadPool`を使用してWebリクエスト以外のなんらかの作業を行う。
-* *https://crates.io* でスレッドプールのクレートを探して、そのクレートを代わりに使用して似たWebサーバを実装する。
+* [crates.io](https://crates.io/) でスレッドプールのクレートを探して、そのクレートを代わりに使用して似たWebサーバを実装する。
   そして、APIと頑健性を我々が実装したものと比較する。
 
 <!--