anchor.diff:  
   The syntax for function definitions becomes the following:
   
  -== (_fn_ name? [params* ] condition-map? exprs*)
  -== (_fn_ name? ([params* ] condition-map? exprs*)+)
  -
  -The syntax extension also applies to `defn` and other macros which expand to fn forms.
  +== (`fn` __name__? [__param__* ] __condition-map__? __expr__*)
  +== (`fn` name? ([__param__* ] __condition-map__? __expr__*)+)
  +
  +The syntax extension also applies to `defn` and other macros which expand to `fn` forms.
   
   Note: If the sole form following the parameter vector is a map, it is treated as the function body, and not the condition map.
   
  -The `condition-map` parameter may be used to specify pre- and post-conditions for a function. It is of the following form:
  +The __condition-map__ parameter may be used to specify pre- and post-conditions for a function. It is of the following form:
   
   [%hardbreaks,source,clojure]
   ----
  
positive.code: 
  toc::[]
  
  Special forms are primitives built into Clojure. They are the fundamental building blocks of the language, used to perform core operations.
  
  Special forms may evaluate their arguments in non-standard ways compared to functions.
  
  Headings for each special form below use the following suffixes in the argument list:
  
  * arguments ending in ? are optional +
  * arguments ending in * represent 0 or more arguments +
  * arguments ending in + represent 1 or more arguments
  
  In the text these arguments are denoted with `monospace`, without suffixes.
  
  [[def]]
  == (_def_ symbol init?)
  
  Creates and interns or locates a global https://clojure.org/reference/vars[var] with the name of `symbol` and a namespace of the value of the current namespace (`_**pass:[*ns*]**_`). If `init` is supplied, it is evaluated, and the root binding of the var is set to the resulting value. If `init` is not supplied, the root binding of the var is unaffected. `_**def**_` always applies to the root binding, even if the var is thread-bound at the point where `_**def**_` is called. `_**def**_` yields the var itself _(not its value)_. Throws an exception if `symbol` is already in the namespace and not mapped to an interned var. Since 1.3, `_**def**_` has allowed an optional `doc-string`: `(_def_ symbol doc-string? init?)`.
  
  Any metadata on the `symbol` will be evaluated, and become metadata on the var itself. There are several metadata keys that have special interpretation:
  
  * _**:private**_
  +
  a boolean indicating the access control for the var. If this key is not present, the default access is public (e.g. as if `:private false`).
  * _**:doc**_
  +
  a string containing short (1-3 line) documentation for the var contents
  * _**:test**_
  +
  a fn of no args that uses `assert` to check various operations. The var itself will be accessible during evaluation of a literal fn in the metadata map.
  * _**:tag**_
  +
  a symbol naming a class or a Class object that indicates the Java type of the object in the var, or its return value if the object is a fn.
  
  In addition the compiler will place the following metadata keys on the var:
  
  * _**:file**_ string
  * _**:line**_ int
  * _**:name**_ simple symbol
  * _**:ns**_ namespace in which var is interned
  * _**:macro**_ `true` if var names a macro
  * _**:arglists**_ a list of vector(s) of argument forms, as were supplied to `defn`
  
  The var metadata can be used for application-specific purposes as well. Consider using namespace-qualified keys (e.g. `:myns/foo`) to avoid clashes.
  
  
negative.code: -> 3
  ----
  
  In the case of using prefixed keys, the bound symbol name will be the same as the right-hand side of the prefixed key. You can also use auto-resolved keyword forms in the `:keys` directive:
  
  [source,clojure]
  ----
  