anchor.diff:      |  newlines, and added as a multiline string.
   
   +aside("What does spaCy consider a stop word?")
  -    |  There's no particularly principal logic behind what words should be
  +    |  There's no particularly principled logic behind what words should be
       |  added to the stop list. Make a list that you think might be useful
       |  to people and is likely to be unsurprising. As a rule of thumb, words
       |  that are very rare are unlikely to be useful stop words.
  
positive.code: 
  +table(["File name", "Variables", "Description"])
      +row
          +cell #[+src(gh()) stop_words.py]
          +cell #[code STOP_WORDS] (set)
          +cell
              |  List of most common words. Matching tokens will return #[code True]
              |  for #[code is_stop].
  
      +row
          +cell #[+src(gh()) tokenizer_exceptions.py]
          +cell #[code TOKENIZER_EXCEPTIONS] (dict), #[code TOKEN_MATCH] (regex)
          +cell
              |  Special-case rules for the tokenizer, for example, contractions
              |  and abbreviations containing punctuation.
  
      +row
          +cell #[+src(gh()) punctuation.py]
          +cell
              |  #[code TOKENIZER_PREFIXES], #[code TOKENIZER_SUFFIXES],
              |  #[code TOKENIZER_INFIXES] (dicts)
          +cell Regular expressions for splitting tokens, e.g. on punctuation.
  
      +row
          +cell #[+src(gh()) lex_attrs.py]
          +cell #[code LEX_ATTRS] (dict)
          +cell
              |  Functions for setting lexical attributes on tokens, e.g.
              |  #[code is_punct] or #[code like_num].
  
      +row
          +cell #[+src(gh()) tag_map.py]
          +cell #[code TAG_MAP] (dict)
          +cell
              |  Dictionary mapping strings in your tag set to
  
negative.code:     |  are overwritten.
  
  +h(3, "lemmatizer") Lemmatizer
  
  p
      |  As of v2.0, spaCy supports simple lookup-based lemmatization. This is
      |  usually the quickest and easiest way to get started. The data is stored
      |  in a dictionary mapping a string to its lemma. To determine a token's
      |  lemma, spaCy simply looks it up in the table. Here's an example from
      |  the Spanish language data:
  
  +code("lang/es/lemmatizer.py (excerpt)").
      LOOKUP = {
          "aba": "abar",
          "ababa": "abar",
          "ababais": "abar",
          "ababan": "abar",
          "ababanes": "ababán",
          "ababas": "abar",
          "ababoles": "ababol",
          "ababábites": "ababábite"
      }
  
  +aside("Where can I find lemmatizer data?")
  
  p
      |  To add a lookup lemmatizer to your language, import the #[code LOOKUP]
      |  table and #[code Lemmatizer], and create a new classmethod:
  
  
  +code("__init__py (excerpt)").
      # other imports here, plus lookup table and lookup lemmatizer
      from .lemmatizer import LOOKUP
      from ...lemmatizerlookup import Lemmatizer
  
      class Xxxxx(Language):
          lang = 'xx'
  
          class Defaults(Language.Defaults):
              # other language defaults here
  
              @classmethod
              def create_lemmatizer(cls, nlp=None):
                  return Lemmatizer(LOOKUP)
  
  +h(3, "tag-map") Tag map
  
  