Use 3-backticks for code blocks in README

Author: xenomachina

README.md

@@ -19,16 +19,18 @@ Typical usage is to create a class to represent the set of parsed arguments,
 which are in turn each represented by properties that delegate to an
 `ArgParser`:
 
-    class MyArgs(parser: ArgParser) {
-        val verbose by parser.flagging("-v", "--verbose",
-                                       help="enable verbose mode")
+```kotlin
+class MyArgs(parser: ArgParser) {
+    val verbose by parser.flagging("-v", "--verbose",
+                                   help="enable verbose mode")
 
-        val name by parser.storing("-N", "--name",
-                                   help = "name of the widget")
+    val name by parser.storing("-N", "--name",
+                               help = "name of the widget")
 
-        val size by parser.storing("-s", "--size",
-                                   help = "size of the plumbus") { toInt() }
-    }
+    val size by parser.storing("-s", "--size",
+                               help = "size of the plumbus") { toInt() }
+}
+```
 
 
 ## Option Types
@@ -38,8 +40,10 @@ Various types of options can be parsed from the command line arguments:
 - Boolean flags are created by asking the parser for a `flagging` delegate.  One
   or more option names, either short or long style, must be provided:
 
-        val verbose by parser.flagging("-v", "--verbose",
-                                       help = "enable verbose mode")
+  ```kotlin
+  val verbose by parser.flagging("-v", "--verbose",
+                                 help = "enable verbose mode")
+  ```
 
   Here the presence of either `-v` or `--verbose` options in the
   arguments will cause the `Boolean` property `verbose` to be `true`, otherwise
@@ -48,36 +52,44 @@ Various types of options can be parsed from the command line arguments:
 - Single argument options are created by asking the parser for a
   `storing` delegate.
 
-        val name by parser.storing("-N", "--name",
-                                   help = "name of the widget")
+  ```kotlin
+  val name by parser.storing("-N", "--name",
+                             help = "name of the widget")
+  ```
 
   Here either `-N` or `--name` with an argument will cause `name` to have that
   argument as its value.
 
   A function can also be supplied to transform the argument into the desired
   type. Here the `size` property will be an `Int` rather than a `String`:
 
-        val size by parser.storing("-s", "--size",
-                                   help = "size of the plumbus") { toInt() }
+  ```kotlin
+  val size by parser.storing("-s", "--size",
+                             help = "size of the plumbus") { toInt() }
+  ```
 
 - Options that add to a `Collection` each time they
   appear in the arguments are created with using the `adding` delegate. Just like `storing`
   delegates, a transform function may optionally be supplied:
 
-        val includeDirs by parser.adding(
-                "-I", help = "directory to search for header files") { File(this) }
+  ```kotlin
+  val includeDirs by parser.adding(
+          "-I", help = "directory to search for header files") { File(this) }
+  ```
 
   Now each time the `-I` option appears, its argument is appended to
   `includeDirs`.
 
 - For choosing between a fixed set of values (typically, but not necessarily,
   from an enum), a `mapping` delegate can be used:
 
-        val mode by parser.mapping(
-                "--fast" to Mode.FAST,
-                "--small" to Mode.SMALL,
-                "--quiet" to Mode.QUIET,
-                help = "mode of operation")
+  ```kotlin
+  val mode by parser.mapping(
+          "--fast" to Mode.FAST,
+          "--small" to Mode.SMALL,
+          "--quiet" to Mode.QUIET,
+          help = "mode of operation")
+  ```
 
   Here the `mode` property will be set to the corresponding `Mode` value depending
   on which of `--fast`, `--small`, and `--quiet` appears (last) in the arguments.
@@ -86,19 +98,21 @@ Various types of options can be parsed from the command line arguments:
   `option` method can be used.  (The methods described above are convenience
   methods built on top of `option`.)
 
-        val zaphod by parser.option(
-                "--fibonacci",
-                help = "collects fibonnaci sequence, remembers length") {
-            var prev = 0
-            var current = 1
-            var result = 0
-            while (peek() == current) {
-                result++
-                prev, current = current, current+prev
-                next()
-            }
-            return result
-        }
+  ```kotlin
+  val zaphod by parser.option(
+          "--fibonacci",
+          help = "collects fibonnaci sequence, remembers length") {
+      var prev = 0
+      var current = 1
+      var result = 0
+      while (peek() == current) {
+          result++
+          prev, current = current, current+prev
+          next()
+      }
+      return result
+  }
+  ```
 
 The delegates returned by any of these methods also have a few methods for setting
 optional attributes:
@@ -107,18 +121,22 @@ optional attributes:
   default value, and hence will be required options unless a default
   value is provided. This is done with the `default` method:
 
-        val name by parser.storing("-N", "--name", help="...")
-                .default("John Doe")
+  ```kotlin
+  val name by parser.storing("-N", "--name", help="...")
+          .default("John Doe")
+  ```
 
 - Sometimes it's easier to validate an option at the end pf parsing, in which
   case the `addValidator` method can be used.
 
-        val percentages by parser.adding("--percentages", help="...") { toInt() }
-                .addValidator {
-                      if (sum() != 100)
-                          throw InvalidArgumentException(
-                                  "Percentages must add up to 100%")
-                }
+  ```kotlin
+  val percentages by parser.adding("--percentages", help="...") { toInt() }
+          .addValidator {
+                if (sum() != 100)
+                    throw InvalidArgumentException(
+                            "Percentages must add up to 100%")
+          }
+  ```
 
 
 ## Positional Arguments
@@ -128,15 +146,19 @@ Positional arguments are collected by using the `positional` and
 
 For a single positional argument:
 
-      val destination by parser.positional("DEST",
-                                           help="destination filename")
+```kotlin
+val destination by parser.positional("DEST",
+                                     help="destination filename")
+```
 
 The name ("DEST", here) is used in error handling and help text.
 
 For a list of positional arguments:
 
-      val sources by parser.positionalList("SOURCE", 1..Int.MAX_VALUE,
-                                           help="source filename")
+```kotlin
+val sources by parser.positionalList("SOURCE", 1..Int.MAX_VALUE,
+                                     help="source filename")
+```
 
 The range indicates how many arguments should be collected, and actually
 defaults to the value shown in this example. As the name suggests, the
@@ -145,11 +167,13 @@ resulting property will be a `List`.
 Both of these methods accept an optional transform function for converting
 arguments from `String` to whatever type is actually desired:
 
-      val destination by parser.positional(
-              "DEST", help="...") { File(this) }
+```kotlin
+val destination by parser.positional("DEST",
+                                     help="...") { File(this) }
 
-      val sources by parser.positionalList(
-              "SOURCE", 1..Int.MAX_VALUE, help="...") { File(this) }
+val sources by parser.positionalList("SOURCE", 1..Int.MAX_VALUE,
+                                     help="...") { File(this) }
+```
 
 
 ## Error Handling
@@ -165,10 +189,12 @@ Additional post-parsing validation can be performed on a delegate using
 As a convenience, these exceptions can be handled by using the `runMain`
 extension function:
 
-      fun main(args: Array<String>) =
-              MyArgs(ArgParser(args)).runMain(PROGRAM_NAME) {
-                  println("Hello, {name}!")
-              }
+```kotlin
+fun main(args: Array<String>) =
+        MyArgs(ArgParser(args)).runMain(PROGRAM_NAME) {
+            println("Hello, {name}!")
+        }
+```
 
 Note that parsing does not take place until at least one delegate is read, or
 `force` is called manually. It may be desirable to call `force` on the parser