pygments.rb 0.5.4 → 0.6.0

data/vendor/pygments-main/pygments/lexers/dalvik.py

@@ -5,10 +5,12 @@
 
     Pygments lexers for Dalvik VM-related languages.
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+import re
+
 from pygments.lexer import RegexLexer, include, bygroups
 from pygments.token import Keyword, Text, Comment, Name, String, Number, \
                            Punctuation
@@ -21,7 +23,7 @@ class SmaliLexer(RegexLexer):
     For `Smali <http://code.google.com/p/smali/>`_ (Android/Dalvik) assembly
     code.
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
     name = 'Smali'
     aliases = ['smali']
@@ -73,22 +75,22 @@ class SmaliLexer(RegexLexer):
             (r'[0-9]+L?', Number.Integer),
         ],
         'field': [
-            (r'(\$?\b)([A-Za-z0-9_$]*)(:)',
+            (r'(\$?\b)([\w$]*)(:)',
              bygroups(Punctuation, Name.Variable, Punctuation)),
         ],
         'method': [
             (r'<(?:cl)?init>', Name.Function), # constructor
-            (r'(\$?\b)([A-Za-z0-9_$]*)(\()',
+            (r'(\$?\b)([\w$]*)(\()',
              bygroups(Punctuation, Name.Function, Punctuation)),
         ],
         'label': [
-            (r':[A-Za-z0-9_]+', Name.Label),
+            (r':\w+', Name.Label),
         ],
         'class': [
             # class names in the form Lcom/namespace/ClassName;
             # I only want to color the ClassName part, so the namespace part is
             # treated as 'Text'
-            (r'(L)((?:[A-Za-z0-9_$]+/)*)([A-Za-z0-9_$]+)(;)',
+            (r'(L)((?:[\w$]+/)*)([\w$]+)(;)',
                 bygroups(Keyword.Type, Text, Name.Class, Text)),
         ],
         'punctuation': [
@@ -102,3 +104,22 @@ class SmaliLexer(RegexLexer):
             (r'#.*?\n', Comment),
         ],
     }
+
+    def analyse_text(text):
+        score = 0
+        if re.search(r'^\s*\.class\s', text, re.MULTILINE):
+            score += 0.5
+            if re.search(r'\b((check-cast|instance-of|throw-verification-error'
+                         r')\b|(-to|add|[ais]get|[ais]put|and|cmpl|const|div|'
+                         r'if|invoke|move|mul|neg|not|or|rem|return|rsub|shl|'
+                         r'shr|sub|ushr)[-/])|{|}', text, re.MULTILINE):
+                score += 0.3
+        if re.search(r'(\.(catchall|epilogue|restart local|prologue)|'
+                     r'\b(array-data|class-change-error|declared-synchronized|'
+                     r'(field|inline|vtable)@0x[0-9a-fA-F]|generic-error|'
+                     r'illegal-class-access|illegal-field-access|'
+                     r'illegal-method-access|instantiation-error|no-error|'
+                     r'no-such-class|no-such-field|no-such-method|'
+                     r'packed-switch|sparse-switch))\b', text, re.MULTILINE):
+            score += 0.6
+        return score

data/vendor/pygments-main/pygments/lexers/dotnet.py

@@ -5,16 +5,16 @@
 
     Lexers for .net languages.
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 import re
 
 from pygments.lexer import RegexLexer, DelegatingLexer, bygroups, include, \
-     using, this
+     using, this, default
 from pygments.token import Punctuation, \
      Text, Comment, Operator, Keyword, Name, String, Number, Literal, Other
-from pygments.util import get_choice_opt
+from pygments.util import get_choice_opt, iteritems
 from pygments import unistring as uni
 
 from pygments.lexers.web import XmlLexer
@@ -44,7 +44,7 @@ class CSharpLexer(RegexLexer):
 
       The default value is ``basic``.
 
-      *New in Pygments 0.8.*
+      .. versionadded:: 0.8
     """
 
     name = 'C#'
@@ -58,7 +58,7 @@ class CSharpLexer(RegexLexer):
     # see http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
 
     levels = {
-        'none': '@?[_a-zA-Z][a-zA-Z0-9_]*',
+        'none': '@?[_a-zA-Z]\w*',
         'basic': ('@?[_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl + ']' +
                   '[' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl +
                   uni.Nd + uni.Pc + uni.Cf + uni.Mn + uni.Mc + ']*'),
@@ -71,7 +71,7 @@ class CSharpLexer(RegexLexer):
     tokens = {}
     token_variants = True
 
-    for levelname, cs_ident in levels.items():
+    for levelname, cs_ident in iteritems(levels):
         tokens[levelname] = {
             'root': [
                 # method names
@@ -126,7 +126,7 @@ class CSharpLexer(RegexLexer):
         }
 
     def __init__(self, **options):
-        level = get_choice_opt(options, 'unicodelevel', self.tokens.keys(), 'basic')
+        level = get_choice_opt(options, 'unicodelevel', list(self.tokens), 'basic')
         if level not in self._all_tokens:
             # compile the regexes now
             self._tokens = self.__class__.process_tokendef(level)
@@ -156,7 +156,7 @@ class NemerleLexer(RegexLexer):
 
       The default value is ``basic``.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Nemerle'
@@ -170,7 +170,7 @@ class NemerleLexer(RegexLexer):
     # http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
 
     levels = dict(
-        none = '@?[_a-zA-Z][a-zA-Z0-9_]*',
+        none = '@?[_a-zA-Z]\w*',
         basic = ('@?[_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl + ']' +
                  '[' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Nl +
                  uni.Nd + uni.Pc + uni.Cf + uni.Mn + uni.Mc + ']*'),
@@ -183,7 +183,7 @@ class NemerleLexer(RegexLexer):
     tokens = {}
     token_variants = True
 
-    for levelname, cs_ident in levels.items():
+    for levelname, cs_ident in iteritems(levels):
         tokens[levelname] = {
             'root': [
                 # method names
@@ -284,7 +284,7 @@ class NemerleLexer(RegexLexer):
         }
 
     def __init__(self, **options):
-        level = get_choice_opt(options, 'unicodelevel', self.tokens.keys(),
+        level = get_choice_opt(options, 'unicodelevel', list(self.tokens),
                                'basic')
         if level not in self._all_tokens:
             # compile the regexes now
@@ -336,7 +336,7 @@ class BooLexer(RegexLexer):
             (r'"""(\\\\|\\"|.*?)"""', String.Double),
             (r'"(\\\\|\\"|[^"]*?)"', String.Double),
             (r"'(\\\\|\\'|[^']*?)'", String.Single),
-            (r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
+            (r'[a-zA-Z_]\w*', Name),
             (r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
             (r'[0-9][0-9\.]*(ms?|d|h|s)', Number),
             (r'0\d+', Number.Oct),
@@ -351,13 +351,13 @@ class BooLexer(RegexLexer):
             ('[*/]', Comment.Multiline)
         ],
         'funcname': [
-            ('[a-zA-Z_][a-zA-Z0-9_]*', Name.Function, '#pop')
+            ('[a-zA-Z_]\w*', Name.Function, '#pop')
         ],
         'classname': [
-            ('[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop')
+            ('[a-zA-Z_]\w*', Name.Class, '#pop')
         ],
         'namespace': [
-            ('[a-zA-Z_][a-zA-Z0-9_.]*', Name.Namespace, '#pop')
+            ('[a-zA-Z_][\w.]*', Name.Namespace, '#pop')
         ]
     }
 
@@ -425,7 +425,7 @@ class VbNetLexer(RegexLexer):
              r'<=|>=|<>|[-&*/\\^+=<>]',
              Operator),
             ('"', String, 'string'),
-            ('[a-zA-Z_][a-zA-Z0-9_]*[%&@!#$]?', Name),
+            ('[a-z_]\w*[%&@!#$]?', Name),
             ('#.*?#', Literal.Date),
             (r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
             (r'\d+([SILDFR]|US|UI|UL)?', Number.Integer),
@@ -439,26 +439,31 @@ class VbNetLexer(RegexLexer):
             (r'[^"]+', String),
         ],
         'dim': [
-            (r'[a-z_][a-z0-9_]*', Name.Variable, '#pop'),
-            (r'', Text, '#pop'),  # any other syntax
+            (r'[a-z_]\w*', Name.Variable, '#pop'),
+            default('#pop'),  # any other syntax
         ],
         'funcname': [
-            (r'[a-z_][a-z0-9_]*', Name.Function, '#pop'),
+            (r'[a-z_]\w*', Name.Function, '#pop'),
         ],
         'classname': [
-            (r'[a-z_][a-z0-9_]*', Name.Class, '#pop'),
+            (r'[a-z_]\w*', Name.Class, '#pop'),
         ],
         'namespace': [
-            (r'[a-z_][a-z0-9_.]*', Name.Namespace, '#pop'),
+            (r'[a-z_][\w.]*', Name.Namespace, '#pop'),
         ],
         'end': [
             (r'\s+', Text),
             (r'(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b',
              Keyword, '#pop'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ]
     }
 
+    def analyse_text(text):
+        if re.search(r'^\s*(#If|Module|Namespace)', text,
+                     re.IGNORECASE | re.MULTILINE):
+            return 0.5
+
 
 class GenericAspxLexer(RegexLexer):
     """
@@ -531,7 +536,10 @@ class FSharpLexer(RegexLexer):
     """
     For the F# language (version 3.0).
 
-    *New in Pygments 1.5.*
+    AAAAACK Strings
+    http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc335818775
+
+    .. versionadded:: 1.5
     """
 
     name = 'FSharp'
@@ -589,9 +597,9 @@ class FSharpLexer(RegexLexer):
         'root': [
             (r'\s+', Text),
             (r'\(\)|\[\]', Name.Builtin.Pseudo),
-            (r'\b(?<!\.)([A-Z][A-Za-z0-9_\']*)(?=\s*\.)',
+            (r'\b(?<!\.)([A-Z][\w\']*)(?=\s*\.)',
              Name.Namespace, 'dotted'),
-            (r'\b([A-Z][A-Za-z0-9_\']*)', Name),
+            (r'\b([A-Z][\w\']*)', Name),
             (r'///.*?\n', String.Doc),
             (r'//.*?\n', Comment.Single),
             (r'\(\*(?!\))', Comment, 'comment'),
@@ -600,13 +608,13 @@ class FSharpLexer(RegexLexer):
             (r'"""', String, 'tqs'),
             (r'"', String, 'string'),
 
-            (r'\b(open|module)(\s+)([a-zA-Z0-9_.]+)',
+            (r'\b(open|module)(\s+)([\w.]+)',
              bygroups(Keyword, Text, Name.Namespace)),
-            (r'\b(let!?)(\s+)([a-zA-Z0-9_]+)',
+            (r'\b(let!?)(\s+)(\w+)',
              bygroups(Keyword, Text, Name.Variable)),
-            (r'\b(type)(\s+)([a-zA-Z0-9_]+)',
+            (r'\b(type)(\s+)(\w+)',
              bygroups(Keyword, Text, Name.Class)),
-            (r'\b(member|override)(\s+)([a-zA-Z0-9_]+)(\.)([a-zA-Z0-9_]+)',
+            (r'\b(member|override)(\s+)(\w+)(\.)(\w+)',
              bygroups(Keyword, Text, Name, Punctuation, Name.Function)),
             (r'\b(%s)\b' % '|'.join(keywords), Keyword),
             (r'(%s)' % '|'.join(keyopts), Operator),
@@ -621,7 +629,7 @@ class FSharpLexer(RegexLexer):
             (r'\d[\d_]*[uU]?[yslLnQRZINGmM]?', Number.Integer),
             (r'0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?', Number.Hex),
             (r'0[oO][0-7][0-7_]*[uU]?[yslLn]?', Number.Oct),
-            (r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Binary),
+            (r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Bin),
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?',
              Number.Float),
 
@@ -630,14 +638,18 @@ class FSharpLexer(RegexLexer):
             (r"'.'", String.Char),
             (r"'", Keyword), # a stray quote is another syntax element
 
+            (r'@?"', String.Double, 'string'),
+
             (r'[~?][a-z][\w\']*:', Name.Variable),
         ],
         'dotted': [
             (r'\s+', Text),
             (r'\.', Punctuation),
-            (r'[A-Z][A-Za-z0-9_\']*(?=\s*\.)', Name.Namespace),
-            (r'[A-Z][A-Za-z0-9_\']*', Name, '#pop'),
-            (r'[a-z_][A-Za-z0-9_\']*', Name, '#pop'),
+            (r'[A-Z][\w\']*(?=\s*\.)', Name.Namespace),
+            (r'[A-Z][\w\']*', Name, '#pop'),
+            (r'[a-z_][\w\']*', Name, '#pop'),
+            # e.g. dictionary index access
+            default('#pop'),
         ],
         'comment': [
             (r'[^(*)@"]+', Comment),

data/vendor/pygments-main/pygments/lexers/foxpro.py

@@ -5,7 +5,7 @@
 
     Simple lexer for Microsoft Visual FoxPro source code.
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -24,11 +24,11 @@ class FoxProLexer(RegexLexer):
     FoxPro syntax allows to shorten all keywords and function names
     to 4 characters.  Shortened forms are not recognized by this lexer.
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     name = 'FoxPro'
-    aliases = ['Clipper', 'XBase']
+    aliases = ['foxpro', 'vfp', 'clipper', 'xbase']
     filenames = ['*.PRG', '*.prg']
     mimetype = []
 

data/vendor/pygments-main/pygments/lexers/functional.py

@@ -5,21 +5,24 @@
 
     Lexers for functional languages.
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
-from pygments.lexer import Lexer, RegexLexer, bygroups, include, do_insertions
+from pygments.lexer import Lexer, RegexLexer, bygroups, include, do_insertions, default
 from pygments.token import Text, Comment, Operator, Keyword, Name, \
      String, Number, Punctuation, Literal, Generic, Error
+from pygments import unistring as uni
 
-__all__ = ['RacketLexer', 'SchemeLexer', 'CommonLispLexer', 'HaskellLexer',
-           'AgdaLexer', 'LiterateHaskellLexer', 'LiterateAgdaLexer',
-           'SMLLexer', 'OcamlLexer', 'ErlangLexer', 'ErlangShellLexer',
-           'OpaLexer', 'CoqLexer', 'NewLispLexer', 'ElixirLexer',
-           'ElixirConsoleLexer', 'KokaLexer']
+__all__ = ['RacketLexer', 'SchemeLexer', 'CommonLispLexer', 'CryptolLexer',
+           'HaskellLexer', 'AgdaLexer', 'LiterateCryptolLexer',
+           'LiterateHaskellLexer', 'LiterateAgdaLexer', 'SMLLexer',
+           'OcamlLexer', 'ErlangLexer', 'ErlangShellLexer', 'OpaLexer',
+           'CoqLexer', 'NewLispLexer', 'NixLexer', 'ElixirLexer',
+           'ElixirConsoleLexer', 'KokaLexer', 'IdrisLexer',
+           'LiterateIdrisLexer']
 
 
 line_re = re.compile('.*?\n')
@@ -27,126 +30,219 @@ line_re = re.compile('.*?\n')
 
 class RacketLexer(RegexLexer):
     """
-    Lexer for `Racket <http://racket-lang.org/>`_ source code (formerly known as
-    PLT Scheme).
+    Lexer for `Racket <http://racket-lang.org/>`_ source code (formerly
+    known as PLT Scheme).
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     name = 'Racket'
     aliases = ['racket', 'rkt']
-    filenames = ['*.rkt', '*.rktl']
+    filenames = ['*.rkt', '*.rktd', '*.rktl']
     mimetypes = ['text/x-racket', 'application/x-racket']
 
-    # From namespace-mapped-symbols
-    keywords = [
-        '#%app', '#%datum', '#%expression', '#%module-begin',
+    # Generated by example.rkt
+    _keywords = [
+        '#%app', '#%datum', '#%declare', '#%expression', '#%module-begin',
         '#%plain-app', '#%plain-lambda', '#%plain-module-begin',
-        '#%provide', '#%require', '#%stratified-body', '#%top',
-        '#%top-interaction', '#%variable-reference', '...', 'and', 'begin',
-        'begin-for-syntax', 'begin0', 'case', 'case-lambda', 'cond',
-        'datum->syntax-object', 'define', 'define-for-syntax',
-        'define-struct', 'define-syntax', 'define-syntax-rule',
-        'define-syntaxes', 'define-values', 'define-values-for-syntax',
-        'delay', 'do', 'expand-path', 'fluid-let', 'hash-table-copy',
-        'hash-table-count', 'hash-table-for-each', 'hash-table-get',
-        'hash-table-iterate-first', 'hash-table-iterate-key',
-        'hash-table-iterate-next', 'hash-table-iterate-value',
-        'hash-table-map', 'hash-table-put!', 'hash-table-remove!',
-        'hash-table?', 'if', 'lambda', 'let', 'let*', 'let*-values',
-        'let-struct', 'let-syntax', 'let-syntaxes', 'let-values', 'let/cc',
-        'let/ec', 'letrec', 'letrec-syntax', 'letrec-syntaxes',
-        'letrec-syntaxes+values', 'letrec-values', 'list-immutable',
-        'make-hash-table', 'make-immutable-hash-table', 'make-namespace',
-        'module', 'module-identifier=?', 'module-label-identifier=?',
-        'module-template-identifier=?', 'module-transformer-identifier=?',
-        'namespace-transformer-require', 'or', 'parameterize',
-        'parameterize*', 'parameterize-break', 'provide',
-        'provide-for-label', 'provide-for-syntax', 'quasiquote',
+        '#%printing-module-begin', '#%provide', '#%require',
+        '#%stratified-body', '#%top', '#%top-interaction',
+        '#%variable-reference', '->', '->*', '->*m', '->d', '->dm', '->i',
+        '->m', '...', ':do-in', '==', '=>', '_', 'absent', 'abstract',
+        'all-defined-out', 'all-from-out', 'and', 'any', 'augment', 'augment*',
+        'augment-final', 'augment-final*', 'augride', 'augride*', 'begin',
+        'begin-for-syntax', 'begin0', 'case', 'case->', 'case->m',
+        'case-lambda', 'class', 'class*', 'class-field-accessor',
+        'class-field-mutator', 'class/c', 'class/derived', 'combine-in',
+        'combine-out', 'command-line', 'compound-unit', 'compound-unit/infer',
+        'cond', 'contract', 'contract-out', 'contract-struct', 'contracted',
+        'define', 'define-compound-unit', 'define-compound-unit/infer',
+        'define-contract-struct', 'define-custom-hash-types',
+        'define-custom-set-types', 'define-for-syntax',
+        'define-local-member-name', 'define-logger', 'define-match-expander',
+        'define-member-name', 'define-module-boundary-contract',
+        'define-namespace-anchor', 'define-opt/c', 'define-sequence-syntax',
+        'define-serializable-class', 'define-serializable-class*',
+        'define-signature', 'define-signature-form', 'define-struct',
+        'define-struct/contract', 'define-struct/derived', 'define-syntax',
+        'define-syntax-rule', 'define-syntaxes', 'define-unit',
+        'define-unit-binding', 'define-unit-from-context',
+        'define-unit/contract', 'define-unit/new-import-export',
+        'define-unit/s', 'define-values', 'define-values-for-export',
+        'define-values-for-syntax', 'define-values/invoke-unit',
+        'define-values/invoke-unit/infer', 'define/augment',
+        'define/augment-final', 'define/augride', 'define/contract',
+        'define/final-prop', 'define/match', 'define/overment',
+        'define/override', 'define/override-final', 'define/private',
+        'define/public', 'define/public-final', 'define/pubment',
+        'define/subexpression-pos-prop', 'delay', 'delay/idle', 'delay/name',
+        'delay/strict', 'delay/sync', 'delay/thread', 'do', 'else', 'except',
+        'except-in', 'except-out', 'export', 'extends', 'failure-cont',
+        'false', 'false/c', 'field', 'field-bound?', 'file',
+        'flat-murec-contract', 'flat-rec-contract', 'for', 'for*', 'for*/and',
+        'for*/first', 'for*/fold', 'for*/fold/derived', 'for*/hash',
+        'for*/hasheq', 'for*/hasheqv', 'for*/last', 'for*/list', 'for*/lists',
+        'for*/mutable-set', 'for*/mutable-seteq', 'for*/mutable-seteqv',
+        'for*/or', 'for*/product', 'for*/set', 'for*/seteq', 'for*/seteqv',
+        'for*/sum', 'for*/vector', 'for*/weak-set', 'for*/weak-seteq',
+        'for*/weak-seteqv', 'for-label', 'for-meta', 'for-syntax',
+        'for-template', 'for/and', 'for/first', 'for/fold', 'for/fold/derived',
+        'for/hash', 'for/hasheq', 'for/hasheqv', 'for/last', 'for/list',
+        'for/lists', 'for/mutable-set', 'for/mutable-seteq',
+        'for/mutable-seteqv', 'for/or', 'for/product', 'for/set', 'for/seteq',
+        'for/seteqv', 'for/sum', 'for/vector', 'for/weak-set',
+        'for/weak-seteq', 'for/weak-seteqv', 'gen:custom-write', 'gen:dict',
+        'gen:equal+hash', 'gen:set', 'gen:stream', 'generic', 'get-field',
+        'if', 'implies', 'import', 'include', 'include-at/relative-to',
+        'include-at/relative-to/reader', 'include/reader', 'inherit',
+        'inherit-field', 'inherit/inner', 'inherit/super', 'init',
+        'init-depend', 'init-field', 'init-rest', 'inner', 'inspect',
+        'instantiate', 'interface', 'interface*', 'invoke-unit',
+        'invoke-unit/infer', 'lambda', 'lazy', 'let', 'let*', 'let*-values',
+        'let-syntax', 'let-syntaxes', 'let-values', 'let/cc', 'let/ec',
+        'letrec', 'letrec-syntax', 'letrec-syntaxes', 'letrec-syntaxes+values',
+        'letrec-values', 'lib', 'link', 'local', 'local-require', 'log-debug',
+        'log-error', 'log-fatal', 'log-info', 'log-warning', 'match', 'match*',
+        'match*/derived', 'match-define', 'match-define-values',
+        'match-lambda', 'match-lambda*', 'match-lambda**', 'match-let',
+        'match-let*', 'match-let*-values', 'match-let-values', 'match-letrec',
+        'match/derived', 'match/values', 'member-name-key', 'method-contract?',
+        'mixin', 'module', 'module*', 'module+', 'nand', 'new', 'nor',
+        'object-contract', 'object/c', 'only', 'only-in', 'only-meta-in',
+        'open', 'opt/c', 'or', 'overment', 'overment*', 'override',
+        'override*', 'override-final', 'override-final*', 'parameterize',
+        'parameterize*', 'parameterize-break', 'parametric->/c', 'place',
+        'place*', 'planet', 'prefix', 'prefix-in', 'prefix-out', 'private',
+        'private*', 'prompt-tag/c', 'protect-out', 'provide',
+        'provide-signature-elements', 'provide/contract', 'public', 'public*',
+        'public-final', 'public-final*', 'pubment', 'pubment*', 'quasiquote',
         'quasisyntax', 'quasisyntax/loc', 'quote', 'quote-syntax',
-        'quote-syntax/prune', 'require', 'require-for-label',
-        'require-for-syntax', 'require-for-template', 'set!',
-        'set!-values', 'syntax', 'syntax-case', 'syntax-case*',
-        'syntax-id-rules', 'syntax-object->datum', 'syntax-rules',
-        'syntax/loc', 'time', 'transcript-off', 'transcript-on', 'unless',
-        'unquote', 'unquote-splicing', 'unsyntax', 'unsyntax-splicing',
-        'when', 'with-continuation-mark', 'with-handlers',
-        'with-handlers*', 'with-syntax', 'λ'
+        'quote-syntax/prune', 'recontract-out', 'recursive-contract',
+        'relative-in', 'rename', 'rename-in', 'rename-inner', 'rename-out',
+        'rename-super', 'require', 'send', 'send*', 'send+', 'send-generic',
+        'send/apply', 'send/keyword-apply', 'set!', 'set!-values',
+        'set-field!', 'shared', 'stream', 'stream-cons', 'struct', 'struct*',
+        'struct-copy', 'struct-field-index', 'struct-out', 'struct/c',
+        'struct/ctc', 'struct/dc', 'submod', 'super', 'super-instantiate',
+        'super-make-object', 'super-new', 'syntax', 'syntax-case',
+        'syntax-case*', 'syntax-id-rules', 'syntax-rules', 'syntax/loc', 'tag',
+        'this', 'this%', 'thunk', 'thunk*', 'time', 'unconstrained-domain->',
+        'unit', 'unit-from-context', 'unit/c', 'unit/new-import-export',
+        'unit/s', 'unless', 'unquote', 'unquote-splicing', 'unsyntax',
+        'unsyntax-splicing', 'values/drop', 'when', 'with-continuation-mark',
+        'with-contract', 'with-handlers', 'with-handlers*', 'with-method',
+        'with-syntax', u'λ'
     ]
 
-    # From namespace-mapped-symbols
-    builtins = [
-        '*', '+', '-', '/', '<', '<=', '=', '>', '>=',
-        'abort-current-continuation', 'abs', 'absolute-path?', 'acos',
-        'add1', 'alarm-evt', 'always-evt', 'andmap', 'angle', 'append',
-        'apply', 'arithmetic-shift', 'arity-at-least',
-        'arity-at-least-value', 'arity-at-least?', 'asin', 'assoc', 'assq',
-        'assv', 'atan', 'banner', 'bitwise-and', 'bitwise-bit-field',
-        'bitwise-bit-set?', 'bitwise-ior', 'bitwise-not', 'bitwise-xor',
-        'boolean?', 'bound-identifier=?', 'box', 'box-immutable', 'box?',
-        'break-enabled', 'break-thread', 'build-path',
-        'build-path/convention-type', 'byte-pregexp', 'byte-pregexp?',
+    # Generated by example.rkt
+    _builtins = [
+        '*', '+', '-', '/', '<', '</c', '<=', '<=/c', '=', '=/c', '>', '>/c',
+        '>=', '>=/c', 'abort-current-continuation', 'abs', 'absolute-path?',
+        'acos', 'add-between', 'add1', 'alarm-evt', 'always-evt', 'and/c',
+        'andmap', 'angle', 'any/c', 'append', 'append*', 'append-map', 'apply',
+        'argmax', 'argmin', 'arithmetic-shift', 'arity-at-least',
+        'arity-at-least-value', 'arity-at-least?', 'arity-checking-wrapper',
+        'arity-includes?', 'arity=?', 'asin', 'assf', 'assoc', 'assq', 'assv',
+        'atan', 'bad-number-of-results', 'banner', 'base->-doms/c',
+        'base->-rngs/c', 'base->?', 'between/c', 'bitwise-and',
+        'bitwise-bit-field', 'bitwise-bit-set?', 'bitwise-ior', 'bitwise-not',
+        'bitwise-xor', 'blame-add-car-context', 'blame-add-cdr-context',
+        'blame-add-context', 'blame-add-missing-party',
+        'blame-add-nth-arg-context', 'blame-add-or-context',
+        'blame-add-range-context', 'blame-add-unknown-context',
+        'blame-context', 'blame-contract', 'blame-fmt->-string',
+        'blame-negative', 'blame-original?', 'blame-positive',
+        'blame-replace-negative', 'blame-source', 'blame-swap',
+        'blame-swapped?', 'blame-update', 'blame-value', 'blame?', 'boolean=?',
+        'boolean?', 'bound-identifier=?', 'box', 'box-cas!', 'box-immutable',
+        'box-immutable/c', 'box/c', 'box?', 'break-enabled', 'break-thread',
+        'build-chaperone-contract-property', 'build-compound-type-name',
+        'build-contract-property', 'build-flat-contract-property',
+        'build-list', 'build-path', 'build-path/convention-type',
+        'build-string', 'build-vector', 'byte-pregexp', 'byte-pregexp?',
         'byte-ready?', 'byte-regexp', 'byte-regexp?', 'byte?', 'bytes',
         'bytes->immutable-bytes', 'bytes->list', 'bytes->path',
-        'bytes->path-element', 'bytes->string/latin-1',
-        'bytes->string/locale', 'bytes->string/utf-8', 'bytes-append',
+        'bytes->path-element', 'bytes->string/latin-1', 'bytes->string/locale',
+        'bytes->string/utf-8', 'bytes-append', 'bytes-append*',
         'bytes-close-converter', 'bytes-convert', 'bytes-convert-end',
-        'bytes-converter?', 'bytes-copy', 'bytes-copy!', 'bytes-fill!',
-        'bytes-length', 'bytes-open-converter', 'bytes-ref', 'bytes-set!',
-        'bytes-utf-8-index', 'bytes-utf-8-length', 'bytes-utf-8-ref',
-        'bytes<?', 'bytes=?', 'bytes>?', 'bytes?', 'caaaar', 'caaadr',
-        'caaar', 'caadar', 'caaddr', 'caadr', 'caar', 'cadaar', 'cadadr',
-        'cadar', 'caddar', 'cadddr', 'caddr', 'cadr',
-        'call-in-nested-thread', 'call-with-break-parameterization',
-        'call-with-composable-continuation',
-        'call-with-continuation-barrier', 'call-with-continuation-prompt',
-        'call-with-current-continuation', 'call-with-escape-continuation',
-        'call-with-exception-handler',
-        'call-with-immediate-continuation-mark', 'call-with-input-file',
-        'call-with-output-file', 'call-with-parameterization',
-        'call-with-semaphore', 'call-with-semaphore/enable-break',
-        'call-with-values', 'call/cc', 'call/ec', 'car', 'cdaaar',
-        'cdaadr', 'cdaar', 'cdadar', 'cdaddr', 'cdadr', 'cdar', 'cddaar',
-        'cddadr', 'cddar', 'cdddar', 'cddddr', 'cdddr', 'cddr', 'cdr',
-        'ceiling', 'channel-get', 'channel-put', 'channel-put-evt',
-        'channel-try-get', 'channel?', 'chaperone-box', 'chaperone-evt',
-        'chaperone-hash', 'chaperone-of?', 'chaperone-procedure',
+        'bytes-converter?', 'bytes-copy', 'bytes-copy!',
+        'bytes-environment-variable-name?', 'bytes-fill!', 'bytes-join',
+        'bytes-length', 'bytes-no-nuls?', 'bytes-open-converter', 'bytes-ref',
+        'bytes-set!', 'bytes-utf-8-index', 'bytes-utf-8-length',
+        'bytes-utf-8-ref', 'bytes<?', 'bytes=?', 'bytes>?', 'bytes?', 'caaaar',
+        'caaadr', 'caaar', 'caadar', 'caaddr', 'caadr', 'caar', 'cadaar',
+        'cadadr', 'cadar', 'caddar', 'cadddr', 'caddr', 'cadr',
+        'call-in-nested-thread', 'call-with-atomic-output-file',
+        'call-with-break-parameterization',
+        'call-with-composable-continuation', 'call-with-continuation-barrier',
+        'call-with-continuation-prompt', 'call-with-current-continuation',
+        'call-with-default-reading-parameterization',
+        'call-with-escape-continuation', 'call-with-exception-handler',
+        'call-with-file-lock/timeout', 'call-with-immediate-continuation-mark',
+        'call-with-input-bytes', 'call-with-input-file',
+        'call-with-input-file*', 'call-with-input-string',
+        'call-with-output-bytes', 'call-with-output-file',
+        'call-with-output-file*', 'call-with-output-string',
+        'call-with-parameterization', 'call-with-semaphore',
+        'call-with-semaphore/enable-break', 'call-with-values', 'call/cc',
+        'call/ec', 'car', 'cdaaar', 'cdaadr', 'cdaar', 'cdadar', 'cdaddr',
+        'cdadr', 'cdar', 'cddaar', 'cddadr', 'cddar', 'cdddar', 'cddddr',
+        'cdddr', 'cddr', 'cdr', 'ceiling', 'channel-get', 'channel-put',
+        'channel-put-evt', 'channel-put-evt?', 'channel-try-get', 'channel/c',
+        'channel?', 'chaperone-box', 'chaperone-channel',
+        'chaperone-continuation-mark-key', 'chaperone-contract-property?',
+        'chaperone-contract?', 'chaperone-evt', 'chaperone-hash',
+        'chaperone-of?', 'chaperone-procedure', 'chaperone-prompt-tag',
         'chaperone-struct', 'chaperone-struct-type', 'chaperone-vector',
         'chaperone?', 'char->integer', 'char-alphabetic?', 'char-blank?',
         'char-ci<=?', 'char-ci<?', 'char-ci=?', 'char-ci>=?', 'char-ci>?',
         'char-downcase', 'char-foldcase', 'char-general-category',
         'char-graphic?', 'char-iso-control?', 'char-lower-case?',
-        'char-numeric?', 'char-punctuation?', 'char-ready?',
-        'char-symbolic?', 'char-title-case?', 'char-titlecase',
-        'char-upcase', 'char-upper-case?', 'char-utf-8-length',
-        'char-whitespace?', 'char<=?', 'char<?', 'char=?', 'char>=?',
-        'char>?', 'char?', 'check-duplicate-identifier',
-        'checked-procedure-check-and-extract', 'choice-evt',
+        'char-numeric?', 'char-punctuation?', 'char-ready?', 'char-symbolic?',
+        'char-title-case?', 'char-titlecase', 'char-upcase',
+        'char-upper-case?', 'char-utf-8-length', 'char-whitespace?', 'char<=?',
+        'char<?', 'char=?', 'char>=?', 'char>?', 'char?',
+        'check-duplicate-identifier', 'checked-procedure-check-and-extract',
+        'choice-evt', 'class->interface', 'class-info', 'class?',
         'cleanse-path', 'close-input-port', 'close-output-port',
-        'collect-garbage', 'collection-file-path', 'collection-path',
-        'compile', 'compile-allow-set!-undefined',
-        'compile-context-preservation-enabled',
+        'coerce-chaperone-contract', 'coerce-chaperone-contracts',
+        'coerce-contract', 'coerce-contract/f', 'coerce-contracts',
+        'coerce-flat-contract', 'coerce-flat-contracts', 'collect-garbage',
+        'collection-file-path', 'collection-path', 'compile',
+        'compile-allow-set!-undefined', 'compile-context-preservation-enabled',
         'compile-enforce-module-constants', 'compile-syntax',
         'compiled-expression?', 'compiled-module-expression?',
-        'complete-path?', 'complex?', 'cons',
-        'continuation-mark-set->context', 'continuation-mark-set->list',
-        'continuation-mark-set->list*', 'continuation-mark-set-first',
-        'continuation-mark-set?', 'continuation-marks',
-        'continuation-prompt-available?', 'continuation-prompt-tag?',
-        'continuation?', 'copy-file', 'cos',
-        'current-break-parameterization', 'current-code-inspector',
-        'current-command-line-arguments', 'current-compile',
-        'current-continuation-marks', 'current-custodian',
-        'current-directory', 'current-drive', 'current-error-port',
+        'complete-path?', 'complex?', 'compose', 'compose1', 'conjugate',
+        'cons', 'cons/c', 'cons?', 'const', 'continuation-mark-key/c',
+        'continuation-mark-key?', 'continuation-mark-set->context',
+        'continuation-mark-set->list', 'continuation-mark-set->list*',
+        'continuation-mark-set-first', 'continuation-mark-set?',
+        'continuation-marks', 'continuation-prompt-available?',
+        'continuation-prompt-tag?', 'continuation?',
+        'contract-continuation-mark-key', 'contract-first-order',
+        'contract-first-order-passes?', 'contract-name', 'contract-proc',
+        'contract-projection', 'contract-property?',
+        'contract-random-generate', 'contract-stronger?',
+        'contract-struct-exercise', 'contract-struct-generate',
+        'contract-val-first-projection', 'contract?', 'convert-stream',
+        'copy-directory/files', 'copy-file', 'copy-port', 'cos', 'cosh',
+        'count', 'current-blame-format', 'current-break-parameterization',
+        'current-code-inspector', 'current-command-line-arguments',
+        'current-compile', 'current-compiled-file-roots',
+        'current-continuation-marks', 'current-contract-region',
+        'current-custodian', 'current-directory', 'current-directory-for-user',
+        'current-drive', 'current-environment-variables', 'current-error-port',
         'current-eval', 'current-evt-pseudo-random-generator',
-        'current-gc-milliseconds', 'current-get-interaction-input-port',
-        'current-inexact-milliseconds', 'current-input-port',
-        'current-inspector', 'current-library-collection-paths',
+        'current-future', 'current-gc-milliseconds',
+        'current-get-interaction-input-port', 'current-inexact-milliseconds',
+        'current-input-port', 'current-inspector',
+        'current-library-collection-links', 'current-library-collection-paths',
         'current-load', 'current-load-extension',
         'current-load-relative-directory', 'current-load/use-compiled',
-        'current-locale', 'current-memory-use', 'current-milliseconds',
-        'current-module-declare-name', 'current-module-declare-source',
-        'current-module-name-resolver', 'current-namespace',
+        'current-locale', 'current-logger', 'current-memory-use',
+        'current-milliseconds', 'current-module-declare-name',
+        'current-module-declare-source', 'current-module-name-resolver',
+        'current-module-path-for-load', 'current-namespace',
         'current-output-port', 'current-parameterization',
         'current-preserved-thread-cell-values', 'current-print',
         'current-process-milliseconds', 'current-prompt-read',
@@ -155,133 +251,229 @@ class RacketLexer(RegexLexer):
         'current-security-guard', 'current-subprocess-custodian-mode',
         'current-thread', 'current-thread-group',
         'current-thread-initial-stack-size',
-        'current-write-relative-directory', 'custodian-box-value',
-        'custodian-box?', 'custodian-limit-memory',
+        'current-write-relative-directory', 'curry', 'curryr',
+        'custodian-box-value', 'custodian-box?', 'custodian-limit-memory',
         'custodian-managed-list', 'custodian-memory-accounting-available?',
         'custodian-require-memory', 'custodian-shutdown-all', 'custodian?',
         'custom-print-quotable-accessor', 'custom-print-quotable?',
-        'custom-write-accessor', 'custom-write?', 'date', 'date*',
-        'date*-nanosecond', 'date*-time-zone-name', 'date*?', 'date-day',
-        'date-dst?', 'date-hour', 'date-minute', 'date-month',
-        'date-second', 'date-time-zone-offset', 'date-week-day',
-        'date-year', 'date-year-day', 'date?', 'datum-intern-literal',
-        'default-continuation-prompt-tag', 'delete-directory',
-        'delete-file', 'denominator', 'directory-exists?',
-        'directory-list', 'display', 'displayln', 'dump-memory-stats',
-        'dynamic-require', 'dynamic-require-for-syntax', 'dynamic-wind',
-        'eof', 'eof-object?', 'ephemeron-value', 'ephemeron?', 'eprintf',
-        'eq-hash-code', 'eq?', 'equal-hash-code',
-        'equal-secondary-hash-code', 'equal?', 'equal?/recur',
-        'eqv-hash-code', 'eqv?', 'error', 'error-display-handler',
-        'error-escape-handler', 'error-print-context-length',
-        'error-print-source-location', 'error-print-width',
-        'error-value->string-handler', 'eval', 'eval-jit-enabled',
-        'eval-syntax', 'even?', 'evt?', 'exact->inexact', 'exact-integer?',
-        'exact-nonnegative-integer?', 'exact-positive-integer?', 'exact?',
-        'executable-yield-handler', 'exit', 'exit-handler', 'exn',
-        'exn-continuation-marks', 'exn-message', 'exn:break',
-        'exn:break-continuation', 'exn:break?', 'exn:fail',
-        'exn:fail:contract', 'exn:fail:contract:arity',
-        'exn:fail:contract:arity?', 'exn:fail:contract:continuation',
-        'exn:fail:contract:continuation?',
-        'exn:fail:contract:divide-by-zero',
+        'custom-write-accessor', 'custom-write-property-proc', 'custom-write?',
+        'date', 'date*', 'date*-nanosecond', 'date*-time-zone-name', 'date*?',
+        'date-day', 'date-dst?', 'date-hour', 'date-minute', 'date-month',
+        'date-second', 'date-time-zone-offset', 'date-week-day', 'date-year',
+        'date-year-day', 'date?', 'datum->syntax', 'datum-intern-literal',
+        'default-continuation-prompt-tag', 'degrees->radians',
+        'delete-directory', 'delete-directory/files', 'delete-file',
+        'denominator', 'dict->list', 'dict-can-functional-set?',
+        'dict-can-remove-keys?', 'dict-clear', 'dict-clear!', 'dict-copy',
+        'dict-count', 'dict-empty?', 'dict-for-each', 'dict-has-key?',
+        'dict-implements/c', 'dict-implements?', 'dict-iter-contract',
+        'dict-iterate-first', 'dict-iterate-key', 'dict-iterate-next',
+        'dict-iterate-value', 'dict-key-contract', 'dict-keys', 'dict-map',
+        'dict-mutable?', 'dict-ref', 'dict-ref!', 'dict-remove',
+        'dict-remove!', 'dict-set', 'dict-set!', 'dict-set*', 'dict-set*!',
+        'dict-update', 'dict-update!', 'dict-value-contract', 'dict-values',
+        'dict?', 'directory-exists?', 'directory-list', 'display',
+        'display-lines', 'display-lines-to-file', 'display-to-file',
+        'displayln', 'double-flonum?', 'drop', 'drop-right', 'dropf',
+        'dropf-right', 'dump-memory-stats', 'dup-input-port',
+        'dup-output-port', 'dynamic-get-field', 'dynamic-place',
+        'dynamic-place*', 'dynamic-require', 'dynamic-require-for-syntax',
+        'dynamic-send', 'dynamic-set-field!', 'dynamic-wind', 'eighth',
+        'empty', 'empty-sequence', 'empty-stream', 'empty?',
+        'environment-variables-copy', 'environment-variables-names',
+        'environment-variables-ref', 'environment-variables-set!',
+        'environment-variables?', 'eof', 'eof-evt', 'eof-object?',
+        'ephemeron-value', 'ephemeron?', 'eprintf', 'eq-contract-val',
+        'eq-contract?', 'eq-hash-code', 'eq?', 'equal-contract-val',
+        'equal-contract?', 'equal-hash-code', 'equal-secondary-hash-code',
+        'equal<%>', 'equal?', 'equal?/recur', 'eqv-hash-code', 'eqv?', 'error',
+        'error-display-handler', 'error-escape-handler',
+        'error-print-context-length', 'error-print-source-location',
+        'error-print-width', 'error-value->string-handler', 'eval',
+        'eval-jit-enabled', 'eval-syntax', 'even?', 'evt/c', 'evt?',
+        'exact->inexact', 'exact-ceiling', 'exact-floor', 'exact-integer?',
+        'exact-nonnegative-integer?', 'exact-positive-integer?', 'exact-round',
+        'exact-truncate', 'exact?', 'executable-yield-handler', 'exit',
+        'exit-handler', 'exn', 'exn-continuation-marks', 'exn-message',
+        'exn:break', 'exn:break-continuation', 'exn:break:hang-up',
+        'exn:break:hang-up?', 'exn:break:terminate', 'exn:break:terminate?',
+        'exn:break?', 'exn:fail', 'exn:fail:contract',
+        'exn:fail:contract:arity', 'exn:fail:contract:arity?',
+        'exn:fail:contract:blame', 'exn:fail:contract:blame-object',
+        'exn:fail:contract:blame?', 'exn:fail:contract:continuation',
+        'exn:fail:contract:continuation?', 'exn:fail:contract:divide-by-zero',
         'exn:fail:contract:divide-by-zero?',
         'exn:fail:contract:non-fixnum-result',
-        'exn:fail:contract:non-fixnum-result?',
-        'exn:fail:contract:variable', 'exn:fail:contract:variable-id',
-        'exn:fail:contract:variable?', 'exn:fail:contract?',
-        'exn:fail:filesystem', 'exn:fail:filesystem:exists',
-        'exn:fail:filesystem:exists?', 'exn:fail:filesystem:version',
+        'exn:fail:contract:non-fixnum-result?', 'exn:fail:contract:variable',
+        'exn:fail:contract:variable-id', 'exn:fail:contract:variable?',
+        'exn:fail:contract?', 'exn:fail:filesystem',
+        'exn:fail:filesystem:errno', 'exn:fail:filesystem:errno-errno',
+        'exn:fail:filesystem:errno?', 'exn:fail:filesystem:exists',
+        'exn:fail:filesystem:exists?', 'exn:fail:filesystem:missing-module',
+        'exn:fail:filesystem:missing-module-path',
+        'exn:fail:filesystem:missing-module?', 'exn:fail:filesystem:version',
         'exn:fail:filesystem:version?', 'exn:fail:filesystem?',
-        'exn:fail:network', 'exn:fail:network?', 'exn:fail:out-of-memory',
-        'exn:fail:out-of-memory?', 'exn:fail:read',
+        'exn:fail:network', 'exn:fail:network:errno',
+        'exn:fail:network:errno-errno', 'exn:fail:network:errno?',
+        'exn:fail:network?', 'exn:fail:object', 'exn:fail:object?',
+        'exn:fail:out-of-memory', 'exn:fail:out-of-memory?', 'exn:fail:read',
         'exn:fail:read-srclocs', 'exn:fail:read:eof', 'exn:fail:read:eof?',
-        'exn:fail:read:non-char', 'exn:fail:read:non-char?',
-        'exn:fail:read?', 'exn:fail:syntax', 'exn:fail:syntax-exprs',
-        'exn:fail:syntax:unbound', 'exn:fail:syntax:unbound?',
-        'exn:fail:syntax?', 'exn:fail:unsupported',
+        'exn:fail:read:non-char', 'exn:fail:read:non-char?', 'exn:fail:read?',
+        'exn:fail:syntax', 'exn:fail:syntax-exprs',
+        'exn:fail:syntax:missing-module',
+        'exn:fail:syntax:missing-module-path',
+        'exn:fail:syntax:missing-module?', 'exn:fail:syntax:unbound',
+        'exn:fail:syntax:unbound?', 'exn:fail:syntax?', 'exn:fail:unsupported',
         'exn:fail:unsupported?', 'exn:fail:user', 'exn:fail:user?',
-        'exn:fail?', 'exn:srclocs-accessor', 'exn:srclocs?', 'exn?', 'exp',
-        'expand', 'expand-once', 'expand-syntax', 'expand-syntax-once',
-        'expand-syntax-to-top-form', 'expand-to-top-form',
-        'expand-user-path', 'expt', 'file-exists?',
-        'file-or-directory-identity', 'file-or-directory-modify-seconds',
-        'file-or-directory-permissions', 'file-position', 'file-size',
-        'file-stream-buffer-mode', 'file-stream-port?',
-        'filesystem-root-list', 'find-executable-path',
-        'find-library-collection-paths', 'find-system-path', 'fixnum?',
+        'exn:fail?', 'exn:misc:match?', 'exn:missing-module-accessor',
+        'exn:missing-module?', 'exn:srclocs-accessor', 'exn:srclocs?', 'exn?',
+        'exp', 'expand', 'expand-once', 'expand-syntax', 'expand-syntax-once',
+        'expand-syntax-to-top-form', 'expand-to-top-form', 'expand-user-path',
+        'explode-path', 'expt', 'externalizable<%>', 'false?', 'field-names',
+        'fifth', 'file->bytes', 'file->bytes-lines', 'file->lines',
+        'file->list', 'file->string', 'file->value', 'file-exists?',
+        'file-name-from-path', 'file-or-directory-identity',
+        'file-or-directory-modify-seconds', 'file-or-directory-permissions',
+        'file-position', 'file-position*', 'file-size',
+        'file-stream-buffer-mode', 'file-stream-port?', 'file-truncate',
+        'filename-extension', 'filesystem-change-evt',
+        'filesystem-change-evt-cancel', 'filesystem-change-evt?',
+        'filesystem-root-list', 'filter', 'filter-map', 'filter-not',
+        'filter-read-input-port', 'find-executable-path', 'find-files',
+        'find-library-collection-links', 'find-library-collection-paths',
+        'find-relative-path', 'find-system-path', 'findf', 'first', 'fixnum?',
+        'flat-contract', 'flat-contract-predicate', 'flat-contract-property?',
+        'flat-contract?', 'flat-named-contract', 'flatten',
         'floating-point-bytes->real', 'flonum?', 'floor', 'flush-output',
-        'for-each', 'force', 'format', 'fprintf', 'free-identifier=?',
-        'gcd', 'generate-temporaries', 'gensym', 'get-output-bytes',
-        'get-output-string', 'getenv', 'global-port-print-handler',
-        'guard-evt', 'handle-evt', 'handle-evt?', 'hash', 'hash-equal?',
-        'hash-eqv?', 'hash-has-key?', 'hash-placeholder?', 'hash-ref!',
-        'hasheq', 'hasheqv', 'identifier-binding',
-        'identifier-label-binding', 'identifier-prune-lexical-context',
+        'fold-files', 'foldl', 'foldr', 'for-each', 'force', 'format',
+        'fourth', 'fprintf', 'free-identifier=?', 'free-label-identifier=?',
+        'free-template-identifier=?', 'free-transformer-identifier=?',
+        'fsemaphore-count', 'fsemaphore-post', 'fsemaphore-try-wait?',
+        'fsemaphore-wait', 'fsemaphore?', 'future', 'future?',
+        'futures-enabled?', 'gcd', 'generate-member-key',
+        'generate-temporaries', 'generic-set?', 'generic?', 'gensym',
+        'get-output-bytes', 'get-output-string', 'get-preference',
+        'get/build-val-first-projection', 'getenv',
+        'global-port-print-handler', 'group-execute-bit', 'group-read-bit',
+        'group-write-bit', 'guard-evt', 'handle-evt', 'handle-evt?',
+        'has-contract?', 'hash', 'hash->list', 'hash-clear', 'hash-clear!',
+        'hash-copy', 'hash-copy-clear', 'hash-count', 'hash-empty?',
+        'hash-eq?', 'hash-equal?', 'hash-eqv?', 'hash-for-each',
+        'hash-has-key?', 'hash-iterate-first', 'hash-iterate-key',
+        'hash-iterate-next', 'hash-iterate-value', 'hash-keys', 'hash-map',
+        'hash-placeholder?', 'hash-ref', 'hash-ref!', 'hash-remove',
+        'hash-remove!', 'hash-set', 'hash-set!', 'hash-set*', 'hash-set*!',
+        'hash-update', 'hash-update!', 'hash-values', 'hash-weak?', 'hash/c',
+        'hash?', 'hasheq', 'hasheqv', 'identifier-binding',
+        'identifier-binding-symbol', 'identifier-label-binding',
+        'identifier-prune-lexical-context',
         'identifier-prune-to-source-module',
         'identifier-remove-from-definition-context',
         'identifier-template-binding', 'identifier-transformer-binding',
-        'identifier?', 'imag-part', 'immutable?', 'impersonate-box',
-        'impersonate-hash', 'impersonate-procedure', 'impersonate-struct',
-        'impersonate-vector', 'impersonator-of?',
-        'impersonator-prop:application-mark',
-        'impersonator-property-accessor-procedure?',
-        'impersonator-property?', 'impersonator?', 'inexact->exact',
-        'inexact-real?', 'inexact?', 'input-port?', 'inspector?',
-        'integer->char', 'integer->integer-bytes',
-        'integer-bytes->integer', 'integer-length', 'integer-sqrt',
-        'integer-sqrt/remainder', 'integer?',
+        'identifier?', 'identity', 'imag-part', 'immutable?',
+        'impersonate-box', 'impersonate-channel',
+        'impersonate-continuation-mark-key', 'impersonate-hash',
+        'impersonate-procedure', 'impersonate-prompt-tag',
+        'impersonate-struct', 'impersonate-vector', 'impersonator-contract?',
+        'impersonator-ephemeron', 'impersonator-of?',
+        'impersonator-prop:application-mark', 'impersonator-prop:contracted',
+        'impersonator-property-accessor-procedure?', 'impersonator-property?',
+        'impersonator?', 'implementation?', 'implementation?/c', 'in-bytes',
+        'in-bytes-lines', 'in-cycle', 'in-dict', 'in-dict-keys',
+        'in-dict-pairs', 'in-dict-values', 'in-directory', 'in-hash',
+        'in-hash-keys', 'in-hash-pairs', 'in-hash-values', 'in-indexed',
+        'in-input-port-bytes', 'in-input-port-chars', 'in-lines', 'in-list',
+        'in-mlist', 'in-naturals', 'in-parallel', 'in-permutations', 'in-port',
+        'in-producer', 'in-range', 'in-sequences', 'in-set', 'in-stream',
+        'in-string', 'in-value', 'in-values*-sequence', 'in-values-sequence',
+        'in-vector', 'inexact->exact', 'inexact-real?', 'inexact?',
+        'infinite?', 'input-port-append', 'input-port?', 'inspector?',
+        'instanceof/c', 'integer->char', 'integer->integer-bytes',
+        'integer-bytes->integer', 'integer-in', 'integer-length',
+        'integer-sqrt', 'integer-sqrt/remainder', 'integer?',
+        'interface->method-names', 'interface-extension?', 'interface?',
         'internal-definition-context-seal', 'internal-definition-context?',
-        'keyword->string', 'keyword<?', 'keyword?', 'kill-thread', 'lcm',
-        'length', 'liberal-define-context?', 'link-exists?', 'list',
-        'list*', 'list->bytes', 'list->string', 'list->vector', 'list-ref',
-        'list-tail', 'list?', 'load', 'load-extension',
-        'load-on-demand-enabled', 'load-relative',
-        'load-relative-extension', 'load/cd', 'load/use-compiled',
-        'local-expand', 'local-expand/capture-lifts',
-        'local-transformer-expand',
-        'local-transformer-expand/capture-lifts', 'locale-string-encoding',
-        'log', 'magnitude', 'make-arity-at-least', 'make-bytes',
-        'make-channel', 'make-continuation-prompt-tag', 'make-custodian',
-        'make-custodian-box', 'make-date', 'make-date*',
-        'make-derived-parameter', 'make-directory', 'make-ephemeron',
-        'make-exn', 'make-exn:break', 'make-exn:fail',
-        'make-exn:fail:contract', 'make-exn:fail:contract:arity',
+        'is-a?', 'is-a?/c', 'keyword->string', 'keyword-apply', 'keyword<?',
+        'keyword?', 'keywords-match', 'kill-thread', 'last', 'last-pair',
+        'lcm', 'length', 'liberal-define-context?', 'link-exists?', 'list',
+        'list*', 'list->bytes', 'list->mutable-set', 'list->mutable-seteq',
+        'list->mutable-seteqv', 'list->set', 'list->seteq', 'list->seteqv',
+        'list->string', 'list->vector', 'list->weak-set', 'list->weak-seteq',
+        'list->weak-seteqv', 'list-ref', 'list-tail', 'list/c', 'list?',
+        'listof', 'load', 'load-extension', 'load-on-demand-enabled',
+        'load-relative', 'load-relative-extension', 'load/cd',
+        'load/use-compiled', 'local-expand', 'local-expand/capture-lifts',
+        'local-transformer-expand', 'local-transformer-expand/capture-lifts',
+        'locale-string-encoding', 'log', 'log-level?', 'log-max-level',
+        'log-message', 'log-receiver?', 'logger-name', 'logger?', 'magnitude',
+        'make-arity-at-least', 'make-base-empty-namespace',
+        'make-base-namespace', 'make-bytes', 'make-channel',
+        'make-chaperone-contract', 'make-continuation-mark-key',
+        'make-continuation-prompt-tag', 'make-contract', 'make-custodian',
+        'make-custodian-box', 'make-custom-hash', 'make-custom-hash-types',
+        'make-custom-set', 'make-custom-set-types', 'make-date', 'make-date*',
+        'make-derived-parameter', 'make-directory', 'make-directory*',
+        'make-do-sequence', 'make-empty-namespace',
+        'make-environment-variables', 'make-ephemeron', 'make-exn',
+        'make-exn:break', 'make-exn:break:hang-up', 'make-exn:break:terminate',
+        'make-exn:fail', 'make-exn:fail:contract',
+        'make-exn:fail:contract:arity', 'make-exn:fail:contract:blame',
         'make-exn:fail:contract:continuation',
         'make-exn:fail:contract:divide-by-zero',
         'make-exn:fail:contract:non-fixnum-result',
         'make-exn:fail:contract:variable', 'make-exn:fail:filesystem',
-        'make-exn:fail:filesystem:exists',
+        'make-exn:fail:filesystem:errno', 'make-exn:fail:filesystem:exists',
+        'make-exn:fail:filesystem:missing-module',
         'make-exn:fail:filesystem:version', 'make-exn:fail:network',
+        'make-exn:fail:network:errno', 'make-exn:fail:object',
         'make-exn:fail:out-of-memory', 'make-exn:fail:read',
         'make-exn:fail:read:eof', 'make-exn:fail:read:non-char',
-        'make-exn:fail:syntax', 'make-exn:fail:syntax:unbound',
-        'make-exn:fail:unsupported', 'make-exn:fail:user',
-        'make-file-or-directory-link', 'make-hash-placeholder',
-        'make-hasheq-placeholder', 'make-hasheqv',
-        'make-hasheqv-placeholder', 'make-immutable-hasheqv',
-        'make-impersonator-property', 'make-input-port', 'make-inspector',
-        'make-known-char-range-list', 'make-output-port', 'make-parameter',
-        'make-pipe', 'make-placeholder', 'make-polar',
-        'make-prefab-struct', 'make-pseudo-random-generator',
+        'make-exn:fail:syntax', 'make-exn:fail:syntax:missing-module',
+        'make-exn:fail:syntax:unbound', 'make-exn:fail:unsupported',
+        'make-exn:fail:user', 'make-file-or-directory-link',
+        'make-flat-contract', 'make-fsemaphore', 'make-generic',
+        'make-handle-get-preference-locked', 'make-hash',
+        'make-hash-placeholder', 'make-hasheq', 'make-hasheq-placeholder',
+        'make-hasheqv', 'make-hasheqv-placeholder',
+        'make-immutable-custom-hash', 'make-immutable-hash',
+        'make-immutable-hasheq', 'make-immutable-hasheqv',
+        'make-impersonator-property', 'make-input-port',
+        'make-input-port/read-to-peek', 'make-inspector',
+        'make-keyword-procedure', 'make-known-char-range-list',
+        'make-limited-input-port', 'make-list', 'make-lock-file-name',
+        'make-log-receiver', 'make-logger', 'make-mixin-contract',
+        'make-mutable-custom-set', 'make-none/c', 'make-object',
+        'make-output-port', 'make-parameter', 'make-phantom-bytes',
+        'make-pipe', 'make-pipe-with-specials', 'make-placeholder',
+        'make-polar', 'make-prefab-struct', 'make-primitive-class',
+        'make-proj-contract', 'make-pseudo-random-generator',
         'make-reader-graph', 'make-readtable', 'make-rectangular',
         'make-rename-transformer', 'make-resolved-module-path',
         'make-security-guard', 'make-semaphore', 'make-set!-transformer',
-        'make-shared-bytes', 'make-sibling-inspector',
-        'make-special-comment', 'make-srcloc', 'make-string',
-        'make-struct-field-accessor', 'make-struct-field-mutator',
-        'make-struct-type', 'make-struct-type-property',
-        'make-syntax-delta-introducer', 'make-syntax-introducer',
-        'make-thread-cell', 'make-thread-group', 'make-vector',
-        'make-weak-box', 'make-weak-hasheqv', 'make-will-executor', 'map',
-        'max', 'mcar', 'mcdr', 'mcons', 'member', 'memq', 'memv', 'min',
-        'module->exports', 'module->imports', 'module->language-info',
-        'module->namespace', 'module-compiled-exports',
+        'make-shared-bytes', 'make-sibling-inspector', 'make-special-comment',
+        'make-srcloc', 'make-string', 'make-struct-field-accessor',
+        'make-struct-field-mutator', 'make-struct-type',
+        'make-struct-type-property', 'make-syntax-delta-introducer',
+        'make-syntax-introducer', 'make-temporary-file',
+        'make-tentative-pretty-print-output-port', 'make-thread-cell',
+        'make-thread-group', 'make-vector', 'make-weak-box',
+        'make-weak-custom-hash', 'make-weak-custom-set', 'make-weak-hash',
+        'make-weak-hasheq', 'make-weak-hasheqv', 'make-will-executor', 'map',
+        'match-equality-test', 'matches-arity-exactly?', 'max', 'mcar', 'mcdr',
+        'mcons', 'member', 'member-name-key-hash-code', 'member-name-key=?',
+        'member-name-key?', 'memf', 'memq', 'memv', 'merge-input',
+        'method-in-interface?', 'min', 'mixin-contract', 'module->exports',
+        'module->imports', 'module->language-info', 'module->namespace',
+        'module-compiled-cross-phase-persistent?', 'module-compiled-exports',
         'module-compiled-imports', 'module-compiled-language-info',
-        'module-compiled-name', 'module-path-index-join',
+        'module-compiled-name', 'module-compiled-submodules',
+        'module-declared?', 'module-path-index-join',
         'module-path-index-resolve', 'module-path-index-split',
-        'module-path-index?', 'module-path?', 'module-predefined?',
-        'module-provide-protected?', 'modulo', 'mpair?', 'nack-guard-evt',
+        'module-path-index-submodule', 'module-path-index?', 'module-path?',
+        'module-predefined?', 'module-provide-protected?', 'modulo', 'mpair?',
+        'mutable-set', 'mutable-seteq', 'mutable-seteqv', 'n->th',
+        'nack-guard-evt', 'namespace-anchor->empty-namespace',
+        'namespace-anchor->namespace', 'namespace-anchor?',
         'namespace-attach-module', 'namespace-attach-module-declaration',
         'namespace-base-phase', 'namespace-mapped-symbols',
         'namespace-module-identifier', 'namespace-module-registry',
@@ -289,136 +481,212 @@ class RacketLexer(RegexLexer):
         'namespace-require/copy', 'namespace-require/expansion-time',
         'namespace-set-variable-value!', 'namespace-symbol->identifier',
         'namespace-syntax-introduce', 'namespace-undefine-variable!',
-        'namespace-unprotect-module', 'namespace-variable-value',
-        'namespace?', 'negative?', 'never-evt', 'newline',
-        'normal-case-path', 'not', 'null', 'null?', 'number->string',
-        'number?', 'numerator', 'object-name', 'odd?', 'open-input-bytes',
+        'namespace-unprotect-module', 'namespace-variable-value', 'namespace?',
+        'nan?', 'natural-number/c', 'negate', 'negative?', 'never-evt',
+        u'new-∀/c', u'new-∃/c', 'newline', 'ninth', 'non-empty-listof',
+        'none/c', 'normal-case-path', 'normalize-arity', 'normalize-path',
+        'normalized-arity?', 'not', 'not/c', 'null', 'null?', 'number->string',
+        'number?', 'numerator', 'object%', 'object->vector', 'object-info',
+        'object-interface', 'object-method-arity-includes?', 'object-name',
+        'object=?', 'object?', 'odd?', 'one-of/c', 'open-input-bytes',
         'open-input-file', 'open-input-output-file', 'open-input-string',
-        'open-output-bytes', 'open-output-file', 'open-output-string',
-        'ormap', 'output-port?', 'pair?', 'parameter-procedure=?',
-        'parameter?', 'parameterization?', 'path->bytes',
-        'path->complete-path', 'path->directory-path', 'path->string',
-        'path-add-suffix', 'path-convention-type', 'path-element->bytes',
-        'path-element->string', 'path-for-some-system?',
-        'path-list-string->path-list', 'path-replace-suffix',
-        'path-string?', 'path?', 'peek-byte', 'peek-byte-or-special',
-        'peek-bytes', 'peek-bytes!', 'peek-bytes-avail!',
-        'peek-bytes-avail!*', 'peek-bytes-avail!/enable-break',
-        'peek-char', 'peek-char-or-special', 'peek-string', 'peek-string!',
-        'pipe-content-length', 'placeholder-get', 'placeholder-set!',
-        'placeholder?', 'poll-guard-evt', 'port-closed-evt',
-        'port-closed?', 'port-commit-peeked', 'port-count-lines!',
-        'port-count-lines-enabled', 'port-display-handler',
-        'port-file-identity', 'port-file-unlock', 'port-next-location',
-        'port-print-handler', 'port-progress-evt',
-        'port-provides-progress-evts?', 'port-read-handler',
-        'port-try-file-lock?', 'port-write-handler', 'port-writes-atomic?',
-        'port-writes-special?', 'port?', 'positive?',
-        'prefab-key->struct-type', 'prefab-struct-key', 'pregexp',
-        'pregexp?', 'primitive-closure?', 'primitive-result-arity',
-        'primitive?', 'print', 'print-as-expression',
+        'open-output-bytes', 'open-output-file', 'open-output-nowhere',
+        'open-output-string', 'or/c', 'order-of-magnitude', 'ormap',
+        'other-execute-bit', 'other-read-bit', 'other-write-bit',
+        'output-port?', 'pair?', 'parameter-procedure=?', 'parameter/c',
+        'parameter?', 'parameterization?', 'parse-command-line', 'partition',
+        'path->bytes', 'path->complete-path', 'path->directory-path',
+        'path->string', 'path-add-suffix', 'path-convention-type',
+        'path-element->bytes', 'path-element->string', 'path-element?',
+        'path-for-some-system?', 'path-list-string->path-list', 'path-only',
+        'path-replace-suffix', 'path-string?', 'path<?', 'path?',
+        'pathlist-closure', 'peek-byte', 'peek-byte-or-special', 'peek-bytes',
+        'peek-bytes!', 'peek-bytes!-evt', 'peek-bytes-avail!',
+        'peek-bytes-avail!*', 'peek-bytes-avail!-evt',
+        'peek-bytes-avail!/enable-break', 'peek-bytes-evt', 'peek-char',
+        'peek-char-or-special', 'peek-string', 'peek-string!',
+        'peek-string!-evt', 'peek-string-evt', 'peeking-input-port',
+        'permutations', 'phantom-bytes?', 'pi', 'pi.f', 'pipe-content-length',
+        'place-break', 'place-channel', 'place-channel-get',
+        'place-channel-put', 'place-channel-put/get', 'place-channel?',
+        'place-dead-evt', 'place-enabled?', 'place-kill', 'place-location?',
+        'place-message-allowed?', 'place-sleep', 'place-wait', 'place?',
+        'placeholder-get', 'placeholder-set!', 'placeholder?',
+        'poll-guard-evt', 'port->bytes', 'port->bytes-lines', 'port->lines',
+        'port->list', 'port->string', 'port-closed-evt', 'port-closed?',
+        'port-commit-peeked', 'port-count-lines!', 'port-count-lines-enabled',
+        'port-counts-lines?', 'port-display-handler', 'port-file-identity',
+        'port-file-unlock', 'port-next-location', 'port-print-handler',
+        'port-progress-evt', 'port-provides-progress-evts?',
+        'port-read-handler', 'port-try-file-lock?', 'port-write-handler',
+        'port-writes-atomic?', 'port-writes-special?', 'port?', 'positive?',
+        'predicate/c', 'prefab-key->struct-type', 'prefab-key?',
+        'prefab-struct-key', 'preferences-lock-file-mode', 'pregexp',
+        'pregexp?', 'pretty-display', 'pretty-format', 'pretty-print',
+        'pretty-print-.-symbol-without-bars',
+        'pretty-print-abbreviate-read-macros', 'pretty-print-columns',
+        'pretty-print-current-style-table', 'pretty-print-depth',
+        'pretty-print-exact-as-decimal', 'pretty-print-extend-style-table',
+        'pretty-print-handler', 'pretty-print-newline',
+        'pretty-print-post-print-hook', 'pretty-print-pre-print-hook',
+        'pretty-print-print-hook', 'pretty-print-print-line',
+        'pretty-print-remap-stylable', 'pretty-print-show-inexactness',
+        'pretty-print-size-hook', 'pretty-print-style-table?',
+        'pretty-printing', 'pretty-write', 'primitive-closure?',
+        'primitive-result-arity', 'primitive?', 'print', 'print-as-expression',
         'print-boolean-long-form', 'print-box', 'print-graph',
         'print-hash-table', 'print-mpair-curly-braces',
         'print-pair-curly-braces', 'print-reader-abbreviations',
         'print-struct', 'print-syntax-width', 'print-unreadable',
-        'print-vector-length', 'printf', 'procedure->method',
-        'procedure-arity', 'procedure-arity-includes?', 'procedure-arity?',
+        'print-vector-length', 'printable/c', 'printable<%>', 'printf',
+        'procedure->method', 'procedure-arity', 'procedure-arity-includes/c',
+        'procedure-arity-includes?', 'procedure-arity?',
         'procedure-closure-contents-eq?', 'procedure-extract-target',
-        'procedure-reduce-arity', 'procedure-rename',
-        'procedure-struct-type?', 'procedure?', 'promise?',
-        'prop:arity-string', 'prop:checked-procedure',
-        'prop:custom-print-quotable', 'prop:custom-write',
-        'prop:equal+hash', 'prop:evt', 'prop:exn:srclocs',
+        'procedure-keywords', 'procedure-reduce-arity',
+        'procedure-reduce-keyword-arity', 'procedure-rename',
+        'procedure-struct-type?', 'procedure?', 'process', 'process*',
+        'process*/ports', 'process/ports', 'processor-count', 'progress-evt?',
+        'promise-forced?', 'promise-running?', 'promise/c', 'promise?',
+        'prop:arity-string', 'prop:chaperone-contract',
+        'prop:checked-procedure', 'prop:contract', 'prop:contracted',
+        'prop:custom-print-quotable', 'prop:custom-write', 'prop:dict',
+        'prop:dict/contract', 'prop:equal+hash', 'prop:evt',
+        'prop:exn:missing-module', 'prop:exn:srclocs', 'prop:flat-contract',
         'prop:impersonator-of', 'prop:input-port',
-        'prop:liberal-define-context', 'prop:output-port',
-        'prop:procedure', 'prop:rename-transformer',
-        'prop:set!-transformer', 'pseudo-random-generator->vector',
+        'prop:liberal-define-context', 'prop:opt-chaperone-contract',
+        'prop:opt-chaperone-contract-get-test', 'prop:opt-chaperone-contract?',
+        'prop:output-port', 'prop:place-location', 'prop:procedure',
+        'prop:rename-transformer', 'prop:sequence', 'prop:set!-transformer',
+        'prop:stream', 'proper-subset?', 'pseudo-random-generator->vector',
         'pseudo-random-generator-vector?', 'pseudo-random-generator?',
-        'putenv', 'quotient', 'quotient/remainder', 'raise',
-        'raise-arity-error', 'raise-mismatch-error', 'raise-syntax-error',
-        'raise-type-error', 'raise-user-error', 'random', 'random-seed',
-        'rational?', 'rationalize', 'read', 'read-accept-bar-quote',
-        'read-accept-box', 'read-accept-compiled', 'read-accept-dot',
-        'read-accept-graph', 'read-accept-infix-dot', 'read-accept-lang',
-        'read-accept-quasiquote', 'read-accept-reader', 'read-byte',
-        'read-byte-or-special', 'read-bytes', 'read-bytes!',
-        'read-bytes-avail!', 'read-bytes-avail!*',
-        'read-bytes-avail!/enable-break', 'read-bytes-line',
-        'read-case-sensitive', 'read-char', 'read-char-or-special',
-        'read-curly-brace-as-paren', 'read-decimal-as-inexact',
-        'read-eval-print-loop', 'read-language', 'read-line',
-        'read-on-demand-source', 'read-square-bracket-as-paren',
-        'read-string', 'read-string!', 'read-syntax',
+        'put-preferences', 'putenv', 'quotient', 'quotient/remainder',
+        'radians->degrees', 'raise', 'raise-argument-error',
+        'raise-arguments-error', 'raise-arity-error', 'raise-blame-error',
+        'raise-contract-error', 'raise-mismatch-error',
+        'raise-not-cons-blame-error', 'raise-range-error',
+        'raise-result-error', 'raise-syntax-error', 'raise-type-error',
+        'raise-user-error', 'random', 'random-seed', 'range', 'rational?',
+        'rationalize', 'read', 'read-accept-bar-quote', 'read-accept-box',
+        'read-accept-compiled', 'read-accept-dot', 'read-accept-graph',
+        'read-accept-infix-dot', 'read-accept-lang', 'read-accept-quasiquote',
+        'read-accept-reader', 'read-byte', 'read-byte-or-special',
+        'read-bytes', 'read-bytes!', 'read-bytes!-evt', 'read-bytes-avail!',
+        'read-bytes-avail!*', 'read-bytes-avail!-evt',
+        'read-bytes-avail!/enable-break', 'read-bytes-evt', 'read-bytes-line',
+        'read-bytes-line-evt', 'read-case-sensitive', 'read-char',
+        'read-char-or-special', 'read-curly-brace-as-paren',
+        'read-decimal-as-inexact', 'read-eval-print-loop', 'read-language',
+        'read-line', 'read-line-evt', 'read-on-demand-source',
+        'read-square-bracket-as-paren', 'read-string', 'read-string!',
+        'read-string!-evt', 'read-string-evt', 'read-syntax',
         'read-syntax/recursive', 'read/recursive', 'readtable-mapping',
-        'readtable?', 'real->double-flonum', 'real->floating-point-bytes',
-        'real->single-flonum', 'real-part', 'real?', 'regexp',
-        'regexp-match', 'regexp-match-peek', 'regexp-match-peek-immediate',
-        'regexp-match-peek-positions',
+        'readtable?', 'real->decimal-string', 'real->double-flonum',
+        'real->floating-point-bytes', 'real->single-flonum', 'real-in',
+        'real-part', 'real?', 'reencode-input-port', 'reencode-output-port',
+        'regexp', 'regexp-match', 'regexp-match*', 'regexp-match-evt',
+        'regexp-match-exact?', 'regexp-match-peek',
+        'regexp-match-peek-immediate', 'regexp-match-peek-positions',
+        'regexp-match-peek-positions*',
         'regexp-match-peek-positions-immediate',
         'regexp-match-peek-positions-immediate/end',
         'regexp-match-peek-positions/end', 'regexp-match-positions',
-        'regexp-match-positions/end', 'regexp-match/end', 'regexp-match?',
-        'regexp-max-lookbehind', 'regexp-replace', 'regexp-replace*',
-        'regexp?', 'relative-path?', 'remainder',
+        'regexp-match-positions*', 'regexp-match-positions/end',
+        'regexp-match/end', 'regexp-match?', 'regexp-max-lookbehind',
+        'regexp-quote', 'regexp-replace', 'regexp-replace*',
+        'regexp-replace-quote', 'regexp-replaces', 'regexp-split',
+        'regexp-try-match', 'regexp?', 'relative-path?', 'relocate-input-port',
+        'relocate-output-port', 'remainder', 'remove', 'remove*',
+        'remove-duplicates', 'remq', 'remq*', 'remv', 'remv*',
         'rename-file-or-directory', 'rename-transformer-target',
-        'rename-transformer?', 'resolve-path', 'resolved-module-path-name',
-        'resolved-module-path?', 'reverse', 'round', 'seconds->date',
-        'security-guard?', 'semaphore-peek-evt', 'semaphore-post',
-        'semaphore-try-wait?', 'semaphore-wait',
-        'semaphore-wait/enable-break', 'semaphore?',
-        'set!-transformer-procedure', 'set!-transformer?', 'set-box!',
-        'set-mcar!', 'set-mcdr!', 'set-port-next-location!',
-        'shared-bytes', 'shell-execute', 'simplify-path', 'sin',
-        'single-flonum?', 'sleep', 'special-comment-value',
-        'special-comment?', 'split-path', 'sqrt', 'srcloc',
-        'srcloc-column', 'srcloc-line', 'srcloc-position', 'srcloc-source',
-        'srcloc-span', 'srcloc?', 'string', 'string->bytes/latin-1',
-        'string->bytes/locale', 'string->bytes/utf-8',
+        'rename-transformer?', 'reroot-path', 'resolve-path',
+        'resolved-module-path-name', 'resolved-module-path?', 'rest',
+        'reverse', 'round', 'second', 'seconds->date', 'security-guard?',
+        'semaphore-peek-evt', 'semaphore-peek-evt?', 'semaphore-post',
+        'semaphore-try-wait?', 'semaphore-wait', 'semaphore-wait/enable-break',
+        'semaphore?', 'sequence->list', 'sequence->stream',
+        'sequence-add-between', 'sequence-andmap', 'sequence-append',
+        'sequence-count', 'sequence-filter', 'sequence-fold',
+        'sequence-for-each', 'sequence-generate', 'sequence-generate*',
+        'sequence-length', 'sequence-map', 'sequence-ormap', 'sequence-ref',
+        'sequence-tail', 'sequence?', 'set', 'set!-transformer-procedure',
+        'set!-transformer?', 'set->list', 'set->stream', 'set-add', 'set-add!',
+        'set-box!', 'set-clear', 'set-clear!', 'set-copy', 'set-copy-clear',
+        'set-count', 'set-empty?', 'set-eq?', 'set-equal?', 'set-eqv?',
+        'set-first', 'set-for-each', 'set-implements/c', 'set-implements?',
+        'set-intersect', 'set-intersect!', 'set-map', 'set-mcar!', 'set-mcdr!',
+        'set-member?', 'set-mutable?', 'set-phantom-bytes!',
+        'set-port-next-location!', 'set-remove', 'set-remove!', 'set-rest',
+        'set-subtract', 'set-subtract!', 'set-symmetric-difference',
+        'set-symmetric-difference!', 'set-union', 'set-union!', 'set-weak?',
+        'set/c', 'set=?', 'set?', 'seteq', 'seteqv', 'seventh', 'sgn',
+        'shared-bytes', 'shell-execute', 'shrink-path-wrt', 'shuffle',
+        'simple-form-path', 'simplify-path', 'sin', 'single-flonum?', 'sinh',
+        'sixth', 'skip-projection-wrapper?', 'sleep',
+        'some-system-path->string', 'sort', 'special-comment-value',
+        'special-comment?', 'special-filter-input-port', 'split-at',
+        'split-at-right', 'split-path', 'splitf-at', 'splitf-at-right', 'sqr',
+        'sqrt', 'srcloc', 'srcloc->string', 'srcloc-column', 'srcloc-line',
+        'srcloc-position', 'srcloc-source', 'srcloc-span', 'srcloc?',
+        'stop-after', 'stop-before', 'stream->list', 'stream-add-between',
+        'stream-andmap', 'stream-append', 'stream-count', 'stream-empty?',
+        'stream-filter', 'stream-first', 'stream-fold', 'stream-for-each',
+        'stream-length', 'stream-map', 'stream-ormap', 'stream-ref',
+        'stream-rest', 'stream-tail', 'stream?', 'string',
+        'string->bytes/latin-1', 'string->bytes/locale', 'string->bytes/utf-8',
         'string->immutable-string', 'string->keyword', 'string->list',
         'string->number', 'string->path', 'string->path-element',
-        'string->symbol', 'string->uninterned-symbol',
-        'string->unreadable-symbol', 'string-append', 'string-ci<=?',
-        'string-ci<?', 'string-ci=?', 'string-ci>=?', 'string-ci>?',
-        'string-copy', 'string-copy!', 'string-downcase', 'string-fill!',
-        'string-foldcase', 'string-length', 'string-locale-ci<?',
-        'string-locale-ci=?', 'string-locale-ci>?',
-        'string-locale-downcase', 'string-locale-upcase',
+        'string->some-system-path', 'string->symbol',
+        'string->uninterned-symbol', 'string->unreadable-symbol',
+        'string-append', 'string-append*', 'string-ci<=?', 'string-ci<?',
+        'string-ci=?', 'string-ci>=?', 'string-ci>?', 'string-copy',
+        'string-copy!', 'string-downcase', 'string-environment-variable-name?',
+        'string-fill!', 'string-foldcase', 'string-join', 'string-len/c',
+        'string-length', 'string-locale-ci<?', 'string-locale-ci=?',
+        'string-locale-ci>?', 'string-locale-downcase', 'string-locale-upcase',
         'string-locale<?', 'string-locale=?', 'string-locale>?',
-        'string-normalize-nfc', 'string-normalize-nfd',
-        'string-normalize-nfkc', 'string-normalize-nfkd', 'string-ref',
-        'string-set!', 'string-titlecase', 'string-upcase',
-        'string-utf-8-length', 'string<=?', 'string<?', 'string=?',
-        'string>=?', 'string>?', 'string?', 'struct->vector',
+        'string-no-nuls?', 'string-normalize-nfc', 'string-normalize-nfd',
+        'string-normalize-nfkc', 'string-normalize-nfkd',
+        'string-normalize-spaces', 'string-ref', 'string-replace',
+        'string-set!', 'string-split', 'string-titlecase', 'string-trim',
+        'string-upcase', 'string-utf-8-length', 'string<=?', 'string<?',
+        'string=?', 'string>=?', 'string>?', 'string?', 'struct->vector',
         'struct-accessor-procedure?', 'struct-constructor-procedure?',
         'struct-info', 'struct-mutator-procedure?',
         'struct-predicate-procedure?', 'struct-type-info',
         'struct-type-make-constructor', 'struct-type-make-predicate',
-        'struct-type-property-accessor-procedure?',
+        'struct-type-property-accessor-procedure?', 'struct-type-property/c',
         'struct-type-property?', 'struct-type?', 'struct:arity-at-least',
         'struct:date', 'struct:date*', 'struct:exn', 'struct:exn:break',
+        'struct:exn:break:hang-up', 'struct:exn:break:terminate',
         'struct:exn:fail', 'struct:exn:fail:contract',
-        'struct:exn:fail:contract:arity',
+        'struct:exn:fail:contract:arity', 'struct:exn:fail:contract:blame',
         'struct:exn:fail:contract:continuation',
         'struct:exn:fail:contract:divide-by-zero',
         'struct:exn:fail:contract:non-fixnum-result',
         'struct:exn:fail:contract:variable', 'struct:exn:fail:filesystem',
+        'struct:exn:fail:filesystem:errno',
         'struct:exn:fail:filesystem:exists',
+        'struct:exn:fail:filesystem:missing-module',
         'struct:exn:fail:filesystem:version', 'struct:exn:fail:network',
+        'struct:exn:fail:network:errno', 'struct:exn:fail:object',
         'struct:exn:fail:out-of-memory', 'struct:exn:fail:read',
         'struct:exn:fail:read:eof', 'struct:exn:fail:read:non-char',
-        'struct:exn:fail:syntax', 'struct:exn:fail:syntax:unbound',
-        'struct:exn:fail:unsupported', 'struct:exn:fail:user',
-        'struct:srcloc', 'struct?', 'sub1', 'subbytes', 'subprocess',
-        'subprocess-group-enabled', 'subprocess-kill', 'subprocess-pid',
-        'subprocess-status', 'subprocess-wait', 'subprocess?', 'substring',
-        'symbol->string', 'symbol-interned?', 'symbol-unreadable?',
-        'symbol?', 'sync', 'sync/enable-break', 'sync/timeout',
-        'sync/timeout/enable-break', 'syntax->list', 'syntax-arm',
-        'syntax-column', 'syntax-disarm', 'syntax-e', 'syntax-line',
-        'syntax-local-bind-syntaxes', 'syntax-local-certifier',
-        'syntax-local-context', 'syntax-local-expand-expression',
-        'syntax-local-get-shadower', 'syntax-local-introduce',
-        'syntax-local-lift-context', 'syntax-local-lift-expression',
+        'struct:exn:fail:syntax', 'struct:exn:fail:syntax:missing-module',
+        'struct:exn:fail:syntax:unbound', 'struct:exn:fail:unsupported',
+        'struct:exn:fail:user', 'struct:srcloc',
+        'struct:wrapped-extra-arg-arrow', 'struct?', 'sub1', 'subbytes',
+        'subclass?', 'subclass?/c', 'subprocess', 'subprocess-group-enabled',
+        'subprocess-kill', 'subprocess-pid', 'subprocess-status',
+        'subprocess-wait', 'subprocess?', 'subset?', 'substring',
+        'symbol->string', 'symbol-interned?', 'symbol-unreadable?', 'symbol<?',
+        'symbol=?', 'symbol?', 'symbols', 'sync', 'sync/enable-break',
+        'sync/timeout', 'sync/timeout/enable-break', 'syntax->datum',
+        'syntax->list', 'syntax-arm', 'syntax-column', 'syntax-disarm',
+        'syntax-e', 'syntax-line', 'syntax-local-bind-syntaxes',
+        'syntax-local-certifier', 'syntax-local-context',
+        'syntax-local-expand-expression', 'syntax-local-get-shadower',
+        'syntax-local-introduce', 'syntax-local-lift-context',
+        'syntax-local-lift-expression',
         'syntax-local-lift-module-end-declaration',
         'syntax-local-lift-provide', 'syntax-local-lift-require',
         'syntax-local-lift-values-expression',
@@ -427,163 +695,232 @@ class RacketLexer(RegexLexer):
         'syntax-local-module-defined-identifiers',
         'syntax-local-module-exports',
         'syntax-local-module-required-identifiers', 'syntax-local-name',
-        'syntax-local-phase-level',
+        'syntax-local-phase-level', 'syntax-local-submodules',
         'syntax-local-transforming-module-provides?', 'syntax-local-value',
-        'syntax-local-value/immediate', 'syntax-original?',
-        'syntax-position', 'syntax-property',
-        'syntax-property-symbol-keys', 'syntax-protect', 'syntax-rearm',
-        'syntax-recertify', 'syntax-shift-phase-level', 'syntax-source',
-        'syntax-source-module', 'syntax-span', 'syntax-taint',
+        'syntax-local-value/immediate', 'syntax-original?', 'syntax-position',
+        'syntax-property', 'syntax-property-symbol-keys', 'syntax-protect',
+        'syntax-rearm', 'syntax-recertify', 'syntax-shift-phase-level',
+        'syntax-source', 'syntax-source-module', 'syntax-span', 'syntax-taint',
         'syntax-tainted?', 'syntax-track-origin',
         'syntax-transforming-module-expression?', 'syntax-transforming?',
-        'syntax?', 'system-big-endian?', 'system-idle-evt',
-        'system-language+country', 'system-library-subpath',
-        'system-path-convention-type', 'system-type', 'tan',
-        'tcp-abandon-port', 'tcp-accept', 'tcp-accept-evt',
-        'tcp-accept-ready?', 'tcp-accept/enable-break', 'tcp-addresses',
-        'tcp-close', 'tcp-connect', 'tcp-connect/enable-break',
-        'tcp-listen', 'tcp-listener?', 'tcp-port?', 'terminal-port?',
-        'thread', 'thread-cell-ref', 'thread-cell-set!', 'thread-cell?',
-        'thread-dead-evt', 'thread-dead?', 'thread-group?',
-        'thread-resume', 'thread-resume-evt', 'thread-rewind-receive',
-        'thread-running?', 'thread-suspend', 'thread-suspend-evt',
+        'syntax/c', 'syntax?', 'system', 'system*', 'system*/exit-code',
+        'system-big-endian?', 'system-idle-evt', 'system-language+country',
+        'system-library-subpath', 'system-path-convention-type', 'system-type',
+        'system/exit-code', 'tail-marks-match?', 'take', 'take-right', 'takef',
+        'takef-right', 'tan', 'tanh', 'tcp-abandon-port', 'tcp-accept',
+        'tcp-accept-evt', 'tcp-accept-ready?', 'tcp-accept/enable-break',
+        'tcp-addresses', 'tcp-close', 'tcp-connect',
+        'tcp-connect/enable-break', 'tcp-listen', 'tcp-listener?', 'tcp-port?',
+        'tentative-pretty-print-port-cancel',
+        'tentative-pretty-print-port-transfer', 'tenth', 'terminal-port?',
+        'the-unsupplied-arg', 'third', 'thread', 'thread-cell-ref',
+        'thread-cell-set!', 'thread-cell-values?', 'thread-cell?',
+        'thread-dead-evt', 'thread-dead?', 'thread-group?', 'thread-receive',
+        'thread-receive-evt', 'thread-resume', 'thread-resume-evt',
+        'thread-rewind-receive', 'thread-running?', 'thread-send',
+        'thread-suspend', 'thread-suspend-evt', 'thread-try-receive',
         'thread-wait', 'thread/suspend-to-kill', 'thread?', 'time-apply',
-        'truncate', 'udp-addresses', 'udp-bind!', 'udp-bound?',
-        'udp-close', 'udp-connect!', 'udp-connected?', 'udp-open-socket',
-        'udp-receive!', 'udp-receive!*', 'udp-receive!-evt',
-        'udp-receive!/enable-break', 'udp-receive-ready-evt', 'udp-send',
-        'udp-send*', 'udp-send-evt', 'udp-send-ready-evt', 'udp-send-to',
-        'udp-send-to*', 'udp-send-to-evt', 'udp-send-to/enable-break',
-        'udp-send/enable-break', 'udp?', 'unbox',
-        'uncaught-exception-handler', 'use-collection-link-paths',
+        'touch', 'transplant-input-port', 'transplant-output-port', 'true',
+        'truncate', 'udp-addresses', 'udp-bind!', 'udp-bound?', 'udp-close',
+        'udp-connect!', 'udp-connected?', 'udp-multicast-interface',
+        'udp-multicast-join-group!', 'udp-multicast-leave-group!',
+        'udp-multicast-loopback?', 'udp-multicast-set-interface!',
+        'udp-multicast-set-loopback!', 'udp-multicast-set-ttl!',
+        'udp-multicast-ttl', 'udp-open-socket', 'udp-receive!',
+        'udp-receive!*', 'udp-receive!-evt', 'udp-receive!/enable-break',
+        'udp-receive-ready-evt', 'udp-send', 'udp-send*', 'udp-send-evt',
+        'udp-send-ready-evt', 'udp-send-to', 'udp-send-to*', 'udp-send-to-evt',
+        'udp-send-to/enable-break', 'udp-send/enable-break', 'udp?', 'unbox',
+        'uncaught-exception-handler', 'unit?', 'unspecified-dom',
+        'unsupplied-arg?', 'use-collection-link-paths',
         'use-compiled-file-paths', 'use-user-specific-search-paths',
-        'values', 'variable-reference->empty-namespace',
+        'user-execute-bit', 'user-read-bit', 'user-write-bit',
+        'value-contract', 'values', 'variable-reference->empty-namespace',
         'variable-reference->module-base-phase',
         'variable-reference->module-declaration-inspector',
-        'variable-reference->module-source',
-        'variable-reference->namespace', 'variable-reference->phase',
+        'variable-reference->module-path-index',
+        'variable-reference->module-source', 'variable-reference->namespace',
+        'variable-reference->phase',
         'variable-reference->resolved-module-path',
         'variable-reference-constant?', 'variable-reference?', 'vector',
         'vector->immutable-vector', 'vector->list',
-        'vector->pseudo-random-generator',
-        'vector->pseudo-random-generator!', 'vector->values',
-        'vector-fill!', 'vector-immutable', 'vector-length', 'vector-ref',
-        'vector-set!', 'vector-set-performance-stats!', 'vector?',
-        'version', 'void', 'void?', 'weak-box-value', 'weak-box?',
-        'will-execute', 'will-executor?', 'will-register',
-        'will-try-execute', 'with-input-from-file', 'with-output-to-file',
-        'wrap-evt', 'write', 'write-byte', 'write-bytes',
+        'vector->pseudo-random-generator', 'vector->pseudo-random-generator!',
+        'vector->values', 'vector-append', 'vector-argmax', 'vector-argmin',
+        'vector-copy', 'vector-copy!', 'vector-count', 'vector-drop',
+        'vector-drop-right', 'vector-fill!', 'vector-filter',
+        'vector-filter-not', 'vector-immutable', 'vector-immutable/c',
+        'vector-immutableof', 'vector-length', 'vector-map', 'vector-map!',
+        'vector-member', 'vector-memq', 'vector-memv', 'vector-ref',
+        'vector-set!', 'vector-set*!', 'vector-set-performance-stats!',
+        'vector-split-at', 'vector-split-at-right', 'vector-take',
+        'vector-take-right', 'vector/c', 'vector?', 'vectorof', 'version',
+        'void', 'void?', 'weak-box-value', 'weak-box?', 'weak-set',
+        'weak-seteq', 'weak-seteqv', 'will-execute', 'will-executor?',
+        'will-register', 'will-try-execute', 'with-input-from-bytes',
+        'with-input-from-file', 'with-input-from-string',
+        'with-output-to-bytes', 'with-output-to-file', 'with-output-to-string',
+        'would-be-future', 'wrap-evt', 'wrapped-extra-arg-arrow',
+        'wrapped-extra-arg-arrow-extra-neg-party-argument',
+        'wrapped-extra-arg-arrow-real-func', 'wrapped-extra-arg-arrow?',
+        'writable<%>', 'write', 'write-byte', 'write-bytes',
         'write-bytes-avail', 'write-bytes-avail*', 'write-bytes-avail-evt',
         'write-bytes-avail/enable-break', 'write-char', 'write-special',
-        'write-special-avail*', 'write-special-evt', 'write-string', 'zero?'
+        'write-special-avail*', 'write-special-evt', 'write-string',
+        'write-to-file', 'xor', 'zero?', '~.a', '~.s', '~.v', '~a', '~e', '~r',
+        '~s', '~v'
     ]
 
-    # From SchemeLexer
-    valid_name = r'[a-zA-Z0-9!$%&*+,/:<=>?@^_~|-]+'
+    _opening_parenthesis = r'[([{]'
+    _closing_parenthesis = r'[)\]}]'
+    _delimiters = r'()[\]{}",\'`;\s'
+    _symbol = r'(?u)(?:\|[^|]*\||\\[\w\W]|[^|\\%s]+)+' % _delimiters
+    _exact_decimal_prefix = r'(?:#e)?(?:#d)?(?:#e)?'
+    _exponent = r'(?:[defls][-+]?\d+)'
+    _inexact_simple_no_hashes = r'(?:\d+(?:/\d+|\.\d*)?|\.\d+)'
+    _inexact_simple = (r'(?:%s|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|'
+                       r'\d+(?:\.\d*#+|/\d+#+)))' % _inexact_simple_no_hashes)
+    _inexact_normal_no_hashes = r'(?:%s%s?)' % (_inexact_simple_no_hashes,
+                                                _exponent)
+    _inexact_normal = r'(?:%s%s?)' % (_inexact_simple, _exponent)
+    _inexact_special = r'(?:(?:inf|nan)\.[0f])'
+    _inexact_real = r'(?:[-+]?%s|[-+]%s)' % (_inexact_normal,
+                                             _inexact_special)
+    _inexact_unsigned = r'(?:%s|%s)' % (_inexact_normal, _inexact_special)
 
     tokens = {
-        'root' : [
-            (r';.*$', Comment.Single),
-            (r'#\|[^|]+\|#', Comment.Multiline),
-
-            # whitespaces - usually not relevant
-            (r'\s+', Text),
-
-            ## numbers: Keep in mind Racket reader hash prefixes,
-            ## which can denote the base or the type. These don't map
-            ## neatly onto pygments token types; some judgment calls
-            ## here.  Note that none of these regexps attempt to
-            ## exclude identifiers that start with a number, such as a
-            ## variable named "100-Continue".
+        'root': [
+            (_closing_parenthesis, Error),
+            (r'(?!\Z)', Text, 'unquoted-datum')
+        ],
+        'datum': [
+            (r'(?s)#;|#![ /]([^\\\n]|\\.)*', Comment),
+            (u';[^\\n\\r\x85\u2028\u2029]*', Comment.Single),
+            (r'#\|', Comment.Multiline, 'block-comment'),
+
+            # Whitespaces
+            (r'(?u)\s+', Text),
+
+            # Numbers: Keep in mind Racket reader hash prefixes, which
+            # can denote the base or the type. These don't map neatly
+            # onto Pygments token types; some judgment calls here.
+
+            # #d or no prefix
+            (r'(?i)%s[-+]?\d+(?=[%s])' % (_exact_decimal_prefix, _delimiters),
+             Number.Integer, '#pop'),
+            (r'(?i)%s[-+]?(\d+(\.\d*)?|\.\d+)([deflst][-+]?\d+)?(?=[%s])' %
+             (_exact_decimal_prefix, _delimiters), Number.Float, '#pop'),
+            (r'(?i)%s[-+]?(%s([-+]%s?i)?|[-+]%s?i)(?=[%s])' %
+             (_exact_decimal_prefix, _inexact_normal_no_hashes,
+              _inexact_normal_no_hashes, _inexact_normal_no_hashes,
+              _delimiters), Number, '#pop'),
+
+            # Inexact without explicit #i
+            (r'(?i)(#d)?(%s([-+]%s?i)?|[-+]%s?i|%s@%s)(?=[%s])' %
+             (_inexact_real, _inexact_unsigned, _inexact_unsigned,
+              _inexact_real, _inexact_real, _delimiters), Number.Float,
+             '#pop'),
+
+            # The remaining extflonums
+            (r'(?i)(([-+]?%st[-+]?\d+)|[-+](inf|nan)\.t)(?=[%s])' %
+             (_inexact_simple, _delimiters), Number.Float, '#pop'),
 
             # #b
-            (r'#b[-+]?[01]+\.[01]+', Number.Float),
-            (r'#b[01]+e[-+]?[01]+', Number.Float),
-            (r'#b[-+]?[01]/[01]+', Number),
-            (r'#b[-+]?[01]+', Number.Integer),
-            (r'#b\S*', Error),
-
-            # #d OR no hash prefix
-            (r'(#d)?[-+]?\d+\.\d+', Number.Float),
-            (r'(#d)?\d+e[-+]?\d+', Number.Float),
-            (r'(#d)?[-+]?\d+/\d+', Number),
-            (r'(#d)?[-+]?\d+', Number.Integer),
-            (r'#d\S*', Error),
-
-            # #e
-            (r'#e[-+]?\d+\.\d+', Number.Float),
-            (r'#e\d+e[-+]?\d+', Number.Float),
-            (r'#e[-+]?\d+/\d+', Number),
-            (r'#e[-+]?\d+', Number),
-            (r'#e\S*', Error),
-
-            # #i is always inexact-real, i.e. float
-            (r'#i[-+]?\d+\.\d+', Number.Float),
-            (r'#i\d+e[-+]?\d+', Number.Float),
-            (r'#i[-+]?\d+/\d+', Number.Float),
-            (r'#i[-+]?\d+', Number.Float),
-            (r'#i\S*', Error),
+            (r'(?i)(#[ei])?#b%s' % _symbol, Number.Bin, '#pop'),
 
             # #o
-            (r'#o[-+]?[0-7]+\.[0-7]+', Number.Oct),
-            (r'#o[0-7]+e[-+]?[0-7]+', Number.Oct),
-            (r'#o[-+]?[0-7]+/[0-7]+', Number.Oct),
-            (r'#o[-+]?[0-7]+', Number.Oct),
-            (r'#o\S*', Error),
+            (r'(?i)(#[ei])?#o%s' % _symbol, Number.Oct, '#pop'),
 
             # #x
-            (r'#x[-+]?[0-9a-fA-F]+\.[0-9a-fA-F]+', Number.Hex),
-            # the exponent variation (e.g. #x1e1) is N/A
-            (r'#x[-+]?[0-9a-fA-F]+/[0-9a-fA-F]+', Number.Hex),
-            (r'#x[-+]?[0-9a-fA-F]+', Number.Hex),
-            (r'#x\S*', Error),
-
-
-            # strings, symbols and characters
-            (r'"(\\\\|\\"|[^"])*"', String),
-            (r"'" + valid_name, String.Symbol),
-            (r"#\\([()/'\"._!§$%& ?=+-]{1}|[a-zA-Z0-9]+)", String.Char),
-            (r'#rx".+"', String.Regex),
-            (r'#px".+"', String.Regex),
-
-            # constants
-            (r'(#t|#f)', Name.Constant),
-
-            # keyword argument names (e.g. #:keyword)
-            (r'#:\S+', Keyword.Declaration),
-
-            # #lang
-            (r'#lang \S+', Keyword.Namespace),
-
-            # special operators
-            (r"('|#|`|,@|,|\.)", Operator),
-
-            # highlight the keywords
-            ('(%s)' % '|'.join([
-                re.escape(entry) + ' ' for entry in keywords]),
-                Keyword
-            ),
-
-            # first variable in a quoted string like
-            # '(this is syntactic sugar)
-            (r"(?<='\()" + valid_name, Name.Variable),
-            (r"(?<=#\()" + valid_name, Name.Variable),
-
-            # highlight the builtins
-            ("(?<=\()(%s)" % '|'.join([
-                re.escape(entry) + ' ' for entry in builtins]),
-                Name.Builtin
-            ),
-
-            # the remaining functions; handle both ( and [
-            (r'(?<=(\(|\[|\{))' + valid_name, Name.Function),
-
-            # find the remaining variables
-            (valid_name, Name.Variable),
-
-            # the famous parentheses!
-            (r'(\(|\)|\[|\]|\{|\})', Punctuation),
+            (r'(?i)(#[ei])?#x%s' % _symbol, Number.Hex, '#pop'),
+
+            # #i is always inexact, i.e. float
+            (r'(?i)(#d)?#i%s' % _symbol, Number.Float, '#pop'),
+
+            # Strings and characters
+            (r'#?"', String.Double, ('#pop', 'string')),
+            (r'#<<(.+)\n(^(?!\1$).*$\n)*^\1$', String.Heredoc, '#pop'),
+            (r'#\\(u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8})', String.Char, '#pop'),
+            (r'(?is)#\\([0-7]{3}|[a-z]+|.)', String.Char, '#pop'),
+            (r'(?s)#[pr]x#?"(\\?.)*?"', String.Regex, '#pop'),
+
+            # Constants
+            (r'#(true|false|[tTfF])', Name.Constant, '#pop'),
+
+            # Keyword argument names (e.g. #:keyword)
+            (r'#:%s' % _symbol, Keyword.Declaration, '#pop'),
+
+            # Reader extensions
+            (r'(#lang |#!)(\S+)',
+             bygroups(Keyword.Namespace, Name.Namespace)),
+            (r'#reader', Keyword.Namespace, 'quoted-datum'),
+
+            # Other syntax
+            (r"(?i)\.(?=[%s])|#c[is]|#['`]|#,@?" % _delimiters, Operator),
+            (r"'|#[s&]|#hash(eqv?)?|#\d*(?=%s)" % _opening_parenthesis,
+             Operator, ('#pop', 'quoted-datum'))
+        ],
+        'datum*': [
+            (r'`|,@?', Operator),
+            (_symbol, String.Symbol, '#pop'),
+            (r'[|\\]', Error),
+            default('#pop')
+        ],
+        'list': [
+            (_closing_parenthesis, Punctuation, '#pop')
+        ],
+        'unquoted-datum': [
+            include('datum'),
+            (r'quote(?=[%s])' % _delimiters, Keyword,
+             ('#pop', 'quoted-datum')),
+            (r'`', Operator, ('#pop', 'quasiquoted-datum')),
+            (r'quasiquote(?=[%s])' % _delimiters, Keyword,
+             ('#pop', 'quasiquoted-datum')),
+            (_opening_parenthesis, Punctuation, ('#pop', 'unquoted-list')),
+            (r'(?u)(%s)(?=[%s])' % ('|'.join(
+                [re.escape(entry) for entry in _keywords]), _delimiters),
+             Keyword, '#pop'),
+            (r'(?u)(%s)(?=[%s])' % ('|'.join(
+                [re.escape(entry) for entry in _builtins]), _delimiters),
+             Name.Builtin, '#pop'),
+            (_symbol, Name, '#pop'),
+            include('datum*')
+        ],
+        'unquoted-list': [
+            include('list'),
+            (r'(?!\Z)', Text, 'unquoted-datum')
+        ],
+        'quasiquoted-datum': [
+            include('datum'),
+            (r',@?', Operator, ('#pop', 'unquoted-datum')),
+            (r'unquote(-splicing)?(?=[%s])' % _delimiters, Keyword,
+             ('#pop', 'unquoted-datum')),
+            (_opening_parenthesis, Punctuation, ('#pop', 'quasiquoted-list')),
+            include('datum*')
+        ],
+        'quasiquoted-list': [
+            include('list'),
+            (r'(?!\Z)', Text, 'quasiquoted-datum')
+        ],
+        'quoted-datum': [
+            include('datum'),
+            (_opening_parenthesis, Punctuation, ('#pop', 'quoted-list')),
+            include('datum*')
+        ],
+        'quoted-list': [
+            include('list'),
+            (r'(?!\Z)', Text, 'quoted-datum')
+        ],
+        'block-comment': [
+            (r'#\|', Comment.Multiline, '#push'),
+            (r'\|#', Comment.Multiline, '#pop'),
+            (r'[^#|]+|.', Comment.Multiline)
         ],
+        'string': [
+            (r'"', String.Double, '#pop'),
+            (r'(?s)\\([0-7]{1,3}|x[\da-fA-F]{1,2}|u[\da-fA-F]{1,4}|'
+             r'U[\da-fA-F]{1,8}|.)', String.Escape),
+            (r'[^\\"]+', String.Double)
+        ]
     }
 
 
@@ -599,7 +936,7 @@ class SchemeLexer(RegexLexer):
 
     It supports the full Scheme syntax as defined in R5RS.
 
-    *New in Pygments 0.6.*
+    .. versionadded:: 0.6
     """
     name = 'Scheme'
     aliases = ['scheme', 'scm']
@@ -662,9 +999,16 @@ class SchemeLexer(RegexLexer):
 
     tokens = {
         'root' : [
-            # the comments - always starting with semicolon
+            # the comments
             # and going to the end of the line
             (r';.*$', Comment.Single),
+            # multi-line comment
+            (r'#\|', Comment.Multiline, 'multiline-comment'),
+            # commented form (entire sexpr folliwng)
+            (r'#;\s*\(', Comment, 'commented-form'),
+            # signifies that the program text that follows is written with the
+            # lexical and datum syntax described in r6rs
+            (r'#!r6rs', Comment),
 
             # whitespaces - usually not relevant
             (r'\s+', Text),
@@ -713,6 +1057,17 @@ class SchemeLexer(RegexLexer):
             (r'(\(|\))', Punctuation),
             (r'(\[|\])', Punctuation),
         ],
+        'multiline-comment' : [
+            (r'#\|', Comment.Multiline, '#push'),
+            (r'\|#', Comment.Multiline, '#pop'),
+            (r'[^|#]+', Comment.Multiline),
+            (r'[|#]', Comment.Multiline),
+        ],
+        'commented-form' : [
+            (r'\(', Comment, '#push'),
+            (r'\)', Comment, '#pop'),
+            (r'[^()]+', Comment),
+        ],
     }
 
 
@@ -720,10 +1075,10 @@ class CommonLispLexer(RegexLexer):
     """
     A Common Lisp lexer.
 
-    *New in Pygments 0.9.*
+    .. versionadded:: 0.9
     """
     name = 'Common Lisp'
-    aliases = ['common-lisp', 'cl', 'lisp']
+    aliases = ['common-lisp', 'cl', 'lisp', 'elisp', 'emacs', 'emacs-lisp']
     filenames = ['*.cl', '*.lisp', '*.el']  # use for Elisp too
     mimetypes = ['text/x-common-lisp']
 
@@ -732,7 +1087,7 @@ class CommonLispLexer(RegexLexer):
     ### couple of useful regexes
 
     # characters that are not macro-characters and can be used to begin a symbol
-    nonmacro = r'\\.|[a-zA-Z0-9!$%&*+-/<=>?@\[\]^_{}~]'
+    nonmacro = r'\\.|[\w!$%&*+-/<=>?@\[\]^{}~]'
     constituent = nonmacro + '|[#.:]'
     terminated = r'(?=[ "()\'\n,;`])' # whitespace or terminating macro characters
 
@@ -844,16 +1199,16 @@ class CommonLispLexer(RegexLexer):
             (r'#\'', Name.Function),
 
             # binary rational
-            (r'#[bB][+-]?[01]+(/[01]+)?', Number),
+            (r'#[bB][+-]?[01]+(/[01]+)?', Number.Bin),
 
             # octal rational
             (r'#[oO][+-]?[0-7]+(/[0-7]+)?', Number.Oct),
 
             # hex rational
-            (r'#[xX][+-]?[0-9a-fA-F]+(/[0-9a-fA-F]+)?', Number.Hex),
+            (r'#[xX][+-]?[0-9a-f]+(/[0-9a-f]+)?', Number.Hex),
 
             # radix rational
-            (r'#\d+[rR][+-]?[0-9a-zA-Z]+(/[0-9a-zA-Z]+)?', Number),
+            (r'#\d+[rR][+-]?[0-9a-z]+(/[0-9a-z]+)?', Number),
 
             # complex
             (r'(#[cC])(\()', bygroups(Number, Punctuation), 'body'),
@@ -894,17 +1249,155 @@ class CommonLispLexer(RegexLexer):
     }
 
 
+class CryptolLexer(RegexLexer):
+    """
+    FIXME: A Cryptol2 lexer based on the lexemes defined in the Haskell 98 Report.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Cryptol'
+    aliases = ['cryptol', 'cry']
+    filenames = ['*.cry']
+    mimetypes = ['text/x-cryptol']
+
+    reserved = ['Arith','Bit','Cmp','False','Inf','True','else',
+                'export','extern','fin','if','import','inf','lg2',
+                'max','min','module','newtype','pragma','property',
+                'then','type','where','width']
+    ascii = ['NUL','SOH','[SE]TX','EOT','ENQ','ACK',
+             'BEL','BS','HT','LF','VT','FF','CR','S[OI]','DLE',
+             'DC[1-4]','NAK','SYN','ETB','CAN',
+             'EM','SUB','ESC','[FGRU]S','SP','DEL']
+
+    tokens = {
+        'root': [
+            # Whitespace:
+            (r'\s+', Text),
+            #(r'--\s*|.*$', Comment.Doc),
+            (r'//.*$', Comment.Single),
+            (r'/\*', Comment.Multiline, 'comment'),
+            # Lexemes:
+            #  Identifiers
+            (r'\bimport\b', Keyword.Reserved, 'import'),
+            (r'\bmodule\b', Keyword.Reserved, 'module'),
+            (r'\berror\b', Name.Exception),
+            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'^[_a-z][\w\']*', Name.Function),
+            (r"'?[_a-z][\w']*", Name),
+            (r"('')?[A-Z][\w\']*", Keyword.Type),
+            #  Operators
+            (r'\\(?![:!#$%&*+.\\/<=>?@^|~-]+)', Name.Function), # lambda operator
+            (r'(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word), # specials
+            (r':[:!#$%&*+.\\/<=>?@^|~-]*', Keyword.Type), # Constructor operators
+            (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator), # Other operators
+            #  Numbers
+            (r'\d+[eE][+-]?\d+', Number.Float),
+            (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
+            (r'0[oO][0-7]+', Number.Oct),
+            (r'0[xX][\da-fA-F]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            #  Character/String Literals
+            (r"'", String.Char, 'character'),
+            (r'"', String, 'string'),
+            #  Special
+            (r'\[\]', Keyword.Type),
+            (r'\(\)', Name.Builtin),
+            (r'[][(),;`{}]', Punctuation),
+        ],
+        'import': [
+            # Import statements
+            (r'\s+', Text),
+            (r'"', String, 'string'),
+            # after "funclist" state
+            (r'\)', Punctuation, '#pop'),
+            (r'qualified\b', Keyword),
+            # import X as Y
+            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)',
+             bygroups(Name.Namespace, Text, Keyword, Text, Name), '#pop'),
+            # import X hiding (functions)
+            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(hiding)(\s+)(\()',
+             bygroups(Name.Namespace, Text, Keyword, Text, Punctuation), 'funclist'),
+            # import X (functions)
+            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
+             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+            # import X
+            (r'[a-zA-Z0-9_.]+', Name.Namespace, '#pop'),
+        ],
+        'module': [
+            (r'\s+', Text),
+            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
+             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+            (r'[A-Z][a-zA-Z0-9_.]*', Name.Namespace, '#pop'),
+        ],
+        'funclist': [
+            (r'\s+', Text),
+            (r'[A-Z][a-zA-Z0-9_]*', Keyword.Type),
+            (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
+            (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
+            (r'{-', Comment.Multiline, 'comment'),
+            (r',', Punctuation),
+            (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
+            # (HACK, but it makes sense to push two instances, believe me)
+            (r'\(', Punctuation, ('funclist', 'funclist')),
+            (r'\)', Punctuation, '#pop:2'),
+        ],
+        'comment': [
+            # Multiline Comments
+            (r'[^/\*]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[\*/]', Comment.Multiline),
+        ],
+        'character': [
+            # Allows multi-chars, incorrectly.
+            (r"[^\\']'", String.Char, '#pop'),
+            (r"\\", String.Escape, 'escape'),
+            ("'", String.Char, '#pop'),
+        ],
+        'string': [
+            (r'[^\\"]+', String),
+            (r"\\", String.Escape, 'escape'),
+            ('"', String, '#pop'),
+        ],
+        'escape': [
+            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
+            (r'\^[][A-Z@\^_]', String.Escape, '#pop'),
+            ('|'.join(ascii), String.Escape, '#pop'),
+            (r'o[0-7]+', String.Escape, '#pop'),
+            (r'x[\da-fA-F]+', String.Escape, '#pop'),
+            (r'\d+', String.Escape, '#pop'),
+            (r'\s+\\', String.Escape, '#pop'),
+        ],
+    }
+
+    EXTRA_KEYWORDS = ['join', 'split', 'reverse', 'transpose', 'width',
+                      'length', 'tail', '<<', '>>', '<<<', '>>>', 'const',
+                      'reg', 'par', 'seq', 'ASSERT', 'undefined', 'error',
+                      'trace']
+
+    def get_tokens_unprocessed(self, text):
+        stack = ['root']
+        for index, token, value in \
+            RegexLexer.get_tokens_unprocessed(self, text, stack):
+            if token is Name and value in self.EXTRA_KEYWORDS:
+                yield index, Name.Builtin, value
+            else:
+                yield index, token, value
+
+
 class HaskellLexer(RegexLexer):
     """
     A Haskell lexer based on the lexemes defined in the Haskell 98 Report.
 
-    *New in Pygments 0.8.*
+    .. versionadded:: 0.8
     """
     name = 'Haskell'
     aliases = ['haskell', 'hs']
     filenames = ['*.hs']
     mimetypes = ['text/x-haskell']
 
+    flags = re.MULTILINE | re.UNICODE
+
     reserved = ['case','class','data','default','deriving','do','else',
                 'if','in','infix[lr]?','instance',
                 'let','newtype','of','then','type','where','_']
@@ -926,9 +1419,9 @@ class HaskellLexer(RegexLexer):
             (r'\bmodule\b', Keyword.Reserved, 'module'),
             (r'\berror\b', Name.Exception),
             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
-            (r'^[_a-z][\w\']*', Name.Function),
-            (r"'?[_a-z][\w']*", Name),
-            (r"('')?[A-Z][\w\']*", Keyword.Type),
+            (r'^[_' + uni.Ll + r'][\w\']*', Name.Function),
+            (r"'?[_" + uni.Ll + r"'][\w']*", Name),
+            (r"('')?[" + uni.Lu + r"][\w\']*", Keyword.Type),
             #  Operators
             (r'\\(?![:!#$%&*+.\\/<=>?@^|~-]+)', Name.Function), # lambda operator
             (r'(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word), # specials
@@ -956,26 +1449,135 @@ class HaskellLexer(RegexLexer):
             (r'\)', Punctuation, '#pop'),
             (r'qualified\b', Keyword),
             # import X as Y
-            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(as)(\s+)([A-Z][a-zA-Z0-9_.]*)',
+            (r'([' + uni.Lu + r'][\w.]*)(\s+)(as)(\s+)([' + uni.Lu + r'][\w.]*)',
              bygroups(Name.Namespace, Text, Keyword, Text, Name), '#pop'),
             # import X hiding (functions)
-            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(hiding)(\s+)(\()',
+            (r'([' + uni.Lu + r'][\w.]*)(\s+)(hiding)(\s+)(\()',
              bygroups(Name.Namespace, Text, Keyword, Text, Punctuation), 'funclist'),
             # import X (functions)
-            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
+            (r'([' + uni.Lu + r'][\w.]*)(\s+)(\()',
              bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
             # import X
-            (r'[a-zA-Z0-9_.]+', Name.Namespace, '#pop'),
+            (r'[\w.]+', Name.Namespace, '#pop'),
         ],
         'module': [
             (r'\s+', Text),
-            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
+            (r'([' + uni.Lu + r'][\w.]*)(\s+)(\()',
              bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
-            (r'[A-Z][a-zA-Z0-9_.]*', Name.Namespace, '#pop'),
+            (r'[' + uni.Lu + r'][\w.]*', Name.Namespace, '#pop'),
         ],
         'funclist': [
             (r'\s+', Text),
-            (r'[A-Z][a-zA-Z0-9_]*', Keyword.Type),
+            (r'[' + uni.Lu + r']\w*', Keyword.Type),
+            (r'(_[\w\']+|[' + uni.Ll + r'][\w\']*)', Name.Function),
+            (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
+            (r'{-', Comment.Multiline, 'comment'),
+            (r',', Punctuation),
+            (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
+            # (HACK, but it makes sense to push two instances, believe me)
+            (r'\(', Punctuation, ('funclist', 'funclist')),
+            (r'\)', Punctuation, '#pop:2'),
+        ],
+        # NOTE: the next four states are shared in the AgdaLexer; make sure
+        # any change is compatible with Agda as well or copy over and change
+        'comment': [
+            # Multiline Comments
+            (r'[^-{}]+', Comment.Multiline),
+            (r'{-', Comment.Multiline, '#push'),
+            (r'-}', Comment.Multiline, '#pop'),
+            (r'[-{}]', Comment.Multiline),
+        ],
+        'character': [
+            # Allows multi-chars, incorrectly.
+            (r"[^\\']'", String.Char, '#pop'),
+            (r"\\", String.Escape, 'escape'),
+            ("'", String.Char, '#pop'),
+        ],
+        'string': [
+            (r'[^\\"]+', String),
+            (r"\\", String.Escape, 'escape'),
+            ('"', String, '#pop'),
+        ],
+        'escape': [
+            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
+            (r'\^[][' + uni.Lu + r'@\^_]', String.Escape, '#pop'),
+            ('|'.join(ascii), String.Escape, '#pop'),
+            (r'o[0-7]+', String.Escape, '#pop'),
+            (r'x[\da-fA-F]+', String.Escape, '#pop'),
+            (r'\d+', String.Escape, '#pop'),
+            (r'\s+\\', String.Escape, '#pop'),
+        ],
+    }
+
+
+class IdrisLexer(RegexLexer):
+    """
+    A lexer for the dependently typed programming language Idris.
+
+    Based on the Haskell and Agda Lexer.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Idris'
+    aliases = ['idris', 'idr']
+    filenames = ['*.idr']
+    mimetypes = ['text/x-idris']
+
+    reserved = ['case','class','data','default','using','do','else',
+                'if','in','infix[lr]?','instance','rewrite','auto',
+                'namespace','codata','mutual','private','public','abstract',
+                'total','partial',
+                'let','proof','of','then','static','where','_','with',
+                'pattern', 'term', 'syntax','prefix',
+                'postulate','parameters','record','dsl','impossible','implicit',
+                'tactics','intros','intro','compute','refine','exaxt','trivial']
+
+    ascii = ['NUL','SOH','[SE]TX','EOT','ENQ','ACK',
+             'BEL','BS','HT','LF','VT','FF','CR','S[OI]','DLE',
+             'DC[1-4]','NAK','SYN','ETB','CAN',
+             'EM','SUB','ESC','[FGRU]S','SP','DEL']
+
+    annotations = ['assert_total','lib','link','include','provide','access',
+                   'default']
+
+    tokens = {
+        'root': [
+            # Declaration
+            (r'^(\s*)([^\s\(\)\{\}]+)(\s*)(:)(\s*)',
+             bygroups(Text, Name.Function, Text, Operator.Word, Text)),
+            # Comments
+            (r'^(\s*)(%%%s)' % '|'.join(annotations),
+             bygroups(Text, Keyword.Reserved)),
+            (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
+            (r'{-', Comment.Multiline, 'comment'),
+            #  Identifiers
+            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
+            (r"('')?[A-Z][\w\']*", Keyword.Type),
+            (r'[a-z][\w\']*', Text),
+            #  Special Symbols
+            (r'(<-|::|->|=>|=)', Operator.Word), # specials
+            (r'([\(\)\{\}\[\]:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word), # specials
+            #  Numbers
+            (r'\d+[eE][+-]?\d+', Number.Float),
+            (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
+            (r'0[xX][\da-fA-F]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            # Strings
+            (r"'", String.Char, 'character'),
+            (r'"', String, 'string'),
+            (r'[^\s\(\)\{\}]+', Text),
+            (r'\s+?', Text),  # Whitespace
+        ],
+        'module': [
+            (r'\s+', Text),
+            (r'([A-Z][\w.]*)(\s+)(\()',
+             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+            (r'[A-Z][\w.]*', Name.Namespace, '#pop'),
+        ],
+        'funclist': [
+            (r'\s+', Text),
+            (r'[A-Z]\w*', Keyword.Type),
             (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
             (r'--.*$', Comment.Single),
             (r'{-', Comment.Multiline, 'comment'),
@@ -1012,7 +1614,7 @@ class HaskellLexer(RegexLexer):
             (r'o[0-7]+', String.Escape, '#pop'),
             (r'x[\da-fA-F]+', String.Escape, '#pop'),
             (r'\d+', String.Escape, '#pop'),
-            (r'\s+\\', String.Escape, '#pop'),
+            (r'\s+\\', String.Escape, '#pop')
         ],
     }
 
@@ -1022,7 +1624,7 @@ class AgdaLexer(RegexLexer):
     For the `Agda <http://wiki.portal.chalmers.se/agda/pmwiki.php>`_
     dependently typed functional programming language and proof assistant.
 
-    *New in Pygments 1.7.*
+    .. versionadded:: 2.0
     """
 
     name = 'Agda'
@@ -1049,12 +1651,12 @@ class AgdaLexer(RegexLexer):
             (r'{!', Comment.Directive, 'hole'),
             # Lexemes:
             #  Identifiers
-            (ur'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
             (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
             (r'\b(Set|Prop)\b', Keyword.Type),
             #  Special Symbols
             (r'(\(|\)|\{|\})', Operator),
-            (ur'(\.{1,3}|\||[\u039B]|[\u2200]|[\u2192]|:|=|->)', Operator.Word),
+            (u'(\\.{1,3}|\\||\u039B|\u2200|\u2192|:|=|->)', Operator.Word),
             #  Numbers
             (r'\d+[eE][+-]?\d+', Number.Float),
             (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
@@ -1075,7 +1677,7 @@ class AgdaLexer(RegexLexer):
         ],
         'module': [
             (r'{-', Comment.Multiline, 'comment'),
-            (r'[a-zA-Z][a-zA-Z0-9_.]*', Name, '#pop'),
+            (r'[a-zA-Z][\w.]*', Name, '#pop'),
             (r'[^a-zA-Z]*', Text)
         ],
         'comment': HaskellLexer.tokens['comment'],
@@ -1150,6 +1752,29 @@ class LiterateLexer(Lexer):
             yield item
 
 
+class LiterateCryptolLexer(LiterateLexer):
+    """
+    For Literate Cryptol (Bird-style or LaTeX) source.
+
+    Additional options accepted:
+
+    `litstyle`
+        If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
+        is autodetected: if the first non-whitespace character in the source
+        is a backslash or percent character, LaTeX is assumed, else Bird.
+
+    .. versionadded:: 0.9
+    """
+    name = 'Literate Cryptol'
+    aliases = ['lcry', 'literate-cryptol', 'lcryptol']
+    filenames = ['*.lcry']
+    mimetypes = ['text/x-literate-cryptol']
+
+    def __init__(self, **options):
+        crylexer = CryptolLexer(**options)
+        LiterateLexer.__init__(self, crylexer, **options)
+
+
 class LiterateHaskellLexer(LiterateLexer):
     """
     For Literate Haskell (Bird-style or LaTeX) source.
@@ -1161,7 +1786,7 @@ class LiterateHaskellLexer(LiterateLexer):
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
 
-    *New in Pygments 0.9.*
+    .. versionadded:: 0.9
     """
     name = 'Literate Haskell'
     aliases = ['lhs', 'literate-haskell', 'lhaskell']
@@ -1173,6 +1798,29 @@ class LiterateHaskellLexer(LiterateLexer):
         LiterateLexer.__init__(self, hslexer, **options)
 
 
+class LiterateIdrisLexer(LiterateLexer):
+    """
+    For Literate Idris (Bird-style or LaTeX) source.
+
+    Additional options accepted:
+
+    `litstyle`
+        If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
+        is autodetected: if the first non-whitespace character in the source
+        is a backslash or percent character, LaTeX is assumed, else Bird.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Literate Idris'
+    aliases = ['lidr', 'literate-idris', 'lidris']
+    filenames = ['*.lidr']
+    mimetypes = ['text/x-literate-idris']
+
+    def __init__(self, **options):
+        hslexer = IdrisLexer(**options)
+        LiterateLexer.__init__(self, hslexer, **options)
+
+
 class LiterateAgdaLexer(LiterateLexer):
     """
     For Literate Agda source.
@@ -1184,7 +1832,7 @@ class LiterateAgdaLexer(LiterateLexer):
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
 
-    *New in Pygments 1.7.*
+    .. versionadded:: 2.0
     """
     name = 'Literate Agda'
     aliases = ['lagda', 'literate-agda']
@@ -1200,7 +1848,7 @@ class SMLLexer(RegexLexer):
     """
     For the Standard ML language.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Standard ML'
@@ -1228,7 +1876,7 @@ class SMLLexer(RegexLexer):
 
     nonid_reserved = [ '(', ')', '[', ']', '{', '}', ',', ';', '...', '_' ]
 
-    alphanumid_re = r"[a-zA-Z][a-zA-Z0-9_']*"
+    alphanumid_re = r"[a-zA-Z][\w']*"
     symbolicid_re = r"[!%&$#+\-/:<=>?@\\~`^|*]+"
 
     # A character constant is a sequence of the form #s, where s is a string
@@ -1318,7 +1966,7 @@ class SMLLexer(RegexLexer):
             (r'\b(type|eqtype)\b(?!\')', Keyword.Reserved, 'tname'),
 
             # Regular identifiers, long and otherwise
-            (r'\'[0-9a-zA-Z_\']*', Name.Decorator),
+            (r'\'[\w\']*', Name.Decorator),
             (r'(%s)(\.)' % alphanumid_re, long_id_callback, "dotted"),
             (r'(%s)' % alphanumid_re, id_callback),
             (r'(%s)' % symbolicid_re, id_callback),
@@ -1333,7 +1981,7 @@ class SMLLexer(RegexLexer):
 
 
         # Main parser (prevents errors in files that have scoping errors)
-        'root': [ (r'', Text, 'main') ],
+        'root': [ default('main') ],
 
         # In this scope, I expect '|' to not be followed by a function name,
         # and I expect 'and' to be followed by a binding site
@@ -1386,7 +2034,7 @@ class SMLLexer(RegexLexer):
             include('breakout'),
 
             (r'(%s)' % alphanumid_re, Name.Namespace),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # Dealing with what comes after the 'fun' (or 'and' or '|') keyword
@@ -1399,7 +2047,7 @@ class SMLLexer(RegexLexer):
             (r'(%s)' % symbolicid_re, Name.Function, '#pop'),
 
             # Ignore interesting function declarations like "fun (x + y) = ..."
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # Dealing with what comes after the 'val' (or 'and') keyword
@@ -1416,7 +2064,7 @@ class SMLLexer(RegexLexer):
             (r'(%s)' % symbolicid_re, Name.Variable, '#pop'),
 
             # Ignore interesting patterns like 'val (x, y)'
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # Dealing with what comes after the 'type' (or 'and') keyword
@@ -1526,7 +2174,7 @@ class OcamlLexer(RegexLexer):
     """
     For the OCaml language.
 
-    *New in Pygments 0.7.*
+    .. versionadded:: 0.7
     """
 
     name = 'OCaml'
@@ -1565,9 +2213,9 @@ class OcamlLexer(RegexLexer):
         'root': [
             (r'\s+', Text),
             (r'false|true|\(\)|\[\]', Name.Builtin.Pseudo),
-            (r'\b([A-Z][A-Za-z0-9_\']*)(?=\s*\.)',
+            (r'\b([A-Z][\w\']*)(?=\s*\.)',
              Name.Namespace, 'dotted'),
-            (r'\b([A-Z][A-Za-z0-9_\']*)', Name.Class),
+            (r'\b([A-Z][\w\']*)', Name.Class),
             (r'\(\*(?![)])', Comment, 'comment'),
             (r'\b(%s)\b' % '|'.join(keywords), Keyword),
             (r'(%s)' % '|'.join(keyopts[::-1]), Operator),
@@ -1580,7 +2228,7 @@ class OcamlLexer(RegexLexer):
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
             (r'0[xX][\da-fA-F][\da-fA-F_]*', Number.Hex),
             (r'0[oO][0-7][0-7_]*', Number.Oct),
-            (r'0[bB][01][01_]*', Number.Binary),
+            (r'0[bB][01][01_]*', Number.Bin),
             (r'\d[\d_]*', Number.Integer),
 
             (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'",
@@ -1607,9 +2255,9 @@ class OcamlLexer(RegexLexer):
         'dotted': [
             (r'\s+', Text),
             (r'\.', Punctuation),
-            (r'[A-Z][A-Za-z0-9_\']*(?=\s*\.)', Name.Namespace),
-            (r'[A-Z][A-Za-z0-9_\']*', Name.Class, '#pop'),
-            (r'[a-z_][A-Za-z0-9_\']*', Name, '#pop'),
+            (r'[A-Z][\w\']*(?=\s*\.)', Name.Namespace),
+            (r'[A-Z][\w\']*', Name.Class, '#pop'),
+            (r'[a-z_][\w\']*', Name, '#pop'),
         ],
     }
 
@@ -1620,7 +2268,7 @@ class ErlangLexer(RegexLexer):
 
     Blame Jeremy Thurgood (http://jerith.za.net/).
 
-    *New in Pygments 0.9.*
+    .. versionadded:: 0.9
     """
 
     name = 'Erlang'
@@ -1669,9 +2317,9 @@ class ErlangLexer(RegexLexer):
         'div', 'not', 'or', 'orelse', 'rem', 'xor'
         ]
 
-    atom_re = r"(?:[a-z][a-zA-Z0-9_]*|'[^\n']*[^\\]')"
+    atom_re = r"(?:[a-z]\w*|'[^\n']*[^\\]')"
 
-    variable_re = r'(?:[A-Z_][a-zA-Z0-9_]*)'
+    variable_re = r'(?:[A-Z_]\w*)'
 
     escape_re = r'(?:\\(?:[bdefnrstv\'"\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))'
 
@@ -1725,7 +2373,7 @@ class ErlangShellLexer(Lexer):
     """
     Shell sessions in erl (for Erlang code).
 
-    *New in Pygments 1.1.*
+    .. versionadded:: 1.1
     """
     name = 'Erlang erl session'
     aliases = ['erl']
@@ -1768,7 +2416,7 @@ class OpaLexer(RegexLexer):
     """
     Lexer for the Opa language (http://opalang.org).
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Opa'
@@ -1828,7 +2476,7 @@ class OpaLexer(RegexLexer):
             (r'-?\d+[eE][+\-]?\d+', Number.Float),
             (r'0[xX][\da-fA-F]+', Number.Hex),
             (r'0[oO][0-7]+', Number.Oct),
-            (r'0[bB][01]+', Number.Binary),
+            (r'0[bB][01]+', Number.Bin),
             (r'\d+', Number.Integer),
             # color literals
             (r'#[\da-fA-F]{3,6}', Number.Integer),
@@ -1918,7 +2566,7 @@ class OpaLexer(RegexLexer):
         'type': [
             include('comments-and-spaces'),
             (r'->', Keyword.Type),
-            (r'', Keyword.Type, ('#pop', 'type-lhs-1', 'type-with-slash')),
+            default(('#pop', 'type-lhs-1', 'type-with-slash')),
         ],
 
         # parses all the atomic or closed constructions in the syntax of type
@@ -1935,7 +2583,7 @@ class OpaLexer(RegexLexer):
             # we think we are parsing types when in fact we are parsing
             # some css, so we just pop the states until we get back into
             # the root state
-            (r'', Keyword.Type, '#pop'),
+            default('#pop'),
         ],
 
         # type-with-slash is either:
@@ -1943,13 +2591,13 @@ class OpaLexer(RegexLexer):
         # * type-1 (/ type-1)+
         'type-with-slash': [
             include('comments-and-spaces'),
-            (r'', Keyword.Type, ('#pop', 'slash-type-1', 'type-1')),
+            default(('#pop', 'slash-type-1', 'type-1')),
         ],
         'slash-type-1': [
             include('comments-and-spaces'),
             ('/', Keyword.Type, ('#pop', 'type-1')),
             # same remark as above
-            (r'', Keyword.Type, '#pop'),
+            default('#pop'),
         ],
 
         # we go in this state after having parsed a type-with-slash
@@ -1961,7 +2609,7 @@ class OpaLexer(RegexLexer):
             include('comments-and-spaces'),
             (r'->', Keyword.Type, ('#pop', 'type')),
             (r'(?=,)', Keyword.Type, ('#pop', 'type-arrow')),
-            (r'', Keyword.Type, '#pop'),
+            default('#pop'),
         ],
         'type-arrow': [
             include('comments-and-spaces'),
@@ -1970,7 +2618,7 @@ class OpaLexer(RegexLexer):
             (r',(?=[^:]*?->)', Keyword.Type, 'type-with-slash'),
             (r'->', Keyword.Type, ('#pop', 'type')),
             # same remark as above
-            (r'', Keyword.Type, '#pop'),
+            default('#pop'),
         ],
 
         # no need to do precise parsing for tuples and records
@@ -1997,7 +2645,7 @@ class OpaLexer(RegexLexer):
 #        'type-tuple': [
 #            include('comments-and-spaces'),
 #            (r'\)', Keyword.Type, '#pop'),
-#            (r'', Keyword.Type, ('#pop', 'type-tuple-1', 'type-1')),
+#            default(('#pop', 'type-tuple-1', 'type-1')),
 #        ],
 #        'type-tuple-1': [
 #            include('comments-and-spaces'),
@@ -2091,7 +2739,7 @@ class CoqLexer(RegexLexer):
     """
     For the `Coq <http://coq.inria.fr/>`_ theorem prover.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Coq'
@@ -2177,9 +2825,9 @@ class CoqLexer(RegexLexer):
             (r'\b(%s)\b' % '|'.join(keywords4), Keyword),
             (r'\b(%s)\b' % '|'.join(keywords5), Keyword.Pseudo),
             (r'\b(%s)\b' % '|'.join(keywords6), Keyword.Reserved),
-            (r'\b([A-Z][A-Za-z0-9_\']*)(?=\s*\.)',
+            (r'\b([A-Z][\w\']*)(?=\s*\.)',
              Name.Namespace, 'dotted'),
-            (r'\b([A-Z][A-Za-z0-9_\']*)', Name.Class),
+            (r'\b([A-Z][\w\']*)', Name.Class),
             (r'(%s)' % '|'.join(keyopts[::-1]), Operator),
             (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
             (r'\b(%s)\b' % '|'.join(word_operators), Operator.Word),
@@ -2190,7 +2838,7 @@ class CoqLexer(RegexLexer):
             (r'\d[\d_]*', Number.Integer),
             (r'0[xX][\da-fA-F][\da-fA-F_]*', Number.Hex),
             (r'0[oO][0-7][0-7_]*', Number.Oct),
-            (r'0[bB][01][01_]*', Number.Binary),
+            (r'0[bB][01][01_]*', Number.Bin),
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
 
             (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'",
@@ -2216,10 +2864,10 @@ class CoqLexer(RegexLexer):
         'dotted': [
             (r'\s+', Text),
             (r'\.', Punctuation),
-            (r'[A-Z][A-Za-z0-9_\']*(?=\s*\.)', Name.Namespace),
-            (r'[A-Z][A-Za-z0-9_\']*', Name.Class, '#pop'),
+            (r'[A-Z][\w\']*(?=\s*\.)', Name.Namespace),
+            (r'[A-Z][\w\']*', Name.Class, '#pop'),
             (r'[a-z][a-z0-9_\']*', Name, '#pop'),
-            (r'', Text, '#pop')
+            default('#pop')
         ],
     }
 
@@ -2232,7 +2880,7 @@ class NewLispLexer(RegexLexer):
     """
     For `newLISP. <www.newlisp.org>`_ source code (version 10.3.0).
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'NewLisp'
@@ -2305,7 +2953,7 @@ class NewLispLexer(RegexLexer):
     ]
 
     # valid names
-    valid_name = r'([a-zA-Z0-9!$%&*+.,/<=>?@^_~|-])+|(\[.*?\])+'
+    valid_name = r'([\w!$%&*+.,/<=>?@^~|-])+|(\[.*?\])+'
 
     tokens = {
         'root': [
@@ -2359,11 +3007,160 @@ class NewLispLexer(RegexLexer):
     }
 
 
+class NixLexer(RegexLexer):
+    """
+    For the `Nix language <http://nixos.org/nix/>`_.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Nix'
+    aliases = ['nixos', 'nix']
+    filenames = ['*.nix']
+    mimetypes = ['text/x-nix']
+
+    flags = re.MULTILINE | re.UNICODE
+
+    keywords = ['rec', 'with', 'let', 'in', 'inherit', 'assert', 'if',
+                'else', 'then', '...']
+    builtins = ['import', 'abort', 'baseNameOf', 'dirOf', 'isNull', 'builtins',
+                'map', 'removeAttrs', 'throw', 'toString', 'derivation']
+    operators = ['++', '+', '?', '.', '!', '//', '==',
+                 '!=', '&&', '||', '->', '=']
+
+    punctuations = ["(", ")", "[", "]", ";", "{", "}", ":", ",", "@"]
+
+    tokens = {
+        'root': [
+            # comments starting with #
+            (r'#.*$', Comment.Single),
+
+            # multiline comments
+            (r'/\*', Comment.Multiline, 'comment'),
+
+            # whitespace
+            (r'\s+', Text),
+
+            # keywords
+            ('(%s)' % '|'.join(re.escape(entry) + '\\b' for entry in keywords), Keyword),
+
+            # highlight the builtins
+            ('(%s)' % '|'.join(re.escape(entry) + '\\b' for entry in builtins),
+             Name.Builtin),
+
+            (r'\b(true|false|null)\b', Name.Constant),
+
+            # operators
+            ('(%s)' % '|'.join(re.escape(entry) for entry in operators),
+             Operator),
+
+            # word operators
+            (r'\b(or|and)\b', Operator.Word),
+
+            # punctuations
+            ('(%s)' % '|'.join(re.escape(entry) for entry in punctuations), Punctuation),
+
+            # integers
+            (r'[0-9]+', Number.Integer),
+
+            # strings
+            (r'"', String.Double, 'doublequote'),
+            (r"''", String.Single, 'singlequote'),
+
+            # paths
+            (r'[\w.+-]*(\/[\w.+-]+)+', Literal),
+            (r'\<[\w.+-]+(\/[\w.+-]+)*\>', Literal),
+
+            # urls
+            (r'[a-zA-Z][a-zA-Z0-9\+\-\.]*\:[\w%/?:@&=+$,\\.!~*\'-]+', Literal),
+
+            # names of variables
+            (r'[\w-]+\s*=', String.Symbol),
+            (r'[a-zA-Z_][\w\'-]*', Text),
+
+        ],
+        'comment': [
+            (r'[^/\*]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[\*/]', Comment.Multiline),
+        ],
+        'singlequote': [
+            (r"'''", String.Escape),
+            (r"''\$\{", String.Escape),
+            (r"''\n", String.Escape),
+            (r"''\r", String.Escape),
+            (r"''\t", String.Escape),
+            (r"''", String.Single, '#pop'),
+            (r'\$\{', String.Interpol, 'antiquote'),
+            (r"[^']", String.Single),
+        ],
+        'doublequote': [
+            (r'\\', String.Escape),
+            (r'\\"', String.Escape),
+            (r'\\${', String.Escape),
+            (r'"', String.Double, '#pop'),
+            (r'\$\{', String.Interpol, 'antiquote'),
+            (r'[^"]', String.Double),
+        ],
+        'antiquote': [
+            (r"}", String.Interpol, '#pop'),
+            # TODO: we should probably escape also here ''${ \${
+            (r"\$\{", String.Interpol, '#push'),
+            include('root'),
+        ],
+    }
+
+    def analyse_text(text):
+        rv = 0.0
+        # TODO: let/in
+        if re.search(r'import.+?<[^>]+>', text):
+            rv += 0.4
+        if re.search(r'mkDerivation\s+(\(|\{|rec)', text):
+            rv += 0.4
+        if re.search(r'with\s+[a-zA-Z\.]+;', text):
+            rv += 0.2
+        if re.search(r'inherit\s+[a-zA-Z()\.];', text):
+            rv += 0.2
+        if re.search(r'=\s+mkIf\s+', text):
+            rv += 0.4
+        if re.search(r'\{[a-zA-Z,\s]+\}:', text):
+            rv += 0.1
+        return rv
+
+
+def gen_elixir_string_rules(name, symbol, token):
+    states = {}
+    states['string_' + name] = [
+        (r'[^#%s\\]+' % (symbol,), token),
+        include('escapes'),
+        (r'\\.', token),
+        (r'(%s)(:?)' % (symbol,), bygroups(token, Punctuation), "#pop"),
+        include('interpol')
+    ]
+    return states
+
+def gen_elixir_sigstr_rules(term, token, interpol=True):
+    if interpol:
+        return [
+            (r'[^#%s\\]+' % (term,), token),
+            include('escapes'),
+            (r'\\.', token),
+            (r'%s[a-zA-Z]*' % (term,), token, '#pop'),
+            include('interpol')
+        ]
+    else:
+        return [
+            (r'[^%s\\]+' % (term,), token),
+            (r'\\.', token),
+            (r'%s[a-zA-Z]*' % (term,), token, '#pop'),
+        ]
+
 class ElixirLexer(RegexLexer):
     """
     For the `Elixir language <http://elixir-lang.org>`_.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Elixir'
@@ -2371,89 +3168,228 @@ class ElixirLexer(RegexLexer):
     filenames = ['*.ex', '*.exs']
     mimetypes = ['text/x-elixir']
 
+    KEYWORD = ['fn', 'do', 'end', 'after', 'else', 'rescue', 'catch']
+    KEYWORD_OPERATOR = ['not', 'and', 'or', 'xor', 'when', 'in']
+    BUILTIN = [
+        'case', 'cond', 'for', 'if', 'unless', 'try', 'receive', 'raise',
+        'quote', 'unquote', 'unquote_splicing', 'throw', 'super'
+    ]
+    BUILTIN_DECLARATION = [
+        'def', 'defp', 'defmodule', 'defprotocol', 'defmacro', 'defmacrop',
+        'defdelegate', 'defexception', 'defstruct', 'defimpl', 'defcallback'
+    ]
+
+    BUILTIN_NAMESPACE = ['import', 'require', 'use', 'alias']
+    CONSTANT = ['nil', 'true', 'false']
+
+    PSEUDO_VAR = ['_', '__MODULE__', '__DIR__', '__ENV__', '__CALLER__']
+
+    OPERATORS3 = ['<<<', '>>>', '|||', '&&&', '^^^', '~~~', '===', '!==']
+    OPERATORS2 = [
+        '==', '!=', '<=', '>=', '&&', '||', '<>', '++', '--', '|>', '=~'
+    ]
+    OPERATORS1 = ['<', '>', '+', '-', '*', '/', '!', '^', '&']
+
+    PUNCTUATION = [
+        '\\\\', '<<', '>>', '::', '->', '<-', '=>', '|', '(', ')',
+        '{', '}', ';', ',', '.', '[', ']', '%', '='
+    ]
+
+    def get_tokens_unprocessed(self, text):
+        for index, token, value in RegexLexer.get_tokens_unprocessed(self, text):
+            if token is Name:
+                if value in self.KEYWORD:
+                    yield index, Keyword, value
+                elif value in self.KEYWORD_OPERATOR:
+                    yield index, Operator.Word, value
+                elif value in self.BUILTIN:
+                    yield index, Keyword, value
+                elif value in self.BUILTIN_DECLARATION:
+                    yield index, Keyword.Declaration, value
+                elif value in self.BUILTIN_NAMESPACE:
+                    yield index, Keyword.Namespace, value
+                elif value in self.CONSTANT:
+                    yield index, Name.Constant, value
+                elif value in self.PSEUDO_VAR:
+                    yield index, Name.Builtin.Pseudo, value
+                else:
+                    yield index, token, value
+            else:
+                yield index, token, value
+
     def gen_elixir_sigil_rules():
-        states = {}
-
-        states['strings'] = [
-            (r'(%[A-Ba-z])?"""(?:.|\n)*?"""', String.Doc),
-            (r"'''(?:.|\n)*?'''", String.Doc),
-            (r'"', String.Double, 'dqs'),
-            (r"'.*'", String.Single),
-            (r'(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b|'
-             r'[^x0MC])|(\\[MC]-)+\w|[^\s\\])', String.Other)
+        # these braces are balanced inside the sigil string
+        braces = [
+            (r'\{', r'\}', 'cb'),
+            (r'\[', r'\]', 'sb'),
+            (r'\(', r'\)', 'pa'),
+            (r'\<', r'\>', 'ab'),
+        ]
+
+        # these are also valid sigil terminators, they are not balanced
+        terms = [
+            (r'/', 'slas'), (r'\|', 'pipe'), ('"', 'quot'), ("'", 'apos'),
         ]
 
-        for lbrace, rbrace, name, in ('\\{', '\\}', 'cb'), \
-                                     ('\\[', '\\]', 'sb'), \
-                                     ('\\(', '\\)', 'pa'), \
-                                     ('\\<', '\\>', 'lt'):
+        # heredocs have slightly different rules, they are not balanced
+        triquotes = [(r'"""', 'triquot'), (r"'''", 'triapos')]
+
+        token = String.Other
+        states = {'sigils': []}
+
+        for term, name in triquotes:
+            states['sigils'] += [
+                (r'(~[a-z])(%s)' % (term,), bygroups(token, String.Heredoc),
+                    (name + '-end', name + '-intp')),
+                (r'(~[A-Z])(%s)' % (term,), bygroups(token, String.Heredoc),
+                    (name + '-end', name + '-no-intp')),
+            ]
 
-            states['strings'] += [
-                (r'%[a-z]' + lbrace, String.Double, name + 'intp'),
-                (r'%[A-Z]' + lbrace, String.Double, name + 'no-intp')
+            states[name +'-end'] = [(r'[a-zA-Z]*', token, '#pop')]
+            states[name +'-intp'] = [
+                (r'^\s*' + term, String.Heredoc, '#pop'),
+                include('heredoc_interpol'),
+            ]
+            states[name +'-no-intp'] = [
+                (r'^\s*' + term, String.Heredoc, '#pop'),
+                include('heredoc_no_interpol'),
             ]
 
-            states[name +'intp'] = [
-                (r'' + rbrace + '[a-z]*', String.Double, "#pop"),
-                include('enddoublestr')
+        for term, name in terms:
+            states['sigils'] += [
+                (r'~[a-z]' + term, token, name + '-intp'),
+                (r'~[A-Z]' + term, token, name + '-no-intp'),
             ]
 
-            states[name +'no-intp'] = [
-                (r'.*' + rbrace + '[a-z]*', String.Double , "#pop")
+            # Similar states to the braced sigils, but no balancing of
+            # terminators
+            states[name +'-intp'] = gen_elixir_sigstr_rules(term, token)
+            states[name +'-no-intp'] = \
+                gen_elixir_sigstr_rules(term, token, interpol=False)
+
+        for lbrace, rbrace, name in braces:
+            states['sigils'] += [
+                (r'~[a-z]' + lbrace, token, name + '-intp'),
+                (r'~[A-Z]' + lbrace, token, name + '-no-intp')
             ]
 
+            states[name +'-intp'] = [
+                (r'\\.', token),
+                (lbrace, token, '#push'),
+            ] + gen_elixir_sigstr_rules(rbrace, token)
+
+            states[name +'-no-intp'] = [
+                (r'\\.', token),
+                (lbrace, token, '#push'),
+            ] + gen_elixir_sigstr_rules(rbrace, token, interpol=False)
+
         return states
 
+    op3_re = "|".join(re.escape(s) for s in OPERATORS3)
+    op2_re = "|".join(re.escape(s) for s in OPERATORS2)
+    op1_re = "|".join(re.escape(s) for s in OPERATORS1)
+    ops_re = r'(?:%s|%s|%s)' % (op3_re, op2_re, op1_re)
+    punctuation_re = "|".join(re.escape(s) for s in PUNCTUATION)
+    name_re = r'[a-z_][a-zA-Z_0-9]*[!\?]?'
+    modname_re = r'[A-Z][A-Za-z_]*(?:\.[A-Z][A-Za-z_]*)*'
+    complex_name_re = r'(?:%s|%s|%s)' % (name_re, modname_re, ops_re)
+    special_atom_re = r'(?:\.\.\.|<<>>|%{}|%|{})'
+
     tokens = {
         'root': [
             (r'\s+', Text),
             (r'#.*$', Comment.Single),
-            (r'\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|'
-             r'defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|'
-             r'defexception|exit|raise|throw|unless|after|rescue|catch|else)\b(?![?!])|'
-             r'(?<!\.)\b(do|\-\>)\b\s*', Keyword),
-            (r'\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])',
-                Keyword.Namespace),
-            (r'(?<!\.)\b(and|not|or|when|xor|in)\b', Operator.Word),
-            (r'%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|'
-             r'<=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[ \t])\?|'
-             r'(?<=[ \t])!+|&&|\|\||\^|\*|\+|\-|/|'
-             r'\||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.', Operator),
-            (r'(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|'
-             r'<=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|'
-             r'\*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)', String.Symbol),
-            (r':"', String.Symbol, 'interpoling_symbol'),
-            (r'\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b', Name.Constant),
-            (r'\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])', Name.Builtin.Pseudo),
-            (r'[a-zA-Z_!][\w_]*[!\?]?', Name),
-            (r'[(){};,/\|:\\\[\]]', Punctuation),
-            (r'@[a-zA-Z_]\w*|&\d', Name.Variable),
-            (r'\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])'
-             r'(_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b', Number),
-            (r'%r\/.*\/', String.Regex),
-            include('strings'),
-        ],
-        'dqs': [
-            (r'"', String.Double, "#pop"),
-            include('enddoublestr')
-        ],
-        'interpoling': [
-            (r'#{', String.Interpol, 'interpoling_string'),
-        ],
-        'interpoling_string' : [
+
+            # Various kinds of characters
+            (r'(?i)(\?)(\\x{)([\da-f]+)(})',
+                bygroups(String.Char,
+                    String.Escape, Number.Hex, String.Escape)),
+            (r'(?i)(\?)(\\x[\da-f]{1,2})',
+                bygroups(String.Char, String.Escape)),
+            (r'(\?)(\\[0-7]{1,3})',
+                bygroups(String.Char, String.Escape)),
+            (r'(\?)(\\[abdefnrstv])',
+                bygroups(String.Char, String.Escape)),
+            (r'\?\\?.', String.Char),
+
+            # atoms
+            (r':' + special_atom_re, String.Symbol),
+            (r':' + complex_name_re, String.Symbol),
+            (r':"', String.Symbol, 'string_double_atom'),
+            (r":'", String.Symbol, 'string_single_atom'),
+
+            # [keywords: ...]
+            (r'(%s|%s)(:)(?=\s|\n)' % (special_atom_re, complex_name_re),
+                bygroups(String.Symbol, Punctuation)),
+
+            # @attributes
+            (r'@' + name_re, Name.Attribute),
+
+            # operators and punctuation
+            (op3_re, Operator),
+            (op2_re, Operator),
+            (punctuation_re, Punctuation),
+            (r'&\d', Name.Entity),   # anon func arguments
+            (op1_re, Operator),
+
+            # identifiers
+            (name_re, Name),
+            (modname_re, Name.Class),
+
+            # numbers
+            (r'0[bB][01]+', Number.Bin),
+            (r'0[0-7]+', Number.Oct),
+            (r'(?i)0x[\da-f]+', Number.Hex),
+            (r'\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?', Number.Float),
+            (r'\d(_?\d)*', Number.Integer),
+
+            # strings and heredocs
+            (r'"""\s*', String.Heredoc, 'heredoc_double'),
+            (r"'''\s*$", String.Heredoc, 'heredoc_single'),
+            (r'"', String.Double, 'string_double'),
+            (r"'", String.Single, 'string_single'),
+
+            include('sigils'),
+        ],
+        'heredoc_double': [
+            (r'^\s*"""', String.Heredoc, '#pop'),
+            include('heredoc_interpol'),
+        ],
+        'heredoc_single': [
+            (r"^\s*'''", String.Heredoc, '#pop'),
+            include('heredoc_interpol'),
+        ],
+        'heredoc_interpol': [
+            (r'[^#\\\n]+', String.Heredoc),
+            include('escapes'),
+            (r'\\.', String.Heredoc),
+            (r'\n+', String.Heredoc),
+            include('interpol'),
+        ],
+        'heredoc_no_interpol': [
+            (r'[^\\\n]+', String.Heredoc),
+            (r'\\.', String.Heredoc),
+            (r'\n+', String.Heredoc),
+        ],
+        'escapes': [
+            (r'(?i)(\\x{)([\da-f]+)(})',
+                bygroups(String.Escape, Number.Hex, String.Escape)),
+            (r'(?i)\\x[\da-f]{1,2}', String.Escape),
+            (r'\\[0-7]{1,3}', String.Escape),
+            (r'\\[abdefnrstv]', String.Escape),
+        ],
+        'interpol': [
+            (r'#{', String.Interpol, 'interpol_string'),
+        ],
+        'interpol_string' : [
             (r'}', String.Interpol, "#pop"),
             include('root')
         ],
-        'interpoling_symbol': [
-            (r'"', String.Symbol, "#pop"),
-            include('interpoling'),
-            (r'[^#"]+', String.Symbol),
-        ],
-        'enddoublestr' : [
-            include('interpoling'),
-            (r'[^#"]+', String.Double),
-        ]
     }
+    tokens.update(gen_elixir_string_rules('double', '"', String.Double))
+    tokens.update(gen_elixir_string_rules('single', "'", String.Single))
+    tokens.update(gen_elixir_string_rules('double_atom', '"', String.Symbol))
+    tokens.update(gen_elixir_string_rules('single_atom', "'", String.Symbol))
     tokens.update(gen_elixir_sigil_rules())
 
 
@@ -2474,29 +3410,32 @@ class ElixirConsoleLexer(Lexer):
         iex> length [head | tail]
         3
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Elixir iex session'
     aliases = ['iex']
     mimetypes = ['text/x-elixir-shellsession']
 
-    _prompt_re = re.compile('(iex|\.{3})> ')
+    _prompt_re = re.compile('(iex|\.{3})(\(\d+\))?> ')
 
     def get_tokens_unprocessed(self, text):
         exlexer = ElixirLexer(**self.options)
 
         curcode = ''
+        in_error = False
         insertions = []
         for match in line_re.finditer(text):
             line = match.group()
             if line.startswith(u'** '):
+                in_error = True
                 insertions.append((len(curcode),
                                    [(0, Generic.Error, line[:-1])]))
                 curcode += line[-1:]
             else:
                 m = self._prompt_re.match(line)
                 if m is not None:
+                    in_error = False
                     end = m.end()
                     insertions.append((len(curcode),
                                        [(0, Generic.Prompt, line[:end])]))
@@ -2504,14 +3443,15 @@ class ElixirConsoleLexer(Lexer):
                 else:
                     if curcode:
                         for item in do_insertions(insertions,
-                                        exlexer.get_tokens_unprocessed(curcode)):
+                                    exlexer.get_tokens_unprocessed(curcode)):
                             yield item
                         curcode = ''
                         insertions = []
-                    yield match.start(), Generic.Output, line
+                    token = Generic.Error if in_error else Generic.Output
+                    yield match.start(), token, line
         if curcode:
             for item in do_insertions(insertions,
-                                      exlexer.get_tokens_unprocessed(curcode)):
+                                  exlexer.get_tokens_unprocessed(curcode)):
                 yield item
 
 
@@ -2520,7 +3460,7 @@ class KokaLexer(RegexLexer):
     Lexer for the `Koka <http://koka.codeplex.com>`_
     language.
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     name = 'Koka'
@@ -2690,7 +3630,7 @@ class KokaLexer(RegexLexer):
             (r'::|\->|[\.:|]', tokenType),
 
             #catchall
-            (r'', Text, '#pop')
+            default('#pop')
         ],
 
         # comments and literals