anchor.diff:  Note that all of these are eager transformations - they produce the output vector when you invoke them. The original sequence version `(map inc (filter odd? [1 2 3]))` is lazy and will only produce values as needed (with chunking under the hood for greater performance). Neither of these is right or wrong, but they are both useful in different circumstances.
   
   [[transducers_vs_seqs]]
  -**What are good use cases for transducers?**
  +**<<faq#transducers_vs_seqs,What are good use cases for transducers?>>**
   
   When performing a series of transformations, sequences will create an intermediate (cached) sequence between each transformation. Transducers create a single compound transformation that is executed in one eager pass over the input. These are different models, which are both useful.
   
  
positive.code: == Reader and Syntax
  
  [[why_keywords]]
  **What's the advantage of representing text tokens as keywords (instead of as strings)?**
  
  Keywords are cached and interned. This means that a keyword is reused (reducing memory) everywhere in your program and that checks for equality really become checks for identity (which are fast). Additionally, keywords are invokable to look themselves up in a map and thus this enables the common pattern of extracting a particular field from a collection of maps possible.
  
  [[reader_macros]]
  **Why does Clojure not have user-extensible reader macros?**
  
  The reader takes text (Clojure source) and returns Clojure data, which is subsequently compiled and evaluated. Reader macros tell the Clojure reader how to read something that is not a typical s-expression (examples are things like quoting `'` and anonymous functions `#()`). Reader macros can be used to define entirely new syntaxes read by the reader (for example: JSON, XML, or other formats) - this is a more powerful syntactic capability than regular macros (which come into play later at compile time). 
  
  However, unlike Lisp, Clojure does not allow the user to extend this set of reader macros. This avoids the possibility of creating code that another user cannot read (because they do not have the proper reader macros). Clojure gives back some of the power of reader macros with tagged literals, allowing you to create generically readable _data_, that is still extensible.
  
  [[underscore]]
  **What does an _ mean in a let binding or parameter?**
  
  _ has no special meaning in Clojure as a symbol. However, it is a convention to use _ (or a leading _) to denote a binding that will not be used in the expression.
  
  
negative.code: == Compiler
  
  [[direct_linking_repl]]
  **<<faq#direct_linking_repl,How does direct linking affect the REPL experience?>>**
  
  Anything that has been direct linked will not see redefinitions to vars. For example, if you redefine something in clojure.core, other parts of core that use that var will not see the redefinition (however anything that you newly compile at the REPL will). In practice, this is not typically a problem.
  
  