content: convert to Markdown-enabled present inputs

Converted blog to Markdown-enabled present (CL 222846)
using present2md (CL 222847).

For golang/go#33955.

Change-Id: Ib39fa1ddd9a46f9c7a62a2ca7b96e117635553e8
Reviewed-on: https://go-review.googlesource.com/c/blog/+/222848
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Andrew Bonventre <andybons@golang.org>

1 files changed, 13 insertions, 12 deletions

diff --git a/content/defer-panic-and-recover.article b/content/defer-panic-and-recover.article
index 2c95aa3..e3773ba 100644
--- a/content/defer-panic-and-recover.article
+++ b/content/defer-panic-and-recover.article
@@ -1,10 +1,11 @@
-Defer, Panic, and Recover
+# Defer, Panic, and Recover
 4 Aug 2010
 Tags: defer, panic, recover, technical, function
+Summary: 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.
 
 Andrew Gerrand
 
-* Introduction
+##
 
 Go has the usual mechanisms for control flow:
 if, for, switch, goto.
@@ -12,7 +13,7 @@ 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.
+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.
 
@@ -64,7 +65,7 @@ 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._
+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.
@@ -76,7 +77,7 @@ The deferred call will print "0" after the function returns.
 	    return
 	}
 
-2. _Deferred_function_calls_are_executed_in_Last_In_First_Out_order_after_the_surrounding_function_returns._
+2. _Deferred function calls are executed in Last In First Out order after the surrounding function returns._
 
 This function prints "3210":
 
@@ -86,7 +87,7 @@ This function prints "3210":
 	    }
 	}
 
-3. _Deferred_functions_may_read_and_assign_to_the_returning_function's_named_return_values._
+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.
@@ -99,7 +100,7 @@ Thus, this function returns 2:
 
 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_.
+**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.
@@ -110,7 +111,7 @@ 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 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
@@ -189,19 +190,19 @@ This modified program will output:
 	panic PC=0x2a9cd8
 	[stack trace omitted]
 
-For a real-world example of *panic* and *recover*,
-see the [[https://golang.org/pkg/encoding/json/][json package]] from the
+For a real-world example of **panic** and **recover**,
+see the [json package](https://golang.org/pkg/encoding/json/) 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 'error' and 'marshal' methods of the encodeState type in [encode.go](https://golang.org/src/pkg/encoding/json/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.
 
-Other uses of *defer* (beyond the file.Close example given earlier) include releasing a mutex:
+Other uses of **defer** (beyond the file.Close example given earlier) include releasing a mutex:
 
 	mu.Lock()
 	defer mu.Unlock()