anchor.diff:  
   ifdef::env-github,env-browser[:outfilesuffix: .adoc]
   
  -[]
  -====
  -This is a reference collection of characters used in Clojure that are difficult to "google".
  +toc::[]
  +
  +This page explains the Clojure syntax for characters that are difficult to "google".
   Sections are not in any particular order, but related items
  -are grouped for ease.
  +are grouped for ease. 
   Please refer to <<xref/../../reference/reader#,the reader reference page>>
   as the authoritative reference on the Clojure reader.
   This guide is based on http://twitter.com/kouphax[James Hughes]
  -brilliant https://yobriefca.se/blog/2014/05/19/the-weird-and-wonderful-characters-of-clojure/[blog post], The weird and wonder characters of Clojure.
  -====
  +original https://yobriefca.se/blog/2014/05/19/the-weird-and-wonderful-characters-of-clojure/[blog post] and has been updated and expanded here with the permission of the author.
  +
  +[[lists]]
  +== `( ... )` - List
  +
  +Lists are sequential heterogeneous collections implemented as a linked list.
  +
  +* <<xref/../../reference/data_structures#Lists,Clojure Documentation: Lists>>
  +
  +A list of three values:
  +
  +[source,clojure]
  +----
  +(1 "two" 3.0)
  +----
  +
  +[[vectors]]
  +== `[ ... ]` - Vector
  +
  +Vectors are sequential, indexed, heterogeneous collections. Indexing is 0-based.
  +
  +An example of retrieving the value at index 1 in a vector of three values:
  +
  +[source,clojure]
  +----
  +user=> (get ["a" 13.7 :foo] 1)
  +13.7
  +----
  +
  +* <<xref/../../reference/data_structures#Vectors,Clojure Documentation: Vectors>>
  +
  +[[maps]]
  +== `{ ... }` - Map
  +
  +Maps are heterogeneous collections specified with alternating keys and values:
  +
  +[source,clojure]
  +----
  +user=> (keys {:a 1 :b 2})
  +(:a :b)
  +----
  +
  +* <<xref/../../reference/data_structures#Maps,Clojure Documentation: Maps>>
  +
   [[dispatch]]
   == `#` - Dispatch character
   
   You'll see this character beside another e.g. `\#(` or `#"`.
   
  -`#` is a reader macro that tells the Clojure reader (the component that takes a
  -file of Clojure code and "parses" it as Clojure data) to go and
  -look at another *read table* for the definition of the next character
  -- in essence this allows extending default reader behaviour.
  -
  -Clojure doesn't provide support for creating new reader macros.
  -
  -For `#` used *at the end of a symbol, see <<xref/../weird_characters#gensym,(Gensym)>>
  -
  -Another place you'll see the `#` is in
  -<<xref/../../reference/reader#tagged_literals,tagged literals>>
  -Most commonly you'll see this use in https://github.com/edn-format/edn[edn]
  -(extensible data notation - a rich data fromat that can be used in Clojure)
  -and in ClojureScript (`#js`). See  <<xref/../weird_characters#tagged_literals,`#inst`, `#uuid`, or `#js`>> for more info.
  -
  -* <<xref/../../reference/reader#tagged_literals,Clojure Documentation Reader>>
  -
  -== `#{...}` - Set
  -
  -See <<xref/../weird_characters#dispatch,(`#`)>> for additional details.
  -
  -`#{...}` defines a set (a collection of unique values) specifically a `hash-set`. The
  +`#` is a special character that tells the Clojure reader (the component that takes Clojure
  +source and "reads" it as Clojure data) how to interpret the next character using a _read table_. Although some Lisps allow the read table to be extended by users, Clojure <<faq#reader_macros,does not>>.
  +
  +The `#` is also used at the _end_ of a symbol when creating  <<xref/../weird_characters#gensym,generated symbols>> inside a syntax quote.
  +
  +== `#{ ... }` - Set
  +
  +See <<xref/../weird_characters#dispatch,`#`>> for additional details.
  +
  +`#{...}` defines a set (a collection of unique values), specifically a `hash-set`. The
   following are equivalent:
   
  -[source, clojure]
  +[source,clojure]
   ----
   user=> #{1 2 3 4}
   #{1 2 3 4}
  
positive.code: 
  == `#'` - Var quote
  
  `#'` is the var quote which expands into the `var` function:
  
  [source,clojure]
  ----
  
negative.code: ----
  * <<xref/../reader_conditionals#,Reader conditonals>>
  
  == `\*var-name*` - "Earmuffs"
  
  Earmuffs (a pair of asterisk bookending var names) is a naming convention in
  many LISPs used to denote _special vars_. Most commonly in Clojure this is
  used to denote _dynamic_ vars, i.e. ones that can change depending on
  dynamic scope. The earmuffs act as a warning that "here be dragons"
  and to never assume the state of the var. Remember, this is a _convention_, not a
  rule.
  
  Core Clojure examples include `\*out*` and `\*in*` which represent the standard in
  and out streams for Clojure.
  