broomhlda 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b531cf8a1deb12865af0da4152652846aa41d4b8
+  data.tar.gz: 940fb9d11c3ed725af5e32c92b6d6988d3edc275
+SHA512:
+  metadata.gz: c747b4053c1bc6b035f49207fcf5262d6b77f3634d79ec9dd46877f0ae28e35e4068c3afadbc8e088314ea51ffb18c791db5c209749497f2e7d4e27f12095c97
+  data.tar.gz: 4a1095545987f373e2a6a807db9d927569fb57985d32db51e854c8eee6dbbdd344e36d24b6533cc03cfa017db0fda818236ba39c09f5888eb02c6355fee6fd38

data/LICENSE.md

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/lib/hl/define.ay

@@ -0,0 +1,131 @@
+use(require("atomy"))
+
+lexer = require(File expand-path("../lexer", __FILE__))
+
+const-set(.Lexer, lexer Lexer)
+Lexer const-set(.Matcher, lexer Matcher)
+Lexer const-set(.State, require(File expand-path("../state", __FILE__)))
+Lexer const-set(.Token, require(File expand-path("../token", __FILE__)))
+
+macro(lexer: ~*body):
+  `(Lexer class:
+      @matchers = Hash new
+      @info = Hash new
+
+      ~*body)
+
+def(short-name(["name", "constant"])): "no"
+def(short-name(["name", "entity"])): "ni"
+def(short-name(["name", "property"])): "py"
+def(short-name(["literal", b])): short-name([b])
+def(short-name([a, "other"])): short-name([a]) + "x"
+def(short-name([a, "error"])): short-name([a]) + "r"
+def(short-name([a, "single"])): short-name([a]) + "1"
+def(short-name([a, "double"])): short-name([a]) + "2"
+def(short-name([a, b])): short-name([a]) + short-name([b])
+def(short-name(["error"])): "err"
+def(short-name(["number"])): "m"
+def(short-name([x])): x slice(0, 1)
+def(short-name(_ . xs)): short-name(xs)
+
+fn(str(x)): Atomy Grammar AST StringLiteral new(x)
+
+def(type-from(x & Atomy Grammar AST Word)):
+  `(Token Tagged new(~str(short-name([x text to-s]))))
+
+def(type-from(`((~a). ~(b)))):
+  tag = short-name([
+    a text to-s
+    b text to-s])
+  `(Token Tagged new(~str(tag)))
+
+def(type-from(`(~_ (~a). ~(b)))):
+  tag = short-name([
+    a text to-s
+    b text to-s])
+  `(Token Tagged new(~str(tag)))
+
+def(type-from(`(by-groups(~*args)))):
+  `(Token ByGroups new([~*(args collect [a]: type-from(a))]))
+
+def(type-from(`(using(~who)))):
+  `(Token Using new(~who))
+
+def(type-from(x)): raise("unknown match type: " + x inspect)
+
+def(regexp-from(x, regexps)):
+  regexps <<
+    `([x]: Regexp new(
+        x source
+        x options | @info fetch(.flags)
+      ); call(~x))
+
+  `(regexps[~(Atomy Grammar AST Number new(regexps size - 1))])
+
+def(state-from('pop)): '(State Pop new)
+def(state-from(`(pop(~n)))): `(State PopNum new(~n))
+def(state-from('push)): '(State Push new)
+def(state-from(`(do-all(~*args)))):
+  `(State DoAll new([~*(args collect [a]: state-from(a))]))
+def(state-from(`(combined(~*args)))):
+  all = args reverse collect [a]:
+    `(@matchers fetch(.~a))
+
+  `(State Combined new([~*all]))
+def(state-from(`(go-to(~n)))):
+  `(State GoTo new(@matchers, .~n))
+def(state-from(x)):
+  raise("unknown state: " + x inspect)
+
+
+macro(lex(~name): ~*tokens):
+  `(lex(~name) []: ~*tokens)
+
+macro(lex(~name) [~*args]: ~*tokens):
+  branches = []
+
+  body = []
+
+  regexps = []
+
+  tokens each [c]:
+    c match:
+      -- implicit continue state
+      `(~x is(~y)):
+        branches <<
+          `(Matcher new(
+              ~(regexp-from(x, regexps))
+              ~(type-from(y))
+              State Continue new
+            ))
+
+      -- specifying a state
+      `(~x is(~y) -> ~z):
+        branches <<
+          `(Matcher new(
+              ~(regexp-from(x, regexps))
+              ~(type-from(y))
+              ~(state-from(z))
+            ))
+
+      -- goto shortcut
+      `(~x is(~y) => ~z):
+        branches <<
+          `(Matcher new(
+              ~(regexp-from(x, regexps))
+              ~(type-from(y))
+              State GoTo new(@matchers, .~z)
+            ))
+
+      `(any-of(~any)):
+        branches <<
+          `(@matchers fetch(.~any) call) -- TODO: parameterization?
+
+      _:
+        body << c
+
+  body << `([~*branches] flatten)
+
+  `([regexps] {
+      @matchers[.~name] = proc [~*args]: ~*body
+    } call([~*regexps]))

data/lib/hl/formatters/html.ay

@@ -0,0 +1,26 @@
+-- TODO: use my li'l html lib from anatomy (extract to gem)
+use(require("atomy"))
+
+require("rubygems")
+require("nokogiri")
+
+formatter = class:
+  def(initialize(@tokens, @line-numbers = false)):
+    .ok
+
+  def(format(builder = Nokogiri XML Builder new)):
+    builder
+      div(#{ .class: "highlight" }) [d]:
+        d pre [p]:
+          format-tokens(p)
+      
+    builder doc children first serialize(#{ .save-with: 0 })
+
+  def(format-tokens(to)):
+    @tokens each [t]:
+      to span(#{ .class: t type tag }) [s]:
+        s text(t contents)
+
+    to
+
+const-set(.Formatter, formatter)

data/lib/hl/lexer.ay

@@ -0,0 +1,99 @@
+use(require("atomy"))
+
+token = require(File expand-path("../token", __FILE__))
+
+
+Error data(NoMatchFor(@input))
+
+def(NoMatchFor(input) message):
+  "no matchers succeeded for: " +
+    (input slice(0, 50) inspect + " [...]")
+
+
+data(Matcher(@regexp, @type, @next))
+
+-- TODO: Using
+fn(tokens(data, gs & token ByGroups)):
+  gs types zip(data to-a drop(1)) [t, d]:
+    when(t nil? || d nil?):
+      return(nil)
+
+    @lexed << token Token new(t, d)
+
+fn(tokens(data, t & token Tagged)):
+  @lexed << token Token new(t, data to-s)
+
+-- go through matchers until one matches the immediate
+-- next input. if none match, try again, but allowing
+-- matches past the start.
+fn(try-all(matchers)):
+  closest = nil
+  worked = nil
+
+  matchers each [m]:
+    d = m regexp match(@input)
+    when(d && (!closest || (d pre-match size < closest pre-match size))):
+      &closest = d
+      &worked = m
+
+      when(closest pre-match empty?):
+        break
+
+  unless(closest):
+    /error(NoMatchFor new(@input))
+
+  skipped = closest pre-match
+  @input = closest post-match
+
+  worked next apply(@state, closest)
+
+  unless(skipped empty?):
+    @lexed <<
+      token Token new(
+        token Tagged new("err")
+        skipped)
+
+  tokens(closest, worked type)
+
+lexer = class:
+  def(initialize(input)):
+    @input = input dup
+
+    @state = [
+      class matchers[class info[.start]][]
+    ] -- [Matcher]
+
+    @lexed = [] -- [Token]
+
+  -- run the lexer until the input is empty, yielding
+  -- the lexed tokens
+  def(run):
+    until(@input empty?):
+      try-all(@state last)
+
+    @lexed
+
+  singleton:
+    attr-accessor(.matchers, .info)
+
+    def(lex(x)): new(x) run
+
+    def(name &x):
+      @info[.name] = x call
+
+    def(aliases &x):
+      @info[.aliases] = x call
+
+    def(extensions &x):
+      @info[.extensions] = x call
+
+    def(mimetypes &x):
+      @info[.mimetypes] = x call
+
+    def(start &x):
+      @info[.start] = x call
+
+    def(flags &x):
+      @info[.flags] = x call
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/atomy.ay

@@ -0,0 +1,122 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Atomy"
+  aliases: "atomy"
+  extensions: [".ay"]
+  mimetypes: "text/x-atomy"
+  start: .root
+  flags: Regexp MULTILINE
+
+  @@ident-char = raw"[\p{L}\d\-_]"
+  @@identifier = r"[\p{Ll}_]#{@@ident-char}*"
+
+  @@op-char = raw"[\p{S}!@#%&*\-\\.\/\?]"
+  @@operator = r"(?!~`):?#{@@op-char}+"
+
+  @@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"
+  ]
+
+
+  fn(word(reg)):
+    r"(?<!#{@@op-char}|#{@@ident-char})#{reg}(?!#{@@op-char}|#{@@ident-char})"
+
+
+  -- starting point for lexing
+  lex(root):
+    -- comments
+    r"--.*?$" is(comment.single)
+    r"{-" is(comment.multiline) => in-comment
+
+    -- primitive constants
+    word(r"true|false|nil|undefined") is(keyword.constant)
+    word(r"self") is(name.builtin.pseudo)
+
+    -- constants
+    r"[A-Z][a-zA-Z0-9_]*" is(name.constant)
+
+    -- floats
+    r"[\+\-]?\d+[eE][\+\-]?\d+" is(number.float)
+    r"[\+\-]?\d+\.\d+([eE][\+\-]?\d+)?" is(number.float)
+
+    -- integers
+    r"[\+\-]?0[oO][0-7]+" is(number.octal)
+    r"[\+\-]?0[xX][\da-fA-F]+" is(number.hexadecimal)
+    r"[\+\-]?\d+" is(number.integer)
+
+    -- reserved words
+    word(r"#language") is(keyword.reserved)
+
+    -- special variables
+    r"@@#{@@identifier}" is(name.variable.class)
+    r"\$#{@@identifier}" is(name.variable.global)
+    r"@#{@@identifier}" is(name.variable.instance)
+
+    -- particles
+    r"\.#{@@identifier}" is(string.symbol)
+
+    -- quoting expressions
+    r"['`]#{@@identifier}" is(string.symbol)
+    r"['`]" is(string.symbol)
+
+    -- unquote
+    r"~#{@@identifier}" is(string.interpolate)
+    r"~" is(string.interpolate)
+
+    -- macro-quotes
+    r"(#{@@identifier})(\")" is(by-groups(name, string)) => macro-quote
+
+    -- identifiers
+    @@identifier is(name)
+
+    -- operators
+    @@operator is(operator)
+
+    -- strings
+    r"\"" is(string) => in-string
+
+    -- whitespace
+    r"\s+" is(text)
+
+    -- punctuation
+    r"[\[\](),:;{}|]" is(punctuation)
+
+
+  -- inside of a block comment; handle nesting
+  lex(in-comment):
+    r"[^\-\{\}]+" is(comment.multiline)
+    r"{-" is(comment.multiline) -> push
+    r"-}" is(comment.multiline) -> pop
+    r"[-{}]" is(comment.mutline)
+
+
+  -- inside of a string; contain escapes
+  lex(in-string):
+    r"[^\\\"]+" is(string)
+    r"\\" is(string.escape) => escape
+    r"\"" is(string) -> pop
+
+
+  -- match delimiters in a macro-quote, skipping escapes
+  lex(macro-quote) [d]:
+    r"[^\\\"]" is(string)
+    r"\\." is(string)
+    r"\"" is(string) -> pop
+
+
+  -- all of our character escapes
+  lex(escape):
+    r"[nsrtvfbae\\\"]" is(string.escape) -> pop
+    r"\^[\]\[A-Z@\^_]" is(string.escape) -> pop
+    Regexp new(@@ascii join("|")) is(string.escape) -> pop
+    r"o[0-7]+" is(string.escape) -> pop
+    r"x[\da-fA-F]+" is(string.escape) -> pop
+    r"\d+" is(string.escape) -> pop
+    r"\s+\\" is(string.escape) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/haskell.ay

@@ -0,0 +1,89 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Haskell"
+  aliases: ["haskell", "hs"]
+  extensions: [".hs"]
+  mimetypes: ["text/x-haskell"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(comment):
+    Regexp new("[^-{}]+") is(comment.multiline)
+    Regexp new("{-") is(comment.multiline) -> push
+    Regexp new("-}") is(comment.multiline) -> pop
+    Regexp new("[-{}]") is(comment.multiline)
+
+  lex(funclist):
+    Regexp new("\\s+") is(text)
+    Regexp new("[A-Z][a-zA-Z0-9_]*") is(keyword.type)
+    Regexp new("(_[\\w']+|[a-z][\\w']*)") is(name.function)
+    Regexp new("--.*$") is(comment.single)
+    Regexp new("{-") is(comment.multiline) -> go-to(comment)
+    Regexp new(",") is(punctuation)
+    Regexp new("[:!#$%&*+.\\\\/<=>?@^|\126-]+") is(operator)
+    Regexp new("\\(") is(punctuation) -> do-all(go-to(funclist), go-to(funclist))
+    Regexp new("\\)") is(punctuation) -> pop(2)
+
+  lex(string):
+    Regexp new("[^\\\\\"]+") is(literal.string)
+    Regexp new("\\\\") is(literal.string.escape) -> go-to(escape)
+    Regexp new("\"") is(literal.string) -> pop
+
+  lex(import):
+    Regexp new("\\s+") is(text)
+    Regexp new("\"") is(literal.string) -> go-to(string)
+    Regexp new("\\)") is(punctuation) -> pop
+    Regexp new("qualified\\b(?!')") is(keyword)
+    Regexp new("([A-Z][a-zA-Z0-9_.]*)(\\s+)(as)(\\s+)([A-Z][a-zA-Z0-9_.]*)") is(by-groups(name.namespace, text, keyword, text, name)) -> pop
+    Regexp new("([A-Z][a-zA-Z0-9_.]*)(\\s+)(hiding)(\\s+)(\\()") is(by-groups(name.namespace, text, keyword, text, punctuation)) -> go-to(funclist)
+    Regexp new("([A-Z][a-zA-Z0-9_.]*)(\\s+)(\\()") is(by-groups(name.namespace, text, punctuation)) -> go-to(funclist)
+    Regexp new("[a-zA-Z0-9_.]+") is(name.namespace) -> pop
+
+  lex(escape):
+    Regexp new("[abfnrtv\"\\'&\\\\]") is(literal.string.escape) -> pop
+    Regexp new("\\^[\\]\\[A-Z@\\^_]") is(literal.string.escape) -> pop
+    Regexp new("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") is(literal.string.escape) -> pop
+    Regexp new("o[0-7]+") is(literal.string.escape) -> pop
+    Regexp new("x[\\da-fA-F]+") is(literal.string.escape) -> pop
+    Regexp new("\\d+") is(literal.string.escape) -> pop
+    Regexp new("\\s+\\\\") is(literal.string.escape) -> pop
+
+  lex(root):
+    Regexp new("\\s+") is(text)
+    Regexp new("--(?![!#$%&*+./<=>?@\\^|_\126]).*?$") is(comment.single)
+    Regexp new("{-") is(comment.multiline) -> go-to(comment)
+    Regexp new("\\bimport(?!\\')\\b") is(keyword.reserved) -> go-to(import)
+    Regexp new("\\bmodule(?!\\')\\b") is(keyword.reserved) -> go-to(module)
+    Regexp new("\\berror(?!\\')\\b") is(name.exception)
+    Regexp new("\\b(case|class|data|default|deriving|do|else|if|in|infix[lr]?|instance|let|newtype|of|then|type|where|_)(?!\\')\\b") is(keyword.reserved)
+    Regexp new("^[_a-z][\\w\\']*") is(name.function)
+    Regexp new("[_a-z][\\w\\']*") is(name)
+    Regexp new("[A-Z][\\w\\']*") is(keyword.type)
+    Regexp new("\\\\(?![:!#$%&*+.\\\\/<=>?@^|\126-]+)") is(name.function)
+    Regexp new("(<-|::|->|=>|=)(?![:!#$%&*+.\\\\/<=>?@^|\126-]+)") is(operator.word)
+    Regexp new(":[:!#$%&*+.\\\\/<=>?@^|\126-]*") is(keyword.type)
+    Regexp new("[:!#$%&*+.\\\\/<=>?@^|\126-]+") is(operator)
+    Regexp new("\\d+[eE][+-]?\\d+") is(literal.number.float)
+    Regexp new("\\d+\\.\\d+([eE][+-]?\\d+)?") is(literal.number.float)
+    Regexp new("0[oO][0-7]+") is(literal.number.oct)
+    Regexp new("0[xX][\\da-fA-F]+") is(literal.number.hex)
+    Regexp new("\\d+") is(literal.number.integer)
+    Regexp new("'") is(literal.string.char) -> go-to(character)
+    Regexp new("\"") is(literal.string) -> go-to(string)
+    Regexp new("\\[\\]") is(keyword.type)
+    Regexp new("\\(\\)") is(name.builtin)
+    Regexp new("[\\]\\[(),;`{}]") is(punctuation)
+
+  lex(module):
+    Regexp new("\\s+") is(text)
+    Regexp new("([A-Z][a-zA-Z0-9_.]*)(\\s+)(\\()") is(by-groups(name.namespace, text, punctuation)) -> go-to(funclist)
+    Regexp new("[A-Z][a-zA-Z0-9_.]*") is(name.namespace) -> pop
+
+  lex(character):
+    Regexp new("[^\\\\']") is(literal.string.char)
+    Regexp new("\\\\") is(literal.string.escape) -> go-to(escape)
+    Regexp new("'") is(literal.string.char) -> pop
+
+const-set(.Lexer, lexer)