anchor.diff:  
   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.
  +Special forms have evaluation rules that differ from standard Clojure evaluation rules and are understood directly by the Clojure compiler.
  +
  +Headings for the special forms informally describe the special form grammar using regular expression syntax: ? (optional), * (0 or more), and + (1 or more). Non-terminals are denoted by _italics_.
   
   [[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**_
  +== (`def` _symbol_ __doc-string__? __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. Support for _doc-string_ was added in Clojure 1.3.
  +
  +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**_
  +* `:doc`
   +
   a string containing short (1-3 line) documentation for the var contents
  -* _**:test**_
  +* `: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**_
  +* `: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`
  +* `: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.
   
  
positive.code: ----
  
  [[throw]]
  == (_throw_ expr)
  
  The `expr` is evaluated and thrown, therefore it should yield an instance of some derivee of `Throwable`.
  
  [[try]]
  == (_try_ expr* catch-clause* finally-clause?)
  
  `catch-clause` -> `(_catch_ classname name expr*)` +
  `finally-clause` -> `(_finally_ expr*)`
  
  The `exprs` are evaluated and, if no exceptions occur, the value of the last expression is returned. If an exception occurs and `catch` clauses are provided, each is examined in turn and the first for which the thrown exception is an instance of the named `class` is considered a matching `catch` clause. If there is a matching `catch` clause, its `exprs` are evaluated in a context in which `name` is bound to the thrown exception, and the value of the last is the return value of the function. If there is no matching `catch` clause, the exception propagates out of the function. Before returning, normally or abnormally, any `finally` `exprs` will be evaluated for their side effects.
  
  [[monitor-enter]]
  == (_monitor-enter_ x)
  
  [[monitor-exit]]
  == (_monitor-exit_ x)
  
  These are synchronization primitives that should be avoided in user code. Use the `_**locking**_` macro.
  
  == Other Special Forms
  
  
negative.code: 
  === Map binding destructuring
  
  Map __binding-form__s allow you to bind names to parts of associative things, like maps, vectors, strings, and arrays (the latter three have integer keys). It consists of a map of __binding-form-key__ pairs, each symbol being bound to the value in the _init-expr_ at the key. In addition, and optionally, an `:as` key in the binding form followed by a symbol will cause that symbol to be bound to the entire __init-expr__. Also optionally, an `:or` key in the binding form followed by another map may be used to supply default values for some or all of the keys if they are not found in the __init-expr__:
  
  [source,clojure]
  ----
  