github-linguist-grammars 4.6.0

data/grammars/source.harbour.json

@@ -0,0 +1,450 @@
+{
+  "name": "harbour",
+  "scopeName": "source.harbour",
+  "fileTypes": [
+    "prg",
+    "ch",
+    "hb"
+  ],
+  "repository": {
+    "block_doc_comment": {
+      "comment": "Block documentation comment",
+      "name": "comment.block.documentation.harbour",
+      "begin": "/\\*[!\\*][^\\*]",
+      "end": "\\*/",
+      "patterns": [
+        {
+          "include": "#block_doc_comment"
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "block_comment": {
+      "comment": "Block comment",
+      "name": "comment.block.harbour",
+      "begin": "/\\*",
+      "end": "\\*/",
+      "patterns": [
+        {
+          "include": "#block_doc_comment"
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "line_doc_comment": {
+      "comment": "Single-line documentation comment",
+      "name": "comment.line.documentation.harbour",
+      "match": "//[!/][^/].*$"
+    },
+    "line_comment": {
+      "comment": "Single-line comment",
+      "name": "comment.line.double-slash.harbour",
+      "match": "//.*$"
+    },
+    "escaped_character": {
+      "name": "constant.character.escape.harbour",
+      "match": "\\\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)"
+    },
+    "sigils": {
+      "comment": "Sigil",
+      "name": "keyword.operator.sigil.harbou",
+      "match": "[@]|[:]{2}|[+]{2}(?=[a-zA-Z0-9_\\(\\[\\|\\\"]+)"
+    },
+    "string_literal": {
+      "comment": "Double-quote string",
+      "name": "string.quoted.double.harbour",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [
+        {
+          "include": "#escaped_character"
+        }
+      ]
+    },
+    "std_types": {
+      "comment": "Standard library type",
+      "name": "support.class.std.harbour",
+      "match": "\\b(Vec|StrBuf|Path|Option|Result|Reader|Writer|Stream|Seek|Buffer|IoError|IoResult|Sender|SyncSender|Receiver|Cell|RefCell|Any)\\b"
+    },
+    "self": {
+      "comment": "Self variable",
+      "name": "variable.self.language.harbour",
+      "match": "\\b(Self|SELF|self)\\b"
+    },
+    "nil": {
+      "comment": "Nil variable",
+      "name": "variable.nil.language.harbour",
+      "match": "\\b(NIL|nil)\\b"
+    },
+    "type_params": {
+      "comment": "Type parameters",
+      "name": "meta.type_params.harbour",
+      "begin": "<",
+      "end": ">",
+      "patterns": [
+        {
+          "include": "#block_comment"
+        },
+        {
+          "include": "#line_comment"
+        },
+        {
+          "include": "#sigils"
+        },
+        {
+          "include": "#types"
+        },
+        {
+          "include": "#std_types"
+        },
+        {
+          "include": "#lifetime"
+        },
+        {
+          "include": "#type_params"
+        }
+      ]
+    }
+  },
+  "patterns": [
+    {
+      "include": "#block_doc_comment"
+    },
+    {
+      "include": "#block_comment"
+    },
+    {
+      "include": "#line_doc_comment"
+    },
+    {
+      "include": "#line_comment"
+    },
+    {
+      "include": "#sigils"
+    },
+    {
+      "comment": "Attribute",
+      "name": "meta.attribute.harbour",
+      "begin": "#\\!?\\[",
+      "end": "\\]",
+      "patterns": [
+        {
+          "include": "#string_literal"
+        }
+      ]
+    },
+    {
+      "comment": "Single-quote string (character literal)",
+      "name": "string.quoted.single.harbour",
+      "match": "'([^'\\\\]|\\\\(x\\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.))'"
+    },
+    {
+      "include": "#string_literal"
+    },
+    {
+      "comment": "Floating point number (fraction)",
+      "name": "constant.numeric.float.harbour",
+      "match": "\\b[0-9][0-9_]*\\.[0-9][0-9_]*([eE][+-][0-9_]+)?(f32|f64)?\\b"
+    },
+    {
+      "comment": "Floating point number (exponent)",
+      "name": "constant.numeric.float.harbour",
+      "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?[eE][+-][0-9_]+(f32|f64)?\\b"
+    },
+    {
+      "comment": "Floating point number (typed)",
+      "name": "constant.numeric.float.harbour",
+      "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?([eE][+-][0-9_]+)?(f32|f64)\\b"
+    },
+    {
+      "comment": "Integer number (decimal)",
+      "name": "constant.numeric.integer.decimal.harbour",
+      "match": "\\b[0-9][0-9_]*([ui](8|16|32|64)?)?\\b"
+    },
+    {
+      "comment": "Integer number (hexadecimal)",
+      "name": "constant.numeric.integer.hexadecimal.harbour",
+      "match": "\\b0x[a-fA-F0-9_]+([ui](8|16|32|64)?)?\\b"
+    },
+    {
+      "comment": "Integer number (octal)",
+      "name": "constant.numeric.integer.octal.harbour",
+      "match": "\\b0o[0-7_]+([ui](8|16|32|64)?)?\\b"
+    },
+    {
+      "comment": "Integer number (binary)",
+      "name": "constant.numeric.integer.binary.harbour",
+      "match": "\\b0b[01_]+([ui](8|16|32|64)?)?\\b"
+    },
+    {
+      "comment": "Static storage modifier",
+      "name": "storage.modifier.static.harbour",
+      "match": "\\b(static|STATIC|THREAD STATIC)\\b"
+    },
+    {
+      "comment": "Boolean constant",
+      "name": "constant.language.boolean.harbour",
+      "match": "(TRUE|FALSE|\\.T\\.|\\.F\\.)"
+    },
+    {
+      "comment": "Keyboard harbour constants",
+      "name": "constant.language.keyboard.harbour",
+      "match": "(K_DOWN|K_PGDN|K_CTRL_PGDN|K_UP|K_PGUP|K_CTRL_PGUP|K_RIGHT|K_LEFT|K_HOME|K_END|K_CTRL_LEFT|K_CTRL_RIGHT|K_CTRL_HOME|K_CTRL_END)"
+    },
+    {
+      "comment": "variable name hungary notation",
+      "name": "variable.name.hungary.harbour",
+      "match": "\\b(s_)?(mtx)?[a,b,c,d,h,l,n,o,u,x][A-Z][A-Za-z0-9_]*\\b"
+    },
+    {
+      "comment": "variable name",
+      "name": "variable.name.special.harbour",
+      "match": "\\b_[a-z][A-Za-z0-9_]*|\\s(i|j)\\s\\b"
+    },
+    {
+      "comment": "Control keyword",
+      "name": "keyword.control.harbour",
+      "match": "\\b(EXIT|ELSEIF|ELSE|IF|ENDIF|FOR|EACH|IN|TO|STEP|DESCEND|NEXT|LOOP|DO CASE|ENDCASE|SWITCH|CASE|OTHERWISE|ENDSWITCH|RETURN|ENDCLASS|VAR|DATA|INIT|WHILE|DO WHILE|ENDDO|BEGIN SEQUENCE|END SEQUENCE|RECOVER USING|WITH|BREAK|PARAMETERS|END|REQUEST|ANNOUNCE)\\b"
+    },
+    {
+      "comment": "xBase keywords",
+      "name": "keyword.command.xbase.harbour",
+      "match": "\\b(GO TOP|SELECT|SAY|GET|PICTURE|SEEK|REPLACE|APPEND BLANK|USE|INDEX ON|TAG)\\b"
+    },
+    {
+      "comment": "xBase keywords",
+      "name": "keyword.command.xbase.harbour",
+      "match": "\\b(HSEEK|RREPLACE|START PRINT|ENDPRINT)\\b"
+    },
+    {
+      "comment": "Keyword",
+      "name": "keyword.other.harbour",
+      "match": "\\b(LOCAL|PRIVATE|PROTECTED|PUBLIC|FIELD|field|MEMVAR)\\b"
+    },
+    {
+      "include": "#types"
+    },
+    {
+      "include": "#std_types"
+    },
+    {
+      "include": "#self"
+    },
+    {
+      "include": "#nil"
+    },
+    {
+      "include": "#lifetime"
+    },
+    {
+      "include": "#ref_lifetime"
+    },
+    {
+      "begin": "^\\s*#\\s*(error|warning|stdout)\\b",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.error.harbour"
+        }
+      },
+      "end": "(?<!\\\\)(?=\\n)",
+      "name": "meta.preprocessor.diagnostic.harbour",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.harbour"
+        }
+      ]
+    },
+    {
+      "begin": "^\\s*#\\s*(include|require)\\b\\s+",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.include.harbour"
+        }
+      },
+      "end": "(?=(?://|/\\*))|(?<!\\\\)(?=\\n)",
+      "name": "meta.preprocessor.harbour.include",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.harbour"
+        },
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.harbour"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.harbour"
+            }
+          },
+          "name": "string.quoted.double.include.harbour"
+        },
+        {
+          "begin": "<",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.harbour"
+            }
+          },
+          "end": ">",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.harbour"
+            }
+          },
+          "name": "string.quoted.other.lt-gt.include.harbour"
+        }
+      ]
+    },
+    {
+      "begin": "^\\s*#\\s*(define|defined|elif|else|if|ifdef|ifndef|endif|line|pragma|undef|command|xcommand|translate|xtranslate)\\b",
+      "captures": {
+        "1": {
+          "name": "keyword.control.import.harbour"
+        }
+      },
+      "end": "(?=(?://|/\\*))|(?<!\\\\)(?=\\n)",
+      "name": "meta.preprocessor.harbour",
+      "patterns": [
+        {
+          "match": "(?>\\\\\\s*\\n)",
+          "name": "punctuation.separator.continuation.harbour"
+        }
+      ]
+    },
+    {
+      "match": "(:=|->|\\+=|-=)",
+      "name": "keyword.operator.assignment.harbour"
+    },
+    {
+      "match": "(\\<=|>=|==|!=|!|\\<>|\\<|>|\\$|\\s\\.OR\\.\\s|\\s\\.AND\\.\\s|\\s\\.NOT\\.\\s)",
+      "name": "keyword.operator.comparison.harbour"
+    },
+    {
+      "comment": "Standard library macro",
+      "name": "support.function.std.harbour",
+      "match": "\\b(log_write|pp|to_str|RTrim|TRIM|Trim|PadR|Padr|PADR|PadC|PadL)!"
+    },
+    {
+      "comment": "Function call",
+      "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+      "captures": {
+        "1": {
+          "name": "entity.name.function.harbour"
+        }
+      }
+    },
+    {
+      "comment": "Method call",
+      "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*):([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+      "captures": {
+        "1": {
+          "name": "entity.name.method.harbour"
+        }
+      }
+    },
+    {
+      "comment": "Class variable usage",
+      "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*):([a-zA-Z_][a-zA-Z0-9_]*)",
+      "captures": {
+        "1": {
+          "name": "variable.name.object.harbour"
+        },
+        "2": {
+          "name": "variable.name.member.harbour"
+        }
+      }
+    },
+    {
+      "comment": "Function definition",
+      "begin": "\\b(FUNCTION|STATIC FUNCTION|PROCEDURE|STATIC PROCEDURE|INIT PROCEDURE|EXIT PROCEDURE)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "end": "[\\n]",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.fn.harbour"
+        },
+        "2": {
+          "name": "entity.name.function.harbour"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "comment": "CLASS definition",
+      "begin": "\\b((?:CREATE\\s+)?(?:CLASS))\\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\\s+(INHERIT)\\s+([a-zA-Z_][a-zA-Z0-9_]*))?",
+      "end": "[\\n]",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.class.harbour"
+        },
+        "2": {
+          "name": "entity.name.class.harbour"
+        },
+        "3": {
+          "name": "keyword.class.inherit.harbour"
+        },
+        "4": {
+          "name": "entity.name.parent.class.harbour"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "comment": "Method definition",
+      "begin": "\\b(METHOD|STATIC METHOD|METHOD PROCEDURE)\\s+((?:(?:[a-zA-Z_][a-zA-Z0-9_]*):)?(?:[a-zA-Z_][a-zA-Z0-9_]*))",
+      "end": "[\\n]",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.method.fn.harbour"
+        },
+        "2": {
+          "name": "entity.name.method.harbour"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "comment": "Variable declaration",
+      "begin": ":",
+      "end": "[=;,\\)\\|]",
+      "patterns": [
+        {
+          "include": "#type_params"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    }
+  ]
+}

data/grammars/source.haskell.json

@@ -0,0 +1,449 @@
+{
+  "fileTypes": [
+    "hs"
+  ],
+  "keyEquivalent": "^~H",
+  "name": "Haskell",
+  "patterns": [
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.entity.haskell"
+        },
+        "2": {
+          "name": "punctuation.definition.entity.haskell"
+        }
+      },
+      "comment": "In case this regex seems unusual for an infix operator, note that Haskell allows any ordinary function application (elem 4 [1..10]) to be rewritten as an infix expression (4 `elem` [1..10]).",
+      "match": "(`)[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(`)",
+      "name": "keyword.operator.function.infix.haskell"
+    },
+    {
+      "match": "\\(\\)",
+      "name": "constant.language.unit.haskell"
+    },
+    {
+      "match": "\\[\\]",
+      "name": "constant.language.empty-list.haskell"
+    },
+    {
+      "begin": "\\b(module)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "end": "\\b(where)\\b",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "name": "meta.declaration.module.haskell",
+      "patterns": [
+        {
+          "include": "#module_name"
+        },
+        {
+          "include": "#module_exports"
+        },
+        {
+          "match": "[a-z]+",
+          "name": "invalid"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(class)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "end": "\\b(where)\\b",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "name": "meta.declaration.class.haskell",
+      "patterns": [
+        {
+          "match": "\\b(Monad|Functor|Eq|Ord|Read|Show|Num|(Frac|Ra)tional|Enum|Bounded|Real(Frac|Float)?|Integral|Floating)\\b",
+          "name": "support.class.prelude.haskell"
+        },
+        {
+          "match": "[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "entity.other.inherited-class.haskell"
+        },
+        {
+          "match": "\\b[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "variable.other.generic-type.haskell"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(instance)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "end": "\\b(where)\\b|$",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "name": "meta.declaration.instance.haskell",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(import)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "end": "($|;|(?=--))",
+      "name": "meta.import.haskell",
+      "patterns": [
+        {
+          "match": "(qualified|as|hiding)",
+          "name": "keyword.other.haskell"
+        },
+        {
+          "include": "#module_name"
+        },
+        {
+          "include": "#module_exports"
+        }
+      ]
+    },
+    {
+      "begin": "(deriving)\\s*\\(",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.haskell"
+        }
+      },
+      "end": "\\)",
+      "name": "meta.deriving.haskell",
+      "patterns": [
+        {
+          "match": "\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "entity.other.inherited-class.haskell"
+        }
+      ]
+    },
+    {
+      "match": "\\b(deriving|where|data|type|case|of|let|in|newtype|default)\\b",
+      "name": "keyword.other.haskell"
+    },
+    {
+      "match": "\\binfix[lr]?\\b",
+      "name": "keyword.operator.haskell"
+    },
+    {
+      "match": "\\b(do|if|then|else)\\b",
+      "name": "keyword.control.haskell"
+    },
+    {
+      "comment": "Floats are always decimal",
+      "match": "\\b([0-9]+\\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\\b",
+      "name": "constant.numeric.float.haskell"
+    },
+    {
+      "match": "\\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\\b",
+      "name": "constant.numeric.haskell"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.preprocessor.c"
+        }
+      },
+      "comment": "In addition to Haskell's \"native\" syntax, GHC permits the C preprocessor to be run on a source file.",
+      "match": "^\\s*(#)\\s*\\w+",
+      "name": "meta.preprocessor.c"
+    },
+    {
+      "include": "#pragma"
+    },
+    {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.haskell"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.haskell"
+        }
+      },
+      "name": "string.quoted.double.haskell",
+      "patterns": [
+        {
+          "match": "\\\\(NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[abfnrtv\\\\\\\"'\\&])",
+          "name": "constant.character.escape.haskell"
+        },
+        {
+          "match": "\\\\o[0-7]+|\\\\x[0-9A-Fa-f]+|\\\\[0-9]+",
+          "name": "constant.character.escape.octal.haskell"
+        },
+        {
+          "match": "\\^[A-Z@\\[\\]\\\\\\^_]",
+          "name": "constant.character.escape.control.haskell"
+        },
+        {
+          "begin": "\\\\\\s",
+          "beginCaptures": {
+            "0": {
+              "name": "constant.character.escape.begin.haskell"
+            }
+          },
+          "end": "\\\\",
+          "endCaptures": {
+            "0": {
+              "name": "constant.character.escape.end.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "match": "\\S+",
+              "name": "invalid.illegal.character-not-allowed-here.haskell"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.string.begin.haskell"
+        },
+        "2": {
+          "name": "constant.character.escape.haskell"
+        },
+        "3": {
+          "name": "constant.character.escape.octal.haskell"
+        },
+        "4": {
+          "name": "constant.character.escape.hexadecimal.haskell"
+        },
+        "5": {
+          "name": "constant.character.escape.control.haskell"
+        },
+        "6": {
+          "name": "punctuation.definition.string.end.haskell"
+        }
+      },
+      "match": "(?x)\n\t\t\t(')\n\t\t\t(?:\n\t\t\t\t[\\ -\\[\\]-~]\t\t\t\t\t\t\t\t# Basic Char\n\t\t\t  | (\\\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE\n\t\t\t\t\t|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS\n\t\t\t\t\t|US|SP|DEL|[abfnrtv\\\\\\\"'\\&]))\t\t# Escapes\n\t\t\t  | (\\\\o[0-7]+)\t\t\t\t\t\t\t\t# Octal Escapes\n\t\t\t  | (\\\\x[0-9A-Fa-f]+)\t\t\t\t\t\t# Hexadecimal Escapes\n\t\t\t  | (\\^[A-Z@\\[\\]\\\\\\^_])\t\t\t\t\t\t# Control Chars\n\t\t\t)\n\t\t\t(')\n\t\t\t",
+      "name": "string.quoted.single.haskell"
+    },
+    {
+      "begin": "^\\s*(?<fn>(?:[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*|\\((?!--+\\))[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+\\))(?:\\s*,\\s*\\g<fn>)?)\\s*(::)",
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "match": "[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+              "name": "entity.name.function.haskell"
+            },
+            {
+              "include": "#infix_op"
+            }
+          ]
+        },
+        "2": {
+          "name": "keyword.other.double-colon.haskell"
+        }
+      },
+      "end": "$\\n?",
+      "name": "meta.function.type-declaration.haskell",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "match": "\\b(Just|Nothing|Left|Right|True|False|LT|EQ|GT|\\(\\)|\\[\\])\\b",
+      "name": "support.constant.haskell"
+    },
+    {
+      "match": "\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+      "name": "constant.other.haskell"
+    },
+    {
+      "include": "#comments"
+    },
+    {
+      "match": "\\b(abs|acos|acosh|all|and|any|appendFile|applyM|asTypeOf|asin|asinh|atan|atan2|atanh|break|catch|ceiling|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|div|divMod|drop|dropWhile|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromEnum|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|head|id|init|interact|ioError|isDenormalized|isIEEE|isInfinite|isNaN|isNegativeZero|iterate|last|lcm|length|lex|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|odd|or|otherwise|pi|pred|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|read|readFile|readIO|readList|readLn|readParen|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showList|showParen|showString|shows|showsPrec|significand|signum|sin|sinh|snd|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|toEnum|toInteger|toRational|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\\b(?!')",
+      "name": "support.function.prelude.haskell"
+    },
+    {
+      "include": "#infix_op"
+    },
+    {
+      "comment": "In case this regex seems overly general, note that Haskell permits the definition of new operators which can be nearly any string of punctuation characters, such as $%^&*.",
+      "match": "[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+",
+      "name": "keyword.operator.haskell"
+    },
+    {
+      "match": ",",
+      "name": "punctuation.separator.comma.haskell"
+    }
+  ],
+  "repository": {
+    "block_comment": {
+      "applyEndPatternLast": 1,
+      "begin": "\\{-(?!#)",
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.haskell"
+        }
+      },
+      "end": "-\\}",
+      "name": "comment.block.haskell",
+      "patterns": [
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "begin": "(^[ \\t]+)?(?=--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.haskell"
+            }
+          },
+          "comment": "Operators may begin with '--' as long as they are not entirely composed of '-' characters. This means comments can't be immediately followed by an allowable operator character.",
+          "end": "(?!\\G)",
+          "patterns": [
+            {
+              "begin": "--",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.comment.haskell"
+                }
+              },
+              "end": "\\n",
+              "name": "comment.line.double-dash.haskell"
+            }
+          ]
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "infix_op": {
+      "comment": "An operator cannot be composed entirely of '-' characters; instead, it should be matched as a comment.",
+      "match": "(\\((?!--+\\))[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+\\)|\\(,+\\))",
+      "name": "entity.name.function.infix.haskell"
+    },
+    "module_exports": {
+      "begin": "\\(",
+      "end": "\\)",
+      "name": "meta.declaration.exports.haskell",
+      "patterns": [
+        {
+          "match": "\\b[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "entity.name.function.haskell"
+        },
+        {
+          "match": "\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "storage.type.haskell"
+        },
+        {
+          "match": ",",
+          "name": "punctuation.separator.comma.haskell"
+        },
+        {
+          "include": "#infix_op"
+        },
+        {
+          "comment": "So named because I don't know what to call this.",
+          "match": "\\(.*?\\)",
+          "name": "meta.other.unknown.haskell"
+        }
+      ]
+    },
+    "module_name": {
+      "match": "(?<conid>[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(\\.\\g<conid>)?)",
+      "name": "support.other.module.haskell"
+    },
+    "pragma": {
+      "begin": "\\{-#",
+      "end": "#-\\}",
+      "name": "meta.preprocessor.haskell",
+      "patterns": [
+        {
+          "match": "\\b(LANGUAGE|UNPACK|INLINE)\\b",
+          "name": "keyword.other.preprocessor.haskell"
+        }
+      ]
+    },
+    "type_signature": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "entity.other.inherited-class.haskell"
+            },
+            "2": {
+              "name": "variable.other.generic-type.haskell"
+            },
+            "3": {
+              "name": "keyword.other.big-arrow.haskell"
+            }
+          },
+          "match": "\\(\\s*([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\s+([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\)\\s*(=>)",
+          "name": "meta.class-constraint.haskell"
+        },
+        {
+          "include": "#pragma"
+        },
+        {
+          "match": "->",
+          "name": "keyword.other.arrow.haskell"
+        },
+        {
+          "match": "=>",
+          "name": "keyword.other.big-arrow.haskell"
+        },
+        {
+          "match": "\\b(Int(eger)?|Maybe|Either|Bool|Float|Double|Char|String|Ordering|ShowS|ReadS|FilePath|IO(Error)?)\\b",
+          "name": "support.type.prelude.haskell"
+        },
+        {
+          "match": "\\b[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "variable.other.generic-type.haskell"
+        },
+        {
+          "match": "\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "storage.type.haskell"
+        },
+        {
+          "match": "\\(\\)",
+          "name": "support.constant.unit.haskell"
+        },
+        {
+          "include": "#comments"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.haskell",
+  "uuid": "5C034675-1F6D-497E-8073-369D37E2FD7D"
+}