Enable syntax highlighting

1 files changed, 70 insertions, 40 deletions

diff --git a/doc/manual/src/expressions/language-values.md b/doc/manual/src/expressions/language-values.md
index eca2cab51..ce31029cc 100644
--- a/doc/manual/src/expressions/language-values.md
+++ b/doc/manual/src/expressions/language-values.md
@@ -19,24 +19,30 @@ Nix has the following basic data types:
     into a string (meaning that it must be a string, a path, or a
     derivation). For instance, rather than writing
     
-        "--with-freetype2-library=" + freetype + "/lib"
+    ```nix
+    "--with-freetype2-library=" + freetype + "/lib"
+    ```
     
     (where `freetype` is a derivation), you can instead write the more
     natural
     
-        "--with-freetype2-library=${freetype}/lib"
+    ```nix
+    "--with-freetype2-library=${freetype}/lib"
+    ```
     
     The latter is automatically translated to the former. A more
     complicated example (from the Nix expression for
     [Qt](http://www.trolltech.com/products/qt)):
     
-        configureFlags = "
-          -system-zlib -system-libpng -system-libjpeg
-          ${if openglSupport then "-dlopen-opengl
-            -L${mesa}/lib -I${mesa}/include
-            -L${libXmu}/lib -I${libXmu}/include" else ""}
-          ${if threadSupport then "-thread" else "-no-thread"}
-        ";
+    ```nix
+    configureFlags = "
+      -system-zlib -system-libpng -system-libjpeg
+      ${if openglSupport then "-dlopen-opengl
+        -L${mesa}/lib -I${mesa}/include
+        -L${libXmu}/lib -I${libXmu}/include" else ""}
+      ${if threadSupport then "-thread" else "-no-thread"}
+    ";
+    ```
     
     Note that Nix expressions and strings can be arbitrarily nested; in
     this case the outer string contains various antiquotations that
@@ -46,11 +52,13 @@ Nix has the following basic data types:
     The second way to write string literals is as an *indented string*,
     which is enclosed between pairs of *double single-quotes*, like so:
     
-        ''
-          This is the first line.
-          This is the second line.
-            This is the third line.
-        ''
+    ```nix
+    ''
+      This is the first line.
+      This is the second line.
+        This is the third line.
+    ''
+    ```
     
     This kind of string literal intelligently strips indentation from
     the start of each line. To be precise, it strips from each line a
@@ -60,7 +68,9 @@ Nix has the following basic data types:
     line is indented four spaces. Thus, two spaces are stripped from
     each line, so the resulting string is
     
-        "This is the first line.\nThis is the second line.\n  This is the third line.\n"
+    ```nix
+    "This is the first line.\nThis is the second line.\n  This is the third line.\n"
+    ```
     
     Note that the whitespace and newline following the opening `''` is
     ignored if there is no non-whitespace text on the initial line.
@@ -82,17 +92,19 @@ Nix has the following basic data types:
     configuration files because `''` is much less common than `"`.
     Example:
     
-        stdenv.mkDerivation {
-          ...
-          postInstall =
-            ''
-              mkdir $out/bin $out/etc
-              cp foo $out/bin
-              echo "Hello World" > $out/etc/foo.conf
-              ${if enableBar then "cp bar $out/bin" else ""}
-            '';
-          ...
-        }
+    ```nix
+    stdenv.mkDerivation {
+      ...
+      postInstall =
+        ''
+          mkdir $out/bin $out/etc
+          cp foo $out/bin
+          echo "Hello World" > $out/etc/foo.conf
+          ${if enableBar then "cp bar $out/bin" else ""}
+        '';
+      ...
+    }
+    ```
     
     Finally, as a convenience, *URIs* as defined in appendix B of
     [RFC 2396](http://www.ietf.org/rfc/rfc2396.txt) can be written *as
@@ -136,13 +148,17 @@ Nix has the following basic data types:
 Lists are formed by enclosing a whitespace-separated list of values
 between square brackets. For example,
 
-    [ 123 ./foo.nix "abc" (f { x = y; }) ]
+```nix
+[ 123 ./foo.nix "abc" (f { x = y; }) ]
+```
 
 defines a list of four elements, the last being the result of a call to
 the function `f`. Note that function calls have to be enclosed in
 parentheses. If they had been omitted, e.g.,
 
-    [ 123 ./foo.nix "abc" f { x = y; } ]
+```nix
+[ 123 ./foo.nix "abc" f { x = y; } ]
+```
 
 the result would be a list of five elements, the fourth one being a
 function and the fifth being a set.
@@ -159,10 +175,12 @@ Sets are just a list of name/value pairs (called *attributes*) enclosed
 in curly brackets, where each value is an arbitrary expression
 terminated by a semicolon. For example:
 
-    { x = 123;
-      text = "Hello";
-      y = f { bla = 456; };
-    }
+```nix
+{ x = 123;
+  text = "Hello";
+  y = f { bla = 456; };
+}
+```
 
 This defines a set with attributes named `x`, `text`, `y`. The order of
 the attributes is irrelevant. An attribute name may only occur once.
@@ -170,24 +188,32 @@ the attributes is irrelevant. An attribute name may only occur once.
 Attributes can be selected from a set using the `.` operator. For
 instance,
 
-    { a = "Foo"; b = "Bar"; }.a
+```nix
+{ a = "Foo"; b = "Bar"; }.a
+```
 
 evaluates to `"Foo"`. It is possible to provide a default value in an
 attribute selection using the `or` keyword. For example,
 
-    { a = "Foo"; b = "Bar"; }.c or "Xyzzy"
+```nix
+{ a = "Foo"; b = "Bar"; }.c or "Xyzzy"
+```
 
 will evaluate to `"Xyzzy"` because there is no `c` attribute in the set.
 
 You can use arbitrary double-quoted strings as attribute names:
 
-    { "foo ${bar}" = 123; "nix-1.0" = 456; }."foo ${bar}"
+```nix
+{ "foo ${bar}" = 123; "nix-1.0" = 456; }."foo ${bar}"
+```
 
 This will evaluate to `123` (Assuming `bar` is antiquotable). In the
 case where an attribute name is just a single antiquotation, the quotes
 can be dropped:
 
-    { foo = 123; }.${bar} or 456 
+```nix
+{ foo = 123; }.${bar} or 456
+```
 
 This will evaluate to `123` if `bar` evaluates to `"foo"` when coerced
 to a string and `456` otherwise (again assuming `bar` is antiquotable).
@@ -196,7 +222,9 @@ In the special case where an attribute name inside of a set declaration
 evaluates to `null` (which is normally an error, as `null` is not
 antiquotable), that attribute is simply not added to the set:
 
-    { ${if foo then "bar" else null} = true; }
+```nix
+{ ${if foo then "bar" else null} = true; }
+```
 
 This will evaluate to `{}` if `foo` evaluates to `false`.
 
@@ -205,9 +233,11 @@ itself a function or a set with a `__functor` attribute whose value is
 callable) can be applied as if it were a function, with the set itself
 passed in first , e.g.,
 
-    let add = { __functor = self: x: x + self.x; };
-        inc = add // { x = 1; };
-    in inc 1
+```nix
+let add = { __functor = self: x: x + self.x; };
+    inc = add // { x = 1; };
+in inc 1
+```
 
 evaluates to `2`. This can be used to attach metadata to a function
 without the caller needing to treat it specially, or to implement a form