content: wrap long lines using new program wrap.go

Wrapping long lines will make diffs easier to read
for the eventual conversion to Markdown.

For golang/go#33955.

Change-Id: Ibcc1b5a84ccc9144b5fcdc9266f2da3e2cf3c5a3
Reviewed-on: https://go-review.googlesource.com/c/blog/+/222839
Reviewed-by: Ian Lance Taylor <iant@golang.org>

1 files changed, 60 insertions, 13 deletions

diff --git a/content/defer-panic-and-recover.article b/content/defer-panic-and-recover.article
index 2c4018c..8bea0ab 100644
--- a/content/defer-panic-and-recover.article
+++ b/content/defer-panic-and-recover.article
@@ -6,10 +6,16 @@ Andrew Gerrand
 
 * Introduction
 
-Go has the usual mechanisms for control flow: if, for, switch, goto.  It also has the go statement to run code in a separate goroutine.  Here I'd like to discuss some of the less common ones: defer, panic, and recover.
+Go has the usual mechanisms for control flow:
+if, for, switch, goto.
+It also has the go statement to run code in a separate goroutine.
+Here I'd like to discuss some of the less common ones:
+defer, panic, and recover.
 
  
-A *defer*statement* pushes a function call onto a list. The list of saved calls is executed after the surrounding function returns. Defer is commonly used to simplify functions that perform various clean-up actions.
+A *defer*statement* pushes a function call onto a list.
+The list of saved calls is executed after the surrounding function returns.
+Defer is commonly used to simplify functions that perform various clean-up actions.
 
  
 For example, let's look at a function that opens two files and copies the contents of one file to the other:
@@ -32,7 +38,12 @@ For example, let's look at a function that opens two files and copies the conten
 	    return
 	}
 
-This works, but there is a bug. If the call to os.Create fails, the function will return without closing the source file. This can be easily remedied by putting a call to src.Close before the second return statement, but if the function were more complex the problem might not be so easily noticed and resolved. By introducing defer statements we can ensure that the files are always closed:
+This works, but there is a bug. If the call to os.Create fails,
+the function will return without closing the source file.
+This can be easily remedied by putting a call to src.Close before the second return statement,
+but if the function were more complex the problem might not be so easily
+noticed and resolved.
+By introducing defer statements we can ensure that the files are always closed:
 
  
 	func CopyFile(dstName, srcName string) (written int64, err error) {
@@ -51,13 +62,16 @@ This works, but there is a bug. If the call to os.Create fails, the function wil
 	    return io.Copy(dst, src)
 	}
 
-Defer statements allow us to think about closing each file right after opening it, guaranteeing that, regardless of the number of return statements in the function, the files _will_ be closed.
+Defer statements allow us to think about closing each file right after opening it,
+guaranteeing that, regardless of the number of return statements in the function,
+the files _will_ be closed.
 
 The behavior of defer statements is straightforward and predictable. There are three simple rules:
  
 1. _A_deferred_function's_arguments_are_evaluated_when_the_defer_statement_is_evaluated._
  
-In this example, the expression "i" is evaluated when the Println call is deferred. The deferred call will print "0" after the function returns.
+In this example, the expression "i" is evaluated when the Println call is deferred.
+The deferred call will print "0" after the function returns.
 
  
 	func a() {
@@ -80,7 +94,9 @@ This function prints "3210":
  
 3. _Deferred_functions_may_read_and_assign_to_the_returning_function's_named_return_values._
  
-In this example, a deferred function increments the return value i _after_ the surrounding function returns. Thus, this function returns 2:
+In this example, a deferred function increments the return value i _after_
+the surrounding function returns.
+Thus, this function returns 2:
 
 	func c() (i int) {
 	    defer func() { i++ }()
@@ -91,10 +107,23 @@ In this example, a deferred function increments the return value i _after_ the s
 This is convenient for modifying the error return value of a function; we will see an example of this shortly.
 
  
-*Panic* is a built-in function that stops the ordinary flow of control and begins _panicking_. When the function F calls panic, execution of F stops, any deferred functions in F are executed normally, and then F returns to its caller. To the caller, F then behaves like a call to panic. The process continues up the stack until all functions in the current goroutine have returned, at which point the program crashes. Panics can be initiated by invoking panic directly. They can also be caused by runtime errors, such as out-of-bounds array accesses.
+*Panic* is a built-in function that stops the ordinary flow of control and begins _panicking_.
+When the function F calls panic, execution of F stops,
+any deferred functions in F are executed normally,
+and then F returns to its caller.
+To the caller, F then behaves like a call to panic.
+The process continues up the stack until all functions in the current goroutine have returned,
+at which point the program crashes.
+Panics can be initiated by invoking panic directly.
+They can also be caused by runtime errors,
+such as out-of-bounds array accesses.
 
  
-*Recover* is a built-in function that regains control of a panicking goroutine. Recover is only useful inside deferred functions. During normal execution, a call to recover will return nil and have no other effect. If the current goroutine is panicking, a call to recover will capture the value given to panic and resume normal execution.
+*Recover* is a built-in function that regains control of a panicking goroutine.
+Recover is only useful inside deferred functions.
+During normal execution, a call to recover will return nil and have no other effect.
+If the current goroutine is panicking, a call to recover will capture the
+value given to panic and resume normal execution.
 
  
 Here's an example program that demonstrates the mechanics of panic and defer:
@@ -130,7 +159,11 @@ Here's an example program that demonstrates the mechanics of panic and defer:
 	}
 
  
-The function g takes the int i, and panics if i is greater than 3, or else it calls itself with the argument i+1. The function f defers a function that calls recover and prints the recovered value (if it is non-nil). Try to picture what the output of this program might be before reading on.
+The function g takes the int i, and panics if i is greater than 3,
+or else it calls itself with the argument i+1.
+The function f defers a function that calls recover and prints the recovered
+value (if it is non-nil).
+Try to picture what the output of this program might be before reading on.
 
  
 The program will output:
@@ -151,7 +184,10 @@ The program will output:
 
  
 
-If we remove the deferred function from f the panic is not recovered and reaches the top of the goroutine's call stack, terminating the program. This modified program will output:
+If we remove the deferred function from f the panic is not recovered and
+reaches the top of the goroutine's call stack,
+terminating the program.
+This modified program will output:
 
  
 	Calling g.
@@ -171,9 +207,17 @@ If we remove the deferred function from f the panic is not recovered and reaches
 
  
 
-For a real-world example of *panic* and *recover*, see the [[https://golang.org/pkg/encoding/json/][json package]] from the Go standard library. It encodes an interface with a set of recursive functions. If an error occurs when traversing the value, panic is called to unwind the stack to the top-level function call, which recovers from the panic and returns an appropriate error value (see the 'error' and 'marshal' methods of the encodeState type in [[https://golang.org/src/pkg/encoding/json/encode.go][encode.go]]).
+For a real-world example of *panic* and *recover*,
+see the [[https://golang.org/pkg/encoding/json/][json package]] from the
+Go standard library.
+It encodes an interface with a set of recursive functions.
+If an error occurs when traversing the value,
+panic is called to unwind the stack to the top-level function call,
+which recovers from the panic and returns an appropriate error value (see
+the 'error' and 'marshal' methods of the encodeState type in [[https://golang.org/src/pkg/encoding/json/encode.go][encode.go]]).
 
-The convention in the Go libraries is that even when a package uses panic internally, its external API still presents explicit error return values.
+The convention in the Go libraries is that even when a package uses panic internally,
+its external API still presents explicit error return values.
 
  
 Other uses of *defer* (beyond the file.Close example given earlier) include releasing a mutex:
@@ -194,4 +238,7 @@ printing a footer:
 and more.
 
  
-In summary, the defer statement (with or without panic and recover) provides an unusual and powerful mechanism for control flow.  It can be used to model a number of features implemented by special-purpose structures in other programming languages. Try it out.
+In summary, the defer statement (with or without panic and recover) provides
+an unusual and powerful mechanism for control flow.
+It can be used to model a number of features implemented by special-purpose
+structures in other programming languages. Try it out.