shiki

{ "fileTypes": ["hs", "hs-boot", "hsig"], "keyEquivalent": "^~H", "name": "haskell", "patterns": [ { "include": "#liquid_haskell" }, { "include": "#comment_like" }, { "include": "#numeric_literals" }, { "include": "#string_literal" }, { "include": "#char_literal" }, { "match": "(?<!@|#)-\\}", "name": "invalid" }, { "match": "(\$)\\s*(\$)", "name": "constant.language.unit.haskell", "captures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "punctuation.paren.haskell" } } }, { "match": "(\$)(#)\\s*(#)(\$)", "name": "constant.language.unit.unboxed.haskell", "captures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "keyword.operator.hash.haskell" }, "3": { "name": "keyword.operator.hash.haskell" }, "4": { "name": "punctuation.paren.haskell" } } }, { "match": "(\$)\\s*,[\\s,]*(\$)", "name": "support.constant.tuple.haskell", "captures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "punctuation.paren.haskell" } } }, { "match": "(\$)(#)\\s*,[\\s,]*(#)(\$)", "name": "support.constant.tuple.unboxed.haskell", "captures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "keyword.operator.hash.haskell" }, "3": { "name": "keyword.operator.hash.haskell" }, "4": { "name": "punctuation.paren.haskell" } } }, { "match": "(\\[)\\s*(\\])", "name": "constant.language.empty-list.haskell", "captures": { "1": { "name": "punctuation.bracket.haskell" }, "2": { "name": "punctuation.bracket.haskell" } } }, { "begin": "(\\b(?<!')(module)|^(signature))(\\b(?!'))", "beginCaptures": { "2": { "name": "keyword.other.module.haskell" }, "3": { "name": "keyword.other.signature.haskell" } }, "end": "(?=\\b(?<!')where\\b(?!'))", "name": "meta.declaration.module.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#module_name" }, { "include": "#module_exports" }, { "match": "[a-z]+", "name": "invalid" } ] }, { "include": "#ffi" }, { "begin": "^(\\s*)(class)(\\b(?!'))", "beginCaptures": { "2": { "name": "keyword.other.class.haskell" } }, "end": "(?x) # Detect end of class declaration:\n # 'where' keyword\n (?=(?<!')\\bwhere\\b(?!')) \n # Decreasing indentation\n |(?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )", "name": "meta.declaration.class.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#where" }, { "include": "#type_signature" } ] }, { "begin": "(?x)\n ^(\\s*)(data|newtype)(?:\\s+(instance))?\\s+\n # Keep consuming characters until:\n ((?:(?!\n # the equals symbol or the start of a single-line comment, or\n (?: \n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n (?:=|--+)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n )\n # the \"where\" or \"deriving\" keywords, or\n | (?:\\b(?<!')(?:where|deriving)\\b(?!'))\n # the start of a block comment.\n | {-\n #\n ).)*)\n (?=\\b(?<!'')where\\b(?!''))", "beginCaptures": { "2": { "name": "keyword.other.$2.haskell" }, "3": { "name": "keyword.other.instance.haskell" }, "4": { "patterns": [ { "include": "#type_signature" } ] } }, "name": "meta.declaration.$2.generalized.haskell", "end": "(?x) # Detect end of data declaration:\n # Deriving clause\n (?=(?<!')\\bderiving\\b(?!')) \n # Decreasing indentation\n |(?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "patterns": [ { "include": "#comment_like" }, { "begin": "(?x)\n (?<!')\\b(where)\n \\s*(\\{)(?!-)", "end": "(\\})", "beginCaptures": { "1": { "name": "keyword.other.where.haskell" }, "2": { "name": "punctuation.brace.haskell" } }, "endCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "patterns": [ { "include": "#comment_like" }, { "include": "#gadt_constructor" }, { "match": ";", "name": "punctuation.semicolon.haskell" } ] }, { "match": "\\b(?<!')(where)\\b(?!')", "name": "keyword.other.where.haskell" }, { "include": "#deriving" }, { "include": "#gadt_constructor" } ] }, { "include": "#role_annotation" }, { "name": "meta.declaration.pattern.type.haskell", "begin": "^(\\s*)(pattern)\\s+(.*?)\\s+(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])", "beginCaptures": { "2": { "name": "keyword.other.pattern.haskell" }, "3": { "patterns": [ { "include": "#comma" }, { "include": "#data_constructor" } ] }, "4": { "name": "keyword.operator.double-colon.haskell" } }, "end": "(?x) # Detect end of pattern type definition by decreasing indentation:\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "patterns": [ { "include": "#type_signature" } ] }, { "name": "meta.declaration.pattern.haskell", "begin": "^\\s*(pattern)\\b(?!')", "captures": { "1": { "name": "keyword.other.pattern.haskell" } }, "end": "(?x) # Detect end of pattern type definition by decreasing indentation:\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "patterns": [ { "include": "$self" } ] }, { "begin": "(?x)\n # Data declaration\n ^(\\s*)(data|newtype)(?:\\s+(family|instance))?\\s+\n # Keep consuming characters until:\n (((?!\n # the equals symbol or the start of a single-line comment, or\n (?: \n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n (?:=|--+)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n )\n # the \"where\" or \"deriving\" keywords, or\n | (?:\\b(?<!')(?:where|deriving)\\b(?!'))\n # the start of a block comment.\n | {-\n #\n ).)*)", "beginCaptures": { "2": { "name": "keyword.other.$2.haskell" }, "3": { "name": "keyword.other.$3.haskell" }, "4": { "patterns": [ { "include": "#type_signature" } ] } }, "name": "meta.declaration.$2.algebraic.haskell", "end": "(?x) # Detect end of data declaration: \n # Decreasing indentation\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )", "patterns": [ { "include": "#comment_like" }, { "include": "#deriving" }, { "include": "#forall" }, { "include": "#adt_constructor" }, { "include": "#context" }, { "include": "#record_decl" }, { "include": "#type_signature" } ] }, { "name": "meta.declaration.type.family.haskell", "begin": "(?x)\n # Type family\n ^(\\s*)(type)\\s+(family)\\b(?!')\n # Keep consuming characters until:\n (((?!\n # the equals symbol or the start of a single-line comment, or\n (?: \n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n (?:=|--+)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n )\n # the \"where\" keyword, or\n | \\b(?<!')where\\b(?!')\n # the start of a block comment.\n | {-\n #\n ).)*)", "beginCaptures": { "2": { "name": "keyword.other.type.haskell" }, "3": { "name": "keyword.other.family.haskell" }, "4": { "patterns": [ { "include": "#comment_like" }, { "include": "#where" }, { "include": "#type_signature" } ] } }, "end": "(?x) # Detect end of type family by decreasing indentation:\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "patterns": [ { "include": "#comment_like" }, { "include": "#where" }, { "include": "#type_signature" } ] }, { "name": "meta.declaration.type.haskell", "begin": "(?x)\n # Type declaration\n ^(\\s*)(type)(?:\\s+(instance))?\\s+\n # Keep consuming characters until:\n (((?!\n # the equals symbol, the start of a single-line comment, or a type signature\n (?: \n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n (?:=|--+|::|∷)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n )\n # the start of a block comment.\n | {-\n #\n ).)*)", "beginCaptures": { "2": { "name": "keyword.other.type.haskell" }, "3": { "name": "keyword.other.instance.haskell" }, "4": { "patterns": [ { "include": "#type_signature" } ] } }, "end": "(?x) # Detect end of type definition by decreasing indentation:\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "patterns": [ { "include": "#type_signature" } ] }, { "begin": "^(\\s*)(instance)(\\b(?!'))", "beginCaptures": { "2": { "name": "keyword.other.instance.haskell" } }, "end": "(?x) # Detect end of instance declaration:\n # 'where' keyword\n (?=\\b(?<!')(where)\\b(?!'))\n # Decreasing indentation\n |(?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "name": "meta.declaration.instance.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#where" }, { "include": "#type_signature" } ] }, { "begin": "^(\\s*)(import)(\\b(?!'))", "beginCaptures": { "2": { "name": "keyword.other.import.haskell" } }, "end": "(?x) # Detect end of import\n # 'where' keyword\n (?=\\b(?<!')(where)\\b(?!'))\n # Decreasing indentation\n |(?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n", "name": "meta.import.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#where" }, { "match": "(qualified|as|hiding)", "captures": { "1": { "name": "keyword.other.$1.haskell" } } }, { "include": "#module_name" }, { "include": "#module_exports" } ] }, { "include": "#deriving" }, { "include": "#layout_herald" }, { "include": "#keyword" }, { "match": "^\\s*(infix[lr]?)\\s+(.*)", "captures": { "1": { "name": "keyword.other.$1.haskell" }, "2": { "patterns": [ { "include": "#comment_like" }, { "include": "#integer_literals" }, { "include": "#infix_op" } ] } }, "name": "meta.fixity-declaration.haskell" }, { "include": "#overloaded_label" }, { "include": "#type_application" }, { "include": "#reserved_symbol" }, { "include": "#fun_decl" }, { "include": "#qualifier" }, { "include": "#data_constructor" }, { "include": "#start_type_signature" }, { "include": "#prefix_op" }, { "include": "#infix_op" }, { "begin": "(\$)(#)\\s", "end": "(#)(\$)", "beginCaptures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "keyword.operator.hash.haskell" } }, "endCaptures": { "1": { "name": "keyword.operator.hash.haskell" }, "2": { "name": "punctuation.paren.haskell" } }, "patterns": [ { "include": "#comma" }, { "include": "$self" } ] }, { "begin": "(\$)", "end": "(\$)", "beginCaptures": { "1": { "name": "punctuation.paren.haskell" } }, "endCaptures": { "1": { "name": "punctuation.paren.haskell" } }, "patterns": [ { "include": "#comma" }, { "include": "$self" } ] }, { "include": "#quasi_quote" }, { "begin": "(\\[)", "end": "(\\])", "beginCaptures": { "1": { "name": "punctuation.bracket.haskell" } }, "endCaptures": { "1": { "name": "punctuation.bracket.haskell" } }, "patterns": [ { "include": "#comma" }, { "include": "$self" } ] }, { "include": "#record" } ], "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": "^(\\s*)(--\\s[\\|\\$])", "beginCaptures": { "2": { "name": "punctuation.whitespace.comment.leading.haskell" } }, "end": "(?=^(?!\\1--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])))", "name": "comment.block.documentation.haskell" }, { "begin": "(^[ \\t]+)?(--\\s[\\^\\*])", "beginCaptures": { "1": { "name": "punctuation.whitespace.comment.leading.haskell" } }, "end": "\\n", "name": "comment.line.documentation.haskell" }, { "applyEndPatternLast": 1, "begin": "\\{-\\s?[\\|\\$\\*\\^]", "captures": { "0": { "name": "punctuation.definition.comment.haskell" } }, "end": "-\\}", "name": "comment.block.documentation.haskell", "patterns": [ { "include": "#block_comment" } ] }, { "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" } ] }, "comment_like": { "patterns": [ { "include": "#cpp" }, { "include": "#pragma" }, { "include": "#comments" } ] }, "cpp": { "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": "^(#).*$", "name": "meta.preprocessor.c" }, "where": { "patterns": [ { "begin": "(?x)\n (?<!')\\b(where)\n \\s*(\\{)(?!-)", "end": "(\\})", "beginCaptures": { "1": { "name": "keyword.other.where.haskell" }, "2": { "name": "punctuation.brace.haskell" } }, "endCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "patterns": [ { "include": "$self" }, { "match": ";", "name": "punctuation.semicolon.haskell" } ] }, { "match": "\\b(?<!')(where)\\b(?!')", "name": "keyword.other.where.haskell" } ] }, "layout_herald": { "begin": "(?x)\n (?<!')\\b(?:(where|let|m?do)|(of))\n \\s*(\\{)(?!-)", "end": "(\\})", "beginCaptures": { "1": { "name": "keyword.other.$1.haskell" }, "2": { "name": "keyword.control.of.haskell" }, "3": { "name": "punctuation.brace.haskell" } }, "endCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "patterns": [ { "include": "$self" }, { "match": ";", "name": "punctuation.semicolon.haskell" } ] }, "keyword": { "match": "\\b(?<!')(?:(where|let|in|default)|(m?do|if|then|else|case|of|proc|rec))\\b(?!')", "captures": { "1": { "name": "keyword.other.$1.haskell" }, "2": { "name": "keyword.control.$2.haskell" } } }, "deriving": { "patterns": [ { "begin": "^(\\s*)(deriving)\\s+(?:(via|stock|newtype|anyclass)\\s+)?", "beginCaptures": { "2": { "name": "keyword.other.deriving.haskell" }, "3": { "name": "keyword.other.deriving.strategy.$3.haskell" } }, "end": "(?x) # Detect end of deriving statement\n # Decreasing indentation\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )", "patterns": [ { "include": "#comment_like" }, { "match": "(?<!')\\b(instance)\\b(?!')", "name": "keyword.other.instance.haskell" }, { "match": "(?<!')\\b(via|stock|newtype|anyclass)\\b(?!')", "captures": { "1": { "name": "keyword.other.deriving.strategy.$1.haskell" } } }, { "include": "#type_signature" } ], "name": "meta.deriving.haskell" }, { "begin": "(deriving)(?:\\s+(stock|newtype|anyclass))?\\s*(\$)", "beginCaptures": { "1": { "name": "keyword.other.deriving.haskell" }, "2": { "name": "keyword.other.deriving.strategy.$2.haskell" }, "3": { "name": "punctuation.paren.haskell" } }, "end": "(\$)", "endCaptures": { "1": { "name": "punctuation.paren.haskell" } }, "name": "meta.deriving.haskell", "patterns": [ { "include": "#type_signature" } ] }, { "match": "(?x)\n (deriving)(?:\\s+(stock|newtype|anyclass))?\\s+\n ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n (\\s+(via)\\s+(.*)$)?\n", "captures": { "1": { "name": "keyword.other.deriving.haskell" }, "2": { "name": "keyword.other.deriving.strategy.$2.haskell" }, "3": { "patterns": [ { "include": "#type_signature" } ] }, "5": { "name": "keyword.other.deriving.strategy.via.haskell" }, "6": { "patterns": [ { "include": "#type_signature" } ] } }, "name": "meta.deriving.haskell" }, { "match": "(?<!')\\b(via)\\b(?!')", "name": "keyword.other.deriving.strategy.via.haskell" } ] }, "prefix_op": { "patterns": [ { "comment": "An operator cannot be composed entirely of '-' characters; instead, it should be matched as a comment.\n", "match": "(?x)\n (\$)\\s*(?!(?:--+|\\.\\.)\$)(\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))\\s*(\\))", "captures": { "1": { "name": "punctuation.paren.haskell" }, "2": { "name": "entity.name.function.infix.haskell" }, "3": { "name": "punctuation.paren.haskell" } } } ] }, "infix_op": { "patterns": [ { "match": "(?x)\n ((?:(?<!'')('')?[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*\\.)*)\n (\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))", "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 $%^&*.\n", "captures": { "1": { "name": "keyword.operator.promotion.haskell" }, "2": { "name": "entity.name.namespace.haskell" }, "3": { "name": "keyword.operator.infix.haskell" } } }, { "match": "(`)((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*\\.)*)([\\p{Ll}\\p{Lu}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*)(`)", "captures": { "1": { "name": "punctuation.backtick.haskell" }, "2": { "name": "entity.name.namespace.haskell" }, "3": { "patterns": [ { "include": "#data_constructor" } ] }, "4": { "name": "punctuation.backtick.haskell" } }, "comment": "In case this regex seems unusual for an infix operator, note that Haskell\nallows any ordinary function application (elem 4 [1..10]) to be rewritten\nas an infix expression (4 `elem` [1..10]).\n", "name": "keyword.operator.function.infix.haskell" } ] }, "module_exports": { "begin": "\$", "beginCaptures": { "0": { "name": "punctuation.paren.haskell" } }, "end": "\$", "endCaptures": { "0": { "name": "punctuation.paren.haskell" } }, "applyEndPatternLast": 1, "name": "meta.declaration.exports.haskell", "patterns": [ { "include": "#comment_like" }, { "match": "\\b(?<!')(module)\\b(?!')", "captures": { "1": { "name": "keyword.other.module.haskell" } } }, { "include": "#comma" }, { "include": "#export_constructs" }, { "begin": "\$", "beginCaptures": { "0": { "name": "punctuation.paren.haskell" } }, "end": "\$", "endCaptures": { "0": { "name": "punctuation.paren.haskell" } }, "patterns": [ { "include": "#comment_like" }, { "include": "#record_wildcard" }, { "include": "#export_constructs" }, { "include": "#comma" } ] } ] }, "export_constructs": { "patterns": [ { "include": "#comment_like" }, { "begin": "\\b(?<!')(pattern)\\b(?!')", "beginCaptures": { "1": { "name": "keyword.other.pattern.haskell" } }, "end": "(?x)\n # Data constructor\n ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n # Prefix form of symbolic constructor\n | (\$)\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\$)", "endCaptures": { "1": { "name": "constant.other.haskell" }, "2": { "name": "punctuation.paren.haskell" }, "3": { "name": "constant.other.operator.haskell" }, "4": { "name": "punctuation.paren.haskell" } }, "patterns": [ { "include": "#comment_like" } ] }, { "begin": "\\b(?<!')(type)\\b(?!')", "beginCaptures": { "1": { "name": "keyword.other.type.haskell" } }, "end": "(?x)\n # Type name\n ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n # Prefix form of type operator\n | (\$)\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\$)", "endCaptures": { "1": { "name": "storage.type.haskell" }, "2": { "name": "punctuation.paren.haskell" }, "3": { "name": "storage.type.operator.haskell" }, "4": { "name": "punctuation.paren.haskell" } }, "patterns": [ { "include": "#comment_like" } ] }, { "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" }, { "include": "#record_wildcard" }, { "include": "#reserved_symbol" }, { "include": "#prefix_op" } ] }, "comma": { "match": ",", "name": "punctuation.separator.comma.haskell" }, "module_name": { "match": "(?<conid>[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(\\.\\g<conid>)?)", "name": "entity.name.namespace.haskell" }, "pragma": { "begin": "\\{-#", "end": "#-\\}", "name": "meta.preprocessor.haskell", "patterns": [ { "begin": "(?xi) \\b(?<!')(LANGUAGE)\\b(?!')", "end": "(?=#-\\})", "beginCaptures": { "1": { "name": "keyword.other.preprocessor.pragma.haskell" } }, "patterns": [ { "match": "(?x)\n (?:No)?\n (?:AutoDeriveTypeable|DatatypeContexts|DoRec|IncoherentInstances|MonadFailDesugaring|MonoPatBinds|NullaryTypeClasses|OverlappingInstances|PatternSignatures|RecordPuns|RelaxedPolyRec)", "name": "invalid.deprecated" }, { "match": "(?x)\n (\n (?:No)?\n (?:AllowAmbiguousTypes|AlternativeLayoutRule|AlternativeLayoutRuleTransitional|Arrows|BangPatterns|BinaryLiterals|CApiFFI|CPP|CUSKs|ConstrainedClassMethods|ConstraintKinds|DataKinds|DefaultSignatures|DeriveAnyClass|DeriveDataTypeable|DeriveFoldable|DeriveFunctor|DeriveGeneric|DeriveLift|DeriveTraversable|DerivingStrategies|DerivingVia|DisambiguateRecordFields|DoAndIfThenElse|BlockArguments|DuplicateRecordFields|EmptyCase|EmptyDataDecls|EmptyDataDeriving|ExistentialQuantification|ExplicitForAll|ExplicitNamespaces|ExtendedDefaultRules|FlexibleContexts|FlexibleInstances|ForeignFunctionInterface|FunctionalDependencies|GADTSyntax|GADTs|GHCForeignImportPrim|Generali(?:s|z)edNewtypeDeriving|ImplicitParams|ImplicitPrelude|ImportQualifiedPost|ImpredicativeTypes|TypeFamilyDependencies|InstanceSigs|ApplicativeDo|InterruptibleFFI|JavaScriptFFI|KindSignatures|LambdaCase|LiberalTypeSynonyms|MagicHash|MonadComprehensions|MonoLocalBinds|MonomorphismRestriction|MultiParamTypeClasses|MultiWayIf|NumericUnderscores|NPlusKPatterns|NamedFieldPuns|NamedWildCards|NegativeLiterals|HexFloatLiterals|NondecreasingIndentation|NumDecimals|OverloadedLabels|OverloadedLists|OverloadedStrings|PackageImports|ParallelArrays|ParallelListComp|PartialTypeSignatures|PatternGuards|PatternSynonyms|PolyKinds|PolymorphicComponents|QuantifiedConstraints|PostfixOperators|QuasiQuotes|Rank2Types|RankNTypes|RebindableSyntax|RecordWildCards|RecursiveDo|RelaxedLayout|RoleAnnotations|ScopedTypeVariables|StandaloneDeriving|StarIsType|StaticPointers|Strict|StrictData|TemplateHaskell|TemplateHaskellQuotes|StandaloneKindSignatures|TraditionalRecordSyntax|TransformListComp|TupleSections|TypeApplications|TypeInType|TypeFamilies|TypeOperators|TypeSynonymInstances|UnboxedTuples|UnboxedSums|UndecidableInstances|UndecidableSuperClasses|UnicodeSyntax|UnliftedFFITypes|UnliftedNewtypes|ViewPatterns)\n )", "captures": { "1": { "name": "keyword.other.preprocessor.extension.haskell" } } }, { "include": "#comma" } ] }, { "begin": "(?xi)\n \\b(?<!')(SPECIALI(?:S|Z)E)\n (?:\n \\s*( \\[ [^\\[\\]]* \\])?\\s*\n |\\s+\n )\n (instance)\\b(?!')", "end": "(?=#-\\})", "beginCaptures": { "1": { "name": "keyword.other.preprocessor.pragma.haskell" }, "2": { "patterns": [ { "include": "#inline_phase" } ] }, "3": { "name": "keyword.other.instance.haskell" } }, "patterns": [ { "include": "#type_signature" } ] }, { "begin": "(?xi)\n \\b(?<!')(SPECIALI(?:S|Z)E)\\b(?!')\n (?:\\s+(INLINE)\\b(?!'))?\n (?:\\s*(\\[ [^\\[\\]]* \\])?)\n \\s*", "end": "(?=#-\\})", "beginCaptures": { "1": { "name": "keyword.other.preprocessor.pragma.haskell" }, "2": { "name": "keyword.other.preprocessor.pragma.haskell" }, "3": { "patterns": [ { "include": "#inline_phase" } ] } }, "patterns": [ { "include": "$self" } ] }, { "match": "(?xi) \\b(?<!')\n (LANGUAGE|OPTIONS_GHC|INCLUDE\n |MINIMAL|UNPACK|OVERLAPS|INCOHERENT\n |NOUNPACK|SOURCE|OVERLAPPING|OVERLAPPABLE|INLINE\n |NOINLINE|INLINE?ABLE|CONLIKE|LINE|COLUMN|RULES\n |COMPLETE)\\b(?!')", "name": "keyword.other.preprocessor.haskell" }, { "begin": "(?i)\\b(DEPRECATED|WARNING)\\b", "beginCaptures": { "1": { "name": "keyword.other.preprocessor.pragma.haskell" } }, "end": "(?=#-\\})", "patterns": [ { "include": "#string_literal" } ] } ] }, "liquid_haskell": { "name": "block.liquidhaskell.haskell", "begin": "\\{-@", "end": "@-\\}", "patterns": [ { "include": "$self" } ] }, "context": { "match": "(?x)\n (.*)\n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n (=>|⇒)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n", "captures": { "1": { "patterns": [ { "include": "#comment_like" }, { "include": "#type_signature" } ] }, "2": { "name": "keyword.operator.big-arrow.haskell" } } }, "data_constructor": { "match": "\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?![\\.'\\w])", "name": "constant.other.haskell" }, "qualifier": { "match": "\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.", "name": "entity.name.namespace.haskell" }, "record_decl": { "begin": "({)(?!-)", "beginCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "end": "(?<!-)(})", "endCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "name": "meta.record.definition.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#record_decl_field" } ] }, "record": { "begin": "({)(?!-)", "beginCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "end": "(?<!-)(})", "endCaptures": { "1": { "name": "punctuation.brace.haskell" } }, "name": "meta.record.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#record_field" } ] }, "record_decl_field": { "begin": "(?x)\n (?:([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n |(\$)\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\$)\n )\n", "end": "(,)|(?=})", "beginCaptures": { "1": { "name": "variable.other.member.definition.haskell" }, "2": { "name": "punctuation.paren.haskell" }, "3": { "name": "variable.other.member.definition.haskell" }, "4": { "name": "punctuation.paren.haskell" } }, "endCaptures": { "1": { "name": "punctuation.comma.haskell" } }, "patterns": [ { "include": "#comment_like" }, { "include": "#comma" }, { "include": "#double_colon" }, { "include": "#type_signature" }, { "include": "#record_decl_field" } ] }, "record_wildcard": { "match": "(?x)\n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n (\\.\\.)\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])", "captures": { "1": { "name": "variable.other.member.wildcard.haskell" } } }, "record_field": { "patterns": [ { "begin": "(?x)\n (?:([\\p{Ll}\\p{Lu}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\.']*)\n |(\$)\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\$)\n )\n", "end": "(,)|(?=})", "beginCaptures": { "1": { "name": "variable.other.member.haskell", "patterns": [ { "include": "#qualifier" } ] }, "2": { "name": "punctuation.paren.haskell" }, "3": { "name": "variable.other.member.haskell" }, "4": { "name": "punctuation.paren.haskell" } }, "endCaptures": { "1": { "name": "punctuation.comma.haskell" } }, "patterns": [ { "include": "#comment_like" }, { "include": "#comma" }, { "include": "$self" } ] }, { "include": "#record_wildcard" } ] }, "role_annotation": { "patterns": [ { "begin": "^(\\s*)(type)\\s+(role)\\b(?!')", "beginCaptures": { "2": { "name": "keyword.other.type.haskell" }, "3": { "name": "keyword.other.role.haskell" } }, "end": "(?x) # Detect end of block by decreasing indentation:\n (?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )", "name": "meta.role-annotation.haskell", "patterns": [ { "include": "#comment_like" }, { "include": "#type_constructor" }, { "match": "\\b(?<!')(nominal|representational|phantom)\\b(?!')", "captures": { "1": { "name": "keyword.other.role.$1.haskell" } } } ] } ] }, "fun_decl": { "begin": "(?x)^(\\s*)\n (?<fn>\n (?:\n [\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\#*\n | \$\\s*\n (?!--+\$)\n [\\p{S}\\p{P}&&[^(),:;\\[\\]`{}_\"']]\n [\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*\n \\s*\\)\n )\n (?:\\s*,\\s*\\g<fn>)?\n )\n \\s*(?<![\\p{S}\\p{P}&&[^\\),;\\]`}_\"']])(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])\n", "beginCaptures": { "2": { "name": "entity.name.function.haskell", "patterns": [ { "include": "#reserved_symbol" }, { "include": "#prefix_op" } ] }, "3": { "name": "keyword.operator.double-colon.haskell" } }, "name": "meta.function.type-declaration.haskell", "patterns": [ { "include": "#type_signature" } ], "end": "(?x)\n # End of type annotation:\n # To the left of a reserved symbolic keyword such as = or <-\n (?= \n # non-symbolic character\n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n # symbolic keyword except (->)\n ((<-|←)|(=)|(-<|↢)|(-<<|⤛))\n # non-symbolic character\n ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n )\n # Decreasing indentation:\n |(?=\\}|;) # Explicit indentation\n |^(?! # Implicit indentation: end match on newline *unless* the new line is either:\n \\1\\s+\\S # - more indented, or\n | \\s* # - starts with whitespace, followed by:\n (?: $ # - the end of the line (i.e. empty line), or\n |\\{-[^@] # - the start of a block comment, or\n |--+ # - the start of a single-line comment.\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n # The double dash may not be followed by other operator characters\n # (then it would be an operator, not a comment)\n )\n" }, "adt_constructor": { "patterns": [ { "include": "#comment_like" }, { "begin": "(?x)\n (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n (?:(=)|(\\|))\n (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol", "beginCaptures": { "1": { "name": "keyword.operator.eq.haskell" }, "2": { "name": "keyword.operator.pipe.haskell" } }, "end": "(?x)\n (?:\\G|^)\\s* # Enforce starting condition to avoid catastrophic backtracking (https://github.com/JustusAdam/language-haskell/issues/161)\n (?: # Infix data constructor\n # First argument\n (?:\n # Simple type\n (?<!')\\b((?:[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\.])+)\n # Type inside balanced parentheses\n | ('? # Optional promotion tick\n (?<paren>\n \$ # Opening parenthesis\n (?:\n [^\\(\$]* # Match non-parentheses\n | \\g<paren> # or recurse into further depth\n )*\n \\) # Closing parenthesis\n )\n )\n # Type inside balanced brackets\n | ('? # Optional promotion tick\n (?<brac>\n \$ # Opening bracket\n (?:\n [^\\[\\]]* # Match non-brackets\n | \\g<brac> # or recurse into further depth\n )*\n \\] # Closing bracket\n )\n )\n ) \n # Then either\n \\s*\n # - a symbolic infix constructor, or\n (?:(?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\n # - an alphabetic infix constructor\n | (`)([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)(`)\n )\n\n ) # Otherwise, prefix data constructor, either:\n | # - an alphabetic data constructor e.g. \"Cons_123\"\n (?:(?<!')\\b([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*))\n | # - a symbolic (prefix) data constructor\n (\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\$)", "endCaptures": { "1": { "patterns": [ { "include": "#type_signature" } ] }, "2": { "patterns": [ { "include": "#type_signature" } ] }, "4": { "patterns": [ { "include": "#type_signature" } ] }, "6": { "name": "constant.other.operator.haskell" }, "7": { "name": "punctuation.backtick.haskell" }, "8": { "name": "constant.other.haskell" }, "9": { "name": "punctuation.backtick.haskell" }, "10": {