Haskell.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: Haskell (better)
file_extensions:
  - hs
scope: source.haskell

variables:
  # Numeric literal patterns taken directly from the "Underscores in Numeric Literals" proposal.
  digit: '0-9'
  hexit: '{{digit}}A-Fa-f'
  octit: '0-7'
  decimal: '[{{digit}}][{{digit}}_]*'
  hexadecimal: '[{{hexit}}][{{hexit}}_]*'
  octal: '[{{octit}}][{{octit}}_]*'
  id_tail: '[a-zA-Z0-9_'']*'
  type_id: '[A-Z]{{id_tail}}'
  val_id: '[a-z_]{{id_tail}}'
  op_id: '[!#$%&*+./<=>?@\\\^|\-~:∷→⇒]+'

contexts:
  main:
    - match: '^<<<<<<<.*$'
      scope: invalid.haskell
    - match: '^>>>>>>>.*$'
      scope: invalid.haskell
    - match: '^=======.*$'
      scope: invalid.haskell
    - match: '\bundefined\b'
      scope: invalid.haskell
    - match: '`{{val_id}}`'
      scope: keyword.operator.haskell
    - match: '\b(module)\b'
      captures:
        1: keyword.other.haskell
      push:
        - include: comments
        - meta_scope: meta.declaration.module.haskell
        - match: '(where)'
          captures:
            1: keyword.other.haskell
          pop: true
        - include: module_name
        - include: module_exports
        - match: '[a-z]+'
          scope: invalid
    - match: '\b(class|instance)\b'
      captures:
        1: keyword.other.haskell
      push:
        - include: comments
        - meta_scope: meta.declaration.class.haskell
        - match: '($|;)'
          pop: true
        - match: '\b(where)\b'
          captures:
            1: keyword.other.haskell
          pop: true
        - match: '{{type_id}}'
          scope: entity.other.inherited-class.haskell
        - match: '\b{{val_id}}\b'
          scope: variable.other.generic-type.haskell
        - match: '{{op_id}}'
          scope: keyword.operator.haskell
    - match: '\b(import)\b'
      captures:
        1: keyword.other.haskell
      push:
        - meta_scope: meta.import.haskell
        - match: '($|;)'
          pop: true
        - match: '(qualified|as|hiding)'
          scope: keyword.other.haskell
        - include: module_name
        - include: module_imports
        - include: comments
    - match: '(deriving)\s*\('
      captures:
        1: keyword.other.haskell
      push:
        - include: comments
        - meta_scope: meta.deriving.haskell
        - match: '\)'
          pop: true
        - match: '\b{{type_id}}'
          scope: entity.other.inherited-class.haskell
    - match: '(deriving)\s*'
      captures:
        1: keyword.other.haskell
      push:
        - meta_scope: meta.deriving.haskell
        - match: '($|;)'
          pop: true
        - match: '{{type_id}}'
          scope: entity.other.inherited-class.haskell
    - match: '\b(deriving|where|data|type|case|of|let|in|newtype|default)\b'
      scope: keyword.other.haskell
    - match: '\binfix[lr]?\b'
      scope: keyword.operator.haskell
    - match: '\b(do|if|then|else)\b'
      scope: keyword.control.haskell
    - match: '\b([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\b'
      comment: Floats are always decimal
      scope: constant.numeric.haskell
    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\b'
      scope: constant.numeric.haskell
    - match: '^(#)\s*\w+'
      comment: In addition to Haskell's "native" syntax, GHC permits the C preprocessor to be run on a source file.
      scope: meta.preprocessor.c
      captures:
        1: punctuation.definition.preprocessor.c
    - include: pragma
    - match: '"'
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.haskell
        - match: '"'
          pop: true
        - match: '(\\)\s*$'
          captures:
            1: constant.character.escape.multi-line.haskell
          push:
            - meta_include_prototype: false
            - match: '\s+'
            - match: '\\'
              scope: constant.character.escape.multi-line.haskell
              pop: true
            - match: '(?=.)'
              pop: true
        - 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\\\"''\&])'
          scope: constant.character.escape.haskell
        - match: '\\o{{octal}}|\\x{{hexadecimal}}|\\{{decimal}}'
          scope: constant.character.escape.octal.haskell
        - match: '\^[A-Z@\[\]\\\^_]'
          scope: constant.character.escape.control.haskell
    - match: '\[(?:|e|d|t|p)\|'
      comment: Points out splices in ast quotes
      scope: keyword.other.quasibracket.haskell
      push:
        - meta_scope: meta.other.quasiquote.haskell
        - match: '(.*)(\|\])'
          captures:
            1: string.quasiquoted.haskell
            2: keyword.other.quasibracket.haskell
          pop: true
        - match: '\$\('
          scope: keyword.other.splice.haskell
        - match: '\$'
          scope: string.quasiquoted.haskell
        - match: '[^$]*'
          scope: string.quasiquoted.haskell
    - match: '\$\('
      comment: Highlight the beginning of a splice.
      scope: keyword.other.splice.haskell
    - match: '\[[a-zA-Z0-9_'']*\|'
      scope: keyword.other.quasibracket.haskell
      push:
        - meta_scope: meta.other.quasiquote.haskell
        - match: '(.*)(\|\])'
          captures:
            1: string.quasiquoted.haskell
            2: keyword.other.quasibracket.haskell
          pop: true
        - match: '.*'
          scope: string.quasiquoted.haskell
    - match: |-
        (?x)
        (')
        (?:
          [\ -\[\]-~]                             # Basic Char
          | (\\(?: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\\\"'\&]))       # Escapes
          | (\\o[0-7]+)                             # Octal Escapes
          | (\\x[0-9A-Fa-f]+)                       # Hexadecimal Escapes
          | (\^[A-Z@\[\]\\\^_])                     # Control Chars
        )
        (')
      scope: string.quoted.single.haskell
      captures:
        1: punctuation.definition.string.begin.haskell
        2: constant.character.escape.haskell
        3: constant.character.escape.octal.haskell
        4: constant.character.escape.hexadecimal.haskell
        5: constant.character.escape.control.haskell
        6: punctuation.definition.string.end.haskell
    - match: '^({{val_id}})\s*$'
      captures:
        1: entity.name.function.haskell
      comment: Dirty hack to capture function declarations where the type sig starts on the line below, potential for false-positives
    - match: '({{val_id}})\s*(::|∷)'
      comment: Function declarations with alphanumeric identifier
      captures:
        1: entity.name.function.haskell
        2: keyword.operator.haskell
    - match: '^\(({{op_id}})\)\s*$'
      captures:
        1: entity.name.function.haskell
      comment: Dirty hack to capture function declarations where the type sig starts on the line below, potential for false-positives
    - match: '\(({{op_id}})\)\s*(::|∷)'
      comment: Function declarations with operator identifier
      captures:
        1: entity.name.function.haskell
        2: keyword.operator.haskell
    - match: '\b{{type_id}}'
      scope: storage.type.haskell
    - include: comments
    - match: '{{op_id}}'
      scope: keyword.operator.haskell
  block_comment:
    - match: '\{-(?!#)'
      scope: punctuation.definition.comment.begin.haskell
      push:
        - meta_scope: comment.block.haskell
        - match: '\{-#'
          push:
            - match: '-\}'
              pop: true
            - include: block_comment
        - include: block_comment
        - match: '-\}'
          scope: punctuation.definition.comment.end.haskell
          pop: true
  comments:
    - match: '--(?![!#$%&*+./<=>?@\\\^|~:])'
      scope: punctuation.definition.comment.haskell
      push:
        - meta_scope: comment.line.haskell
        - match: '$'
          pop: true
    - include: block_comment
  imports_exports:
    - include: comments
    - match: '\b({{type_id}})(\(.[^\)]*\)|)'
      captures:
        1: storage.type.haskell
    - match: '\(({{op_id}})\)'
      captures:
        1: keyword.operator.haskell
    - match: '\)'
      pop: true
  module_exports:
    - match: '\('
      push:
        - meta_scope: meta.declaration.exports.haskell
        - include: imports_exports
  module_imports:
    - match: '\('
      push:
        - meta_scope: meta.declaration.imports.haskell
        - include: imports_exports
  module_name:
    - match: '{{type_id}}'
      scope: support.other.module.haskell
  pragma:
    - match: '\{-#'
      push:
        - meta_scope: meta.preprocessor.haskell
        - match: '#-\}'
          pop: true
        - match: '\b(LANGUAGE|OPTIONS_GHC|INCLUDE|WARNING|DEPRECATED|MINIMAL|UNPACK|NOUNPACK|SOURCE|OVERLAPPING|OVERLAPPABLE|OVERLAPS|INCOHERENT|INLINE|NOINLINE|INLINABLE|CONLIKE|LINE|RULES|SPECIALIZE|SPECIALISE)\b'
          # https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pragmas
          scope: keyword.other.preprocessor.haskell