Update to edition 2018 (#565)

* Update to edition 2018

Update mdbook to 0.3.5

Command:
sed -i '/extern crate/ {N;s/\n$//}' src/**.md; sed -i 's/extern crate error_chain;/use error_chain::error_chain;/; s/extern crate lazy_static;/use lazy_static::lazy_static;/; s/extern crate bitflags;/use bitflags::bitflags;/; s/extern crate serde_json;/ use serde_json::json;/; s/extern crate serde_derive;/use serde::{Serialize, Deserialize};/; /macro_use/d; /extern crate/ d; s/```rust/```rust,edition2018/; s/bail!/error_chain::&/; s/\(debug\|info\|warn\|error\)!/log::&/;' src/**.md

Fix #530

* Update rand-dist.md

* Fixes #569

* dump syslog

version 4 depends on error-chain v 0.11 and version 5 depends on v 0.12 
!!!!

Co-authored-by: Andrew Gauger <andygauge@gmail.com>

CONTRIBUTING.md

@@ -20,7 +20,7 @@ cd rust-cookbook
 Cookbook is built with [mdBook], so install that first with Cargo:
 
 ```
-cargo install --version 0.1.8 mdbook
+cargo install --version 0.3.5 mdbook
 ```
 
 To build and view the cookbook locally, run:

Cargo.toml

@@ -2,6 +2,7 @@
 name = "rust-cookbook"
 version = "0.1.0"
 authors = ["Brian Anderson <banderson@mozilla.com>"]
+edition = "2018"
 license = "MIT/Apache-2.0"
 publish = false
 
@@ -9,6 +10,7 @@ build = "build.rs"
 
 [dependencies]
 ansi_term = "0.11.0"
+approx = "0.3"
 base64 = "0.9"
 bitflags = "1.0"
 byteorder = "1.0"
@@ -58,7 +60,7 @@ url = "2.1"
 walkdir = "2.0"
 
 [target.'cfg(target_os = "linux")'.dependencies]
-syslog = "4.0"
+syslog = "5.0"
 
 [build-dependencies]
 skeptic = "0.13"

README.md

@@ -19,7 +19,7 @@ If you'd like to read it locally:
 ```bash
 $ git clone https://github.com/rust-lang-nursery/rust-cookbook
 $ cd rust-cookbook
-$ cargo install mdbook --vers "0.1.8"
+$ cargo install mdbook --vers "0.3.5"
 $ mdbook serve --open
 ```
 

book.toml

@@ -3,12 +3,14 @@
 title = "Rust Cookbook"
 description = "Collection of useful Rust code examples"
 authors = ["Rust Language Community"]
+edition = "2018"
 multilingual = false
+language = "en"
 src = "src"
 
 [output.html]
 mathjax-support = false
-theme = "theme"
+# theme = "theme"
 additional-css = ["theme/custom.css"]
 
 [output.html.playpen]

ci/install_deps.sh

@@ -18,7 +18,7 @@ if [[ "${CONTENT_TESTS:-}" == 1 ]]; then
         pyenv local 3.6.0
         pip3 install --user link-checker==0.1.0
     fi
-    cargo install mdbook --vers '0.1.8' --debug
+    cargo install mdbook --vers '0.3.5' --debug
 fi
 
 exit 0

src/about.md

@@ -56,8 +56,7 @@ Consider this example for "generate random numbers within a range":
 
 [![rand-badge]][rand] [![cat-science-badge]][cat-science]
 
-```rust
-extern crate rand;
+```rust,edition2018
 use rand::Rng;
 
 fn main() {
@@ -111,10 +110,8 @@ The basic pattern we use is to have a `fn main() -> Result`.
 
 The structure generally looks like:
 
-```rust
-#[macro_use]
-extern crate error_chain;
-
+```rust,edition2018
+use error_chain::error_chain;
 use std::net::IpAddr;
 use std::str;
 
@@ -150,10 +147,8 @@ default like below.  In order to read full contents click on the
 "expand" (<i class="fa fa-expand"></i>) button located in the top
 right corner of the snippet.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate url;
+```rust,edition2018
+# use error_chain::error_chain;
 
 use url::{Url, Position};
 #

src/algorithms/randomness/rand-choose.md

@@ -5,9 +5,7 @@
 Randomly generates a string of given length ASCII characters with custom
 user-defined bytestring, with [`gen_range`].
 
-```rust
-extern crate rand;
-
+```rust,edition2018
 fn main() {
     use rand::Rng;
     const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\

src/algorithms/randomness/rand-custom.md

@@ -5,9 +5,7 @@
 Randomly generates a tuple `(i32, bool, f64)` and variable of user defined type `Point`.
 Implements the [`Distribution`] trait on type Point for [`Standard`] in order to allow random generation.
 
-```rust,ignore
-extern crate rand;
-
+```rust,edition2018,ignore
 use rand::Rng;
 use rand::distributions::{Distribution, Standard};
 

src/algorithms/randomness/rand-dist.md

@@ -12,10 +12,7 @@ generator [`rand::Rng`].
 The [distributions available are documented here][rand-distributions].
 An example using the [`Normal`] distribution is shown below.
 
-```rust,ignore
-extern crate rand_distr;
-extern crate rand;
-
+```rust,edition2018,ignore
 use rand_distr::{Distribution, Normal, NormalError};
 
 fn main() -> Result<(), NormalError> {

src/algorithms/randomness/rand-passwd.md

@@ -5,9 +5,7 @@
 Randomly generates a string of given length ASCII characters in the range `A-Z,
 a-z, 0-9`, with [`Alphanumeric`] sample.
 
-```rust,ignore
-extern crate rand;
-
+```rust,edition2018,ignore
 use rand::{thread_rng, Rng};
 use rand::distributions::Alphanumeric;
 

src/algorithms/randomness/rand-range.md

@@ -4,9 +4,7 @@
 
 Generates a random value within half-open `[0, 10)` range (not including `10`) with [`Rng::gen_range`].
 
-```rust,ignore
-extern crate rand;
-
+```rust,edition2018,ignore
 use rand::Rng;
 
 fn main() {
@@ -20,9 +18,7 @@ fn main() {
 This has the same effect, but may be faster when repeatedly generating numbers
 in the same range.
 
-```rust,ignore
-extern crate rand;
-
+```rust,edition2018,ignore
 
 use rand::distributions::{Distribution, Uniform};
 

src/algorithms/randomness/rand.md

@@ -8,9 +8,7 @@ initialized generator. Integers are uniformly distributed over the range of the
 type, and floating point numbers are uniformly distributed from 0 up to but not
 including 1.
 
-```rust
-extern crate rand;
-
+```rust,edition2018
 use rand::Rng;
 
 fn main() {

src/algorithms/sorting/sort.md

@@ -6,7 +6,7 @@ This example sorts a Vector of integers via [`vec::sort`]. Alternative would
 be to use [`vec::sort_unstable`] which can be faster, but does not preserve
 the order of equal elements.
 
-```rust
+```rust,edition2018
 fn main() {
     let mut vec = vec![1, 5, 10, 2, 15];
     

src/algorithms/sorting/sort_float.md

@@ -4,7 +4,7 @@
 
 A Vector of f32 or f64 can be sorted with [`vec::sort_by`] and [`PartialOrd::partial_cmp`].
 
-```rust
+```rust,edition2018
 fn main() {
     let mut vec = vec![1.1, 1.15, 5.5, 1.123, 2.0];
 

src/algorithms/sorting/sort_struct.md

@@ -7,7 +7,7 @@ order (By name and age). In order to make Person sortable you need four traits [
 [`PartialEq`], [`Ord`] and [`PartialOrd`]. These traits can be simply derived.
 You can also provide a custom comparator function using a [`vec:sort_by`] method and sort only by age.
 
-```rust
+```rust,edition2018
 #[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
 struct Person {
     name: String,

src/cli/ansi_terminal/ansi_term-basic.md

@@ -10,9 +10,7 @@ There are two main data structures in [`ansi_term`]: [`ANSIString`] and [`Style`
 
 ### Printing colored text to the Terminal
 
-```rust
-extern crate ansi_term;
-
+```rust,edition2018
 use ansi_term::Colour;
 
 fn main() {
@@ -29,9 +27,7 @@ For anything more complex than plain foreground colour changes, the code
 needs to construct `Style` struct. [`Style::new()`] creates the struct,
 and properties chained.
 
-```rust
-extern crate ansi_term;
-
+```rust,edition2018
 use ansi_term::Style;
 
 fn main() {
@@ -43,9 +39,7 @@ fn main() {
 
 `Colour` implements many similar functions as `Style` and can chain methods.
 
-```rust
-extern crate ansi_term;
-
+```rust,edition2018
 use ansi_term::Colour;
 use ansi_term::Style;
 

src/cli/arguments/clap-basic.md

@@ -11,9 +11,7 @@ use to retrieve the value passed. The `short` and `long` options control the
 flag the user will be expected to type; short flags look like `-f` and long
 flags look like `--file`.
 
-```rust
-extern crate clap;
-
+```rust,edition2018
 use clap::{Arg, App};
 
 fn main() {

src/compression/tar/tar-compress.md

@@ -10,9 +10,7 @@ under `backup/logs`path with [`Builder::append_dir_all`].
 [`GzEncoder`] is responsible for transparently compressing the
 data prior to writing it into `archive.tar.gz`.
 
-```rust,no_run
-extern crate tar;
-extern crate flate2;
+```rust,edition2018,no_run
 
 use std::fs::File;
 use flate2::Compression;

src/compression/tar/tar-decompress.md

@@ -7,9 +7,7 @@ extract ([`Archive::unpack`]) all files from a compressed tarball
 named `archive.tar.gz` located in the current working directory
 to the same location.
 
-```rust,no_run
-extern crate flate2;
-extern crate tar;
+```rust,edition2018,no_run
 
 use std::fs::File;
 use flate2::read::GzDecoder;

src/compression/tar/tar-strip-prefix.md

@@ -6,12 +6,8 @@ Iterate over the [`Archive::entries`].  Use [`Path::strip_prefix`] to remove
 the specified path prefix (`bundle/logs`).  Finally, extract the [`tar::Entry`]
 via [`Entry::unpack`].
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate flate2;
-extern crate tar;
-
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 use std::fs::File;
 use std::path::PathBuf;
 use flate2::read::GzDecoder;

src/concurrency/parallel/rayon-any-all.md

@@ -4,9 +4,7 @@
 
 This example demonstrates using the [`rayon::any`] and [`rayon::all`] methods, which are parallelized counterparts to [`std::any`] and [`std::all`]. [`rayon::any`] checks in parallel whether any element of the iterator matches the predicate, and returns as soon as one is found. [`rayon::all`] checks in parallel whether all elements of the iterator match the predicate, and returns as soon as a non-matching element is found.
 
-```rust
-extern crate rayon;
-
+```rust,edition2018
 use rayon::prelude::*;
 
 fn main() {

src/concurrency/parallel/rayon-iter-mut.md

@@ -6,9 +6,7 @@ The example uses the `rayon` crate, which is a data parallelism library for Rust
 `rayon` provides the [`par_iter_mut`] method for any parallel iterable data type.
 This is an iterator-like chain that potentially executes in parallel.
 
-```rust
-extern crate rayon;
-
+```rust,edition2018
 use rayon::prelude::*;
 
 fn main() {

src/concurrency/parallel/rayon-map-reduce.md

@@ -11,9 +11,7 @@ new iteration, and [`rayon::reduce`] performs an operation given the previous
 reduction and the current element.  Also shows use of [`rayon::sum`],
 which has the same result as the reduce operation in this example.
 
-```rust
-extern crate rayon;
-
+```rust,edition2018
 use rayon::prelude::*;
 
 struct Person {

src/concurrency/parallel/rayon-parallel-search.md

@@ -12,9 +12,7 @@ necessarily the first one.
 Also note that the argument to the closure is a reference to a reference
 (`&&x`). See the discussion on [`std::find`] for additional details.
 
-```rust
-extern crate rayon;
-
+```rust,edition2018
 use rayon::prelude::*;
 
 fn main() {

src/concurrency/parallel/rayon-parallel-sort.md

@@ -9,9 +9,7 @@ values in parallel.  Although [multiple options]
 exist to sort an enumerable data type, [`par_sort_unstable`]
 is usually faster than [stable sorting] algorithms.
 
-```rust,ignore
-extern crate rand;
-extern crate rayon;
+```rust,edition2018,ignore
 
 use rand::{Rng, thread_rng};
 use rand::distributions::Alphanumeric;

src/concurrency/parallel/rayon-thumbnails.md

@@ -8,12 +8,8 @@ then saves them in a new folder called `thumbnails`.
 [`glob::glob_with`] finds jpeg files in current directory. `rayon` resizes
 images in parallel using [`par_iter`] calling  [`DynamicImage::resize`].
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate glob;
-extern crate image;
-extern crate rayon;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use std::path::Path;
 use std::fs::create_dir_all;
@@ -38,7 +34,7 @@ fn main() -> Result<()> {
         .collect();
 
     if files.len() == 0 {
-        bail!("No .jpg files found in current directory");
+        error_chain::bail!("No .jpg files found in current directory");
     }
 
     let thumb_dir = "thumbnails";

src/concurrency/thread/crossbeam-spawn.md

@@ -9,9 +9,7 @@ you can reference data from the calling function.
 
 This example splits the array in half and performs the work in separate threads.
 
-```rust
-extern crate crossbeam;
-
+```rust,edition2018
 fn main() {
     let arr = &[1, 25, -4, 10];
     let max = find_max(arr);

src/concurrency/thread/crossbeam-spsc.md

@@ -9,9 +9,7 @@ exchanged between the two threads using a [`crossbeam_channel::unbounded`]
 channel, meaning there is no limit to the number of storeable messages. The
 producer thread sleeps for half a second in between messages.
 
-```rust
-extern crate crossbeam;
-extern crate crossbeam_channel;
+```rust,edition2018
 
 use std::{thread, time};
 use crossbeam_channel::unbounded;

src/concurrency/thread/global-mut-state.md

@@ -9,12 +9,9 @@ the state cannot be simultaneously accessed by multiple threads, preventing
 race conditions. A [`MutexGuard`] must be acquired to read or mutate the
 value stored in a [`Mutex`].
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-#[macro_use]
-extern crate lazy_static;
-
+```rust,edition2018
+# use error_chain::error_chain;
+use lazy_static::lazy_static;
 use std::sync::Mutex;
 #
 # error_chain!{ }

src/concurrency/thread/threadpool-fractal.md

@@ -16,14 +16,8 @@ Create [`ThreadPool`] with thread count equal to number of cores with [`num_cpus
 [`ImageBuffer::put_pixel`] uses the data to set the pixel color.
 [`ImageBuffer::save`] writes the image to `output.png`.
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate threadpool;
-extern crate num;
-extern crate num_cpus;
-extern crate image;
-
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 use std::sync::mpsc::{channel, RecvError};
 use threadpool::ThreadPool;
 use num::complex::Complex;

src/concurrency/thread/threadpool-walk.md

@@ -8,11 +8,7 @@ present in the system found with [`num_cpus::get`].  [`Walkdir::new`] iterates
 the current directory and calls [`execute`] to perform the operations of reading
 and computing SHA256 hash.
 
-```rust,no_run
-extern crate walkdir;
-extern crate ring;
-extern crate num_cpus;
-extern crate threadpool;
+```rust,edition2018,no_run
 
 use walkdir::WalkDir;
 use std::fs::File;

src/cryptography/encryption/pbkdf2.md

@@ -9,9 +9,7 @@ function [`pbkdf2::derive`].  Verifies the hash is correct with
 [`SecureRandom::fill`], which fills the salt byte array with
 securely generated random numbers.
 
-```rust,ignore
-extern crate ring;
-extern crate data_encoding;
+```rust,edition2018,ignore
 
 use data_encoding::HEXUPPER;
 use ring::error::Unspecified;

src/cryptography/hashing/hmac.md

@@ -4,9 +4,8 @@
 
 Uses [`ring::hmac`] to creates a [`hmac::Signature`] of a string then verifies the signature is correct.
 
-```rust
-extern crate ring;
 
+```rust,edition2018
 use ring::{hmac, rand};
 use ring::rand::SecureRandom;
 use ring::error::Unspecified;

src/cryptography/hashing/sha-digest.md

@@ -5,12 +5,8 @@
 Writes some data to a file, then calculates the SHA-256 [`digest::Digest`] of
 the file's contents using [`digest::Context`].
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate data_encoding;
-extern crate ring;
-
+```rust,edition2018
+# use error_chain::error_chain;
 use data_encoding::HEXUPPER;
 use ring::digest::{Context, Digest, SHA256};
 use std::fs::File;

src/data_structures/bitfield/bitfield.md

@@ -6,10 +6,8 @@ Creates type safe bitfield type `MyFlags` with help of [`bitflags!`] macro
 and implements elementary `clear` operation as well as [`Display`] trait for it.
 Subsequently, shows basic bitwise operations and formatting.
 
-```rust
-#[macro_use]
-extern crate bitflags;
-
+```rust,edition2018
+use bitflags::bitflags;
 use std::fmt;
 
 bitflags! {

src/database/postgres/aggregate_data.md

@@ -4,8 +4,7 @@
 
 This recipe lists the nationalities of the first 7999 artists in the database of the [`Museum of Modern Art`] in descending order.
 
-```rust,no_run
-extern crate postgres;
+```rust,edition2018,no_run
 use postgres::{Client, Error, NoTls};
 
 struct Nation {

src/database/postgres/create_tables.md

@@ -6,9 +6,7 @@ Use the [`postgres`] crate to create tables in a Postgres database.
 
 [`Client::connect`] helps in connecting to an existing database. The recipe uses a URL string format with `Client::connect`. It assumes an existing database named `library`, the username is `postgres` and the password is `postgres`.
 
-```rust,no_run
-extern crate postgres;
-
+```rust,edition2018,no_run
 use postgres::{Client, NoTls, Error};
 
 fn main() -> Result<(), Error> {

src/database/postgres/insert_query_data.md

@@ -4,9 +4,8 @@
 
 The recipe inserts data into the `author` table using [`execute`] method of `Client`. Then, displays the data from the `author` table  using [`query`] method of `Client`.
 
-```rust,no_run
-extern crate postgres;
 
+```rust,edition2018,no_run
 use postgres::{Client, NoTls, Error};
 use std::collections::HashMap;
 

src/database/sqlite/initialization.md

@@ -7,9 +7,7 @@ Use the `rusqlite` crate to open SQLite databases. See
 
 [`Connection::open`] will create the database if it doesn't already exist.
 
-```rust,no_run
-extern crate rusqlite;
-
+```rust,edition2018,no_run
 use rusqlite::{Connection, Result};
 use rusqlite::NO_PARAMS;
 

src/database/sqlite/insert_select.md

@@ -6,7 +6,6 @@
 This recipe inserts data into `cat_colors` and `cats` tables using the [`execute`] method of `Connection`. First, the data is inserted into the `cat_colors` table. After a record for a color is inserted, [`last_insert_rowid`] method of `Connection` is used to get `id` of the last color inserted. This `id` is used while inserting data into the `cats` table. Then, the select query is prepared using the [`prepare`] method which gives a [`statement`] struct. Then, query is executed using [`query_map`] method of [`statement`].
 
 ```rust,no_run
-extern crate rusqlite;
 
 use rusqlite::NO_PARAMS;
 use rusqlite::{Connection, Result};

src/database/sqlite/transactions.md

@@ -12,9 +12,7 @@ a unique constraint on the color name. When an attempt to insert
 a duplicate color is made, the transaction rolls back.
 
 
-```rust,no_run
-extern crate rusqlite;
-
+```rust,edition2018,no_run
 use rusqlite::{Connection, Result, NO_PARAMS};
 
 fn main() -> Result<()> {

src/datetime/duration/checked.md

@@ -10,8 +10,7 @@ cannot be calculated.
 Escape sequences that are available for the
 [`DateTime::format`] can be found at [`chrono::format::strftime`].
 
-```rust
-extern crate chrono;
+```rust,edition2018
 use chrono::{DateTime, Duration, Utc};
 
 fn day_earlier(date_time: DateTime<Utc>) -> Option<DateTime<Utc>> {

src/datetime/duration/profile.md

@@ -7,7 +7,7 @@ Measures [`time::Instant::elapsed`] since [`time::Instant::now`].
 Calling [`time::Instant::elapsed`] returns a [`time::Duration`] that we print at the end of the example.
 This method will not mutate or reset the [`time::Instant`] object.
 
-```rust
+```rust,edition2018
 use std::time::{Duration, Instant};
 # use std::thread;
 #

src/datetime/duration/timezone.md

@@ -4,8 +4,7 @@
 
 Gets the local time and displays it using [`offset::Local::now`] and then converts it to the UTC standard using the [`DateTime::from_utc`] struct method. A time is then converted using the [`offset::FixedOffset`] struct and the UTC time is then converted to UTC+8 and UTC-2.
 
-```rust
-extern crate chrono;
+```rust,edition2018
 
 use chrono::{DateTime, FixedOffset, Local, Utc};
 

src/datetime/parse/current.md

@@ -5,8 +5,7 @@
 Gets the current UTC [`DateTime`] and its hour/minute/second via [`Timelike`]
 and its year/month/day/weekday via [`Datelike`].
 
-```rust
-extern crate chrono;
+```rust,edition2018
 use chrono::{Datelike, Timelike, Utc};
 
 fn main() {

src/datetime/parse/format.md

@@ -7,8 +7,7 @@ current time in the well-known formats [RFC 2822] using [`DateTime::to_rfc2822`]
 and [RFC 3339] using [`DateTime::to_rfc3339`], and in a custom format using
 [`DateTime::format`].
 
-```rust
-extern crate chrono;
+```rust,edition2018
 use chrono::{DateTime, Utc};
 
 fn main() {

src/datetime/parse/string.md

@@ -13,8 +13,7 @@ requires that such a DateTime struct must be creatable that it uniquely
 identifies a date and a time. For parsing dates and times without timezones use
 [`NaiveDate`], [`NaiveTime`], and [`NaiveDateTime`].
 
-```rust
-extern crate chrono;
+```rust,edition2018
 use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime};
 use chrono::format::ParseError;
 

src/datetime/parse/timestamp.md

@@ -6,8 +6,7 @@ to [UNIX timestamp] using [`NaiveDateTime::timestamp`].
 Then it calculates what was the date after one billion seconds
 since January 1, 1970 0:00:00 UTC, using [`NaiveDateTime::from_timestamp`].
 
-```rust
-extern crate chrono;
+```rust,edition2018
 
 use chrono::{NaiveDate, NaiveDateTime};
 

src/development_tools/build_tools/cc-bundled-cpp.md

@@ -18,9 +18,7 @@ cc = "1"
 
 ### `build.rs`
 
-```rust,no_run
-extern crate cc;
-
+```rust,edition2018,no_run
 fn main() {
     cc::Build::new()
         .cpp(true)
@@ -43,7 +41,7 @@ int multiply(int x, int y) {
 
 ### `src/main.rs`
 
-```rust,ignore
+```rust,edition2018,ignore
 extern {
     fn multiply(x : i32, y : i32) -> i32;
 }

src/development_tools/build_tools/cc-bundled-static.md

@@ -30,9 +30,7 @@ error-chain = "0.11"
 
 ### `build.rs`
 
-```rust,no_run
-extern crate cc;
-
+```rust,edition2018,no_run
 fn main() {
     cc::Build::new()
         .file("src/hello.c")
@@ -57,8 +55,7 @@ void greet(const char* name) {
 
 ### `src/main.rs`
 
-```rust,ignore
-# #[macro_use] extern crate error_chain;
+```rust,edition2018,ignore
 use std::ffi::CString;
 use std::os::raw::c_char;
 #

src/development_tools/build_tools/cc-defines.md

@@ -23,9 +23,7 @@ cc = "1"
 
 ### `build.rs`
 
-```rust,no_run
-extern crate cc;
-
+```rust,edition2018,no_run
 fn main() {
     cc::Build::new()
         .define("APP_NAME", "\"foo\"")
@@ -51,7 +49,7 @@ void print_app_info() {
 
 ### `src/main.rs`
 
-```rust,ignore
+```rust,edition2018,ignore
 extern {
     fn print_app_info();
 }

src/development_tools/debugging/config_log/log-custom.md

@@ -11,12 +11,8 @@ encoding using a custom pattern from [`log4rs::encode::pattern`].
 Assigns the configuration to [`log4rs::config::Config`] and sets the default
 [`log::LevelFilter`].
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-#[macro_use]
-extern crate log;
-extern crate log4rs;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use log::LevelFilter;
 use log4rs::append::file::FileAppender;
@@ -44,7 +40,7 @@ fn main() -> Result<()> {
 
     log4rs::init_config(config)?;
 
-    info!("Hello, world!");
+    log::info!("Hello, world!");
 
     Ok(())
 }

src/development_tools/debugging/config_log/log-env-variable.md

@@ -9,10 +9,7 @@ environment variable contents in the form of [`RUST_LOG`] syntax.
 Then, [`Builder::init`] initializes the logger.
 All these steps are normally done internally by [`env_logger::init`].
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate env_logger;
+```rust,edition2018
 
 use std::env;
 use env_logger::Builder;
@@ -22,9 +19,9 @@ fn main() {
         .parse(&env::var("MY_APP_LOG").unwrap_or_default())
         .init();
 
-    info!("informational message");
-    warn!("warning message");
-    error!("this is an error {}", "message");
+    log::info!("informational message");
+    log::warn!("warning message");
+    log::error!("this is an error {}", "message");
 }
 ```
 

src/development_tools/debugging/config_log/log-mod.md

@@ -5,33 +5,30 @@
 Creates two modules `foo` and nested `foo::bar` with logging directives
 controlled separately with [`RUST_LOG`] environmental variable.
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate env_logger;
+```rust,edition2018
 
 mod foo {
     mod bar {
         pub fn run() {
-            warn!("[bar] warn");
-            info!("[bar] info");
-            debug!("[bar] debug");
+            log::warn!("[bar] warn");
+            log::info!("[bar] info");
+            log::debug!("[bar] debug");
         }
     }
 
     pub fn run() {
-        warn!("[foo] warn");
-        info!("[foo] info");
-        debug!("[foo] debug");
+        log::warn!("[foo] warn");
+        log::info!("[foo] info");
+        log::debug!("[foo] debug");
         bar::run();
     }
 }
 
 fn main() {
     env_logger::init();
-    warn!("[root] warn");
-    info!("[root] info");
-    debug!("[root] debug");
+    log::warn!("[root] warn");
+    log::info!("[root] info");
+    log::debug!("[root] debug");
     foo::run();
 }
 ```

src/development_tools/debugging/config_log/log-timestamp.md

@@ -10,12 +10,7 @@ a timestamp used in the final log.
 The example calls [`Builder::format`] to set a closure which formats each
 message text with timestamp, [`Record::level`] and body ([`Record::args`]).
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate chrono;
-extern crate env_logger;
-
+```rust,edition2018
 use std::io::Write;
 use chrono::Local;
 use env_logger::Builder;
@@ -34,9 +29,9 @@ fn main() {
         .filter(None, LevelFilter::Info)
         .init();
 
-    warn!("warn");
-    info!("info");
-    debug!("debug");
+    log::warn!("warn");
+    log::info!("info");
+    log::debug!("debug");
 }
 ```
 stderr output will contain

src/development_tools/debugging/log/log-custom-logger.md

@@ -6,10 +6,7 @@ Implements a custom logger `ConsoleLogger` which prints to stdout.
 In order to use the logging macros, `ConsoleLogger` implements
 the [`log::Log`] trait and [`log::set_logger`] installs it.
 
-```rust
-#[macro_use]
-extern crate log;
-
+```rust,edition2018
 use log::{Record, Level, Metadata, LevelFilter, SetLoggerError};
 
 static CONSOLE_LOGGER: ConsoleLogger = ConsoleLogger;
@@ -34,9 +31,9 @@ fn main() -> Result<(), SetLoggerError> {
     log::set_logger(&CONSOLE_LOGGER)?;
     log::set_max_level(LevelFilter::Info);
 
-    info!("hello log");
-    warn!("warning");
-    error!("oops");
+    log::info!("hello log");
+    log::warn!("warning");
+    log::error!("oops");
     Ok(())
 }
 ```

src/development_tools/debugging/log/log-debug.md

@@ -3,16 +3,13 @@
 [![log-badge]][log] [![env_logger-badge]][env_logger] [![cat-debugging-badge]][cat-debugging]
 
 The `log` crate provides logging utilities. The `env_logger` crate configures
-logging via an environment variable.  The [`debug!`] macro works like other
+logging via an environment variable.  The [`log::debug!`] macro works like other
 [`std::fmt`] formatted strings.
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate env_logger;
+```rust,edition2018
 
 fn execute_query(query: &str) {
-    debug!("Executing query: {}", query);
+    log::debug!("Executing query: {}", query);
 }
 
 fn main() {
@@ -38,5 +35,5 @@ following line at the very end of the output:
 DEBUG:main: Executing query: DROP TABLE students
 ```
 
-[`debug!`]: https://docs.rs/log/*/log/macro.debug.html
+[`log::debug!`]: https://docs.rs/log/*/log/macro.debug.html
 [`std::fmt`]: https://doc.rust-lang.org/std/fmt/

src/development_tools/debugging/log/log-error.md

@@ -3,12 +3,9 @@
 [![log-badge]][log] [![env_logger-badge]][env_logger] [![cat-debugging-badge]][cat-debugging]
 
 Proper error handling considers exceptions exceptional.  Here, an error logs
-to stderr with `log`'s convenience macro [`error!`].
+to stderr with `log`'s convenience macro [`log::error!`].
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate env_logger;
+```rust,edition2018
 
 fn execute_query(_query: &str) -> Result<(), &'static str> {
     Err("I'm afraid I can't do that")
@@ -19,9 +16,9 @@ fn main() {
 
     let response = execute_query("DROP TABLE students");
     if let Err(err) = response {
-        error!("Failed to execute query: {}", err);
+        log::error!("Failed to execute query: {}", err);
     }
 }
 ```
 
-[`error!`]: https://docs.rs/log/*/log/macro.error.html
+[`log::error!`]: https://docs.rs/log/*/log/macro.error.html

src/development_tools/debugging/log/log-stdout.md

@@ -4,10 +4,7 @@
 
 Creates a custom logger configuration using the [`Builder::target`] to set the target of the log output to [`Target::Stdout`].
 
-```rust
-#[macro_use]
-extern crate log;
-extern crate env_logger;
+```rust,edition2018
 
 use env_logger::{Builder, Target};
 
@@ -16,7 +13,7 @@ fn main() {
         .target(Target::Stdout)
         .init();
 
-    error!("This error has been printed to Stdout");
+    log::error!("This error has been printed to Stdout");
 }
 ```
 

src/development_tools/debugging/log/log-syslog.md

@@ -7,12 +7,8 @@ with [`syslog::init`]. [`syslog::Facility`] records the program submitting
 the log entry's classification, [`log::LevelFilter`] denotes allowed log verbosity
 and `Option<&str>` holds optional application name.
 
-```rust
-#[macro_use]
-extern crate log;
+```rust,edition2018
 # #[cfg(target_os = "linux")]
-extern crate syslog;
-
 # #[cfg(target_os = "linux")]
 use syslog::{Facility, Error};
 
@@ -21,8 +17,8 @@ fn main() -> Result<(), Error> {
     syslog::init(Facility::LOG_USER,
                  log::LevelFilter::Debug,
                  Some("My app name"))?;
-    debug!("this is a debug {}", "message");
-    error!("this is an error!");
+    log::debug!("this is a debug {}", "message");
+    log::error!("this is an error!");
     Ok(())
 }
 

src/development_tools/versioning/semver-command.md

@@ -7,10 +7,8 @@ Runs `git --version` using [`Command`], then parses the version number into a
 [`semver::VersionReq`] to the parsed version.  The command output resembles
 "git version x.y.z".
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate semver;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use std::process::Command;
 use semver::{Version, VersionReq};
@@ -30,7 +28,7 @@ fn main() -> Result<()> {
     let output = Command::new("git").arg("--version").output()?;
 
     if !output.status.success() {
-        bail!("Command executed with failing error code");
+        error_chain::bail!("Command executed with failing error code");
     }
 
     let stdout = String::from_utf8(output.stdout)?;
@@ -40,7 +38,7 @@ fn main() -> Result<()> {
     let parsed_version = Version::parse(version)?;
 
     if !version_test.matches(&parsed_version) {
-        bail!("Command version lower than minimum supported version (found {}, need {})",
+        error_chain::bail!("Command version lower than minimum supported version (found {}, need {})",
             parsed_version, version_constraint);
     }
 

src/development_tools/versioning/semver-complex.md

@@ -8,9 +8,7 @@ contains pre-release and build metadata as defined in the [Semantic Versioning S
 Note that, in accordance with the Specification, build metadata is parsed but not considered when
 comparing versions. In other words, two versions may be equal even if their build strings differ.
 
-```rust
-extern crate semver;
-
+```rust,edition2018
 use semver::{Identifier, Version, SemVerError};
 
 fn main() -> Result<(), SemVerError> {

src/development_tools/versioning/semver-increment.md

@@ -10,9 +10,7 @@ incrementing the minor version number resets the patch version number to 0 and
 incrementing the major version number resets both the minor and patch version
 numbers to 0.
 
-```rust
-extern crate semver;
-
+```rust,edition2018
 use semver::{Version, SemVerError};
 
 fn main() -> Result<(), SemVerError> {

src/development_tools/versioning/semver-latest.md

@@ -6,10 +6,8 @@ Given a list of version &strs, finds the latest [`semver::Version`].
 [`semver::VersionReq`] filters the list with [`VersionReq::matches`].
 Also demonstrates `semver` pre-release preferences.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate semver;
+```rust,edition2018
+# use error_chain::error_chain;
 
 use semver::{Version, VersionReq};
 #

src/development_tools/versioning/semver-prerelease.md

@@ -4,9 +4,7 @@
 
 Given two versions, [`is_prerelease`] asserts that one is pre-release and the other is not.
 
-```rust
-extern crate semver;
-
+```rust,edition2018
 use semver::{Version, SemVerError};
 
 fn main() -> Result<(), SemVerError> {

src/encoding/complex/endian-byte.md

@@ -6,8 +6,7 @@
 be necessary when receiving information over the network, such that bytes
 received are from another system.
 
-```rust
-extern crate byteorder;
+```rust,edition2018
 
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use std::io::Error;

src/encoding/complex/json.md

@@ -10,10 +10,8 @@ is able to represent any valid JSON data.
 
 The example below shows a `&str` of JSON being parsed.  The expected value is declared using the [`json!`] macro.
 
-```rust
-#[macro_use]
-extern crate serde_json;
-
+```rust,edition2018
+ use serde_json::json;
 use serde_json::{Value, Error};
 
 fn main() -> Result<(), Error> {

src/encoding/complex/toml.md

@@ -5,9 +5,7 @@
 Parse some TOML into a universal `toml::Value` that is able to represent any
 valid TOML data.
 
-```rust
-extern crate toml;
-
+```rust,edition2018
 use toml::{Value, de::Error};
 
 fn main() -> Result<(), Error> {
@@ -33,10 +31,8 @@ fn main() -> Result<(), Error> {
 
 Parse TOML into your own structs using [Serde].
 
-```rust
-#[macro_use]
-extern crate serde_derive;
-extern crate toml;
+```rust,edition2018
+use serde::Deserialize;
 
 use toml::de::Error;
 use std::collections::HashMap;

src/encoding/csv/delimiter.md

@@ -4,12 +4,9 @@
 
 Reads CSV records with a tab [`delimiter`].
 
-```rust
-extern crate csv;
+```rust,edition2018
 use csv::Error;
-#[macro_use]
-extern crate serde_derive;
-
+use serde::Deserialize;
 #[derive(Debug, Deserialize)]
 struct Record {
     name: String,

src/encoding/csv/filter.md

@@ -4,10 +4,8 @@
 
 Returns _only_ the rows from `data` with a field that matches `query`.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate csv;
+```rust,edition2018
+# use error_chain::error_chain;
 
 use std::io;
 #

src/encoding/csv/invalid.md

@@ -6,11 +6,9 @@ CSV files often contain invalid data. For these cases, the `csv` crate
 provides a custom deserializer, [`csv::invalid_option`], which automatically
 converts invalid data to None values.
 
-```rust
-extern crate csv;
+```rust,edition2018
 use csv::Error;
-#[macro_use]
-extern crate serde_derive;
+use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 struct Record {

src/encoding/csv/read.md

@@ -6,8 +6,7 @@ Reads standard CSV records into [`csv::StringRecord`] — a weakly typed
 data representation which expects valid UTF-8 rows. Alternatively,
 [`csv::ByteRecord`] makes no assumptions about UTF-8.
 
-```rust
-extern crate csv;
+```rust,edition2018
 use csv::Error;
 
 fn main() -> Result<(), Error> {
@@ -34,11 +33,8 @@ fn main() -> Result<(), Error> {
 Serde deserializes data into strongly type structures. See the
 [`csv::Reader::deserialize`] method.
 
-```rust
-extern crate csv;
-#[macro_use]
-extern crate serde_derive;
-
+```rust,edition2018
+use serde::Deserialize;
 #[derive(Deserialize)]
 struct Record {
     year: u16,

src/encoding/csv/serde-serialize.md

@@ -5,13 +5,9 @@
 The following example shows how to serialize custom structs as CSV records using
 the [serde] crate.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate csv;
-#[macro_use]
-extern crate serde_derive;
-
+```rust,edition2018
+# use error_chain::error_chain;
+use serde::Serialize;
 use std::io;
 #
 # error_chain! {

src/encoding/csv/serialize.md

@@ -8,10 +8,8 @@ a simple record containing string data only. Data with more complex values
 such as numbers, floats, and options use [`serialize`]. Since CSV
 writer uses internal buffer, always explicitly [`flush`] when done.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate csv;
+```rust,edition2018
+# use error_chain::error_chain;
 
 use std::io;
 #

src/encoding/csv/transform.md

@@ -8,14 +8,8 @@ csv file, and [serde] to deserialize and serialize the rows to and from bytes.
 
 See [`csv::Reader::deserialize`], [`serde::Deserialize`], and [`std::str::FromStr`]
 
-```rust
-extern crate csv;
-# #[macro_use]
-# extern crate error_chain;
-#[macro_use]
-extern crate serde_derive;
-extern crate serde;
-
+```rust,edition2018
+# use error_chain::error_chain;
 use csv::{Reader, Writer};
 use serde::{de, Deserialize, Deserializer};
 use std::str::FromStr;

src/encoding/string/base64.md

@@ -5,10 +5,8 @@
 Encodes byte slice into `base64` String using [`encode`]
 and decodes it with [`decode`].
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
-extern crate base64;
+```rust,edition2018
+# use error_chain::error_chain;
 
 use std::str;
 use base64::{encode, decode};

src/encoding/string/hex.md

@@ -12,9 +12,7 @@ returns a `Vec<u8>` if the input data is successfully decoded.
 The example below coverts `&[u8]` data to hexadecimal equivalent.  Compares this
 value to the expected value.
 
-```rust
-extern crate data_encoding;
-
+```rust,edition2018
 use data_encoding::{HEXUPPER, DecodeError};
 
 fn main() -> Result<(), DecodeError> {

src/encoding/string/percent-encode.md

@@ -6,9 +6,7 @@ Encode an input string with [percent-encoding] using the [`utf8_percent_encode`]
 function from the `percent-encoding` crate. Then decode using the [`percent_decode`]
 function.
 
-```rust,ignore
-extern crate percent_encoding;
-
+```rust,edition2018,ignore
 use percent_encoding::{utf8_percent_encode, percent_decode, AsciiSet, CONTROLS};
 use std::str::Utf8Error;
 

src/encoding/string/url-encode.md

@@ -7,8 +7,7 @@ using the [`form_urlencoded::byte_serialize`] and subsequently
 decodes it with [`form_urlencoded::parse`]. Both functions return iterators
 that collect into a `String`.
 
-```rust
-extern crate url;
+```rust,edition2018
 use url::form_urlencoded::{byte_serialize, parse};
 
 fn main() {

src/errors/handle/backtrace.md

@@ -11,12 +11,9 @@ The below recipes attempts to deserialize the value `256` into a
 `u8`. An error will bubble up from Serde then csv and finally up to the
 user code.
 
-```rust
-# extern crate csv;
-#[macro_use]
-extern crate error_chain;
-# #[macro_use]
-# extern crate serde_derive;
+```rust,edition2018
+use error_chain::error_chain;
+# use serde::Deserialize;
 #
 # use std::fmt;
 #

src/errors/handle/main.md

@@ -17,9 +17,8 @@ first number. Returns uptime unless there is an error.
 Other recipes in this book will hide the [error-chain] boilerplate, and can be
 seen by expanding the code with the ⤢ button.
 
-```rust
-#[macro_use]
-extern crate error_chain;
+```rust,edition2018
+use error_chain::error_chain;
 
 use std::fs::File;
 use std::io::Read;

src/errors/handle/retain.md

@@ -12,10 +12,8 @@ the string response into an integer. The Rust standard library,
 use [`foreign_links`]. An additional [`ErrorKind`] variant for the web service
 error uses `errors` block of the `error_chain!` macro.
 
-```rust
-#[macro_use]
-extern crate error_chain;
-extern crate reqwest;
+```rust,edition2018
+use error_chain::error_chain;
 
 use std::io::Read;
 

src/file/dir/duplicate-name.md

@@ -5,9 +5,7 @@
 Find recursively in the current directory duplicate filenames,
 printing them only once.
 
-```rust,no_run
-extern crate walkdir;
-
+```rust,edition2018,no_run
 use std::collections::HashMap;
 use walkdir::WalkDir;
 

src/file/dir/find-file.md

@@ -6,10 +6,8 @@ Find JSON files modified within the last day in the current directory.
 Using [`follow_links`] ensures symbolic links are followed like they were
 normal directories and files.
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate walkdir;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use walkdir::WalkDir;
 #

src/file/dir/ignore-case.md

@@ -6,10 +6,8 @@ Find all image files in the `/media/` directory matching the `img_[0-9]*.png` pa
 
 A custom [`MatchOptions`] struct is passed to the [`glob_with`] function making the glob pattern case insensitive while keeping the other options [`Default`].
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate glob;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use glob::{glob_with, MatchOptions};
 #

src/file/dir/loops.md

@@ -10,9 +10,7 @@ ln -s /tmp/foo/  /tmp/foo/bar/baz/qux
 ```
 The following would assert that a loop exists.
 
-```rust,no_run
-extern crate same_file;
-
+```rust,edition2018,no_run
 use std::io;
 use std::path::{Path, PathBuf};
 use same_file::is_same_file;

src/file/dir/modified.md

@@ -10,9 +10,8 @@ last modification. [`Duration::as_secs`] converts the time to seconds and
 compared with 24 hours (24 * 60 * 60 seconds). [`Metadata::is_file`] filters
 out directories.
 
-```rust
-# #[macro_use]
-# extern crate error_chain;
+```rust,edition2018
+# use error_chain::error_chain;
 #
 use std::{env, fs};
 

src/file/dir/png.md

@@ -8,10 +8,8 @@ In this case, the `**` pattern matches the current directory and all subdirector
 Use the `**` pattern in any path portion. For example, `/media/**/*.png`
 matches all PNGs in `media` and it's subdirectories.
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate glob;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use glob::glob;
 #

src/file/dir/sizes.md

@@ -5,9 +5,7 @@
 Recursion depth can be flexibly set by [`WalkDir::min_depth`] & [`WalkDir::max_depth`] methods.
 Calculates sum of all file sizes to 3 subfolders depth, ignoring files in the root folder.
 
-```rust
-extern crate walkdir;
-
+```rust,edition2018
 use walkdir::WalkDir;
 
 fn main() {

src/file/dir/skip-dot.md

@@ -10,9 +10,7 @@ Uses [`filter_entry`] to descend recursively into entries passing the
 Root dir `"."` yields through [`WalkDir::depth`] usage in `is_not_hidden`
 predicate.
 
-```rust,no_run
-extern crate walkdir;
-
+```rust,edition2018,no_run
 use walkdir::{DirEntry, WalkDir};
 
 fn is_not_hidden(entry: &DirEntry) -> bool {

src/file/read-write/memmap.md

@@ -10,9 +10,7 @@ The [`Mmap::map`] function assumes the file
 behind the memory map is not being modified at the same time by another process
 or else a [race condition] occurs.
 
-```rust
-extern crate memmap;
-
+```rust,edition2018
 use memmap::Mmap;
 use std::fs::File;
 use std::io::{Write, Error};

src/file/read-write/read-file.md

@@ -8,7 +8,7 @@ time with the [`Lines`] iterator created by
 trait.  [`File::create`] opens a [`File`] for writing, [`File::open`] for
 reading.
 
-```rust
+```rust,edition2018
 use std::fs::File;
 use std::io::{Write, BufReader, BufRead, Error};
 

src/file/read-write/same-file.md

@@ -6,9 +6,7 @@ Use [`same_file::Handle`] to a file that can be tested for equality with
 other handles. In this example, the handles of file to be read from and
 to be written to are tested for equality.
 
-```rust,no_run
-extern crate same_file;
-
+```rust,edition2018,no_run
 use same_file::Handle;
 use std::fs::File;
 use std::io::{BufRead, BufReader, Error, ErrorKind};

src/hardware/processor/cpu-count.md

@@ -4,9 +4,7 @@
 
 Shows the number of logical CPU cores in current machine using [`num_cpus::get`].
 
-```rust
-extern crate num_cpus;
-
+```rust,edition2018
 fn main() {
     println!("Number of logical cores is {}", num_cpus::get());
 }

src/mem/global_static/lazy-constant.md

@@ -5,10 +5,8 @@
 Declares a lazily evaluated constant [`HashMap`]. The [`HashMap`] will
 be evaluated once and stored behind a global static reference.
 
-```rust
-#[macro_use]
-extern crate lazy_static;
-
+```rust,edition2018
+use lazy_static::lazy_static;
 use std::collections::HashMap;
 
 lazy_static! {

src/net/server/listen-unused.md

@@ -6,7 +6,7 @@ In this example, the port is displayed on the console, and the program will
 listen until a request is made.  `SocketAddrV4` assigns a random port when
 setting port to 0.
 
-```rust,no_run
+```rust,edition2018,no_run
 use std::net::{SocketAddrV4, Ipv4Addr, TcpListener};
 use std::io::{Read, Error};
 

src/os/external/continuous.md

@@ -10,7 +10,7 @@ The recipe below calls [`Stdio::piped`] to create a pipe, and reads
 The below recipe is equivalent to the Unix shell command
 `journalctl | grep usb`.
 
-```rust,no_run
+```rust,edition2018,no_run
 use std::process::{Command, Stdio};
 use std::io::{BufRead, BufReader, Error, ErrorKind};
 

src/os/external/error-file.md

@@ -12,7 +12,7 @@ cursor position.
 The below recipe is equivalent to run the Unix shell command `ls
 . oops >out.txt 2>&1`.
 
-```rust,no_run
+```rust,edition2018,no_run
 use std::fs::File;
 use std::io::Error;
 use std::process::{Command, Stdio};

src/os/external/piped.md

@@ -9,9 +9,8 @@ sort -hr | head -n 10`.
 [`Command`]s represent a process. Output of a child process is captured with a
 [`Stdio::piped`] between parent and child.
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 #
 use std::process::{Command, Stdio};
 #

src/os/external/process-output.md

@@ -5,10 +5,8 @@
 Runs `git log --oneline` as an external [`Command`] and inspects its [`Output`]
 using [`Regex`] to get the hash and message of the last 5 commits.
 
-```rust,no_run
-# #[macro_use]
-# extern crate error_chain;
-extern crate regex;
+```rust,edition2018,no_run
+# use error_chain::error_chain;
 
 use std::process::Command;
 use regex::Regex;
@@ -31,7 +29,7 @@ fn main() -> Result<()> {
     let output = Command::new("git").arg("log").arg("--oneline").output()?;
 
     if !output.status.success() {
-        bail!("Command executed with failing error code");
+        error_chain::bail!("Command executed with failing error code");
     }
 
     let pattern = Regex::new(r"(?x)