Update concept documents to match style guide.

Author: verdammelt

concepts/conditionals/about.md

@@ -2,7 +2,8 @@
 
 Common Lisp provides the programmer with several different conditionals that can be categorised by the number of "branches" they support.
 
-Also, unlike many other programming languages, all conditionals in Common Lisp are _expressions_ not statements. This means that all Lisp conditionals evaluate to some value and can be substituted for concrete parameters.
+Also, unlike many other programming languages, all conditionals in Common Lisp are _expressions_ not statements.
+This means that all Lisp conditionals evaluate to some value and can be substituted for concrete parameters.
 
 As an example:
 
@@ -30,7 +31,9 @@ The `if` conditional evaluates the first expression of the body when the test is
 
 ## Many-Branch Conditionals
 
-The Lisp "super-conditional" is `cond`, which can have an infinite number of branches. Each branch has a test condition and body expression that are surrounded by an extra pair of parentheses. If all of the tests evaluate to false, then `nil` is returned.
+The Lisp "super-conditional" is `cond`, which can have an infinite number of branches.
+Each branch has a test condition and body expression that are surrounded by an extra pair of parentheses.
+If all of the tests evaluate to false, then `nil` is returned.
 
 ```lisp
 (cond ((= 0 2) 'nope)
@@ -41,7 +44,9 @@ The Lisp "super-conditional" is `cond`, which can have an infinite number of bra
 ; => QUITE-TRUE
 ```
 
-If you just want to test one value against a number of branches, you can use the cleaner `case` expression. If none of the cases match, `nil` is returned. Both `t` and `otherwise` can be used as catch-all cases
+If you just want to test one value against a number of branches, you can use the cleaner `case` expression.
+If none of the cases match, `nil` is returned.
+Both `t` and `otherwise` can be used as catch-all cases:
 
 ```lisp
 (case 'elder-beast
@@ -54,20 +59,16 @@ If you just want to test one value against a number of branches, you can use the
 
 ## The Stealth Conditionals
 
-The boolean `and` and `or` operations in Common Lisp are short-circuiting macros
-that can be used to reduce the duplication of certain conditional
-expressions.
+The boolean `and` and `or` operations in Common Lisp are short-circuiting macros that can be used to reduce the duplication of certain conditional expressions.
 
-The `and` macro will immediately return `nil` if a single false value is
-encountered, but the last true value of the `and` otherwise:
+The `and` macro will immediately return `nil` if a single false value is encountered, but the last true value of the `and` otherwise:
 
 ```lisp
 (and 42 "Magic" :cool) ; => :COOL
 (and () "Magic" :cool) ; => NIL
 ```
 
-The `or` macro returns the first true value it encounters or `nil` if there were
-no true values:
+The `or` macro returns the first true value it encounters or `nil` if there were no true values:
 
 ```lisp
 (or () 42 nil) ; => 42
@@ -76,13 +77,10 @@ no true values:
 
 ## I'm Exhausted...
 
-As mentioned previously, when none of the branches in a `case` statement match,
-and there is no `otherwise` clause, `nil` is returned. Occasionally, however, a
-failure to match any branch should be treated as an error – this is where
-`ecase` (for **exhaustive** matching) comes in.
+As mentioned previously, when none of the branches in a `case` statement match, and there is no `otherwise` clause, `nil` is returned.
+Occasionally, however, a failure to match any branch should be treated as an error – this is where `ecase` (for **exhaustive** matching) comes in.
 
-It's used in exactly the same way as `case`, but signals an error instead of
-returning `nil` when there is no match.
+It's used in exactly the same way as `case`, but signals an error instead of returning `nil` when there is no match.
 
 ```lisp
 (case 'elder-beast

concepts/default-parameters/about.md

@@ -1,22 +1,25 @@
 # About
 
-An optional parameter is designated by the `&optional` lambda list keyword in a lambda list. Optional parameters are not required, can have a default and also can specify a "supplied-p parameter" which will be "true" or "false" depending on whether an argument was provided for the parameter.
+An optional parameter is designated by the `&optional` lambda list keyword in a lambda list.
+Optional parameters are not required, can have a default and also can specify a "supplied-p parameter" which will be "true" or "false" depending on whether an argument was provided for the parameter.
 
 ```lisp
 (defun optional-parameter (&optional (arg -1)) arg)
 (optional-parameter)    ;; => -1
 (optional-parameter 13) ;; => 13
 ```
 
-Optional parameters must be put after required parameters but before named or rest parameters. Arguments are first bound to required parameters, then optional parameters and finally to rest and named parameters.
+Optional parameters must be put after required parameters but before named or rest parameters.
+Arguments are first bound to required parameters, then optional parameters and finally to rest and named parameters.
 
 ```lisp
 (defun req-and-opt (req &optional (opt -1)) (list req opt)
 (req-and-opt 1)    ;; => (1 -1)
 (req-and-opt 1 13) ;; => (1 13)
 ```
 
-While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully. See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
+While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully.
+See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
 
 --
 

concepts/default-parameters/introduction.md

@@ -1,6 +1,11 @@
 # Introduction
 
-In Common Lisp a function can have some arguments are are optional. These are designated in the lambda list by `&optional` lambda list keyword. A parameter will be bound to the value `nil` if it is not specified. If there are several optional parameters they are bound in order. Default values can be specified for optional parameters. Finally a symbol an be specified for each optional parameter which will be bound to true or false depending on whether that parameter was supplied by the caller of the function (this is referred to as the "supplied-p parameter").
+In Common Lisp a function can have some arguments are are optional.
+These are designated in the lambda list by `&optional` lambda list keyword.
+A parameter will be bound to the value `nil` if it is not specified.
+If there are several optional parameters they are bound in order.
+Default values can be specified for optional parameters.
+Finally a symbol an be specified for each optional parameter which will be bound to true or false depending on whether that parameter was supplied by the caller of the function (this is referred to as the "supplied-p parameter").
 
 ```lisp
 (defun default-parameters (&optional x (y 'default) (z nil z-supplied-p))

concepts/functions/about.md

@@ -2,31 +2,22 @@
 
 In Common Lisp, global, named functions are defined with `defun`.
 
-This form takes as its first argument a list of parameters for the
-function being defined (the list of parameters is also called a
-'lambda list'). After that it can, optionally, take a string for use
-as documentation to that function. Finally there are zero or more
-expressions which make up the body of the function.
+This form takes as its first argument a list of parameters for the function being defined (the list of parameters is also called a 'lambda list').
+After that it can, optionally, take a string for use as documentation to that function.
+Finally there are zero or more expressions which make up the body of the function.
 
-Calling a function is done by using the name of the function as the
-first element of an expression, followed by any parameters to that
-function.
+Calling a function is done by using the name of the function as the first element of an expression, followed by any parameters to that function.
 
 ```lisp
 (defun add-one (x) (1+ x))
 
 (add-one 3) ;; => 4
 ```
 
-Functions can also take [optional
-parameters](../default-parameters/about.md), [keyword
-parameters](../named-parameters/about.md), [rest
-parameters](../rest-parameters/about.md). These will be discussed in
-later concepts.
+Functions can also take [optional parameters](../default-parameters/about.md), [keyword parameters](../named-parameters/about.md), [rest parameters](../rest-parameters/about.md).
+These will be discussed in later concepts.
 
-The name of the function is in [scope](../scope/about.md) in the body of
-the function so that [recursion](../recursion/about.md) can be
-performed.
+The name of the function is in [scope](../scope/about.md) in the body of the function so that [recursion](../recursion/about.md) can be performed.
 
 ```lisp
 (defun countdown (x)

concepts/functions/introduction.md

@@ -1,10 +1,8 @@
 # Introduction
 
-To define a global function in Common Lisp one uses the `defun`
-expression. This expression takes as its first argument a list of
-parameters (and empty list means the function has no parameters). This
-is followed by an optional documentation string (see below), then zero
-or more expressions which make up the "body" of the function.
+To define a global function in Common Lisp one uses the `defun` expression.
+This expression takes as its first argument a list of parameters (and empty list means the function has no parameters).
+This is followed by an optional documentation string (see below), then zero or more expressions which make up the "body" of the function.
 
 Functions may have zero or more parameters.
 
@@ -16,23 +14,17 @@ Functions may have zero or more parameters.
 (defun add-nums (x y) (+ x y))
 ```
 
-Calling a function is done by evaluating an expression with the symbol
-designating the function as the first element of the expression with
-the arguments to the function (if any) as the remaining items in the
-expression.
+Calling a function is done by evaluating an expression with the symbol designating the function as the first element of the expression with the arguments to the function (if any) as the remaining items in the expression.
 
-The value that a function evaluates to is the value of the last
-expression in the function body that was evaluated. All functions
-evaluate to a value.
+The value that a function evaluates to is the value of the last expression in the function body that was evaluated. All functions evaluate to a value.
 
 ```lisp
 (add-nums 2 2) ;; => 4
 ```
 
-Functions can also have, optionally, a documentation string (also
-called a 'docstring'). If provided it comes after the argument list
-but before the body of the function. The documentation string can be
-accessed via `documentation`.
+Functions can also have, optionally, a documentation string (also called a 'docstring').
+If provided it comes after the argument list but before the body of the function.
+The documentation string can be via `documentation`.
 
 ```lisp
 (defun add-nums (x y) "Add X and Y together" (+ x y))

concepts/lambda-list/about.md

@@ -1,10 +1,12 @@
 # About
 
-In Common Lisp a parameter list (such as for defining a function) is also known as a (lambda list)[lambda-list]. Lambda lists are also used for defining macros and destructuring.
+In Common Lisp a parameter list (such as for defining a function) is also known as a (lambda list)[lambda-list]. 
+Lambda lists are also used for defining macros and destructuring.
 
 Lambda lists can contain (lambda list keywords)[lambda-list-keyword] such as `&rest`, `&optional`, `&key` and others.
 
-While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully. See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
+While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully.
+See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
 
 --
 

concepts/lambda-list/introduction.md

@@ -1,6 +1,11 @@
 # Introduction
 
-In Common Lisp a function's argument list is known as a ('lambda list')[lambda-list]. A lambda list can can have arguments of different types. These different types are designated with the use of ('lambda list keywords')[lambda-list-keyword] which all begin with `&`. The most commonly used types are optional, keyword and rest arguments types. Every parameter in the lambda list after a particular lambda list keyword is will be of that type. A lambda list keyword can only be used once in a lambda list.
+In Common Lisp a function's argument list is known as a ('lambda list')[lambda-list].
+A lambda list can can have arguments of different types.
+These different types are designated with the use of ('lambda list keywords')[lambda-list-keyword] which all begin with `&`.
+The most commonly used types are optional, keyword and rest arguments types.
+Every parameter in the lambda list after a particular lambda list keyword is will be of that type.
+A lambda list keyword can only be used once in a lambda list.
 
 Lambda lists are also used in other constructs which will be discussed later such as destructuring and macros.
 

concepts/lists/about.md

@@ -1,12 +1,16 @@
 # About
 
-[Lists][hyper-cons-as-list] are a very common data type in Common Lisp. They are made up of a sequence of [cons][../cons/about.md] cells. Each `car` is an element of the list and every `cdr` is a either the next cons cell or a terminating atom.
+[Lists][hyper-cons-as-list] are a very common data type in Common Lisp.
+They are made up of a sequence of [cons][../cons/about.md] cells.
+Each `car` is an element of the list and every `cdr` is a either the next cons cell or a terminating atom.
 
 A list which terminates with the empty list is called a "proper list".
 
 A list which terminates with an atom that is not th empty list is called a "dotted list" (based upon how it is printed: `(cons 'a 'b) ;=> (a . b)`).
 
-A list can also be circular if some cons cell in the list `cdr` of a later cons cell. For example: `(let ((x (list 1))) (setf (cdr x) x) (write x :stream t :circle t) :done)`. Take care when working with circular lists as allowing them to be printed out without binding [`*print-circle*`][hyper-print-circle] to `t` will cause an infinite loop and will lock up the REPL (in this example by specifying `:circle t` to `write`, `*print-circle` will be bound to `t`).
+A list can also be circular if some cons cell in the list `cdr` of a later cons cell.
+For example: `(let ((x (list 1))) (setf (cdr x) x) (write x :stream t :circle t) :done)`.
+Take care when working with circular lists as allowing them to be printed out without binding [`*print-circle*`][hyper-print-circle] to `t` will cause an infinite loop and will lock up the REPL (in this example by specifying `:circle t` to `write`, `*print-circle` will be bound to `t`).
 
 [hyper-cons-as-list]: http://l1sp.org/cl/14.1.2
 [hyper-print-circle]: http://l1sp.org/cl/*print-circle*

concepts/lists/introduction.md

@@ -4,7 +4,9 @@ Given that the name of the language is Lisp which stands of _LISt Processing_ on
 
 While Common Lisp has other data structures as well as lists, lists are still heavily used.
 
-A list in Common Lisp is a sequence of items. The items themselves do not have to be the same type. For example you can have a list of `1`, `two`, `"III"`.
+A list in Common Lisp is a sequence of items.
+The items themselves do not have to be the same type.
+For example you can have a list of `1`, `two`, `"III"`.
 
 ## Creating Lists
 
@@ -32,11 +34,13 @@ There are also two main functions used to create lists: `list` and `cons`.
 
 ## Length & Random Access
 
-The length of a list can be determined by the use of `length`. An empty list has length zero.
+The length of a list can be determined by the use of `length`.
+An empty list has length zero.
 
 An arbitrary item can be accessed with `nth` (note that lists are zero-indexed).
 
-It is _not_ an error to request an index that is more than the length. Instead it evaluates to `nil`:
+It is _not_ an error to request an index that is more than the length.
+Instead it evaluates to `nil`:
 
 ```lisp
 (nth 23 '(short list))` ; => nil

concepts/named-parameters/about.md

@@ -2,22 +2,25 @@
 
 In Common Lisp named parameters are called keyword parameters.
 
-Keyword parameters are designated by the `&key` lambda list keyword in a lambda list. Keyword parameters are not required, can have a default and also can specify a "supplied-p parameter" which will be "true" or "false" depending on whether an argument was provided for the parameter.
+Keyword parameters are designated by the `&key` lambda list keyword in a lambda list.
+Keyword parameters are not required, can have a default and also can specify a "supplied-p parameter" which will be "true" or "false" depending on whether an argument was provided for the parameter.
 
 ```lisp
 (defun keyword-parameter (&key (arg -1) arg)
 (keyword-parameter)         ;; => -1
 (keyword-parameter :arg 13) ;; => 13
 ```
 
-In the arguments to a function the keyword parameters are specified by their "keyword name" which is, by default, a keyword symbol version of the parameter name (_i.e._ keyword parameter `name` has a keyword name of `:name`). It is possible to specify another name for the keyword parameter by using a list of keyword name and parameter name instead of just the parameter name:
+In the arguments to a function the keyword parameters are specified by their "keyword name" which is, by default, a keyword symbol version of the parameter name (_i.e._ keyword parameter `name` has a keyword name of `:name`).
+It is possible to specify another name for the keyword parameter by using a list of keyword name and parameter name instead of just the parameter name:
 
 ```lisp
 (defun other-keyword-name (&key ((other-name arg))) (list arg))
 (other-keyword-name 'other-name 5) ;; => (5)
 ```
 
-While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully. See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
+While multiple types of parameters can be combined with other types of parameters (optional and keyword arguments) this can be be problematic and should be done carefully.
+See the section on ("Mixing Different Parameter Types")(pcl-function) in Practical Common Lisp.
 
 --
 

concepts/named-parameters/introduction.md

@@ -1,8 +1,12 @@
 # Introduction
 
-In Common Lisp a function can have named parameters (referred to as "keyword parameters" or "keyword arguments"). These are designated in the lambda list by the `&key` lambda list keyword. Keyword parameters are not required parameters. Like optional parameters they can be given default values and symbols to bind to their 'supplied-or-not' state.
+In Common Lisp a function can have named parameters (referred to as "keyword parameters" or "keyword arguments").
+These are designated in the lambda list by the `&key` lambda list keyword.
+Keyword parameters are not required parameters.
+Like optional parameters they can be given default values and symbols to bind to their 'supplied-or-not' state.
 
-When calling a function with keyword parameters the name of the parameter as a keyword is used in front of the parameter value. Keyword parameters can be specified by the caller of the function in any order.
+When calling a function with keyword parameters the name of the parameter as a keyword is used in front of the parameter value.
+Keyword parameters can be specified by the caller of the function in any order.
 
 ```lisp
 (defun keyword-parameters (&key x (y 'default) (z nil z-supplied-p))