393 lines
16 KiB
VimL
393 lines
16 KiB
VimL
if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vim') == -1
|
|
|
|
" Vim syntax file
|
|
" Language: Haskell
|
|
" Maintainer: Haskell Cafe mailinglist <haskell-cafe@haskell.org>
|
|
" Last Change: 2017 Jun 04
|
|
" Original Author: John Williams <jrw@pobox.com>
|
|
"
|
|
" Thanks to Ryan Crumley for suggestions and John Meacham for
|
|
" pointing out bugs. Also thanks to Ian Lynagh and Donald Bruce Stewart
|
|
" for providing the inspiration for the inclusion of the handling
|
|
" of C preprocessor directives, and for pointing out a bug in the
|
|
" end-of-line comment handling.
|
|
"
|
|
" Options-assign a value to these variables to turn the option on:
|
|
"
|
|
" hs_highlight_delimiters - Highlight delimiter characters--users
|
|
" with a light-colored background will
|
|
" probably want to turn this on.
|
|
" hs_highlight_boolean - Treat True and False as keywords.
|
|
" hs_highlight_types - Treat names of primitive types as keywords.
|
|
" hs_highlight_more_types - Treat names of other common types as keywords.
|
|
" hs_highlight_debug - Highlight names of debugging functions.
|
|
" hs_allow_hash_operator - Don't highlight seemingly incorrect C
|
|
" preprocessor directives but assume them to be
|
|
" operators
|
|
"
|
|
" 2004 Feb 19: Added C preprocessor directive handling, corrected eol comments
|
|
" cleaned away literate haskell support (should be entirely in
|
|
" lhaskell.vim)
|
|
" 2004 Feb 20: Cleaned up C preprocessor directive handling, fixed single \
|
|
" in eol comment character class
|
|
" 2004 Feb 23: Made the leading comments somewhat clearer where it comes
|
|
" to attribution of work.
|
|
" 2008 Dec 15: Added comments as contained element in import statements
|
|
|
|
" quit when a syntax file was already loaded
|
|
if exists("b:current_syntax")
|
|
finish
|
|
endif
|
|
|
|
" (Qualified) identifiers (no default highlighting)
|
|
syn match ConId "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=\<[A-Z][a-zA-Z0-9_']*\>"
|
|
syn match VarId "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=\<[a-z][a-zA-Z0-9_']*\>"
|
|
|
|
" Infix operators--most punctuation characters and any (qualified) identifier
|
|
" enclosed in `backquotes`. An operator starting with : is a constructor,
|
|
" others are variables (e.g. functions).
|
|
syn match hsVarSym "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[-!#$%&\*\+/<=>\?@\\^|~.][-!#$%&\*\+/<=>\?@\\^|~:.]*"
|
|
syn match hsConSym "\(\<[A-Z][a-zA-Z0-9_']*\.\)\=:[-!#$%&\*\+./<=>\?@\\^|~:]*"
|
|
syn match hsVarSym "`\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[a-z][a-zA-Z0-9_']*`"
|
|
syn match hsConSym "`\(\<[A-Z][a-zA-Z0-9_']*\.\)\=[A-Z][a-zA-Z0-9_']*`"
|
|
|
|
" Reserved symbols--cannot be overloaded.
|
|
syn match hsDelimiter "(\|)\|\[\|\]\|,\|;\|_\|{\|}"
|
|
|
|
" Strings and constants
|
|
syn match hsSpecialChar contained "\\\([0-9]\+\|o[0-7]\+\|x[0-9a-fA-F]\+\|[\"\\'&\\abfnrtv]\|^[A-Z^_\[\\\]]\)"
|
|
syn match hsSpecialChar contained "\\\(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\)"
|
|
syn match hsSpecialCharError contained "\\&\|'''\+"
|
|
syn region hsString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=hsSpecialChar
|
|
syn match hsCharacter "[^a-zA-Z0-9_']'\([^\\]\|\\[^']\+\|\\'\)'"lc=1 contains=hsSpecialChar,hsSpecialCharError
|
|
syn match hsCharacter "^'\([^\\]\|\\[^']\+\|\\'\)'" contains=hsSpecialChar,hsSpecialCharError
|
|
syn match hsNumber "\<[0-9]\+\>\|\<0[xX][0-9a-fA-F]\+\>\|\<0[oO][0-7]\+\>"
|
|
syn match hsFloat "\<[0-9]\+\.[0-9]\+\([eE][-+]\=[0-9]\+\)\=\>"
|
|
|
|
" Keyword definitions. These must be patterns instead of keywords
|
|
" because otherwise they would match as keywords at the start of a
|
|
" "literate" comment (see lhs.vim).
|
|
syn match hsModule "\<module\>"
|
|
syn match hsImport "\<import\>.*"he=s+6 contains=hsImportMod,hsLineComment,hsBlockComment
|
|
syn match hsImportMod contained "\<\(as\|qualified\|hiding\)\>"
|
|
syn match hsInfix "\<\(infix\|infixl\|infixr\)\>"
|
|
syn match hsStructure "\<\(class\|data\|deriving\|instance\|default\|where\)\>"
|
|
syn match hsTypedef "\<\(type\|newtype\)\>"
|
|
syn match hsStatement "\<\(do\|case\|of\|let\|in\)\>"
|
|
syn match hsConditional "\<\(if\|then\|else\)\>"
|
|
|
|
" Not real keywords, but close.
|
|
if exists("hs_highlight_boolean")
|
|
" Boolean constants from the standard prelude.
|
|
syn match hsBoolean "\<\(True\|False\)\>"
|
|
endif
|
|
if exists("hs_highlight_types")
|
|
" Primitive types from the standard prelude and libraries.
|
|
syn match hsType "\<\(Int\|Integer\|Char\|Bool\|Float\|Double\|IO\|Void\|Addr\|Array\|String\)\>"
|
|
endif
|
|
if exists("hs_highlight_more_types")
|
|
" Types from the standard prelude libraries.
|
|
syn match hsType "\<\(Maybe\|Either\|Ratio\|Complex\|Ordering\|IOError\|IOResult\|ExitCode\)\>"
|
|
syn match hsMaybe "\<Nothing\>"
|
|
syn match hsExitCode "\<\(ExitSuccess\)\>"
|
|
syn match hsOrdering "\<\(GT\|LT\|EQ\)\>"
|
|
endif
|
|
if exists("hs_highlight_debug")
|
|
" Debugging functions from the standard prelude.
|
|
syn match hsDebug "\<\(undefined\|error\|trace\)\>"
|
|
endif
|
|
|
|
|
|
" Comments
|
|
syn match hsLineComment "---*\([^-!#$%&\*\+./<=>\?@\\^|~].*\)\?$"
|
|
syn region hsBlockComment start="{-" end="-}" contains=hsBlockComment
|
|
syn region hsPragma start="{-#" end="#-}"
|
|
|
|
" C Preprocessor directives. Shamelessly ripped from c.vim and trimmed
|
|
" First, see whether to flag directive-like lines or not
|
|
if (!exists("hs_allow_hash_operator"))
|
|
syn match cError display "^\s*\(%:\|#\).*$"
|
|
endif
|
|
" Accept %: for # (C99)
|
|
syn region cPreCondit start="^\s*\(%:\|#\)\s*\(if\|ifdef\|ifndef\|elif\)\>" skip="\\$" end="$" end="//"me=s-1 contains=cComment,cCppString,cCommentError
|
|
syn match cPreCondit display "^\s*\(%:\|#\)\s*\(else\|endif\)\>"
|
|
syn region cCppOut start="^\s*\(%:\|#\)\s*if\s\+0\+\>" end=".\@=\|$" contains=cCppOut2
|
|
syn region cCppOut2 contained start="0" end="^\s*\(%:\|#\)\s*\(endif\>\|else\>\|elif\>\)" contains=cCppSkip
|
|
syn region cCppSkip contained start="^\s*\(%:\|#\)\s*\(if\>\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\(%:\|#\)\s*endif\>" contains=cCppSkip
|
|
syn region cIncluded display contained start=+"+ skip=+\\\\\|\\"+ end=+"+
|
|
syn match cIncluded display contained "<[^>]*>"
|
|
syn match cInclude display "^\s*\(%:\|#\)\s*include\>\s*["<]" contains=cIncluded
|
|
syn cluster cPreProcGroup contains=cPreCondit,cIncluded,cInclude,cDefine,cCppOut,cCppOut2,cCppSkip,cCommentStartError
|
|
syn region cDefine matchgroup=cPreCondit start="^\s*\(%:\|#\)\s*\(define\|undef\)\>" skip="\\$" end="$"
|
|
syn region cPreProc matchgroup=cPreCondit start="^\s*\(%:\|#\)\s*\(pragma\>\|line\>\|warning\>\|warn\>\|error\>\)" skip="\\$" end="$" keepend
|
|
|
|
syn region cComment matchgroup=cCommentStart start="/\*" end="\*/" contains=cCommentStartError,cSpaceError contained
|
|
syntax match cCommentError display "\*/" contained
|
|
syntax match cCommentStartError display "/\*"me=e-1 contained
|
|
syn region cCppString start=+L\="+ skip=+\\\\\|\\"\|\\$+ excludenl end=+"+ end='$' contains=cSpecial contained
|
|
|
|
" Define the default highlighting.
|
|
" Only when an item doesn't have highlighting yet
|
|
|
|
hi def link hsModule hsStructure
|
|
hi def link hsImport Include
|
|
hi def link hsImportMod hsImport
|
|
hi def link hsInfix PreProc
|
|
hi def link hsStructure Structure
|
|
hi def link hsStatement Statement
|
|
hi def link hsConditional Conditional
|
|
hi def link hsSpecialChar SpecialChar
|
|
hi def link hsTypedef Typedef
|
|
hi def link hsVarSym hsOperator
|
|
hi def link hsConSym hsOperator
|
|
hi def link hsOperator Operator
|
|
if exists("hs_highlight_delimiters")
|
|
" Some people find this highlighting distracting.
|
|
hi def link hsDelimiter Delimiter
|
|
endif
|
|
hi def link hsSpecialCharError Error
|
|
hi def link hsString String
|
|
hi def link hsCharacter Character
|
|
hi def link hsNumber Number
|
|
hi def link hsFloat Float
|
|
hi def link hsConditional Conditional
|
|
hi def link hsLiterateComment hsComment
|
|
hi def link hsBlockComment hsComment
|
|
hi def link hsLineComment hsComment
|
|
hi def link hsComment Comment
|
|
hi def link hsPragma SpecialComment
|
|
hi def link hsBoolean Boolean
|
|
hi def link hsType Type
|
|
hi def link hsMaybe hsEnumConst
|
|
hi def link hsOrdering hsEnumConst
|
|
hi def link hsEnumConst Constant
|
|
hi def link hsDebug Debug
|
|
|
|
hi def link cCppString hsString
|
|
hi def link cCommentStart hsComment
|
|
hi def link cCommentError hsError
|
|
hi def link cCommentStartError hsError
|
|
hi def link cInclude Include
|
|
hi def link cPreProc PreProc
|
|
hi def link cDefine Macro
|
|
hi def link cIncluded hsString
|
|
hi def link cError Error
|
|
hi def link cPreCondit PreCondit
|
|
hi def link cComment Comment
|
|
hi def link cCppSkip cCppOut
|
|
hi def link cCppOut2 cCppOut
|
|
hi def link cCppOut Comment
|
|
|
|
|
|
let b:current_syntax = "haskell"
|
|
|
|
" Options for vi: ts=8 sw=2 sts=2 nowrap noexpandtab ft=vim
|
|
|
|
endif
|
|
if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haskell') == -1
|
|
|
|
" syntax highlighting for haskell
|
|
"
|
|
" Heavily modified version of the haskell syntax
|
|
" highlighter to support haskell.
|
|
"
|
|
" author: raichoo (raichoo@googlemail.com)
|
|
|
|
if version < 600
|
|
syn clear
|
|
elseif exists("b:current_syntax")
|
|
finish
|
|
endif
|
|
|
|
if get(g:, 'haskell_backpack', 0)
|
|
syn keyword haskellBackpackStructure unit signature
|
|
syn keyword haskellBackpackDependency dependency
|
|
endif
|
|
|
|
syn spell notoplevel
|
|
syn match haskellRecordField contained containedin=haskellBlock
|
|
\ "[_a-z][a-zA-Z0-9_']*\(,\s*[_a-z][a-zA-Z0-9_']*\)*\_s\+::\_s"
|
|
\ contains=
|
|
\ haskellIdentifier,
|
|
\ haskellOperators,
|
|
\ haskellSeparator,
|
|
\ haskellParens
|
|
syn match haskellTypeSig
|
|
\ "^\s*\(where\s\+\|let\s\+\|default\s\+\)\?[_a-z][a-zA-Z0-9_']*#\?\(,\s*[_a-z][a-zA-Z0-9_']*#\?\)*\_s\+::\_s"
|
|
\ contains=
|
|
\ haskellWhere,
|
|
\ haskellLet,
|
|
\ haskellDefault,
|
|
\ haskellIdentifier,
|
|
\ haskellOperators,
|
|
\ haskellSeparator,
|
|
\ haskellParens
|
|
syn keyword haskellWhere where
|
|
syn keyword haskellLet let
|
|
syn keyword haskellDeclKeyword module class instance newtype deriving in
|
|
syn match haskellDecl "\<\(type\|data\)\>\s\+\(\<family\>\)\?"
|
|
syn keyword haskellDefault default
|
|
syn keyword haskellImportKeywords import qualified safe as hiding contained
|
|
syn keyword haskellForeignKeywords foreign export import ccall safe unsafe interruptible capi prim contained
|
|
syn region haskellForeignImport start="\<foreign\>" end="\_s\+::\s" keepend
|
|
\ contains=
|
|
\ haskellString,
|
|
\ haskellOperators,
|
|
\ haskellForeignKeywords,
|
|
\ haskellIdentifier
|
|
syn match haskellImport "^\s*\<import\>\s\+\(\<safe\>\s\+\)\?\(\<qualified\>\s\+\)\?.\+\(\s\+\<as\>\s\+.\+\)\?\(\s\+\<hiding\>\)\?"
|
|
\ contains=
|
|
\ haskellParens,
|
|
\ haskellOperators,
|
|
\ haskellImportKeywords,
|
|
\ haskellType,
|
|
\ haskellLineComment,
|
|
\ haskellBlockComment,
|
|
\ haskellPragma
|
|
syn keyword haskellKeyword do case of
|
|
if get(g:, 'haskell_enable_static_pointers', 0)
|
|
syn keyword haskellStatic static
|
|
endif
|
|
syn keyword haskellConditional if then else
|
|
syn match haskellNumber "\<[0-9]\+\>\|\<0[xX][0-9a-fA-F]\+\>\|\<0[oO][0-7]\+\>\|\<0[bB][10]\+\>"
|
|
syn match haskellFloat "\<[0-9]\+\.[0-9]\+\([eE][-+]\=[0-9]\+\)\=\>"
|
|
syn match haskellSeparator "[,;]"
|
|
syn region haskellParens matchgroup=haskellDelimiter start="(" end=")" contains=TOP,haskellTypeSig,@Spell
|
|
syn region haskellBrackets matchgroup=haskellDelimiter start="\[" end="]" contains=TOP,haskellTypeSig,@Spell
|
|
syn region haskellBlock matchgroup=haskellDelimiter start="{" end="}" contains=TOP,@Spell
|
|
syn keyword haskellInfix infix infixl infixr
|
|
syn keyword haskellBottom undefined error
|
|
syn match haskellOperators "[-!#$%&\*\+/<=>\?@\\^|~:.]\+\|\<_\>"
|
|
syn match haskellQuote "\<'\+" contained
|
|
syn match haskellQuotedType "[A-Z][a-zA-Z0-9_']*\>" contained
|
|
syn region haskellQuoted start="\<'\+" end="\>"
|
|
\ contains=
|
|
\ haskellType,
|
|
\ haskellQuote,
|
|
\ haskellQuotedType,
|
|
\ haskellSeparator,
|
|
\ haskellParens,
|
|
\ haskellOperators,
|
|
\ haskellIdentifier
|
|
syn match haskellLineComment "---*\([^-!#$%&\*\+./<=>\?@\\^|~].*\)\?$"
|
|
\ contains=
|
|
\ haskellTodo,
|
|
\ @Spell
|
|
syn match haskellBacktick "`[A-Za-z_][A-Za-z0-9_\.']*#\?`"
|
|
syn region haskellString start=+"+ skip=+\\\\\|\\"+ end=+"+
|
|
\ contains=@Spell
|
|
syn match haskellIdentifier "[_a-z][a-zA-z0-9_']*" contained
|
|
syn match haskellChar "\<'[^'\\]'\|'\\.'\|'\\u[0-9a-fA-F]\{4}'\>"
|
|
syn match haskellType "\<[A-Z][a-zA-Z0-9_']*\>"
|
|
syn region haskellBlockComment start="{-" end="-}"
|
|
\ contains=
|
|
\ haskellBlockComment,
|
|
\ haskellTodo,
|
|
\ @Spell
|
|
syn region haskellPragma start="{-#" end="#-}"
|
|
syn match haskellPreProc "^#.*$"
|
|
syn keyword haskellTodo TODO FIXME contained
|
|
" Treat a shebang line at the start of the file as a comment
|
|
syn match haskellShebang "\%^#!.*$"
|
|
if !get(g:, 'haskell_disable_TH', 0)
|
|
syn match haskellQuasiQuoted "." containedin=haskellQuasiQuote contained
|
|
syn region haskellQuasiQuote matchgroup=haskellTH start="\[[_a-zA-Z][a-zA-z0-9._']*|" end="|\]"
|
|
syn region haskellTHBlock matchgroup=haskellTH start="\[\(d\|t\|p\)\?|" end="|]" contains=TOP
|
|
syn region haskellTHDoubleBlock matchgroup=haskellTH start="\[||" end="||]" contains=TOP
|
|
endif
|
|
if get(g:, 'haskell_enable_typeroles', 0)
|
|
syn keyword haskellTypeRoles phantom representational nominal contained
|
|
syn region haskellTypeRoleBlock matchgroup=haskellTypeRoles start="type\s\+role" end="$" keepend
|
|
\ contains=
|
|
\ haskellType,
|
|
\ haskellTypeRoles
|
|
endif
|
|
if get(g:, 'haskell_enable_quantification', 0)
|
|
syn keyword haskellForall forall
|
|
endif
|
|
if get(g:, 'haskell_enable_recursivedo', 0)
|
|
syn keyword haskellRecursiveDo mdo rec
|
|
endif
|
|
if get(g:, 'haskell_enable_arrowsyntax', 0)
|
|
syn keyword haskellArrowSyntax proc
|
|
endif
|
|
if get(g:, 'haskell_enable_pattern_synonyms', 0)
|
|
syn keyword haskellPatternKeyword pattern
|
|
endif
|
|
|
|
highlight def link haskellBottom Macro
|
|
highlight def link haskellTH Boolean
|
|
highlight def link haskellIdentifier Identifier
|
|
highlight def link haskellForeignKeywords Structure
|
|
highlight def link haskellKeyword Keyword
|
|
highlight def link haskellDefault Keyword
|
|
highlight def link haskellConditional Conditional
|
|
highlight def link haskellNumber Number
|
|
highlight def link haskellFloat Float
|
|
highlight def link haskellSeparator Delimiter
|
|
highlight def link haskellDelimiter Delimiter
|
|
highlight def link haskellInfix Keyword
|
|
highlight def link haskellOperators Operator
|
|
highlight def link haskellQuote Operator
|
|
highlight def link haskellShebang Comment
|
|
highlight def link haskellLineComment Comment
|
|
highlight def link haskellBlockComment Comment
|
|
highlight def link haskellPragma SpecialComment
|
|
highlight def link haskellString String
|
|
highlight def link haskellChar String
|
|
highlight def link haskellBacktick Operator
|
|
highlight def link haskellQuasiQuoted String
|
|
highlight def link haskellTodo Todo
|
|
highlight def link haskellPreProc PreProc
|
|
highlight def link haskellAssocType Type
|
|
highlight def link haskellQuotedType Type
|
|
highlight def link haskellType Type
|
|
highlight def link haskellImportKeywords Include
|
|
if get(g:, 'haskell_classic_highlighting', 0)
|
|
highlight def link haskellDeclKeyword Keyword
|
|
highlight def link haskellDecl Keyword
|
|
highlight def link haskellWhere Keyword
|
|
highlight def link haskellLet Keyword
|
|
else
|
|
highlight def link haskellDeclKeyword Structure
|
|
highlight def link haskellDecl Structure
|
|
highlight def link haskellWhere Structure
|
|
highlight def link haskellLet Structure
|
|
endif
|
|
|
|
if get(g:, 'haskell_enable_quantification', 0)
|
|
highlight def link haskellForall Operator
|
|
endif
|
|
if get(g:, 'haskell_enable_recursivedo', 0)
|
|
highlight def link haskellRecursiveDo Keyword
|
|
endif
|
|
if get(g:, 'haskell_enable_arrowsyntax', 0)
|
|
highlight def link haskellArrowSyntax Keyword
|
|
endif
|
|
if get(g:, 'haskell_enable_static_pointers', 0)
|
|
highlight def link haskellStatic Keyword
|
|
endif
|
|
if get(g:, 'haskell_classic_highlighting', 0)
|
|
if get(g:, 'haskell_enable_pattern_synonyms', 0)
|
|
highlight def link haskellPatternKeyword Keyword
|
|
endif
|
|
if get(g:, 'haskell_enable_typeroles', 0)
|
|
highlight def link haskellTypeRoles Keyword
|
|
endif
|
|
else
|
|
if get(g:, 'haskell_enable_pattern_synonyms', 0)
|
|
highlight def link haskellPatternKeyword Structure
|
|
endif
|
|
if get(g:, 'haskell_enable_typeroles', 0)
|
|
highlight def link haskellTypeRoles Structure
|
|
endif
|
|
endif
|
|
|
|
if get(g:, 'haskell_backpack', 0)
|
|
highlight def link haskellBackpackStructure Structure
|
|
highlight def link haskellBackpackDependency Include
|
|
endif
|
|
let b:current_syntax = "haskell"
|
|
|
|
endif
|