Can now mark definitions as deprecated in their documentation.

17 files changed, 151 insertions, 151 deletions

diff --git a/stdlib/source/documentation/lux/data/collection/array.lux b/stdlib/source/documentation/lux/data/collection/array.lux
index e821b976c..0f2c5094f 100644
--- a/stdlib/source/documentation/lux/data/collection/array.lux
+++ b/stdlib/source/documentation/lux/data/collection/array.lux
@@ -28,72 +28,72 @@
 
         ($.definition /.empty
           "An empty array of the specified size."
-          [(empty size)])
+          ($.example (empty size)))
 
         ($.definition /.size
           ""
-          [(size array)])
+          ($.example (size array)))
 
         ($.definition /.item
           ""
-          [(item index array)])
+          ($.example (item index array)))
 
         ($.definition /.has!
           "Mutate the array by writing a value to the specified index."
-          [(has! index value array)])
+          ($.example (has! index value array)))
 
         ($.definition /.lacks!
           "Mutate the array by deleting the value at the specified index."
-          [(lacks! index array)])
+          ($.example (lacks! index array)))
 
         ($.definition /.has?
           ""
-          [(has? index array)])
+          ($.example (has? index array)))
 
         ($.definition /.revised!
           "Mutate the array by updating the value at the specified index."
-          [(revised! index transform array)])
+          ($.example (revised! index transform array)))
 
         ($.definition /.upsert!
           (format "Mutate the array by updating the value at the specified index."
                   \n "If there is no value, update and write the default value given.")
-          [(upsert! index default transform array)])
+          ($.example (upsert! index default transform array)))
 
         ($.definition /.copy!
           "Writes the contents of one array into the other."
-          [(copy! length src_start src_array dest_start dest_array)])
+          ($.example (copy! length src_start src_array dest_start dest_array)))
 
         ($.definition /.occupancy
           "Finds out how many cells in an array are occupied."
-          [(occupancy array)])
+          ($.example (occupancy array)))
 
         ($.definition /.vacancy
           "Finds out how many cells in an array are vacant."
-          [(vacancy array)])
+          ($.example (vacancy array)))
 
         ($.definition /.only!
           "Delete every item of the array that fails to satisfy the predicate."
-          [(only! p xs)])
+          ($.example (only! p xs)))
 
         ($.definition /.example
           "Yields the first item in the array that satisfies the predicate."
-          [(example p xs)])
+          ($.example (example p xs)))
 
         ($.definition /.example'
           "Just like 'example', but with access to the index of each value."
-          [(example' p xs)])
+          ($.example (example' p xs)))
 
         ($.definition /.clone
           "Yields a shallow clone of the array."
-          [(clone xs)])
+          ($.example (clone xs)))
 
         ($.definition /.of_list
           ""
-          [(of_list xs)])
+          ($.example (of_list xs)))
 
         ($.definition /.list
           (format "Yields a list with every non-empty item in the array."
                   \n "Can use the optional default value when encountering an empty cell in the array.")
-          [(list {.#None} array)
-           (list {.#Some default} array)])
+          ($.example (list {.#None} array))
+          ($.example (list {.#Some default} array)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/bits.lux b/stdlib/source/documentation/lux/data/collection/bits.lux
index 296d9f087..98e02080f 100644
--- a/stdlib/source/documentation/lux/data/collection/bits.lux
+++ b/stdlib/source/documentation/lux/data/collection/bits.lux
@@ -27,21 +27,21 @@
 
         ($.definition /.size
           "Measures the size of a bit-map by counting all the 1s in the bit-map."
-          [(size bits)])
+          ($.example (size bits)))
 
         ($.definition /.capacity
           ""
-          [(capacity bits)])
+          ($.example (capacity bits)))
 
         ($.definition /.bit
           ""
-          [(bit index bits)])
+          ($.example (bit index bits)))
 
         ($.definition /.intersects?
           ""
-          [(intersects? reference sample)])
+          ($.example (intersects? reference sample)))
 
         ($.definition /.not
           ""
-          [(not input)])
+          ($.example (not input)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/dictionary.lux b/stdlib/source/documentation/lux/data/collection/dictionary.lux
index da8bd13e8..eaabd8c26 100644
--- a/stdlib/source/documentation/lux/data/collection/dictionary.lux
+++ b/stdlib/source/documentation/lux/data/collection/dictionary.lux
@@ -32,58 +32,58 @@
 
                 ($.definition /.empty
                   "An empty dictionary."
-                  [(empty key_hash)])
+                  ($.example (empty key_hash)))
 
                 ($.definition /.has
                   ""
-                  [(has key val dict)])
+                  ($.example (has key val dict)))
 
                 ($.definition /.lacks
                   ""
-                  [(lacks key dict)])
+                  ($.example (lacks key dict)))
 
                 ($.definition /.value
                   ""
-                  [(value key dict)])
+                  ($.example (value key dict)))
 
                 ($.definition /.key?
                   ""
-                  [(key? dict key)])
+                  ($.example (key? dict key)))
 
                 ($.definition /.has'
                   "Only puts the KV-pair if the key is not already present."
-                  [(has' key val dict)])
+                  ($.example (has' key val dict)))
 
                 ($.definition /.revised
                   "Transforms the value located at key (if available), using the given function."
-                  [(revised key f dict)])
+                  ($.example (revised key f dict)))
 
                 ($.definition /.revised'
                   (format "Updates the value at the key; if it exists."
                           \n "Otherwise, puts a value by applying the function to a default.")
-                  [(revised' key default f dict)])
+                  ($.example (revised' key default f dict)))
 
                 ($.definition /.of_list
                   ""
-                  [(of_list key_hash kvs)])
+                  ($.example (of_list key_hash kvs)))
 
                 ($.definition /.composite
                   (format "Merges 2 dictionaries."
                           \n "If any collisions with keys occur, the values of dict2 will overwrite those of dict1.")
-                  [(composite dict2 dict1)])
+                  ($.example (composite dict2 dict1)))
 
                 ($.definition /.composite_with
                   (format "Merges 2 dictionaries."
                           \n "If any collisions with keys occur, a new value will be computed by applying 'f' to the values of dict2 and dict1.")
-                  [(composite_with f dict2 dict1)])
+                  ($.example (composite_with f dict2 dict1)))
 
                 ($.definition /.re_bound
                   "If there is a value under 'from_key', remove 'from_key' and store the value under 'to_key'."
-                  [(re_bound from_key to_key dict)])
+                  ($.example (re_bound from_key to_key dict)))
 
                 ($.definition /.sub
                   "A sub-dictionary, with only the specified keys."
-                  [(sub keys dict)])
+                  ($.example (sub keys dict)))
 
                 /ordered.documentation
                 ))
diff --git a/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux b/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux
index d44fe0863..a9da85140 100644
--- a/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/source/documentation/lux/data/collection/dictionary/ordered.lux
@@ -27,15 +27,15 @@
 
             ($.definition /.empty
               "An empty dictionary, employing the given order."
-              [(empty order)])
+              ($.example (empty order)))
 
             ($.definition /.value
               ""
-              [(value key dict)])
+              ($.example (value key dict)))
 
             ($.definition /.key?
               ""
-              [(key? dict key)])
+              ($.example (key? dict key)))
 
             (,, (with_template [<name>]
                   [(`` ($.definition <name>
@@ -47,21 +47,21 @@
 
             ($.definition /.size
               ""
-              [(size dict)])
+              ($.example (size dict)))
 
             ($.definition /.has
               ""
-              [(has key value dict)])
+              ($.example (has key value dict)))
 
             ($.definition /.lacks
               ""
-              [(lacks key dict)])
+              ($.example (lacks key dict)))
 
             ($.definition /.revised
               ""
-              [(revised key transform dict)])
+              ($.example (revised key transform dict)))
 
             ($.definition /.of_list
               ""
-              [(of_list order list)])
+              ($.example (of_list order list)))
             )))
diff --git a/stdlib/source/documentation/lux/data/collection/list.lux b/stdlib/source/documentation/lux/data/collection/list.lux
index 9726f5d39..8d75d3a63 100644
--- a/stdlib/source/documentation/lux/data/collection/list.lux
+++ b/stdlib/source/documentation/lux/data/collection/list.lux
@@ -14,17 +14,17 @@
       (List $.Documentation)
       (let [zipped (list ($.definition /.zipped
                            "Create list zippers with the specified number of input lists."
-                           [(def zipped_2 (zipped 2))
-                            (def zipped_3 (zipped 3))
-                            (zipped_3 xs ys zs)
-                            ((zipped 3) xs ys zs)])
+                           ($.example (def zipped_2 (zipped 2)))
+                           ($.example (def zipped_3 (zipped 3)))
+                           ($.example (zipped_3 xs ys zs))
+                           ($.example ((zipped 3) xs ys zs)))
 
                          ($.definition /.zipped_with
                            "Create list zippers with the specified number of input lists."
-                           [(def zipped_with_2 (zipped_with 2))
-                            (def zipped_with_3 (zipped_with 3))
-                            (zipped_with_2 + xs ys)
-                            ((zipped_with 2) + xs ys)])
+                           ($.example (def zipped_with_2 (zipped_with 2)))
+                           ($.example (def zipped_with_3 (zipped_with 3)))
+                           ($.example (zipped_with_2 + xs ys))
+                           ($.example ((zipped_with 2) + xs ys)))
 
                          ($.definition /.zipped_2)
                          ($.definition /.zipped_3)
@@ -50,79 +50,79 @@
 
                    ($.definition /.mixes
                      ""
-                     [(mixes f init inputs)])
+                     ($.example (mixes f init inputs)))
 
                    ($.definition /.reversed
                      ""
-                     [(reversed xs)])
+                     ($.example (reversed xs)))
 
                    ($.definition /.only
                      "A list with only values that satisfy the predicate."
-                     [(only keep? xs)])
+                     ($.example (only keep? xs)))
 
                    ($.definition /.partition
                      "Divide the list into all elements that satisfy a predicate, and all elements that do not."
-                     [(partition satisfies? list)])
+                     ($.example (partition satisfies? list)))
 
                    ($.definition /.pairs
                      "Cut the list into pairs of 2."
-                     [(pairs list)])
+                     ($.example (pairs list)))
 
                    ($.definition /.split_at
                      ""
-                     [(split_at n xs)])
+                     ($.example (split_at n xs)))
 
                    ($.definition /.split_when
                      "Segment the list by using a predicate to tell when to cut."
-                     [(split_when predicate xs)])
+                     ($.example (split_when predicate xs)))
 
                    ($.definition /.sub
                      "Segment the list into sub-lists of (at most) the given size."
-                     [(sub size list)])
+                     ($.example (sub size list)))
 
                    ($.definition /.repeated
                      "A list of the value x, repeated n times."
-                     [(repeated n x)])
+                     ($.example (repeated n x)))
 
                    ($.definition /.iterations
                      "Generates a list element by element until the function returns .#None."
-                     [(iterations f x)])
+                     ($.example (iterations f x)))
 
                    ($.definition /.one
                      ""
-                     [(one check xs)])
+                     ($.example (one check xs)))
 
                    ($.definition /.all
                      ""
-                     [(all check xs)])
+                     ($.example (all check xs)))
 
                    ($.definition /.example
                      "Yields the first value in the list that satisfies the predicate."
-                     [(example predicate xs)])
+                     ($.example (example predicate xs)))
 
                    ($.definition /.interposed
                      "Puts a value between every two elements in the list."
-                     [(interposed sep xs)])
+                     ($.example (interposed sep xs)))
 
                    ($.definition /.size
                      ""
-                     [(size list)])
+                     ($.example (size list)))
 
                    ($.definition /.item
                      "Fetches the element at the specified index."
-                     [(item i xs)])
+                     ($.example (item i xs)))
 
                    ($.definition /.sorted
                      "A list ordered by a comparison function."
-                     [(sorted < xs)])
+                     ($.example (sorted < xs)))
 
                    ($.definition /.empty?
                      ""
-                     [(empty? xs)])
+                     ($.example (empty? xs)))
 
                    ($.definition /.member?
                      ""
-                     [(member? eq xs x)])
+                     ($.example (member? eq xs x)))
 
                    (,, (with_template [<name> <doc>]
                          [($.definition <name>
@@ -134,38 +134,38 @@
 
                    ($.definition /.indices
                      "Produces all the valid indices for a given size."
-                     [(indices size)])
+                     ($.example (indices size)))
 
                    ($.definition /.last
                      ""
-                     [(last xs)])
+                     ($.example (last xs)))
 
                    ($.definition /.inits
                      (format "For a list of size N, yields the first N-1 elements."
                              \n "Will yield a .#None for empty lists.")
-                     [(inits xs)])
+                     ($.example (inits xs)))
 
                    ($.definition /.together
                      "The sequential combination of all the lists.")
 
                    ($.definition /.with
                      "Enhances a monad with List functionality."
-                     [(with monad)])
+                     ($.example (with monad)))
 
                    ($.definition /.lifted
                      "Wraps a monadic value with List machinery."
-                     [(lifted monad)])
+                     ($.example (lifted monad)))
 
                    ($.definition /.enumeration
                      "Pairs every element in the list with its index, starting at 0."
-                     [(enumeration xs)])
+                     ($.example (enumeration xs)))
 
                    ($.definition /.when
                      "Can be used as a guard in (co)monadic be/do expressions."
-                     [(do monad
-                        [value (do_something 1 2 3)
-                         .when (passes_test? value)]
-                        (do_something_else 4 5 6))])
+                     ($.example (do monad
+                                  [value (do_something 1 2 3)
+                                   .when (passes_test? value)]
+                                  (do_something_else 4 5 6))))
 
                    (all /#composite
                         zipped
diff --git a/stdlib/source/documentation/lux/data/collection/list/property.lux b/stdlib/source/documentation/lux/data/collection/list/property.lux
index c2d694d62..faa7a79a1 100644
--- a/stdlib/source/documentation/lux/data/collection/list/property.lux
+++ b/stdlib/source/documentation/lux/data/collection/list/property.lux
@@ -26,21 +26,21 @@
 
         ($.definition /.value
           ""
-          [(value key properties)])
+          ($.example (value key properties)))
 
         ($.definition /.contains?
           ""
-          [(contains? key properties)])
+          ($.example (contains? key properties)))
 
         ($.definition /.has
           ""
-          [(has key val properties)])
+          ($.example (has key val properties)))
 
         ($.definition /.revised
           ""
-          [(revised key f properties)])
+          ($.example (revised key f properties)))
 
         ($.definition /.lacks
           ""
-          [(lacks key properties)])
+          ($.example (lacks key properties)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/queue.lux b/stdlib/source/documentation/lux/data/collection/queue.lux
index 44dd7f209..87d5bf4db 100644
--- a/stdlib/source/documentation/lux/data/collection/queue.lux
+++ b/stdlib/source/documentation/lux/data/collection/queue.lux
@@ -26,26 +26,26 @@
 
                 ($.definition /.of_list
                   ""
-                  [(of_list entries)])
+                  ($.example (of_list entries)))
 
                 ($.definition /.list
                   ""
-                  [(list queue)])
+                  ($.example (list queue)))
 
                 ($.definition /.front
                   "Yields the first value in the queue, if any.")
 
                 ($.definition /.member?
                   ""
-                  [(member? equivalence queue member)])
+                  ($.example (member? equivalence queue member)))
 
                 ($.definition /.next
                   ""
-                  [(next queue)])
+                  ($.example (next queue)))
 
                 ($.definition /.end
                   ""
-                  [(end val queue)])
+                  ($.example (end val queue)))
 
                 /priority.documentation
                 ))
diff --git a/stdlib/source/documentation/lux/data/collection/queue/priority.lux b/stdlib/source/documentation/lux/data/collection/queue/priority.lux
index e08056fe3..8a61d7122 100644
--- a/stdlib/source/documentation/lux/data/collection/queue/priority.lux
+++ b/stdlib/source/documentation/lux/data/collection/queue/priority.lux
@@ -22,9 +22,9 @@
 
         ($.definition /.member?
           ""
-          [(member? equivalence queue member)])
+          ($.example (member? equivalence queue member)))
 
         ($.definition /.end
           ""
-          [(end priority value queue)])
+          ($.example (end priority value queue)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/sequence.lux b/stdlib/source/documentation/lux/data/collection/sequence.lux
index 5dbbe420f..0d6e71629 100644
--- a/stdlib/source/documentation/lux/data/collection/sequence.lux
+++ b/stdlib/source/documentation/lux/data/collection/sequence.lux
@@ -30,38 +30,38 @@
 
         ($.definition /.suffix
           ""
-          [(suffix val sequence)])
+          ($.example (suffix val sequence)))
 
         ($.definition /.within_bounds?
           "Determines whether the index is within the bounds of the sequence."
-          [(within_bounds? sequence idx)])
+          ($.example (within_bounds? sequence idx)))
 
         ($.definition /.item
           ""
-          [(item idx sequence)])
+          ($.example (item idx sequence)))
 
         ($.definition /.has
           ""
-          [(has idx val sequence)])
+          ($.example (has idx val sequence)))
 
         ($.definition /.revised
           ""
-          [(revised idx f sequence)])
+          ($.example (revised idx f sequence)))
 
         ($.definition /.prefix
           ""
-          [(prefix sequence)])
+          ($.example (prefix sequence)))
 
         ($.definition /.list
           ""
-          [(list sequence)])
+          ($.example (list sequence)))
 
         ($.definition /.member?
           ""
-          [(member? equivalence sequence val)])
+          ($.example (member? equivalence sequence val)))
 
         ($.definition /.sequence
           "Sequence literals."
-          [(is (Sequence Nat)
-               (sequence 12 34 56 78 90))])
+          ($.example (is (Sequence Nat)
+                         (sequence 12 34 56 78 90))))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/set.lux b/stdlib/source/documentation/lux/data/collection/set.lux
index 94ad8e8d9..f9033964f 100644
--- a/stdlib/source/documentation/lux/data/collection/set.lux
+++ b/stdlib/source/documentation/lux/data/collection/set.lux
@@ -35,23 +35,23 @@
 
                 ($.definition /.has
                   ""
-                  [(has elem set)])
+                  ($.example (has elem set)))
 
                 ($.definition /.difference
                   ""
-                  [(difference sub base)])
+                  ($.example (difference sub base)))
 
                 ($.definition /.intersection
                   ""
-                  [(intersection filter base)])
+                  ($.example (intersection filter base)))
 
                 ($.definition /.sub?
                   ""
-                  [(sub? super sub)])
+                  ($.example (sub? super sub)))
 
                 ($.definition /.super?
                   ""
-                  [(super? sub super)])
+                  ($.example (super? sub super)))
 
                 (all list#composite
                      /multi.documentation
diff --git a/stdlib/source/documentation/lux/data/collection/set/multi.lux b/stdlib/source/documentation/lux/data/collection/set/multi.lux
index 8c84efe56..1f9cd1e98 100644
--- a/stdlib/source/documentation/lux/data/collection/set/multi.lux
+++ b/stdlib/source/documentation/lux/data/collection/set/multi.lux
@@ -31,27 +31,27 @@
 
         ($.definition /.has
           ""
-          [(has multiplicity elem set)])
+          ($.example (has multiplicity elem set)))
 
         ($.definition /.lacks
           ""
-          [(lacks multiplicity elem set)])
+          ($.example (lacks multiplicity elem set)))
 
         ($.definition /.multiplicity
           ""
-          [(multiplicity set elem)])
+          ($.example (multiplicity set elem)))
 
         ($.definition /.sub?
           "Is 'subject' a sub-set of 'reference'?"
-          [(sub? reference subject)])
+          ($.example (sub? reference subject)))
 
         ($.definition /.support
           "A set of the unique (non repeated) members."
-          [(support set)])
+          ($.example (support set)))
 
         ($.definition /.member?
           ""
-          [(member? set elem)])
+          ($.example (member? set elem)))
 
         ($.definition /.super?
           "Is 'subject' a super-set of 'reference'?")
diff --git a/stdlib/source/documentation/lux/data/collection/set/ordered.lux b/stdlib/source/documentation/lux/data/collection/set/ordered.lux
index 82f29e9d9..d3abe10a4 100644
--- a/stdlib/source/documentation/lux/data/collection/set/ordered.lux
+++ b/stdlib/source/documentation/lux/data/collection/set/ordered.lux
@@ -29,25 +29,25 @@
 
         ($.definition /.member?
           ""
-          [(member? set elem)])
+          ($.example (member? set elem)))
 
         ($.definition /.has
           ""
-          [(has elem set)])
+          ($.example (has elem set)))
 
         ($.definition /.lacks
           ""
-          [(lacks elem set)])
+          ($.example (lacks elem set)))
 
         ($.definition /.difference
           ""
-          [(difference param subject)])
+          ($.example (difference param subject)))
 
         ($.definition /.sub?
           "Is 'sub' a sub-set of 'super'?"
-          [(sub? super sub)])
+          ($.example (sub? super sub)))
 
         ($.definition /.super?
           "Is 'super' a super-set of 'sub'?"
-          [(super? sub super)])
+          ($.example (super? sub super)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/stack.lux b/stdlib/source/documentation/lux/data/collection/stack.lux
index e882391c7..9364c54c0 100644
--- a/stdlib/source/documentation/lux/data/collection/stack.lux
+++ b/stdlib/source/documentation/lux/data/collection/stack.lux
@@ -24,13 +24,13 @@
 
         ($.definition /.value
           "Yields the top value in the stack, if any."
-          [(value stack)])
+          ($.example (value stack)))
 
         ($.definition /.next
           ""
-          [(next stack)])
+          ($.example (next stack)))
 
         ($.definition /.top
           ""
-          [(top value stack)])
+          ($.example (top value stack)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/stream.lux b/stdlib/source/documentation/lux/data/collection/stream.lux
index d32960d0d..cef25618b 100644
--- a/stdlib/source/documentation/lux/data/collection/stream.lux
+++ b/stdlib/source/documentation/lux/data/collection/stream.lux
@@ -29,33 +29,33 @@
 
         ($.definition /.iterations
           "A stateful way of infinitely calculating the values of a stream."
-          [(iterations step init)])
+          ($.example (iterations step init)))
 
         ($.definition /.repeated
           "Repeat a value forever."
-          [(repeated x)])
+          ($.example (repeated x)))
 
         ($.definition /.cycle
           "Go over the elements of a list forever."
-          [(cycle [start next])])
+          ($.example (cycle [start next])))
 
         ($.definition /.item
           ""
-          [(item idx stream)])
+          ($.example (item idx stream)))
 
         ($.definition /.only
           "A new stream only with items that satisfy the predicate."
-          [(only predicate stream)])
+          ($.example (only predicate stream)))
 
         ($.definition /.partition
           (format "Split a stream in two based on a predicate."
                   \n "The left side contains all entries for which the predicate is #1."
                   \n "The right side contains all entries for which the predicate is #0.")
-          [(partition left? xs)])
+          ($.example (partition left? xs)))
 
         ($.definition /.pattern
           (format "Allows destructuring of streams in pattern-matching expressions."
                   \n "Caveat emptor: Only use it for destructuring, and not for testing values within the streams.")
-          [(let [(pattern x y z _tail) (some_stream_func +1 +2 +3)]
-             (func x y z))])
+          ($.example (let [(pattern x y z _tail) (some_stream_func +1 +2 +3)]
+                       (func x y z))))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/tree.lux b/stdlib/source/documentation/lux/data/collection/tree.lux
index ef03b419c..35108c6c5 100644
--- a/stdlib/source/documentation/lux/data/collection/tree.lux
+++ b/stdlib/source/documentation/lux/data/collection/tree.lux
@@ -26,11 +26,11 @@
 
             ($.definition \\parser.result'
               "Applies the parser against a tree zipper."
-              [(result' parser zipper)])
+              ($.example (result' parser zipper)))
 
             ($.definition \\parser.result
               "Applies the parser against a tree."
-              [(result parser tree)])
+              ($.example (result parser tree)))
 
             ($.definition \\parser.value
               "Yields the value inside the current tree node.")
@@ -70,23 +70,23 @@
 
                 ($.definition /.flat
                   "All the leaf values of the tree, in order."
-                  [(flat tree)])
+                  ($.example (flat tree)))
 
                 ($.definition /.leaf
                   ""
-                  [(leaf value)])
+                  ($.example (leaf value)))
 
                 ($.definition /.branch
                   ""
-                  [(branch value children)])
+                  ($.example (branch value children)))
 
                 ($.definition /.tree
                   "Tree literals."
-                  [(is (Tree Nat)
-                       (tree 12
-                             {34 {}
-                                 56 {}
-                                 78 {90 {}}}))])
+                  ($.example (is (Tree Nat)
+                                 (tree 12
+                                       {34 {}
+                                           56 {}
+                                           78 {90 {}}}))))
 
                 (all list#composite
                      ..\\parser
diff --git a/stdlib/source/documentation/lux/data/collection/tree/finger.lux b/stdlib/source/documentation/lux/data/collection/tree/finger.lux
index dacba465b..08ca4d639 100644
--- a/stdlib/source/documentation/lux/data/collection/tree/finger.lux
+++ b/stdlib/source/documentation/lux/data/collection/tree/finger.lux
@@ -24,25 +24,25 @@
 
         ($.definition /.builder
           "A new builder using the given monoid."
-          [(builder monoid)])
+          ($.example (builder monoid)))
 
         ($.definition /.value
           ""
-          [(value tree)])
+          ($.example (value tree)))
 
         ($.definition /.tags
           ""
-          [(tags tree)])
+          ($.example (tags tree)))
 
         ($.definition /.values
           ""
-          [(values tree)])
+          ($.example (values tree)))
 
         ($.definition /.one
           "Finds one value that meets the predicate."
-          [(one predicate tree)])
+          ($.example (one predicate tree)))
 
         ($.definition /.exists?
           "Verifies that a value exists which meets the predicate."
-          [(exists? predicate tree)])
+          ($.example (exists? predicate tree)))
         ))
diff --git a/stdlib/source/documentation/lux/data/collection/tree/zipper.lux b/stdlib/source/documentation/lux/data/collection/tree/zipper.lux
index 052f816fb..c4a3d730c 100644
--- a/stdlib/source/documentation/lux/data/collection/tree/zipper.lux
+++ b/stdlib/source/documentation/lux/data/collection/tree/zipper.lux
@@ -42,17 +42,17 @@
 
         ($.definition /.set
           ""
-          [(set value zipper)])
+          ($.example (set value zipper)))
 
         ($.definition /.update
           ""
-          [(update transform zipper)])
+          ($.example (update transform zipper)))
 
         ($.definition /.interpose
           ""
-          [(interpose value zipper)])
+          ($.example (interpose value zipper)))
 
         ($.definition /.adopt
           ""
-          [(adopt value zipper)])
+          ($.example (adopt value zipper)))
         ))