haskell.json

{
  "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": {
              "name": "constant.other.haskell"
            },
            "11": {
              "name": "punctuation.paren.haskell"
            },
            "12": {
              "name": "constant.other.operator.haskell"
            },
            "13": {
              "name": "punctuation.paren.haskell"
            }
          },
          "patterns": [
            {
              "include": "#comment_like"
            },
            {
              "include": "#deriving"
            },
            {
              "include": "#record_decl"
            },
            {
              "include": "#forall"
            },
            {
              "include": "#context"
            }
          ]
        }
      ]
    },
    "gadt_constructor": {
      "patterns": [
        {
          "begin": "(?x)\n   ^(\\s*)\n      (?:\n        (\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n      |(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))\n      )",
          "beginCaptures": {
            "2": {
              "name": "constant.other.haskell"
            },
            "3": {
              "name": "punctuation.paren.haskell"
            },
            "4": {
              "name": "constant.other.operator.haskell"
            },
            "5": {
              "name": "punctuation.paren.haskell"
            }
          },
          "end": "(?x)\n  # GADT constructor ends\n  (?=\\b(?<!'')deriving\\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"
            },
            {
              "include": "#deriving"
            },
            {
              "include": "#double_colon"
            },
            {
              "include": "#record_decl"
            },
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "begin": "(?x)\n  (\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}]*) # named constructor\n |(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))    # prefix operator",
          "beginCaptures": {
            "1": {
              "name": "constant.other.haskell"
            },
            "2": {
              "name": "punctuation.paren.haskell"
            },
            "3": {
              "name": "constant.other.operator.haskell"
            },
            "4": {
              "name": "punctuation.paren.haskell"
            }
          },
          "end": "$",
          "patterns": [
            {
              "include": "#comment_like"
            },
            {
              "include": "#deriving"
            },
            {
              "include": "#double_colon"
            },
            {
              "include": "#record_decl"
            },
            {
              "include": "#type_signature"
            }
          ]
        }
      ]
    },
    "type_application": {
      "patterns": [
        {
          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(')?(\\()",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.prefix.at.haskell"
            },
            "2": {
              "name": "keyword.operator.promotion.haskell"
            },
            "3": {
              "name": "punctuation.paren.haskell"
            }
          },
          "end": "\\)",
          "endCaptures": {
            "0": {
              "name": "punctuation.paren.haskell"
            }
          },
          "name": "meta.type-application.haskell",
          "patterns": [
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(')?(\\[)",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.prefix.at.haskell"
            },
            "2": {
              "name": "keyword.operator.promotion.haskell"
            },
            "3": {
              "name": "punctuation.bracket.haskell"
            }
          },
          "end": "\\]",
          "name": "meta.type-application.haskell",
          "endCaptures": {
            "0": {
              "name": "punctuation.bracket.haskell"
            }
          },
          "patterns": [
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(?=\\\")",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.prefix.at.haskell"
            }
          },
          "end": "(?<=\\\")",
          "name": "meta.type-application.haskell",
          "patterns": [
            {
              "include": "#string_literal"
            }
          ]
        },
        {
          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.prefix.at.haskell"
            }
          },
          "end": "(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])",
          "name": "meta.type-application.haskell",
          "patterns": [
            {
              "include": "#type_signature"
            }
          ]
        }
      ]
    },
    "type_signature": {
      "patterns": [
        {
          "include": "#comment_like"
        },
        {
          "match": "(')?(\\()\\s*(\\))",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.paren.haskell"
            },
            "3": {
              "name": "punctuation.paren.haskell"
            }
          },
          "name": "support.constant.unit.haskell"
        },
        {
          "match": "(\\()(#)\\s*(#)(\\))",
          "name": "support.constant.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,]*(\\))",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.paren.haskell"
            },
            "3": {
              "name": "punctuation.paren.haskell"
            }
          },
          "name": "support.constant.tuple.haskell"
        },
        {
          "match": "(\\()(#)\\s*(#)(\\))",
          "name": "support.constant.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,]*(#)(\\))",
          "captures": {
            "1": {
              "name": "punctuation.paren.haskell"
            },
            "2": {
              "name": "keyword.operator.hash.haskell"
            },
            "3": {
              "name": "keyword.operator.hash.haskell"
            },
            "4": {
              "name": "punctuation.paren.haskell"
            }
          },
          "name": "support.constant.tuple.unboxed.haskell"
        },
        {
          "match": "(')?(\\[)\\s*(\\])",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.bracket.haskell"
            },
            "3": {
              "name": "punctuation.bracket.haskell"
            }
          },
          "name": "support.constant.empty-list.haskell"
        },
        {
          "include": "#integer_literals"
        },
        {
          "match": "(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])",
          "name": "keyword.operator.double-colon.haskell"
        },
        {
          "include": "#forall"
        },
        {
          "match": "=>|⇒",
          "name": "keyword.operator.big-arrow.haskell"
        },
        {
          "include": "#string_literal"
        },
        {
          "match": "'[^']'",
          "name": "invalid"
        },
        {
          "include": "#type_application"
        },
        {
          "include": "#reserved_symbol"
        },
        {
          "include": "#type_operator"
        },
        {
          "include": "#type_constructor"
        },
        {
          "begin": "(\\()(#)",
          "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": "#type_signature"
            }
          ]
        },
        {
          "begin": "(')?(\\()",
          "end": "(\\))",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.paren.haskell"
            }
          },
          "endCaptures": {
            "1": {
              "name": "punctuation.paren.haskell"
            }
          },
          "patterns": [
            {
              "include": "#comma"
            },
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "begin": "(')?(\\[)",
          "end": "(\\])",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.bracket.haskell"
            }
          },
          "endCaptures": {
            "1": {
              "name": "punctuation.bracket.haskell"
            }
          },
          "patterns": [
            {
              "include": "#comma"
            },
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "include": "#type_variable"
        }
      ]
    },
    "double_colon": {
      "match": "\\s*(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\\s*",
      "captures": {
        "1": {
          "name": "keyword.operator.double-colon.haskell"
        }
      }
    },
    "start_type_signature": {
      "patterns": [
        {
          "begin": "^(\\s*)(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])\\s*",
          "beginCaptures": {
            "2": {
              "name": "keyword.operator.double-colon.haskell"
            }
          },
          "end": "(?x)\n  # End type annotation when seeing one of:\n  (?=\n    \\#?\\)                             # closing parenthesis\n    |\\]                               # closing bracket\n    |,                                # comma\n    |(?<!')\\b(in|then|else|of)\\b(?!') # keyword\n    |                                 # symbolic keyword except (->)\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      (?:\n         (\\\\|λ)\n        |(<-|←)\n        |(=)\n        |(-<|↢)\n        |(-<<|⤛)\n      )\n      ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n    |(\\#|@)-\\}                             # End of annotation block (LiquidHaskell or pragma)\n    # Decreasing indentation:\n    | (?=\\}|;)     # Explicit indentation\n    |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n        \\1\\s*\\S    # - equally 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.type-declaration.haskell"
        },
        {
          "begin": "(?<![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.double-colon.haskell"
            }
          },
          "end": "(?x)\n  # End type annotation when seeing one of:\n  (?=\n    \\#?\\)                             # closing parenthesis\n    |\\]                               # closing bracket\n    |,                                # comma\n    |\\b(?<!')(in|then|else|of)\\b(?!') # keyword\n    |(\\#|@)-\\}                        # End of annotation block (LiquidHaskell or pragma)\n    |                                 # symbolic keyword except (->)\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      (?:\n         (\\\\|λ)\n        |(<-|←)\n        |(=)\n        |(-<|↢)\n        |(-<<|⤛)\n      )\n      ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n    # Indentation \n    |(?=\\}|;)      # Explicit indentation\n    |$             # End of line\n  )",
          "patterns": [
            {
              "include": "#type_signature"
            }
          ]
        }
      ]
    },
    "type_variable": {
      "match": "\\b(?<!')(?!(?:forall|deriving)\\b(?!'))[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
      "name": "variable.other.generic-type.haskell"
    },
    "type_constructor": {
      "patterns": [
        {
          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Optional qualified name\n    ((?:\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    (\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "entity.name.namespace.haskell"
            },
            "3": {
              "name": "storage.type.haskell"
            }
          }
        },
        {
          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Opening parenthesis\n    (\\()\\s*\n  # Optional qualified name\n    ((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type operator proper\n    ([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\n  # Closing parenthesis\n    \\s*(\\))",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.paren.haskell"
            },
            "3": {
              "name": "entity.name.namespace.haskell"
            },
            "4": {
              "name": "storage.type.operator.haskell"
            },
            "5": {
              "name": "punctuation.paren.haskell"
            }
          }
        }
      ]
    },
    "overloaded_label": {
      "patterns": [
        {
          "match": "(?x) \n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^(,;\\[`{]]) # Disallow closing characters\n  (\\#)\n    (?:\n    # String\n    (\"(?:\\\\\"|[^\"])*\")\n    # Sequence of allowed label identifiers\n    |[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\.]+\n    )",
          "captures": {
            "1": {
              "name": "keyword.operator.prefix.hash.haskell"
            },
            "2": {
              "patterns": [
                {
                  "include": "#string_literal"
                }
              ]
            }
          },
          "name": "entity.name.label.haskell"
        }
      ]
    },
    "reserved_symbol": {
      "patterns": [
        {
          "match": "(?x)\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])\n  (?:\n     (\\.\\.)\n    |(:)\n    |(=)\n    |(\\\\)     # λ not reserved as it is a letter\n    |(\\|)\n    |(<-|←)\n    |(->|→)\n    |(-<|↢)\n    |(-<<|⤛)\n    |(>-|⤚)\n    |(>>-|⤜)\n    |(∀)\n  )\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])",
          "captures": {
            "1": {
              "name": "keyword.operator.double-dot.haskell"
            },
            "2": {
              "name": "keyword.operator.colon.haskell"
            },
            "3": {
              "name": "keyword.operator.eq.haskell"
            },
            "4": {
              "name": "keyword.operator.lambda.haskell"
            },
            "5": {
              "name": "keyword.operator.pipe.haskell"
            },
            "6": {
              "name": "keyword.operator.arrow.left.haskell"
            },
            "7": {
              "name": "keyword.operator.arrow.haskell"
            },
            "8": {
              "name": "keyword.operator.arrow.left.tail.haskell"
            },
            "9": {
              "name": "keyword.operator.arrow.left.tail.double.haskell"
            },
            "10": {
              "name": "keyword.operator.arrow.tail.haskell"
            },
            "11": {
              "name": "keyword.operator.arrow.tail.double.haskell"
            },
            "12": {
              "name": "keyword.other.forall.haskell"
            }
          }
        },
        {
          "match": "(?x)\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^\\#,;\\[`{]]) # Require closing characters\n  (\\#+)\n  (?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^),;\\]`}]])   # Disallow opening character",
          "captures": {
            "1": {
              "name": "keyword.operator.postfix.hash.haskell"
            }
          }
        },
        {
          "match": "(?x)\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\)\\}\\]]) # Require closing characters\n  (@)\n  (?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\(\\[\\{]) # Require opening character",
          "captures": {
            "1": {
              "name": "keyword.operator.infix.tight.at.haskell"
            }
          }
        },
        {
          "match": "(?x)\n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^(,;\\[`{]])  # Disallow closing characters\n  (?:(~)|(!)|(-)|(\\$)|(\\$\\$))\n  (?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\(\\{\\[]) # Require opening character (non operator symbol)",
          "captures": {
            "1": {
              "name": "keyword.operator.prefix.tilde.haskell"
            },
            "2": {
              "name": "keyword.operator.prefix.bang.haskell"
            },
            "3": {
              "name": "keyword.operator.prefix.minus.haskell"
            },
            "4": {
              "name": "keyword.operator.prefix.dollar.haskell"
            },
            "5": {
              "name": "keyword.operator.prefix.double-dollar.haskell"
            }
          }
        }
      ]
    },
    "type_operator": {
      "patterns": [
        {
          "match": "(?x)\n  # Optional promotion tick\n    (?:(?<!')('))?\n  # Optional qualified name\n    ((?:\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type operator proper\n    (?![#@]?-})(\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))\n    #((?:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']&&[^#@]]|[@#](?!-}))+)",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "entity.name.namespace.haskell"
            },
            "3": {
              "name": "storage.type.operator.infix.haskell"
            }
          }
        },
        {
          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Opening backtick\n    (\\`)\n  # Optional qualified name\n    ((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n  # Closing backtick\n    (`)",
          "captures": {
            "1": {
              "name": "keyword.operator.promotion.haskell"
            },
            "2": {
              "name": "punctuation.backtick.haskell"
            },
            "3": {
              "name": "entity.name.namespace.haskell"
            },
            "4": {
              "name": "storage.type.infix.haskell"
            },
            "5": {
              "name": "punctuation.backtick.haskell"
            }
          }
        }
      ]
    },
    "forall": {
      "begin": "\\b(?<!')(forall|∀)\\b(?!')",
      "end": "(\\.)|(->|→)",
      "beginCaptures": {
        "1": {
          "name": "keyword.other.forall.haskell"
        }
      },
      "endCaptures": {
        "1": {
          "name": "keyword.operator.period.haskell"
        },
        "2": {
          "name": "keyword.operator.arrow.haskell"
        }
      },
      "patterns": [
        {
          "include": "#comment_like"
        },
        {
          "include": "#type_variable"
        },
        {
          "include": "#type_signature"
        }
      ]
    },
    "string_literal": {
      "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"
            }
          ]
        }
      ]
    },
    "char_literal": {
      "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  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])\n  (')\n  (?:\n    [\\ -\\[\\]-~]                         # Basic Char\n  | (\\\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE\n       |DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS\n       |US|SP|DEL|[abfnrtv\\\\\\\"'\\\\&]))   # Escapes\n  | (\\\\o[0-7]+)                         # Octal Escapes\n  | (\\\\x[0-9A-Fa-f]+)                   # Hexadecimal Escapes\n  | (\\\\\\^[A-Z@\\[\\]\\\\\\^_])                 # Control Chars\n  )\n  (')\n",
      "name": "string.quoted.single.haskell"
    },
    "float_literals": {
      "comment": "Floats are decimal or hexadecimal",
      "match": "(?x)\n  \\b(?<!')\n  (?:  # Decimal\n    ([0-9][_0-9]*\\.[0-9][_0-9]*(?:[eE][-+]?[0-9][_0-9]*)?\n    |[0-9][_0-9]*[eE][-+]?[0-9][_0-9]*\n    )\n  |    # Hexadecimal\n    (0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*\\.[0-9a-fA-F][_0-9a-fA-F]*(?:[pP][-+]?[0-9][_0-9]*)?\n    |0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*[pP][-+]?[0-9][_0-9]*\n    )\n  )\\b(?!')",
      "captures": {
        "1": {
          "name": "constant.numeric.floating.decimal.haskell"
        },
        "2": {
          "name": "constant.numeric.floating.hexadecimal.haskell"
        }
      }
    },
    "integer_literals": {
      "match": "(?x)\n  \\b(?<!')\n  (?:\n    ([0-9][_0-9]*)                    # Decimal integer\n  | (0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*) # Hexadecimal integer\n  | (0[oO]_*[0-7][_0-7]*)             # Octal integer\n  | (0[bB]_*[01][_01]*)               # Binary integer\n  )\n  \\b(?!')",
      "captures": {
        "1": {
          "name": "constant.numeric.integral.decimal.haskell"
        },
        "2": {
          "name": "constant.numeric.integral.hexadecimal.haskell"
        },
        "3": {
          "name": "constant.numeric.integral.octal.haskell"
        },
        "4": {
          "name": "constant.numeric.integral.binary.haskell"
        }
      }
    },
    "numeric_literals": {
      "patterns": [
        {
          "include": "#float_literals"
        },
        {
          "include": "#integer_literals"
        }
      ]
    },
    "ffi": {
      "begin": "^(\\s*)(foreign)\\s+(import|export)\\s+",
      "beginCaptures": {
        "2": {
          "name": "keyword.other.foreign.haskell"
        },
        "3": {
          "name": "keyword.other.$3.haskell"
        }
      },
      "name": "meta.$3.foreign.haskell",
      "end": "(?x) # Detect end of FFI 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    )\n",
      "patterns": [
        {
          "include": "#comment_like"
        },
        {
          "match": "\\b(?<!')(ccall|cplusplus|dotnet|jvm|stdcall|prim|capi)\\s+",
          "captures": {
            "1": {
              "name": "keyword.other.calling-convention.$1.haskell"
            }
          }
        },
        {
          "begin": "(?=\")|(?=\\b(?<!')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))",
          "end": "(?=(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))",
          "patterns": [
            {
              "include": "#comment_like"
            },
            {
              "match": "(?x)\n  \\b(?<!')(safe|unsafe|interruptible)\\b(?!')\n  \\s*\n  (\"(?:\\\\\"|[^\"])*\")?\n  \\s*\n  (?:\n    (?:\\b(?<!'')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))\n   |(?:\\(\\s*(?!--+\\))([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*\\))\n  )\n",
              "captures": {
                "1": {
                  "name": "keyword.other.safety.$1.haskell"
                },
                "2": {
                  "name": "entity.name.foreign.haskell",
                  "patterns": [
                    {
                      "include": "#string_literal"
                    }
                  ]
                },
                "3": {
                  "name": "entity.name.function.haskell"
                },
                "4": {
                  "name": "entity.name.function.infix.haskell"
                }
              }
            },
            {
              "match": "(?x)\n  \\b(?<!')(safe|unsafe|interruptible)\\b(?!')\n  \\s*\n  (\"(?:\\\\\"|[^\"])*\")?\n  \\s*$\n",
              "captures": {
                "1": {
                  "name": "keyword.other.safety.$1.haskell"
                },
                "2": {
                  "name": "entity.name.foreign.haskell",
                  "patterns": [
                    {
                      "include": "#string_literal"
                    }
                  ]
                }
              }
            },
            {
              "match": "(?x)\n  \"(?:\\\\\"|[^\"])*\"",
              "captures": {
                "0": {
                  "name": "entity.name.foreign.haskell",
                  "patterns": [
                    {
                      "include": "#string_literal"
                    }
                  ]
                }
              }
            },
            {
              "match": "(?x)\n   (?:\\b(?<!'')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))\n  |(?:(\\()\\s*(?!--+\\))([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\)))\n",
              "captures": {
                "1": {
                  "name": "entity.name.function.haskell"
                },
                "2": {
                  "name": "punctuation.paren.haskell"
                },
                "3": {
                  "name": "entity.name.function.infix.haskell"
                },
                "4": {
                  "name": "punctuation.paren.haskell"
                }
              }
            }
          ]
        },
        {
          "include": "#double_colon"
        },
        {
          "include": "#type_signature"
        }
      ]
    },
    "inline_phase": {
      "begin": "\\[",
      "beginCaptures": {
        "0": {
          "name": "punctuation.bracket.haskell"
        }
      },
      "end": "\\]",
      "endCaptures": {
        "0": {
          "name": "punctuation.bracket.haskell"
        }
      },
      "name": "meta.inlining-phase.haskell",
      "patterns": [
        {
          "match": "~",
          "name": "punctuation.tilde.haskell"
        },
        {
          "include": "#integer_literals"
        },
        {
          "match": "\\w*",
          "name": "invalid"
        }
      ]
    },
    "quasi_quote": {
      "patterns": [
        {
          "begin": "(?x)\n  (\\[)\n  (e|d|p)?\n  (\\|\\|?)",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            },
            "2": {
              "name": "entity.name.quasi-quoter.haskell"
            },
            "3": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            }
          },
          "end": "\\3\\]",
          "endCaptures": {
            "0": {
              "name": "keyword.operator.quasi-quotation.end.haskell"
            }
          },
          "name": "meta.quasi-quotation.haskell",
          "patterns": [
            {
              "include": "$self"
            }
          ]
        },
        {
          "begin": "(?x)\n  (\\[)\n  (t)\n  (\\|\\|?)",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            },
            "2": {
              "name": "entity.name.quasi-quoter.haskell"
            },
            "3": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            }
          },
          "end": "\\3\\]",
          "endCaptures": {
            "0": {
              "name": "keyword.operator.quasi-quotation.end.haskell"
            }
          },
          "name": "meta.quasi-quotation.haskell",
          "patterns": [
            {
              "include": "#type_signature"
            }
          ]
        },
        {
          "begin": "(?x)\n  (\\[)\n  (?:(\\$\\$)|(\\$))?\n  ((?:[^\\s\\p{S}\\p{P}]|[\\.'_])*)\n  (\\|\\|?)",
          "beginCaptures": {
            "1": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            },
            "2": {
              "name": "keyword.operator.prefix.double-dollar.haskell"
            },
            "3": {
              "name": "keyword.operator.prefix.dollar.haskell"
            },
            "4": {
              "patterns": [
                {
                  "include": "#qualifier"
                }
              ],
              "name": "entity.name.quasi-quoter.haskell"
            },
            "5": {
              "name": "keyword.operator.quasi-quotation.begin.haskell"
            }
          },
          "end": "\\5\\]",
          "endCaptures": {
            "0": {
              "name": "keyword.operator.quasi-quotation.end.haskell"
            }
          },
          "name": "meta.quasi-quotation.haskell"
        }
      ]
    }
  },
  "scopeName": "source.haskell",
  "uuid": "5C034675-1F6D-497E-8073-369D37E2FD7D"
}