[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[nongnu] elpa/haskell-tng-mode bd4ff6f 192/385: standardise on naming co
|
From: |
ELPA Syncer |
|
Subject: |
[nongnu] elpa/haskell-tng-mode bd4ff6f 192/385: standardise on naming convention: |
|
Date: |
Tue, 5 Oct 2021 23:59:29 -0400 (EDT) |
branch: elpa/haskell-tng-mode
commit bd4ff6f22b4971daefb5306ace175bb774f98209
Author: Tseen She <ts33n.sh3@gmail.com>
Commit: Tseen She <ts33n.sh3@gmail.com>
standardise on naming convention:
1. public symbols can live in the `haskell-tng-*` namespace
2. all internal symbols are in a `haskell-tng--FILE-*` namespace
---
README.md | 2 +-
haskell-tng-compile.el | 32 +++---
haskell-tng-contrib.el | 6 +-
haskell-tng-font-lock.el | 142 +++++++++++------------
haskell-tng-layout.el | 38 +++----
haskell-tng-lexer.el | 172 ++++++++++++++--------------
haskell-tng-mode.el | 18 +--
haskell-tng-rx.el | 58 +++++-----
haskell-tng-smie.el | 108 +++++++++---------
haskell-tng-syntax.el | 32 +++---
haskell-tng-util.el | 18 +--
test/haskell-tng-compile-test.el | 6 +-
test/haskell-tng-font-lock-test.el | 2 +-
test/haskell-tng-indent-test.el | 34 +++---
test/haskell-tng-layout-test.el | 12 +-
test/haskell-tng-lexer-test.el | 82 +++++++-------
test/haskell-tng-sexp-test.el | 20 ++--
test/haskell-tng-syntax-test.el | 2 +-
test/haskell-tng-testutils.el | 6 +-
test/src/layout.hs.faceup | 28 ++---
test/src/medley.hs.faceup | 224 ++++++++++++++++++-------------------
21 files changed, 522 insertions(+), 520 deletions(-)
diff --git a/README.md b/README.md
index acb2417..30eb87c 100644
--- a/README.md
+++ b/README.md
@@ -75,7 +75,7 @@ This is the status of core features:
- [x] `stylish-haskell` support
- Compiling:
- [x] `haskell-tng-compile` for `cabal` batch commands
- - [x] `stack`, `nix`, `shake`, etc support (customise
`haskell-tng-compile:*`)
+ - [x] `stack`, `nix`, `shake`, etc support (customise
`haskell-tng--compile-*`)
- [ ] `comint-mode` based `ghc` repl
Compatibility with `lsp-mode` /
[`haskell-ide-engine`](https://github.com/haskell/haskell-ide-engine) is
important for more advanced IDE features.
diff --git a/haskell-tng-compile.el b/haskell-tng-compile.el
index bd527a3..a7fb555 100644
--- a/haskell-tng-compile.el
+++ b/haskell-tng-compile.el
@@ -58,15 +58,15 @@
))
"The `compilation-error-regexp-alist' for `haskell-tng'.")
-(defvar haskell-tng-compile:history
+(defvar haskell-tng--compile-history
;; Prefer --enable-tests due to
;; https://github.com/haskell/cabal/issues/6114
'("cabal v2-build -O0 --enable-tests "
"cabal v2-run -O0 --enable-tests tasty -- "))
-(defvar-local haskell-tng-compile:command nil)
-(defvar-local haskell-tng-compile:alt "cabal v2-clean")
+(defvar-local haskell-tng--compile-command nil)
+(defvar-local haskell-tng--compile-alt "cabal v2-clean")
-(defvar haskell-tng-compile:dominating-file
+(defvar haskell-tng--compile-dominating-file
(rx (| "cabal.project" "cabal.project.local" "cabal.project.freeze"
(: (+ any) ".cabal")
"package.yaml" "stack.yaml")))
@@ -82,41 +82,41 @@ command, otherwise the last command is used.
The command history is global across all Haskell files.
-A universal argument will invoke `haskell-tng-compile:alt', which
+A universal argument will invoke `haskell-tng--compile-alt', which
will cause the subsequent call to prompt."
(interactive "P")
(save-some-buffers (not compilation-ask-about-save)
compilation-save-buffers-predicate)
- (let* ((last haskell-tng-compile:command)
+ (let* ((last haskell-tng--compile-command)
(command (pcase edit-command
((and 'nil (guard last)) last)
- ('- haskell-tng-compile:alt)
+ ('- haskell-tng--compile-alt)
(_ (read-shell-command
"Compile command: "
- (or last (car haskell-tng-compile:history))
- ;; TODO haskell-tng-compile:command should always be
+ (or last (car haskell-tng--compile-history))
+ ;; TODO haskell-tng--compile-command should always be
;; first in the prompted history, even if another
;; command was used elsewhere. Might require
;; mutating / reordering the global history here.
- '(haskell-tng-compile:history . 1))))))
- (setq haskell-tng-compile:command
- (unless (equal command haskell-tng-compile:alt) command))
+ '(haskell-tng--compile-history . 1))))))
+ (setq haskell-tng--compile-command
+ (unless (equal command haskell-tng--compile-alt) command))
(when-let (default-directory
- (haskell-tng:locate-dominating-file
- haskell-tng-compile:dominating-file))
+ (haskell-tng--util-locate-dominating-file
+ haskell-tng--compile-dominating-file))
(compilation-start
command
'haskell-tng-compilation-mode
;; TODO name the compilation buffer
))))
-(defun haskell-tng-compile:ansi-color ()
+(defun haskell-tng--compile-ansi-color ()
(ansi-color-apply-on-region compilation-filter-start (point-max)))
(define-compilation-mode haskell-tng-compilation-mode "haskell-tng-compilation"
(add-hook 'compilation-filter-hook
- 'haskell-tng-compile:ansi-color nil t))
+ 'haskell-tng--compile-ansi-color nil t))
(provide 'haskell-tng-compile)
;;; haskell-tng-compile.el ends here
diff --git a/haskell-tng-contrib.el b/haskell-tng-contrib.el
index b90fbe5..c133b76 100644
--- a/haskell-tng-contrib.el
+++ b/haskell-tng-contrib.el
@@ -16,7 +16,7 @@
;; cabal v2-install.
;;;###autoload
-(defun haskell-tng-contrib:stylish-haskell ()
+(defun haskell-tng-stylish-haskell ()
"Apply `stylish-haskell' rules."
(interactive)
(save-buffer)
@@ -24,13 +24,13 @@
(revert-buffer t t t))
;;;###autoload
-(defun haskell-tng-contrib:stack2cabal ()
+(defun haskell-tng-stack2cabal ()
"Prepare a stack project for use with cabal."
(interactive)
(when-let (default-directory
(locate-dominating-file default-directory "stack.yaml"))
(call-process "stack2cabal")))
-(defalias 'stack2cabal 'haskell-tng-contrib:stack2cabal)
+(defalias 'stack2cabal 'haskell-tng-stack2cabal)
(provide 'haskell-tng-contrib)
;;; haskell-tng-contrib.el ends here
diff --git a/haskell-tng-font-lock.el b/haskell-tng-font-lock.el
index 6f6950f..cbe8343 100644
--- a/haskell-tng-font-lock.el
+++ b/haskell-tng-font-lock.el
@@ -38,68 +38,68 @@
(require 'haskell-tng-rx)
(require 'haskell-tng-util)
-(defgroup haskell-tng:faces nil
+(defgroup haskell-tng-faces nil
"Haskell font faces."
:group 'haskell-tng)
-(defface haskell-tng:keyword
+(defface haskell-tng-keyword-face
'((t :inherit font-lock-keyword-face))
"Haskell reserved names and operators."
- :group 'haskell-tng:faces)
+ :group 'haskell-tng-faces)
;; TODO module when defining and importing should be different than when using
;; (which should make the text more subtle rather than highlighted)
-(defface haskell-tng:module
+(defface haskell-tng-module-face
'((t :inherit font-lock-variable-name-face :weight bold))
"Haskell modules (packages)."
- :group 'haskell-tng:faces)
+ :group 'haskell-tng-faces)
-(defface haskell-tng:type
+(defface haskell-tng-type-face
'((t :inherit font-lock-type-face))
"Haskell types."
- :group 'haskell-tng:faces)
+ :group 'haskell-tng-faces)
-(defface haskell-tng:constructor
+(defface haskell-tng-conid-face
'((t :inherit font-lock-constant-face))
"Haskell constructors."
- :group 'haskell-tng:faces)
+ :group 'haskell-tng-faces)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Here is the `font-lock-keywords' table of matchers and highlighters.
(defconst
- haskell-tng:keywords
+ haskell-tng--font-lock-keywords
;; These regexps use the `rx' library so we can reuse common subpatterns. It
;; also increases the readability of the code and, in many cases, allows us
to
;; do more work in a single regexp instead of multiple passes.
- (let ((conid haskell-tng:rx:conid)
- ;;(qual haskell-tng:rx:qual)
- (consym haskell-tng:rx:consym)
- (qual haskell-tng:rx:qual)
- (bigspace `(| space ,haskell-tng:rx:newline)))
+ (let ((conid haskell-tng--rx-conid)
+ ;;(qual haskell-tng--rx-qual)
+ (consym haskell-tng--rx-consym)
+ (qual haskell-tng--rx-qual)
+ (bigspace `(| space ,haskell-tng--rx-newline)))
`(;; reservedid / reservedop
- (,haskell-tng:regexp:reserved
- . 'haskell-tng:keyword)
+ (,haskell-tng--rx-c-reserved
+ . 'haskell-tng-keyword-face)
;; Some things are not technically keywords but are always special so
make
;; sense to be fontified as such.
(,(rx (any ?\( ?\) ?\[ ?\] ?\{ ?\} ?,))
- (0 'haskell-tng:keyword))
+ (0 'haskell-tng-keyword-face))
;; TypeFamilies
(,(rx word-start "type" (+ space) (group "family") word-end)
- (1 'haskell-tng:keyword))
+ (1 'haskell-tng-keyword-face))
;; EXT:TypeFamilies (associated types, is this the right extension?)
;; Types
(haskell-tng:font:explicit-type:keyword
- (1 'haskell-tng:type keep))
+ (1 'haskell-tng-type-face keep))
(haskell-tng:font:topdecl:keyword
- (1 'haskell-tng:type keep))
+ (1 'haskell-tng-type-face keep))
(haskell-tng:font:type:keyword
- (1 'haskell-tng:type keep))
+ (1 'haskell-tng-type-face keep))
(haskell-tng:font:deriving:keyword
- (1 'haskell-tng:keyword keep)
- (2 'haskell-tng:type keep))
+ (1 'haskell-tng-keyword-face keep)
+ (2 'haskell-tng-type-face keep))
;; TODO unnamed newtype fields should be a type, not a constructor
;; TODO bug, multiple standalone instance declarations in a row do not
fire
@@ -110,7 +110,7 @@
;; applications and value extractor in a pattern. Needs work.
;; (,(rx-to-string `(: symbol-start "@" (* space)
;; (group (? ,qual) (| ,conid ,consym))))
- ;; (1 'haskell-tng:type))
+ ;; (1 'haskell-tng-type-face))
;; imports
(haskell-tng:font:import:keyword
@@ -121,40 +121,40 @@
;; EXT:Safe, EXT:Trustworthy, EXT:Unsafe
(group word-start (* ,qual) ,conid word-end) (* ,bigspace)
(group (? word-start "hiding" word-end)) (* space)))
- (haskell-tng:font:multiline:anchor-rewind) nil
- (1 'haskell-tng:keyword)
- (2 'haskell-tng:module)
- (3 'haskell-tng:keyword))
+ (haskell-tng--font-lock-multiline-anchor-rewind) nil
+ (1 'haskell-tng-keyword-face)
+ (2 'haskell-tng-module-face)
+ (3 'haskell-tng-keyword-face))
(,(rx-to-string `(: word-start (group "as") word-end (+ space)
word-start (group ,conid) word-end))
- (haskell-tng:font:multiline:anchor-rewind) nil
- (1 'haskell-tng:keyword)
- (2 'haskell-tng:module))
- (haskell-tng:font:explicit-constructors
- (haskell-tng:font:multiline:anchor-rewind 1)
- (haskell-tng:font:multiline:anchor-rewind)
- (0 'haskell-tng:constructor keep))
+ (haskell-tng--font-lock-multiline-anchor-rewind) nil
+ (1 'haskell-tng-keyword-face)
+ (2 'haskell-tng-module-face))
+ (haskell-tng--font-lock-explicit-conids
+ (haskell-tng--font-lock-multiline-anchor-rewind 1)
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (0 'haskell-tng-conid-face keep))
(,(rx-to-string `(: word-start ,conid word-end))
- (haskell-tng:font:multiline:anchor-rewind 1)
- (haskell-tng:font:multiline:anchor-rewind)
- (0 'haskell-tng:type keep))
+ (haskell-tng--font-lock-multiline-anchor-rewind 1)
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (0 'haskell-tng-type-face keep))
;; EXT:ExplicitNamespaces
)
(haskell-tng:font:module:keyword
(,(rx-to-string `(: word-start "module" word-end (+ space)
(group word-start (* ,qual) ,conid word-end)))
- (haskell-tng:font:multiline:anchor-rewind)
- (haskell-tng:font:multiline:anchor-rewind)
- (1 'haskell-tng:module))
- (haskell-tng:font:explicit-constructors
- (haskell-tng:font:multiline:anchor-rewind 2)
- (haskell-tng:font:multiline:anchor-rewind)
- (0 'haskell-tng:constructor keep))
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (1 'haskell-tng-module-face))
+ (haskell-tng--font-lock-explicit-conids
+ (haskell-tng--font-lock-multiline-anchor-rewind 2)
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (0 'haskell-tng-conid-face keep))
(,(rx-to-string `(: word-start ,conid word-end))
- (haskell-tng:font:multiline:anchor-rewind 2)
- (haskell-tng:font:multiline:anchor-rewind)
- (0 'haskell-tng:type keep)))
+ (haskell-tng--font-lock-multiline-anchor-rewind 2)
+ (haskell-tng--font-lock-multiline-anchor-rewind)
+ (0 'haskell-tng-type-face keep)))
;; TODO pragmas
;; TODO numeric / char primitives?
@@ -164,15 +164,15 @@
;; TODO should perhaps be in a different font than module/import use,
e.g.
;; lighter not bolder.
(,(rx-to-string `(: symbol-start (+ ,qual)))
- . 'haskell-tng:module)
+ . 'haskell-tng-module-face)
;; constructors
(,(rx-to-string `(: symbol-start (| ,conid ,consym) symbol-end))
- . 'haskell-tng:constructor)
+ . 'haskell-tng-conid-face)
)))
-(defun haskell-tng:font:multiline:anchor-rewind (&optional group jump end)
+(defun haskell-tng--font-lock-multiline-anchor-rewind (&optional group jump
end)
"MATCH-ANCHORED moving point to group beginning (plus JUMP) and declaring
LIMIT.
Can be used as PRE-FORM or POST-FORM, allowing anchors to
refontify the previously matched region.
@@ -190,7 +190,7 @@ If there is no match for GROUP, move to the end of the
line, canceling this ANCH
(forward-char jump))
(match-end 0)))
-(defun haskell-tng:font:explicit-constructors (limit)
+(defun haskell-tng--font-lock-explicit-conids (limit)
"Finds paren blocks of constructors when in an import statement.
Some complexity to avoid matching on operators."
(when (re-search-forward
@@ -198,7 +198,7 @@ Some complexity to avoid matching on operators."
(rx (any lower) (* space) "(")
limit t)
(let ((open (point)))
- (when-let (close (haskell-tng:paren-close))
+ (when-let (close (haskell-tng--util-paren-close))
(when (<= close limit)
(goto-char open)
(re-search-forward (rx (+ anything)) close t))))))
@@ -218,16 +218,16 @@ Some complexity to avoid matching on operators."
(defvar font-lock-beg)
(defvar font-lock-end))
-(defconst haskell-tng:extend-region-functions
+(defconst haskell-tng--font-lock-extend-region-functions
'(font-lock-extend-region-wholelines
font-lock-extend-region-multiline)
"Used in `font-lock-extend-region-functions'.
-Automatically populated by `haskell-tng:font:multiline'")
+Automatically populated by `haskell-tng--font-lock-multiline'")
;; TODO (perf) don't extend if the TRIGGER has a multiline prop already or
;; consider only using multiline instead of trying to add custom
;; font-lock-extend-region-functions entries.
-(defmacro haskell-tng:font:multiline (name trigger find &rest limiters)
+(defmacro haskell-tng--font-lock-multiline (name trigger find &rest limiters)
"Defines `font-lock-keywords' / `font-lock-extend-region-functions' entries.
TRIGGER and FIND are forms that produce a regexp, which is
@@ -276,55 +276,55 @@ succeeds and may further restrict the FIND search limit."
(when (re-search-forward ,regexp-1 limit t)
(goto-char (match-beginning 0))
,(finder 'limit)))
- (add-to-list 'haskell-tng:extend-region-functions ',extend t)))))
+ (add-to-list 'haskell-tng--font-lock-extend-region-functions ',extend
t)))))
-(haskell-tng:font:multiline explicit-type
+(haskell-tng--font-lock-multiline explicit-type
(rx symbol-start "::" symbol-end)
(rx symbol-start "::" symbol-end (group (+
anything)))
- haskell-tng:paren-close
- haskell-tng:indent-close-previous
- haskell-tng:do-bind)
+ haskell-tng--util-paren-close
+ haskell-tng--util-indent-close-previous
+ haskell-tng--util-do-bind)
-(haskell-tng:font:multiline topdecl
+(haskell-tng--font-lock-multiline topdecl
(rx line-start (| "data" "newtype" "class"
"instance") word-end)
(rx line-start (| "data" "newtype" "class"
"instance") word-end
(group (+? anything))
(| (: line-start symbol-start)
(: symbol-start (| "where" "=")
symbol-end))))
-(haskell-tng:font:multiline type
+(haskell-tng--font-lock-multiline type
(rx line-start "type" word-end)
(rx line-start "type" word-end (group (+
anything)))
- haskell-tng:indent-close)
+ haskell-tng--util-indent-close)
;; DeriveAnyClass
;; DerivingStrategies
;; GeneralizedNewtypeDeriving
;; EXT:DerivingVia
;; EXT:StandaloneDeriving
-(haskell-tng:font:multiline deriving
+(haskell-tng--font-lock-multiline deriving
(rx word-start "deriving" word-end)
(rx word-start "deriving" word-end
(+ space) (group (? (| "anyclass" "stock"
"newtype") word-end))
;; TODO support a lone derivation without
brackets
(* space) ?\( (group (* anything)) ?\))
- haskell-tng:indent-close)
+ haskell-tng--util-indent-close)
-(haskell-tng:font:multiline import
+(haskell-tng--font-lock-multiline import
(rx line-start "import" word-end)
(rx line-start "import" word-end
(+ (not (any ?\( )))
(? "(" (group (+ anything))))
- haskell-tng:indent-close)
+ haskell-tng--util-indent-close)
-(haskell-tng:font:multiline module
+(haskell-tng--font-lock-multiline module
(rx line-start "module" word-end)
(rx line-start "module" word-end
(+ space)
(group word-start (+ (not (any space)))
word-end)
(group (+ anything))
word-start "where" word-end)
- haskell-tng:next-where)
+ haskell-tng--util-next-where)
(provide 'haskell-tng-font-lock)
;;; haskell-tng-font-lock.el ends here
diff --git a/haskell-tng-layout.el b/haskell-tng-layout.el
index 3517708..08fe7ce 100644
--- a/haskell-tng-layout.el
+++ b/haskell-tng-layout.el
@@ -39,29 +39,29 @@
;; Easiest cache... full buffer parse with full invalidation on any insertion.
;;
;; A list of (OPEN . (CLOSE . SEPS)) positions, one per inferred block.
-(defvar-local haskell-tng-layout:cache nil)
+(defvar-local haskell-tng--layout-cache nil)
-(defun haskell-tng-layout:cache-invalidation (_beg _end _pre-length)
+(defun haskell-tng--layout-cache-invalidation (_beg _end _pre-length)
"For use in `after-change-functions' to invalidate the state of
the layout engine."
- (when haskell-tng-layout:cache
- (setq haskell-tng-layout:cache nil)))
+ (when haskell-tng--layout-cache
+ (setq haskell-tng--layout-cache nil)))
;; TODO a visual debugging option would be great, showing virtuals as overlays
;; EXT:NonDecreasingIndentation
-(defun haskell-tng-layout:virtuals-at-point ()
+(defun haskell-tng--layout-virtuals-at-point ()
"List of virtual `{' `}' and `;' at point, according to the
Haskell2010 Layout rules.
Designed to be called repeatedly, managing its own caching."
- (unless haskell-tng-layout:cache
- (haskell-tng-layout:rebuild-cache-full))
+ (unless haskell-tng--layout-cache
+ (haskell-tng--layout-rebuild-cache-full))
(let ((pos (point))
opens breaks closes)
- (dolist (block haskell-tng-layout:cache)
+ (dolist (block haskell-tng--layout-cache)
(let ((open (car block))
(close (cadr block))
(lines (cddr block)))
@@ -75,25 +75,25 @@ Designed to be called repeatedly, managing its own caching."
(push ";" breaks))))))
(append opens closes breaks)))
-(defun haskell-tng-layout:has-virtual-at-point ()
+(defun haskell-tng--layout-has-virtual-at-point ()
"t if there is a virtual at POINT"
;; avoids a measured performance hit (append indentation)
- (unless haskell-tng-layout:cache
- (haskell-tng-layout:rebuild-cache-full))
+ (unless haskell-tng--layout-cache
+ (haskell-tng--layout-rebuild-cache-full))
(--any (member (point) it)
- haskell-tng-layout:cache))
+ haskell-tng--layout-cache))
-(defun haskell-tng-layout:rebuild-cache-full ()
+(defun haskell-tng--layout-rebuild-cache-full ()
(let (case-fold-search
cache)
(save-excursion
(goto-char 0)
(while (not (eobp))
- (when-let (wldo (haskell-tng-layout:next-wldo))
+ (when-let (wldo (haskell-tng--layout-next-wldo))
(push wldo cache))))
- (setq haskell-tng-layout:cache (reverse cache))))
+ (setq haskell-tng--layout-cache (reverse cache))))
-(defun haskell-tng-layout:next-wldo ()
+(defun haskell-tng--layout-next-wldo ()
(catch 'wldo
(while (not (eobp))
(forward-comment (point-max))
@@ -105,11 +105,11 @@ Designed to be called repeatedly, managing its own
caching."
(goto-char (match-end 0))
(forward-comment (point-max))
(when (not (looking-at "{"))
- (throw 'wldo (haskell-tng-layout:wldo))))
+ (throw 'wldo (haskell-tng--layout-wldo))))
(t (skip-syntax-forward "^-"))))))
-(defun haskell-tng-layout:wldo ()
+(defun haskell-tng--layout-wldo ()
"A list holding virtual `{', then `}', then virtual `;' in order.
Assumes that point is at the beginning of the first token after a
@@ -118,7 +118,7 @@ WLDO that is using the offside rule."
(let* ((open (point))
seps
(level (current-column))
- (limit (or (haskell-tng:paren-close) (point-max)))
+ (limit (or (haskell-tng--util-paren-close) (point-max)))
(close (catch 'closed
(while (not (eobp))
(forward-line)
diff --git a/haskell-tng-lexer.el b/haskell-tng-lexer.el
index afb6912..d21701a 100644
--- a/haskell-tng-lexer.el
+++ b/haskell-tng-lexer.el
@@ -38,25 +38,25 @@
;; The list of virtual tokens that must be played back at point, or `t' to
;; indicate that virtual tokens have already been played back at point and
;; normal lexing may continue.
-(defvar-local haskell-tng-lexer:state nil)
+(defvar-local haskell-tng--lexer-state nil)
;; A cons cell of the last known direction and point when forward or backward
-;; lexing was called. Used to invalidate `haskell-tng-lexer:state' during
+;; lexing was called. Used to invalidate `haskell-tng--lexer-state' during
;; read-only navigation.
-(defvar-local haskell-tng-lexer:last nil)
+(defvar-local haskell-tng--lexer-last nil)
;; syntax-tables supported by SMIE
-(defconst haskell-tng-lexer:fast-syntax
+(defconst haskell-tng--lexer-fast-syntax
(rx (| (syntax open-parenthesis)
(syntax close-parenthesis)
(syntax string-quote)
(syntax string-delimiter))))
-(defun haskell-tng-lexer:state-invalidation (_beg _end _pre-length)
+(defun haskell-tng--lexer-state-invalidation (_beg _end _pre-length)
"For use in `after-change-functions' to invalidate the state of
the lexer."
- (when haskell-tng-lexer:state
- (setq haskell-tng-lexer:state nil)))
+ (when haskell-tng--lexer-state
+ (setq haskell-tng--lexer-state nil)))
;; Implementation of `smie-forward-token' for Haskell, i.e.
;;
@@ -72,167 +72,167 @@ the lexer."
;; were to support a 4th return type: a list of any of the above.
;;
;; Any changes to this function must be reflected in
-;; `haskell-tng-lexer:backward-token'.
-(defun haskell-tng-lexer:forward-token ()
+;; `haskell-tng--lexer-backward-token'.
+(defun haskell-tng--lexer-forward-token ()
(unwind-protect
(let (case-fold-search)
- (haskell-tng-lexer:check-last 'forward)
+ (haskell-tng--lexer-check-last 'forward)
- (if (consp haskell-tng-lexer:state)
+ (if (consp haskell-tng--lexer-state)
;; continue replaying virtual tokens
- (haskell-tng-lexer:replay-virtual)
+ (haskell-tng--lexer-replay-virtual)
(forward-comment (point-max))
;; TODO: performance. Only request virtuals when they make sense...
;; e.g. on newlines, or following a WLDO (assuming a comment-aware
;; lookback is fast).
- (setq haskell-tng-lexer:state
- (unless haskell-tng-lexer:state
- (haskell-tng-layout:virtuals-at-point)))
+ (setq haskell-tng--lexer-state
+ (unless haskell-tng--lexer-state
+ (haskell-tng--layout-virtuals-at-point)))
(cond
;; new virtual tokens
- (haskell-tng-lexer:state
- (haskell-tng-lexer:replay-virtual))
+ (haskell-tng--lexer-state
+ (haskell-tng--lexer-replay-virtual))
((eobp) nil)
;; reserved keywords take precedence
- ((looking-at haskell-tng:regexp:reserved-hack)
- (pcase (haskell-tng-lexer:last-match)
+ ((looking-at haskell-tng--rx-c-reserved-hack)
+ (pcase (haskell-tng--lexer-last-match)
(":" "CONSYM")
("':" "KINDSYM") ;; DataKinds
- ((and "->" (guard (haskell-tng-lexer:arrow-is-type))) "=>")
+ ((and "->" (guard (haskell-tng--lexer-arrow-is-type))) "=>")
(other other)))
;; syntax tables (supported by `smie-indent-forward-token')
- ((looking-at haskell-tng-lexer:fast-syntax) nil)
+ ((looking-at haskell-tng--lexer-fast-syntax) nil)
;; known identifiers
;;
;; Ordering is important because regexps are greedy.
- ((looking-at haskell-tng:regexp:qual)
+ ((looking-at haskell-tng--rx-c-qual)
;; Matches qualifiers separately from identifiers because the
;; backwards lexer is not greedy enough. Qualifiers are not
;; interesting from a grammar point of view so we ignore them.
- (haskell-tng-lexer:last-match nil "")
- (haskell-tng-lexer:forward-token))
+ (haskell-tng--lexer-last-match nil "")
+ (haskell-tng--lexer-forward-token))
((looking-at (rx "'["))
;; DataKinds
(null (goto-char (+ (point) 1))))
- ((looking-at haskell-tng:regexp:kindsym)
+ ((looking-at haskell-tng--rx-c-kindsym)
;; caveat: doesn't include typelevel lists, see fast-syntax
- (haskell-tng-lexer:last-match nil "KINDSYM"))
- ((looking-at haskell-tng:regexp:kindid)
- (haskell-tng-lexer:last-match nil "KINDID"))
- ((looking-at haskell-tng:regexp:consym)
- (haskell-tng-lexer:last-match nil "CONSYM"))
- ((looking-at haskell-tng:regexp:conid)
- (haskell-tng-lexer:last-match nil "CONID"))
- ((looking-at haskell-tng:regexp:varid)
- (haskell-tng-lexer:last-match nil "VARID"))
- ((looking-at haskell-tng:regexp:symid)
- (haskell-tng-lexer:last-match nil "SYMID"))
+ (haskell-tng--lexer-last-match nil "KINDSYM"))
+ ((looking-at haskell-tng--rx-c-kindid)
+ (haskell-tng--lexer-last-match nil "KINDID"))
+ ((looking-at haskell-tng--rx-c-consym)
+ (haskell-tng--lexer-last-match nil "CONSYM"))
+ ((looking-at haskell-tng--rx-c-conid)
+ (haskell-tng--lexer-last-match nil "CONID"))
+ ((looking-at haskell-tng--rx-c-varid)
+ (haskell-tng--lexer-last-match nil "VARID"))
+ ((looking-at haskell-tng--rx-c-symid)
+ (haskell-tng--lexer-last-match nil "SYMID"))
;; TODO numeric literals
;; unknown things
((looking-at (rx (+ (| (syntax word) (syntax symbol)))))
- (haskell-tng-lexer:last-match))
+ (haskell-tng--lexer-last-match))
;; single char
(t
(forward-char)
(string (char-before))))))
;; save the state
- (haskell-tng-lexer:set-last 'forward)))
+ (haskell-tng--lexer-set-last 'forward)))
;; Implementation of `smie-backward-token' for Haskell, matching
-;; `haskell-tng-lexer:forward-token'.
-(defun haskell-tng-lexer:backward-token ()
+;; `haskell-tng--lexer-forward-token'.
+(defun haskell-tng--lexer-backward-token ()
(unwind-protect
(let (case-fold-search)
- (haskell-tng-lexer:check-last 'backward)
+ (haskell-tng--lexer-check-last 'backward)
- (if (consp haskell-tng-lexer:state)
- (haskell-tng-lexer:replay-virtual 'reverse)
+ (if (consp haskell-tng--lexer-state)
+ (haskell-tng--lexer-replay-virtual 'reverse)
- (setq haskell-tng-lexer:state
- (unless haskell-tng-lexer:state
+ (setq haskell-tng--lexer-state
+ (unless haskell-tng--lexer-state
;; TODO semicolon cannot be used as a separator and a line
end
;; in the grammar rules, so should we emit multiple tokens?
- (haskell-tng-layout:virtuals-at-point)))
+ (haskell-tng--layout-virtuals-at-point)))
- (if haskell-tng-lexer:state
- (haskell-tng-lexer:replay-virtual 'reverse)
+ (if haskell-tng--lexer-state
+ (haskell-tng--lexer-replay-virtual 'reverse)
(forward-comment (- (point)))
(let ((lbp (min (point) (line-beginning-position))))
(cond
((bobp) nil)
- ((looking-back haskell-tng:regexp:reserved-hack
+ ((looking-back haskell-tng--rx-c-reserved-hack
(max lbp (- (point) 8)) 't)
- (pcase (haskell-tng-lexer:last-match 'reverse)
+ (pcase (haskell-tng--lexer-last-match 'reverse)
(":" "CONSYM")
("':" "KINDSYM") ;; DataKinds
- ((and "->" (guard (haskell-tng-lexer:arrow-is-type))) "=>")
+ ((and "->" (guard (haskell-tng--lexer-arrow-is-type))) "=>")
(other other)))
- ((looking-back haskell-tng-lexer:fast-syntax
+ ((looking-back haskell-tng--lexer-fast-syntax
(max lbp (- (point) 1)))
nil)
- ((looking-back haskell-tng:regexp:qual lbp 't)
- (haskell-tng-lexer:last-match 'reverse "")
- (haskell-tng-lexer:backward-token))
+ ((looking-back haskell-tng--rx-c-qual lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "")
+ (haskell-tng--lexer-backward-token))
((and (looking-at (rx "["))
(looking-back (rx "'") (- (point) 1)))
;; non-trivial inversion
(goto-char (- (point) 1))
- (haskell-tng-lexer:backward-token))
- ((looking-back haskell-tng:regexp:kindsym lbp 't)
- (haskell-tng-lexer:last-match 'reverse "KINDSYM"))
- ((looking-back haskell-tng:regexp:kindid lbp 't)
- (haskell-tng-lexer:last-match 'reverse "KINDID"))
- ((looking-back haskell-tng:regexp:consym lbp 't)
- (haskell-tng-lexer:last-match 'reverse "CONSYM"))
- ((looking-back haskell-tng:regexp:conid lbp 't)
- (haskell-tng-lexer:last-match 'reverse "CONID"))
- ((looking-back haskell-tng:regexp:varid lbp 't)
- (haskell-tng-lexer:last-match 'reverse "VARID"))
- ((looking-back haskell-tng:regexp:symid lbp 't)
- (haskell-tng-lexer:last-match 'reverse "SYMID"))
+ (haskell-tng--lexer-backward-token))
+ ((looking-back haskell-tng--rx-c-kindsym lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "KINDSYM"))
+ ((looking-back haskell-tng--rx-c-kindid lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "KINDID"))
+ ((looking-back haskell-tng--rx-c-consym lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "CONSYM"))
+ ((looking-back haskell-tng--rx-c-conid lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "CONID"))
+ ((looking-back haskell-tng--rx-c-varid lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "VARID"))
+ ((looking-back haskell-tng--rx-c-symid lbp 't)
+ (haskell-tng--lexer-last-match 'reverse "SYMID"))
((looking-back (rx (+ (| (syntax word) (syntax symbol)))) lbp 't)
- (haskell-tng-lexer:last-match 'reverse))
+ (haskell-tng--lexer-last-match 'reverse))
(t
(forward-char -1)
(string (char-after))))))))
- (haskell-tng-lexer:set-last 'backward)))
+ (haskell-tng--lexer-set-last 'backward)))
-(defun haskell-tng-lexer:set-last (direction)
- (setq haskell-tng-lexer:last (cons direction (point))))
+(defun haskell-tng--lexer-set-last (direction)
+ (setq haskell-tng--lexer-last (cons direction (point))))
-(defun haskell-tng-lexer:check-last (direction)
- (when (and haskell-tng-lexer:state
- (not (equal haskell-tng-lexer:last (cons direction (point)))))
- (setq haskell-tng-lexer:state nil)))
+(defun haskell-tng--lexer-check-last (direction)
+ (when (and haskell-tng--lexer-state
+ (not (equal haskell-tng--lexer-last (cons direction (point)))))
+ (setq haskell-tng--lexer-state nil)))
-(defun haskell-tng-lexer:replay-virtual (&optional reverse)
+(defun haskell-tng--lexer-replay-virtual (&optional reverse)
"read a virtual token from state, set 't when all done"
(unwind-protect
(if reverse
(unwind-protect
- (car (last haskell-tng-lexer:state))
- (setq haskell-tng-lexer:state
- (butlast haskell-tng-lexer:state)))
- (pop haskell-tng-lexer:state))
- (unless haskell-tng-lexer:state
- (setq haskell-tng-lexer:state 't))))
-
-(defun haskell-tng-lexer:last-match (&optional reverse alt)
+ (car (last haskell-tng--lexer-state))
+ (setq haskell-tng--lexer-state
+ (butlast haskell-tng--lexer-state)))
+ (pop haskell-tng--lexer-state))
+ (unless haskell-tng--lexer-state
+ (setq haskell-tng--lexer-state 't))))
+
+(defun haskell-tng--lexer-last-match (&optional reverse alt)
(goto-char (if reverse (match-beginning 0) (match-end 0)))
(or alt (match-string-no-properties 0)))
-(defun haskell-tng-lexer:arrow-is-type ()
+(defun haskell-tng--lexer-arrow-is-type ()
"Assuming that we just parsed a `->' arrow, search backwards to
find reserved tokens that can disambiguate the usecase as a type,
returning non-nil for types."
diff --git a/haskell-tng-mode.el b/haskell-tng-mode.el
index 2ca5ce1..4999ecd 100644
--- a/haskell-tng-mode.el
+++ b/haskell-tng-mode.el
@@ -26,7 +26,7 @@
"Haskell support: The Next Generation."
:group 'languages)
-(defcustom haskell-tng-mode:prettify-symbols
+(defcustom haskell-tng-prettify-symbols
'(("forall" . ?∀))
"Integration with `prettify-symbols' giving the impression of UnicodeSyntax.
@@ -41,7 +41,7 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
(define-derived-mode haskell-tng-mode prog-mode "Hask"
"Major mode for editing Haskell programs."
:group 'haskell-tng
- :syntax-table haskell-tng:syntax-table
+ :syntax-table haskell-tng--syntax-table
;; TODO paragraph-start, paragraph-separate, fill-paragraph-function
;;
@@ -59,7 +59,7 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
dabbrev-case-replace nil
words-include-escapes t
- syntax-propertize-function #'haskell-tng:syntax-propertize
+ syntax-propertize-function #'haskell-tng--syntax-propertize
parse-sexp-lookup-properties t
parse-sexp-ignore-comments t
@@ -71,11 +71,11 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
comment-end-skip (rx (* "\s") (group (| (any ?\n) (syntax comment-end))))
comment-auto-fill-only-comments t
- font-lock-defaults '(haskell-tng:keywords)
+ font-lock-defaults '(haskell-tng--font-lock-keywords)
font-lock-multiline t
- font-lock-extend-region-functions haskell-tng:extend-region-functions
+ font-lock-extend-region-functions
haskell-tng--font-lock-extend-region-functions
- prettify-symbols-alist haskell-tng-mode:prettify-symbols)
+ prettify-symbols-alist haskell-tng-prettify-symbols)
;; whitespace is meaningful, disable electric indentation. Note that
;; `electric-indent-inhibit' causes a performance regression in SMIE
@@ -85,7 +85,7 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
(setq-local projectile-tags-command "fast-tags -Re --exclude=dist-newstyle
.")
(setq-local smie-blink-matching-inners nil) ;; c.f. `smie-closer-alist'
- (haskell-tng-smie:setup)
+ (haskell-tng--smie-setup)
(bind-key "<return>" 'haskell-tng-newline haskell-tng-mode-map)
@@ -98,8 +98,8 @@ Load `prettify-symbols-mode' in `haskell-tng-mode-hook'."
(bind-key "C-c e" 'next-error haskell-tng-compilation-mode-map)
;; external tools
- (bind-key "C-c C" 'haskell-tng-contrib:stack2cabal haskell-tng-mode-map)
- (bind-key "C-c C-r f" 'haskell-tng-contrib:stylish-haskell
haskell-tng-mode-map)
+ (bind-key "C-c C" 'haskell-tng-stack2cabal haskell-tng-mode-map)
+ (bind-key "C-c C-r f" 'haskell-tng-stylish-haskell haskell-tng-mode-map)
)
diff --git a/haskell-tng-rx.el b/haskell-tng-rx.el
index 6feb315..650c9ea 100644
--- a/haskell-tng-rx.el
+++ b/haskell-tng-rx.el
@@ -12,16 +12,16 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Here are `rx' patterns that are reused as a very simple form of BNF grammar.
-(defconst haskell-tng:rx:consym '(: ":" (+ (syntax symbol))))
-(defconst haskell-tng:rx:conid '(: upper (* word)))
-(defconst haskell-tng:rx:varid '(: (any lower ?_) (* word)))
-(defconst haskell-tng:rx:symid `(| (+ (syntax symbol))
- (: "`" ,haskell-tng:rx:varid "`")))
-(defconst haskell-tng:rx:qual `(+ (: ,haskell-tng:rx:conid (char ?.))))
-(defconst haskell-tng:rx:kindsym `(: "'" ,haskell-tng:rx:consym)) ;; DataKinds
-(defconst haskell-tng:rx:kindid `(: "'" ,haskell-tng:rx:conid)) ;; DataKinds
+(defconst haskell-tng--rx-consym '(: ":" (+ (syntax symbol))))
+(defconst haskell-tng--rx-conid '(: upper (* word)))
+(defconst haskell-tng--rx-varid '(: (any lower ?_) (* word)))
+(defconst haskell-tng--rx-symid `(| (+ (syntax symbol))
+ (: "`" ,haskell-tng--rx-varid "`")))
+(defconst haskell-tng--rx-qual `(+ (: ,haskell-tng--rx-conid (char ?.))))
+(defconst haskell-tng--rx-kindsym `(: "'" ,haskell-tng--rx-consym)) ;;
DataKinds
+(defconst haskell-tng--rx-kindid `(: "'" ,haskell-tng--rx-conid)) ;; DataKinds
-(defun haskell-tng:rx:reserved (hack)
+(defun haskell-tng--rx-reserved (hack)
"reservedid / reservedop.
This is a function, not a constant, because the lexer needs a
@@ -54,7 +54,7 @@ give false positives." `(|
(| "[]" "()") ;; empty list / void
(: symbol-start (char ?\\)))) ;; TODO only for lambdas, don't include ops
like \\
-(defconst haskell-tng:rx:newline
+(defconst haskell-tng--rx-newline
'(| ?\n
(: symbol-start "--" (+ (not (any ?\n))) ?\n))
"Newline or line comment.")
@@ -66,27 +66,27 @@ give false positives." `(|
;;
;; Word/symbol boundaries to help backwards regexp searches to be greedy and
;; are not in the BNF form as it breaks composability.
-(defconst haskell-tng:regexp:reserved
- (rx-to-string (haskell-tng:rx:reserved nil)))
-(defconst haskell-tng:regexp:reserved-hack
- (rx-to-string (haskell-tng:rx:reserved t)))
-(defconst haskell-tng:regexp:qual
- (rx-to-string `(: symbol-start ,haskell-tng:rx:qual)))
-(defconst haskell-tng:regexp:kindsym
- (rx-to-string `(: word-start ,haskell-tng:rx:kindsym)))
-(defconst haskell-tng:regexp:kindid
- (rx-to-string `(: word-start ,haskell-tng:rx:kindid)))
-(defconst haskell-tng:regexp:consym
- (rx-to-string haskell-tng:rx:consym))
-(defconst haskell-tng:regexp:conid
- (rx-to-string `(: word-start ,haskell-tng:rx:conid)))
-(defconst haskell-tng:regexp:varid
- (rx-to-string `(| (: word-start ,haskell-tng:rx:varid)
+(defconst haskell-tng--rx-c-reserved
+ (rx-to-string (haskell-tng--rx-reserved nil)))
+(defconst haskell-tng--rx-c-reserved-hack
+ (rx-to-string (haskell-tng--rx-reserved t)))
+(defconst haskell-tng--rx-c-qual
+ (rx-to-string `(: symbol-start ,haskell-tng--rx-qual)))
+(defconst haskell-tng--rx-c-kindsym
+ (rx-to-string `(: word-start ,haskell-tng--rx-kindsym)))
+(defconst haskell-tng--rx-c-kindid
+ (rx-to-string `(: word-start ,haskell-tng--rx-kindid)))
+(defconst haskell-tng--rx-c-consym
+ (rx-to-string haskell-tng--rx-consym))
+(defconst haskell-tng--rx-c-conid
+ (rx-to-string `(: word-start ,haskell-tng--rx-conid)))
+(defconst haskell-tng--rx-c-varid
+ (rx-to-string `(| (: word-start ,haskell-tng--rx-varid)
;; TODO symids in brackets (==)
- (: symbol-start (char ??) ,haskell-tng:rx:varid) ;;
ImplicitParams
+ (: symbol-start (char ??) ,haskell-tng--rx-varid) ;;
ImplicitParams
)))
-(defconst haskell-tng:regexp:symid
- (rx-to-string haskell-tng:rx:symid))
+(defconst haskell-tng--rx-c-symid
+ (rx-to-string haskell-tng--rx-symid))
(provide 'haskell-tng-rx)
;;; haskell-tng-rx.el ends here
diff --git a/haskell-tng-smie.el b/haskell-tng-smie.el
index f83d975..b3429f8 100644
--- a/haskell-tng-smie.el
+++ b/haskell-tng-smie.el
@@ -50,8 +50,8 @@
;; TODO autodetection of indent options
-;; TODO implement haskell-tng-indent-aligntypes
-(defcustom haskell-tng-indent-aligntypes nil
+;; TODO implement haskell-tng-aligntypes
+(defcustom haskell-tng-aligntypes nil
"Whether to align arrows to their parent :: declaration.
For example, nil and t, respectively:
@@ -64,8 +64,8 @@ foobar :: Monad m
:type 'booleanp
:group 'haskell-tng)
-;; TODO implement haskell-tng-indent-typelead
-(defcustom haskell-tng-indent-typelead 3
+;; TODO implement haskell-tng-typelead
+(defcustom haskell-tng-typelead 3
"Leading spaces in a trailing type signature, relative to type arrows.
For example 3 and 1 are respectively:
@@ -100,7 +100,7 @@ foobar1 ::
;; We do not include rules unless they have an impact on indentation.
Navigation
;; with a more complete grammar has been shown to be less than satisfactory,
;; therefore there is no reason to do more than is needed.
-(defvar haskell-tng-smie:grammar
+(defvar haskell-tng--smie-grammar
;; see docs for `smie-bnf->prec2'
(smie-prec2->grammar
(smie-bnf->prec2
@@ -170,25 +170,25 @@ foobar1 ::
)))
-(defvar haskell-tng-smie:debug nil)
-(defun haskell-tng-smie:debug (command)
+(defvar haskell-tng--smie-debug nil)
+(defun haskell-tng--smie-debug (command)
"An alternative to RETURN that outputs SMIE debugging
information, to aid in the creation of new rules."
(let ((output " *haskell-tng-smie*"))
(when (get-buffer output)
(kill-buffer output))
- (let ((haskell-tng-smie:debug (get-buffer-create output))
+ (let ((haskell-tng--smie-debug (get-buffer-create output))
(inhibit-read-only t))
- (with-current-buffer haskell-tng-smie:debug
+ (with-current-buffer haskell-tng--smie-debug
(read-only-mode 1))
(call-interactively command)
(display-buffer output))))
-(defun haskell-tng-smie:debug-newline ()
+(defun haskell-tng--smie-debug-newline ()
(interactive)
- (haskell-tng-smie:debug #'newline-and-indent))
-(defun haskell-tng-smie:debug-tab ()
+ (haskell-tng--smie-debug #'newline-and-indent))
+(defun haskell-tng--smie-debug-tab ()
(interactive)
- (haskell-tng-smie:debug #'indent-for-tab-command))
+ (haskell-tng--smie-debug #'indent-for-tab-command))
;;
https://www.gnu.org/software/emacs/manual/html_mono/elisp.html#SMIE-Indentation
;;
@@ -205,12 +205,12 @@ information, to aid in the creation of new rules."
;; NOTE https://debbugs.gnu.org/cgi/bugreport.cgi?bug=36434
;;
;; smie-rule-* are not designed be used in :elem or :list-intro
-(defun haskell-tng-smie:rules (method arg)
- (when haskell-tng-smie:debug
+(defun haskell-tng--smie-rules (method arg)
+ (when haskell-tng--smie-debug
(let ((sym (symbol-at-point))
(parent (and (boundp 'smie--parent)
(caddr (smie-indent--parent)))))
- (with-current-buffer haskell-tng-smie:debug
+ (with-current-buffer haskell-tng--smie-debug
(insert
(format
"RULES: %S %S %S\n P: %S\n"
@@ -224,22 +224,22 @@ information, to aid in the creation of new rules."
;; TODO insert the predicted token... code completion!
('empty-line-token
(let* ((ancestors (save-excursion
- (haskell-tng-smie:ancestors 3)))
+ (haskell-tng--smie-ancestors 3)))
(parent (car ancestors))
(grand (cadr ancestors))
(great (caddr ancestors))
(prev (save-excursion
(car (smie-indent-backward-token))))
(psexp (save-excursion
- (caddr (haskell-tng:until
+ (caddr (haskell-tng--util-until
(or (smie-backward-sexp)
(bobp))))))
(next (save-excursion
(car (smie-indent-forward-token))))
- (prevline (haskell-tng-smie:prev-line-tokens)))
+ (prevline (haskell-tng--smie-prev-line-tokens)))
- (when haskell-tng-smie:debug
- (with-current-buffer haskell-tng-smie:debug
+ (when haskell-tng--smie-debug
+ (with-current-buffer haskell-tng--smie-debug
(insert (format "^^^: %S\n ^^: %S\n ^: %S\n -1: %S\n -(: %S\n
+1: %S\n"
great grand parent prev psexp next))))
@@ -321,7 +321,7 @@ information, to aid in the creation of new rules."
(smie-rule-parent))
("|"
(if (smie-rule-parent-p "=")
- (haskell-tng-smie:rule-parent-column)
+ (haskell-tng--smie-rule-parent-column)
(smie-rule-separator method)))
((and (or "[" "(" "{") (guard (smie-rule-hanging-p)))
(smie-rule-parent))
@@ -334,41 +334,41 @@ information, to aid in the creation of new rules."
))
-(defconst haskell-tng-smie:return
+(defconst haskell-tng--smie-return
'(haskell-tng-newline
comment-indent-new-line
newline-and-indent
newline
- haskell-tng-smie:debug-newline)
+ haskell-tng--smie-debug-newline)
"Users with custom newlines should add their command.")
-(defvar-local haskell-tng-smie:indentations nil)
-(defun haskell-tng-smie:indent-cycle ()
+(defvar-local haskell-tng--smie-indentations nil)
+(defun haskell-tng--smie-indent-cycle ()
"When invoked more than once, returns an alternative indentation level."
;; There is a design choice here: either we compute all the indentation
levels
;; (including a recursive call to `smie-indent-calculate') and put them into
a
;; ring that we cycle, or we push/pop with recalculation. We choose the
;; latter, because cache invalidation is easier.
- (if (or (member this-command haskell-tng-smie:return)
+ (if (or (member this-command haskell-tng--smie-return)
(not
(or (eq this-command last-command)
- (member last-command haskell-tng-smie:return))))
- (setq haskell-tng-smie:indentations nil)
+ (member last-command haskell-tng--smie-return))))
+ (setq haskell-tng--smie-indentations nil)
;; TAB+TAB or RETURN+TAB
- (when (null haskell-tng-smie:indentations)
+ (when (null haskell-tng--smie-indentations)
(let ((prime (current-column)))
- (setq haskell-tng-smie:indentations
+ (setq haskell-tng--smie-indentations
(append
;; TODO backtab cycle in reverse
- (-remove-item prime (haskell-tng-smie:indent-alts))
+ (-remove-item prime (haskell-tng--smie-indent-alts))
(list prime))))))
- (when haskell-tng-smie:debug
- (when-let (alts haskell-tng-smie:indentations)
- (with-current-buffer haskell-tng-smie:debug
+ (when haskell-tng--smie-debug
+ (when-let (alts haskell-tng--smie-indentations)
+ (with-current-buffer haskell-tng--smie-debug
(insert (format "ALTS: %S\n" alts)))))
- (pop haskell-tng-smie:indentations))
+ (pop haskell-tng--smie-indentations))
-(defun haskell-tng-smie:indent-alts ()
+(defun haskell-tng--smie-indent-alts ()
"Returns a list of alternative indentation levels for the
current line."
(let ((pos (point))
@@ -376,7 +376,7 @@ current line."
(save-excursion
(end-of-line 0)
(re-search-backward (rx bol (not space)) nil t)
- (when-let (new (haskell-tng-smie:relevant-alts pos t))
+ (when-let (new (haskell-tng--smie-relevant-alts pos t))
(setq indents (append new indents))))
;; alts are easier to use when ordered
@@ -388,12 +388,12 @@ current line."
(--each '(-1 1)
(save-excursion
(forward-line it)
- (when-let (new (haskell-tng-smie:relevant-alts (point-at-eol) (< it
0)))
+ (when-let (new (haskell-tng--smie-relevant-alts (point-at-eol) (< it
0)))
(setq indents (append new indents)))))
(-distinct indents)))
-(defun haskell-tng-smie:relevant-alts (bound before)
+(defun haskell-tng--smie-relevant-alts (bound before)
"A list of indentation levels from point to BOUND.
BEFORE is t if the line appears before the indentation."
@@ -416,35 +416,35 @@ BEFORE is t if the line appears before the indentation."
(forward-line))
(goto-char start)
(while (< (point) bound)
- (when (haskell-tng-layout:has-virtual-at-point)
+ (when (haskell-tng--layout-has-virtual-at-point)
(push (current-column) relevant))
(forward-char))
relevant))
-(defun haskell-tng-smie:setup ()
+(defun haskell-tng--smie-setup ()
(add-hook
'after-change-functions
- #'haskell-tng-layout:cache-invalidation
+ #'haskell-tng--layout-cache-invalidation
nil 'local)
(add-hook
'after-change-functions
- #'haskell-tng-lexer:state-invalidation
+ #'haskell-tng--lexer-state-invalidation
nil 'local)
(add-hook
'smie-indent-functions
- #'haskell-tng-smie:indent-cycle
+ #'haskell-tng--smie-indent-cycle
nil 'local)
(smie-setup
- haskell-tng-smie:grammar
- #'haskell-tng-smie:rules
- :forward-token #'haskell-tng-lexer:forward-token
- :backward-token #'haskell-tng-lexer:backward-token)
+ haskell-tng--smie-grammar
+ #'haskell-tng--smie-rules
+ :forward-token #'haskell-tng--lexer-forward-token
+ :backward-token #'haskell-tng--lexer-backward-token)
)
-(defun haskell-tng-smie:rule-parent-column ()
+(defun haskell-tng--smie-rule-parent-column ()
"For use inside `smie-rules-function',
use the column indentation as the parent. Note that
`smie-rule-parent' may use relative values."
@@ -452,7 +452,7 @@ use the column indentation as the parent. Note that
(goto-char (cadr (smie-indent--parent)))
`(column . ,(current-column))))
-(defun haskell-tng-smie:ancestors (n)
+(defun haskell-tng--smie-ancestors (n)
"A list of the Nth non-{identifier, matched paren, string}
tokens before point, closest first. Leaves the point at the most
extreme parent.
@@ -460,7 +460,7 @@ extreme parent.
Inspired by `smie-indent--parent', which can only be used in
:before and :after."
(when-let ((res (or (smie-backward-sexp t)
- (haskell-tng:until
+ (haskell-tng--util-until
(or (smie-backward-sexp)
(bobp)))))
(tok (if (car res)
@@ -468,10 +468,10 @@ Inspired by `smie-indent--parent', which can only be used
in
(car (smie-indent-backward-token))
(caddr res))))
(if (< 1 n)
- (cons tok (haskell-tng-smie:ancestors (- n 1)))
+ (cons tok (haskell-tng--smie-ancestors (- n 1)))
(list tok))))
-(defun haskell-tng-smie:prev-line-tokens ()
+(defun haskell-tng--smie-prev-line-tokens ()
"Search forward on the previous non-empty line"
(save-excursion
(beginning-of-line)
diff --git a/haskell-tng-syntax.el b/haskell-tng-syntax.el
index 697520b..9925be7 100644
--- a/haskell-tng-syntax.el
+++ b/haskell-tng-syntax.el
@@ -17,7 +17,7 @@
(require 'cl-lib)
(require 'dash)
-(defconst haskell-tng:syntax-table
+(defconst haskell-tng--syntax-table
(let ((table (make-syntax-table)))
(map-char-table
#'(lambda (k v)
@@ -77,15 +77,15 @@
table)
"Haskell syntax table.")
-(defun haskell-tng:syntax-propertize (start end)
+(defun haskell-tng--syntax-propertize (start end)
"For some context-sensitive syntax entries."
(let (case-fold-search)
- (haskell-tng:syntax:char-delims start end)
- (haskell-tng:syntax:fqn-punct start end)
- (haskell-tng:syntax:string-escapes start end)
- (haskell-tng:syntax:escapes start end)))
+ (haskell-tng--syntax-char-delims start end)
+ (haskell-tng--syntax-fqn-punct start end)
+ (haskell-tng--syntax-string-escapes start end)
+ (haskell-tng--syntax-escapes start end)))
-(defun haskell-tng:syntax:char-delims (start end)
+(defun haskell-tng--syntax-char-delims (start end)
"Matching apostrophes are string delimiters (literal chars)."
(goto-char start)
;; should handle: foo' 'a' 2 because ' is a word here
@@ -95,7 +95,7 @@
(put-text-property open (1+ open) 'syntax-table '(7 . ?\'))
(put-text-property close (1+ close) 'syntax-table '(7 . ?\')))))
-(defun haskell-tng:syntax:fqn-punct (start end)
+(defun haskell-tng--syntax-fqn-punct (start end)
"dot/period is typically a symbol, unless it is used in a
module or qualifier, then it is punctuation."
(goto-char start)
@@ -103,10 +103,10 @@ module or qualifier, then it is punctuation."
(let ((dot (match-beginning 0)))
(put-text-property dot (1+ dot) 'syntax-table '(1)))))
-(defun haskell-tng:syntax:string-escapes (start end)
+(defun haskell-tng--syntax-string-escapes (start end)
"Backslash before quotes is a string escape.
-This needs to run before `haskell-tng:syntax:escapes' or string
+This needs to run before `haskell-tng--syntax-escapes' or string
detection will not work correctly.
There is an expected false positive: an operator has an odd
@@ -117,11 +117,11 @@ string or char as the 2nd parameter and no whitespace."
(rx "\\" (syntax string-quote))
end t)
(let* ((escape (match-beginning 0))
- (before (haskell-tng:syntax:count-escapes escape t)))
+ (before (haskell-tng--syntax-count-escapes escape t)))
(when (cl-evenp before) ;; makes sure it's a real escape
(put-text-property escape (1+ escape) 'syntax-table '(9))))))
-(defun haskell-tng:syntax:count-escapes (pos &optional skip-whitespace)
+(defun haskell-tng--syntax-count-escapes (pos &optional skip-whitespace)
"Count the number of escapes before POS.
Even means the next char is not escaped.
@@ -129,12 +129,12 @@ SKIP-WHITESPACE can be used to ignore whitespace gaps."
(if (= (point-min) pos) 0
(let ((c (char-before pos)))
(if (and skip-whitespace (or (= ?\n c) (= 32 (char-syntax c))))
- (haskell-tng:syntax:count-escapes (1- pos) t)
+ (haskell-tng--syntax-count-escapes (1- pos) t)
(if (= c ?\\)
- (1+ (haskell-tng:syntax:count-escapes (1- pos)))
+ (1+ (haskell-tng--syntax-count-escapes (1- pos)))
0)))))
-(defun haskell-tng:syntax:escapes (start end)
+(defun haskell-tng--syntax-escapes (start end)
"Backslash inside String is an escape character \n."
;; TODO does this pull its weight? (slow, requires a ppss)
(goto-char start)
@@ -143,7 +143,7 @@ SKIP-WHITESPACE can be used to ignore whitespace gaps."
(if (= 9 (car (syntax-after escape))) ;; already calculated
(forward-char 1)
(unless (looking-at (rx (+ (| space ?\n)) "\\"))
- (let ((before (haskell-tng:syntax:count-escapes escape t)))
+ (let ((before (haskell-tng--syntax-count-escapes escape t)))
(unless (and (cl-oddp before)
(looking-back (rx (| space ?\n)) (1- escape)))
(when (and (cl-evenp before)
diff --git a/haskell-tng-util.el b/haskell-tng-util.el
index 15068b7..4155bd7 100644
--- a/haskell-tng-util.el
+++ b/haskell-tng-util.el
@@ -9,9 +9,11 @@
;;
;;; Code:
+;; TODO move things to single use sites (twas premature abstraction!)
+
(require 'subr-x)
-(defun haskell-tng:paren-close (&optional pos)
+(defun haskell-tng--util-paren-close (&optional pos)
"The next `)', if it closes `POS's paren depth."
(save-excursion
(goto-char (or pos (point)))
@@ -22,7 +24,7 @@
;; TODO comment / paren aware, like haskell-tng:layout-of-next-token
;; TODO refactor to share code with haskell-tng:layout-of-next-token
-(defun haskell-tng:indent-close (&optional pos)
+(defun haskell-tng--util-indent-close (&optional pos)
"The beginning of the line with indentation that closes `POS'."
(save-excursion
(goto-char (or pos (point)))
@@ -33,34 +35,34 @@
(throw 'closed (point))))
nil))))
-(defun haskell-tng:do-bind (&optional pos)
+(defun haskell-tng--util-do-bind (&optional pos)
;; trivial, should just be called as an inline regexp
"The next `<-'"
(save-excursion
(goto-char (or pos (point)))
(re-search-forward "<-" nil t)))
-(defun haskell-tng:next-where (&optional pos)
+(defun haskell-tng--util-next-where (&optional pos)
;; trivial, should just be called as an inline regexp
"The next `where'"
(save-excursion
(goto-char (or pos (point)))
(re-search-forward (rx word-start "where" word-end) nil t)))
-(defun haskell-tng:indent-close-previous ()
+(defun haskell-tng--util-indent-close-previous ()
"Indentation closing the previous symbol."
(save-excursion
(forward-symbol -1)
- (haskell-tng:indent-close)))
+ (haskell-tng--util-indent-close)))
-(defun haskell-tng:locate-dominating-file (regexp)
+(defun haskell-tng--util-locate-dominating-file (regexp)
"`locate-dominating-file' but starting from `default-directory'
and taking a regexp."
(locate-dominating-file
default-directory
(lambda (dir) (directory-files dir nil regexp))))
-(defmacro haskell-tng:until (test &rest body)
+(defmacro haskell-tng--util-until (test &rest body)
;; https://lists.gnu.org/r/emacs-devel/2018-10/msg00250.html
;; by Stefan Monnier
"Run BODY while TEST is non-nil, returning the final TEST."
diff --git a/test/haskell-tng-compile-test.el b/test/haskell-tng-compile-test.el
index 2208441..0d0b40d 100644
--- a/test/haskell-tng-compile-test.el
+++ b/test/haskell-tng-compile-test.el
@@ -23,9 +23,9 @@
(while compilation-in-progress
(sit-for 0.01))
- (haskell-tng-compile:clean-output)
+ (haskell-tng--compile-clean-output)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
output
#'buffer-to-faceup-string
@@ -36,7 +36,7 @@
(defun compilation-handle-exit (_1 _2 _3)
"Overrides the default behaviour to remove noise")
-(defun haskell-tng-compile:clean-output ()
+(defun haskell-tng--compile-clean-output ()
"Removes timestamps and local file paths"
(let ((inhibit-read-only t))
(goto-char (point-min))
diff --git a/test/haskell-tng-font-lock-test.el
b/test/haskell-tng-font-lock-test.el
index 21702ac..f931ab4 100644
--- a/test/haskell-tng-font-lock-test.el
+++ b/test/haskell-tng-font-lock-test.el
@@ -11,7 +11,7 @@
"test/haskell-tng-testutils.el")
(defun have-expected-faces (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
#'buffer-to-faceup-string
diff --git a/test/haskell-tng-indent-test.el b/test/haskell-tng-indent-test.el
index f068a4f..a4d662c 100644
--- a/test/haskell-tng-indent-test.el
+++ b/test/haskell-tng-indent-test.el
@@ -48,22 +48,22 @@
(ert-deftest haskell-tng-append-indent-file-tests:indentation ()
(should (have-expected-append-indent (testdata "src/indentation.hs"))))
(ert-deftest haskell-tng-append-indent-file-tests:options ()
- (let ((haskell-tng-indent-aligntypes t)
- (haskell-tng-indent-typelead 1))
+ (let ((haskell-tng-aligntypes t)
+ (haskell-tng-typelead 1))
(should (have-expected-append-indent (testdata
"src/indentation-options.hs")))))
(ert-deftest haskell-tng-insert-indent-file-tests:indentation ()
(should (have-expected-insert-indent (testdata "src/indentation.hs"))))
(ert-deftest haskell-tng-insert-indent-file-tests:options ()
- (let ((haskell-tng-indent-aligntypes t)
- (haskell-tng-indent-typelead 1))
+ (let ((haskell-tng-aligntypes t)
+ (haskell-tng-typelead 1))
(should (have-expected-insert-indent (testdata
"src/indentation-options.hs")))))
;; TODO reindenting needs attention, it's all over the radar
;; (ert-deftest haskell-tng-reindent-file-tests ()
;; (should (have-expected-reindent (testdata "src/indentation.hs"))))
-(defun haskell-tng-indent-test:work (mode)
+(defun haskell-tng--indent-test-work (mode)
"MODE can be 'insert, 'reindent, or 'append."
(let (indents lines)
(pcase mode
@@ -124,7 +124,7 @@
(ert-simulate-command '(forward-line)))))))
(reverse indents)))
-(defun haskell-tng-indent-test:indents-to-string (indents)
+(defun haskell-tng--indent-test-indents-to-string (indents)
"INDENTS is a list of INDENT.
INDENT is a non-empty list of (RET . (LINE . (INDENT . ALTS)))
@@ -135,9 +135,9 @@ the current line).
INDENT is the integer suggested next line indentation column and
ALTS is a list of integer alternative indentations."
(s-join "\n" (-flatten
- (-map #'haskell-tng-indent-test:indent-to-string indents))))
+ (-map #'haskell-tng--indent-test-indent-to-string indents))))
-(defun haskell-tng-indent-test:indent-to-string (indent)
+(defun haskell-tng--indent-test-indent-to-string (indent)
(let* ((ret (car indent))
(line (cadr indent))
(prime (caddr indent))
@@ -161,30 +161,30 @@ ALTS is a list of integer alternative indentations."
(list indents line)))))
(defun have-expected-insert-indent (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
(lambda ()
- (haskell-tng-indent-test:indents-to-string
- (haskell-tng-indent-test:work 'insert)))
+ (haskell-tng--indent-test-indents-to-string
+ (haskell-tng--indent-test-work 'insert)))
"insert.indent"))
(defun have-expected-reindent (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
(lambda ()
- (haskell-tng-indent-test:indents-to-string
- (haskell-tng-indent-test:work 'reindent)))
+ (haskell-tng--indent-test-indents-to-string
+ (haskell-tng--indent-test-work 'reindent)))
"reindent"))
(defun have-expected-append-indent (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
(lambda ()
- (haskell-tng-indent-test:indents-to-string
- (haskell-tng-indent-test:work 'append)))
+ (haskell-tng--indent-test-indents-to-string
+ (haskell-tng--indent-test-work 'append)))
"append.indent"))
;;; haskell-tng-indent-test.el ends here
diff --git a/test/haskell-tng-layout-test.el b/test/haskell-tng-layout-test.el
index 2a410cd..7c6f485 100644
--- a/test/haskell-tng-layout-test.el
+++ b/test/haskell-tng-layout-test.el
@@ -24,11 +24,11 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Testing utilities
-(defun haskell-tng-layout-test:parse-to-string ()
+(defun haskell-tng--layout-test-parse-to-string ()
(goto-char 0)
(let (tokens exit)
(while (not exit)
- (when-let (virtuals (haskell-tng-layout:virtuals-at-point))
+ (when-let (virtuals (haskell-tng--layout-virtuals-at-point))
(push (s-join "" virtuals) tokens))
(if (eobp)
(setq exit t)
@@ -37,10 +37,10 @@
(s-join "" (reverse tokens))))
(defun have-expected-layout (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
- #'haskell-tng-layout-test:parse-to-string
+ #'haskell-tng--layout-test-parse-to-string
"layout"))
(ert-deftest haskell-tng-layout-cache-invalidation-tests ()
@@ -51,13 +51,13 @@
(goto-char 317)
(should
(equal
- (haskell-tng-layout:virtuals-at-point)
+ (haskell-tng--layout-virtuals-at-point)
'(";")))
(insert " ")
(goto-char 317)
(should
(not
- (haskell-tng-layout:virtuals-at-point)))))
+ (haskell-tng--layout-virtuals-at-point)))))
;;; haskell-tng-layout-test.el ends here
diff --git a/test/haskell-tng-lexer-test.el b/test/haskell-tng-lexer-test.el
index efbfded..95f8b05 100644
--- a/test/haskell-tng-lexer-test.el
+++ b/test/haskell-tng-lexer-test.el
@@ -31,57 +31,57 @@
;; three parses at this position will produce a virtual token and a real
;; token, then move the point for another token.
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "VARID"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "«"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "VARID"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "«"))
;; repeating the above, but with a user edit, should reset the state
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
(save-excursion
(goto-char (point-max))
(insert " "))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "VARID"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "«"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "VARID"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "«"))
;; repeating again, but jumping the lexer, should reset the state
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
(goto-char 327)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "CONID"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "CONID"))
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "VARID"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) "«"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "VARID"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) "«"))
;; repeating those tests, but for the backward lexer
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) "[]"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) "[]"))
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
(save-excursion
(goto-char (point-max))
(insert " "))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) "[]"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) "[]"))
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
(goto-char 327)
- (should (equal (haskell-tng-lexer-test:indent-backward-token) "«"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) "«"))
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) "[]"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) "[]"))
;; jumping between forward and backward at point should reset state
(goto-char 317)
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-forward-token) ";"))
- (should (equal (haskell-tng-lexer-test:indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-forward-token) ";"))
+ (should (equal (haskell-tng--lexer-test-indent-backward-token) ";"))
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -89,16 +89,16 @@
;; copy/pasta of `smie-indent-forward-token' but rendering lexed tokens in a
way
;; more ammenable to regression testing (e.g. syntax table usage)
-(defun haskell-tng-lexer-test:indent-forward-token ()
+(defun haskell-tng--lexer-test-indent-forward-token ()
(let ((tok (funcall smie-forward-token-function)))
(cond
((< 0 (length tok)) tok)
((eobp) nil)
((looking-at (rx (syntax open-parenthesis)))
- (haskell-tng-lexer:last-match)
+ (haskell-tng--lexer-last-match)
"«")
((looking-at (rx (syntax close-parenthesis)))
- (haskell-tng-lexer:last-match)
+ (haskell-tng--lexer-last-match)
"»")
((looking-at (rx (| (syntax string-quote)
(syntax string-delimiter))))
@@ -112,16 +112,16 @@
(syntax-after (point)))))))
;; same as above, but for `smie-indent-backward-token'
-(defun haskell-tng-lexer-test:indent-backward-token ()
+(defun haskell-tng--lexer-test-indent-backward-token ()
(let ((tok (funcall smie-backward-token-function)))
(cond
((< 0 (length tok)) tok)
((bobp) nil)
((looking-back (rx (syntax open-parenthesis)) (- (point) 1))
- (haskell-tng-lexer:last-match 'reverse)
+ (haskell-tng--lexer-last-match 'reverse)
"«")
((looking-back (rx (syntax close-parenthesis)) (- (point) 1))
- (haskell-tng-lexer:last-match 'reverse)
+ (haskell-tng--lexer-last-match 'reverse)
"»")
((looking-back (rx (| (syntax string-quote)
(syntax string-delimiter)))
@@ -137,7 +137,7 @@
(backward-char)
(syntax-after (point))))))))
-(defun haskell-tng-lexer-test:tokens (&optional reverse)
+(defun haskell-tng--lexer-test-tokens (&optional reverse)
"Lex the current buffer using SMIE and return the list of lines,
where each line is a list of tokens.
@@ -148,8 +148,8 @@ When called interactively, shows the tokens in a buffer."
(while (not quit)
(let* ((start (point))
(token (if reverse
- (haskell-tng-lexer-test:indent-backward-token)
- (haskell-tng-lexer-test:indent-forward-token))))
+ (haskell-tng--lexer-test-indent-backward-token)
+ (haskell-tng--lexer-test-indent-forward-token))))
(let* ((line-diff (- (line-number-at-pos (point))
(line-number-at-pos start)))
(multiline (/= line-diff 0))
@@ -168,23 +168,23 @@ When called interactively, shows the tokens in a buffer."
lines
(reverse (--map (reverse it) lines)))))
-(defun haskell-tng-lexer-test:tokens-to-string (lines)
+(defun haskell-tng--lexer-test-tokens-to-string (lines)
(concat (s-join "\n" (--map (s-join " " it) lines)) "\n"))
(defun have-expected-forward-lex (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
- (lambda () (haskell-tng-lexer-test:tokens-to-string
- (haskell-tng-lexer-test:tokens)))
+ (lambda () (haskell-tng--lexer-test-tokens-to-string
+ (haskell-tng--lexer-test-tokens)))
"lexer"))
(defun have-expected-backward-lex (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
- (lambda () (haskell-tng-lexer-test:tokens-to-string
- (haskell-tng-lexer-test:tokens 'reverse)))
+ (lambda () (haskell-tng--lexer-test-tokens-to-string
+ (haskell-tng--lexer-test-tokens 'reverse)))
"lexer"))
;;; haskell-tng-lexer-test.el ends here
diff --git a/test/haskell-tng-sexp-test.el b/test/haskell-tng-sexp-test.el
index 0aa23f7..bbf07ee 100644
--- a/test/haskell-tng-sexp-test.el
+++ b/test/haskell-tng-sexp-test.el
@@ -20,13 +20,13 @@
;; However, this fails to find all bounds because there is ambiguity at virtual
;; tokens.
-(ert-deftest haskell-tng-sexp-file-tests:layout ()
+(ert-deftest haskell-tng--sexp-file-tests-layout ()
(should (have-expected-sexps (testdata "src/layout.hs"))))
-(ert-deftest haskell-tng-sexp-file-tests:indentation ()
+(ert-deftest haskell-tng--sexp-file-tests-indentation ()
(should (have-expected-sexps (testdata "src/indentation.hs"))))
-(ert-deftest haskell-tng-sexp-file-tests:grammar ()
+(ert-deftest haskell-tng--sexp-file-tests-grammar ()
(should (have-expected-sexps (testdata "src/grammar.hs"))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -37,7 +37,7 @@
;; forward/backward sexps at the current point (which is not necessarilly
;; beginning / end of current sexp), using only the primitives `forward-sexp'
;; and `backward-sexp', provided by SMIE.
-(defun haskell-tng-sexp-test:sexps-at-point (p)
+(defun haskell-tng--sexp-test-sexps-at-point (p)
"Return a list of cons cells (start . end)"
(let (sexps
(forward-backward
@@ -66,18 +66,18 @@
(push backward-forward sexps))
sexps))
-(defun haskell-tng-sexp-test:sexps ()
+(defun haskell-tng--sexp-test-sexps ()
"All the unique sexp bounds for the current buffer."
(goto-char (point-min))
(let (sexps)
(while (not (eobp))
(unless (is-comment-at-point)
- (let ((here (haskell-tng-sexp-test:sexps-at-point (point))))
+ (let ((here (haskell-tng--sexp-test-sexps-at-point (point))))
(setq sexps (append here sexps))))
(forward-char))
(delete-dups sexps)))
-(defun haskell-tng-sexp-test:sexps-to-string (sexps)
+(defun haskell-tng--sexp-test-sexps-to-string (sexps)
"Renders the current buffer, marked up by sexps."
(let (chars exit)
(goto-char (point-min))
@@ -98,12 +98,12 @@
(s-join "" (reverse chars))))
(defun have-expected-sexps (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
(lambda ()
- (haskell-tng-sexp-test:sexps-to-string
- (haskell-tng-sexp-test:sexps)))
+ (haskell-tng--sexp-test-sexps-to-string
+ (haskell-tng--sexp-test-sexps)))
"sexps"))
;;; haskell-tng-sexp-test.el ends here
diff --git a/test/haskell-tng-syntax-test.el b/test/haskell-tng-syntax-test.el
index ad94879..6c09431 100644
--- a/test/haskell-tng-syntax-test.el
+++ b/test/haskell-tng-syntax-test.el
@@ -12,7 +12,7 @@
"test/haskell-tng-testutils.el")
(defun have-expected-syntax (file)
- (haskell-tng-testutils:assert-file-contents
+ (haskell-tng--testutils-assert-file-contents
file
#'haskell-tng-mode
#'buffer-to-syntax-string
diff --git a/test/haskell-tng-testutils.el b/test/haskell-tng-testutils.el
index 078f642..e9520c7 100644
--- a/test/haskell-tng-testutils.el
+++ b/test/haskell-tng-testutils.el
@@ -11,13 +11,13 @@
(require 'faceup)
-(defmacro haskell-tng-testutils:this-lisp-directory ()
+(defmacro haskell-tng--testutils-this-lisp-directory ()
(expand-file-name
(if load-file-name
(file-name-directory load-file-name)
default-directory)))
-(defun haskell-tng-testutils:assert-file-contents
+(defun haskell-tng--testutils-assert-file-contents
(file mode to-string suffix)
"For FILE, enable MODE and run TO-STRING and compare with the golden data in
FILE.SUFFIX.
@@ -47,7 +47,7 @@ Alternatively, if MODE is a buffer object, run TO-STRING
there instead."
(defun testdata (file)
(expand-file-name
file
- (haskell-tng-testutils:this-lisp-directory)))
+ (haskell-tng--testutils-this-lisp-directory)))
(defun is-comment-at-point ()
;; this could be sped up by storing all comment regions in an alist
diff --git a/test/src/layout.hs.faceup b/test/src/layout.hs.faceup
index 8e1d9e8..e923cce 100644
--- a/test/src/layout.hs.faceup
+++ b/test/src/layout.hs.faceup
@@ -1,20 +1,20 @@
«m:-- »«x:Figure 2.1 from the Haskell2010 report
-»«:haskell-tng:keyword:module»
«:haskell-tng:module:AStack»«:haskell-tng:keyword:(»
«:haskell-tng:type:Stack»«:haskell-tng:keyword:,» push«:haskell-tng:keyword:,»
pop«:haskell-tng:keyword:,» top«:haskell-tng:keyword:,» size
«:haskell-tng:keyword:)» «:haskell-tng:keyword:where»
-«:haskell-tng:keyword:data»«:haskell-tng:type: Stack a
»«:haskell-tng:keyword:=» «:haskell-tng:constructor:Empty»
- «:haskell-tng:keyword:|» «:haskell-tng:constructor:MkStack» a
«:haskell-tng:keyword:(»«:haskell-tng:constructor:Stack»
a«:haskell-tng:keyword:)»
+»«:haskell-tng-keyword-face:module»
«:haskell-tng-module-face:AStack»«:haskell-tng-keyword-face:(»
«:haskell-tng-type-face:Stack»«:haskell-tng-keyword-face:,»
push«:haskell-tng-keyword-face:,» pop«:haskell-tng-keyword-face:,»
top«:haskell-tng-keyword-face:,» size «:haskell-tng-keyword-face:)»
«:haskell-tng-keyword-face:where»
+«:haskell-tng-keyword-face:data»«:haskell-tng-type-face: Stack a
»«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Empty»
+ «:haskell-tng-keyword-face:|» «:haskell-tng-conid-face:MkStack» a
«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Stack»
a«:haskell-tng-keyword-face:)»
-push «:haskell-tng:keyword:::»«:haskell-tng:type: a
»«:haskell-tng:keyword:->»«:haskell-tng:type: Stack a
»«:haskell-tng:keyword:->»«:haskell-tng:type: Stack a
-»push x s «:haskell-tng:keyword:=» «:haskell-tng:constructor:MkStack» x s
+push «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Stack a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Stack a
+»push x s «:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:MkStack» x s
-size «:haskell-tng:keyword:::»«:haskell-tng:type: Stack a
»«:haskell-tng:keyword:->»«:haskell-tng:type: Int
-»size s «:haskell-tng:keyword:=» length «:haskell-tng:keyword:(»stkToLst
s«:haskell-tng:keyword:)» «:haskell-tng:keyword:where»
- stkToLst «:haskell-tng:constructor:Empty»
«:haskell-tng:keyword:=» «:haskell-tng:keyword:[]»
- stkToLst «:haskell-tng:keyword:(»«:haskell-tng:constructor:MkStack»
x s«:haskell-tng:keyword:)» «:haskell-tng:keyword:=»
x«:haskell-tng:keyword::»xs «:haskell-tng:keyword:where» xs
«:haskell-tng:keyword:=» stkToLst s
+size «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Stack a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Int
+»size s «:haskell-tng-keyword-face:=» length
«:haskell-tng-keyword-face:(»stkToLst s«:haskell-tng-keyword-face:)»
«:haskell-tng-keyword-face:where»
+ stkToLst «:haskell-tng-conid-face:Empty»
«:haskell-tng-keyword-face:=» «:haskell-tng-keyword-face:[]»
+ stkToLst
«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:MkStack» x
s«:haskell-tng-keyword-face:)» «:haskell-tng-keyword-face:=»
x«:haskell-tng-keyword-face::»xs «:haskell-tng-keyword-face:where» xs
«:haskell-tng-keyword-face:=» stkToLst s
-pop «:haskell-tng:keyword:::»«:haskell-tng:type: Stack a
»«:haskell-tng:keyword:->»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:a»«:haskell-tng:keyword:,»«:haskell-tng:type:
Stack a»«:haskell-tng:keyword:)»«:haskell-tng:type:
-»pop «:haskell-tng:keyword:(»«:haskell-tng:constructor:MkStack» x
s«:haskell-tng:keyword:)»
- «:haskell-tng:keyword:=» «:haskell-tng:keyword:(»x«:haskell-tng:keyword:,»
«:haskell-tng:keyword:case» s «:haskell-tng:keyword:of» r
«:haskell-tng:keyword:->» i r «:haskell-tng:keyword:where» i x
«:haskell-tng:keyword:=» x«:haskell-tng:keyword:)» «m:-- »«x:(pop Empty) is an
error
+pop «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Stack a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:a»«:haskell-tng-keyword-face:,»«:haskell-tng-type-face:
Stack a»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
+»pop «:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:MkStack» x
s«:haskell-tng-keyword-face:)»
+ «:haskell-tng-keyword-face:=»
«:haskell-tng-keyword-face:(»x«:haskell-tng-keyword-face:,»
«:haskell-tng-keyword-face:case» s «:haskell-tng-keyword-face:of» r
«:haskell-tng-keyword-face:->» i r «:haskell-tng-keyword-face:where» i x
«:haskell-tng-keyword-face:=» x«:haskell-tng-keyword-face:)» «m:-- »«x:(pop
Empty) is an error
»
-top «:haskell-tng:keyword:::»«:haskell-tng:type: Stack a
»«:haskell-tng:keyword:->»«:haskell-tng:type: a
-»top «:haskell-tng:keyword:(»«:haskell-tng:constructor:MkStack» x
s«:haskell-tng:keyword:)» «:haskell-tng:keyword:=» x «m:--
»«x:(top Empty) is an error
+top «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Stack a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: a
+»top «:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:MkStack» x
s«:haskell-tng-keyword-face:)» «:haskell-tng-keyword-face:=» x
«m:-- »«x:(top Empty) is an error
»
\ No newline at end of file
diff --git a/test/src/medley.hs.faceup b/test/src/medley.hs.faceup
index 7c26e33..a1a7da7 100644
--- a/test/src/medley.hs.faceup
+++ b/test/src/medley.hs.faceup
@@ -2,152 +2,152 @@
«x:{-# LANGUAGE ScopedTypeVariables #-}»
«m:-- »«x:| This file is a medley of various constructs and some corner cases
-»«:haskell-tng:keyword:module» «:haskell-tng:module:Foo.Bar.Main»
- «:haskell-tng:keyword:(»
«:haskell-tng:type:Wibble»«:haskell-tng:keyword:(..),»
«:haskell-tng:type:Wobble»«:haskell-tng:keyword:(»«:haskell-tng:constructor:Wobb»«:haskell-tng:keyword:,»«:haskell-tng:constructor:
»«:haskell-tng:keyword:(»«:haskell-tng:constructor:!!!»«:haskell-tng:keyword:)),»
«:haskell-tng:type:Woo»
+»«:haskell-tng-keyword-face:module» «:haskell-tng-module-face:Foo.Bar.Main»
+ «:haskell-tng-keyword-face:(»
«:haskell-tng-type-face:Wibble»«:haskell-tng-keyword-face:(..),»
«:haskell-tng-type-face:Wobble»«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Wobb»«:haskell-tng-keyword-face:,»«:haskell-tng-conid-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:!!!»«:haskell-tng-keyword-face:)),»
«:haskell-tng-type-face:Woo»
«m:-- »«x:* Operations
-» «:haskell-tng:keyword:,» getFooByBar«:haskell-tng:keyword:,»
getWibbleByWobble
- «:haskell-tng:keyword:,» «:haskell-tng:keyword:module»
«:haskell-tng:module:Bloo.Foo»
-«:haskell-tng:keyword:)» «:haskell-tng:keyword:where»
-
-«:haskell-tng:keyword:import»
«:haskell-tng:module:Control.Applicative»
«:haskell-tng:keyword:(»many«:haskell-tng:keyword:,»
optional«:haskell-tng:keyword:,» pure«:haskell-tng:keyword:,»
«:haskell-tng:keyword:(»<*>«:haskell-tng:keyword:),»
«:haskell-tng:keyword:(»<|>«:haskell-tng:keyword:))»
-«:haskell-tng:keyword:import» «:haskell-tng:module:Data.Foldable»
«:haskell-tng:keyword:(»traverse_«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:Data.Functor»
«:haskell-tng:keyword:((»<$>«:haskell-tng:keyword:))»
-«:haskell-tng:keyword:import» «:haskell-tng:module:Data.List»
«:haskell-tng:keyword:(»intercalate«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:Data.Monoid»
«:haskell-tng:keyword:((»<>«:haskell-tng:keyword:))»
-«:haskell-tng:keyword:import» «:haskell-tng:keyword:qualified»
«:haskell-tng:module:Options.Monad»
-«:haskell-tng:keyword:import» «:haskell-tng:keyword:qualified»
«:haskell-tng:module:Options.Applicative» «:haskell-tng:keyword:as»
«:haskell-tng:module:Opts»
-«:haskell-tng:keyword:import» «:haskell-tng:keyword:qualified»
«:haskell-tng:module:Options.Divisible» «m:-- »«x:wibble (wobble)
-» «:haskell-tng:keyword:as» «:haskell-tng:module:Div»
-«:haskell-tng:keyword:import» «:haskell-tng:keyword:qualified»
«:haskell-tng:module:ProfFile.App» «:haskell-tng:keyword:hiding»
«:haskell-tng:keyword:(»as«:haskell-tng:keyword:,»
hiding«:haskell-tng:keyword:,» qualified«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:ProfFile.App»
«:haskell-tng:keyword:(»as«:haskell-tng:keyword:,»
hiding«:haskell-tng:keyword:,» qualified«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:ProfFile.App»
«:haskell-tng:keyword:hiding»
«:haskell-tng:keyword:(»as«:haskell-tng:keyword:,»
hiding«:haskell-tng:keyword:,» qualified«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:keyword:qualified»
«:haskell-tng:module:ProfFile.App»
«:haskell-tng:keyword:(»as«:haskell-tng:keyword:,»
hiding«:haskell-tng:keyword:,» qualified«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:System.Exit»
«:haskell-tng:keyword:(»«:haskell-tng:type:ExitCode»
«:haskell-tng:keyword:(..),» exitFailure«:haskell-tng:keyword:,»
qualified«:haskell-tng:keyword:,»
-
«:haskell-tng:type:Typey»«:haskell-tng:keyword:,»
- wibble«:haskell-tng:keyword:,»
-
«:haskell-tng:type:Wibble»«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:System.FilePath»
«:haskell-tng:keyword:(»replaceExtension«:haskell-tng:keyword:,»
«:haskell-tng:type:Foo»«:haskell-tng:keyword:(»«:haskell-tng:constructor:Bar»«:haskell-tng:keyword:,»«:haskell-tng:constructor:
»«:haskell-tng:keyword:(»«:haskell-tng:constructor::<»«:haskell-tng:keyword:)))»
-«:haskell-tng:keyword:import» «:haskell-tng:module:System.IO»
«:haskell-tng:keyword:(»«:haskell-tng:type:IOMode»
«:haskell-tng:keyword:(..),» hClose«:haskell-tng:keyword:,»
hGetContents«:haskell-tng:keyword:,»
- hPutStr«:haskell-tng:keyword:,»
hPutStrLn«:haskell-tng:keyword:,» openFile«:haskell-tng:keyword:,»
stderr«:haskell-tng:keyword:,»
- stdout«:haskell-tng:keyword:,»
«:haskell-tng:type:MoarTypey»«:haskell-tng:keyword:)»
-«:haskell-tng:keyword:import» «:haskell-tng:module:System.Process»
«:haskell-tng:keyword:(»«:haskell-tng:type:CreateProcess»
«:haskell-tng:keyword:(..),» «:haskell-tng:type:StdStream»
«:haskell-tng:keyword:(..),»
- createProcess«:haskell-tng:keyword:,»
proc«:haskell-tng:keyword:,» waitForProcess«:haskell-tng:keyword:)»
+» «:haskell-tng-keyword-face:,» getFooByBar«:haskell-tng-keyword-face:,»
getWibbleByWobble
+ «:haskell-tng-keyword-face:,» «:haskell-tng-keyword-face:module»
«:haskell-tng-module-face:Bloo.Foo»
+«:haskell-tng-keyword-face:)» «:haskell-tng-keyword-face:where»
+
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:Control.Applicative»
«:haskell-tng-keyword-face:(»many«:haskell-tng-keyword-face:,»
optional«:haskell-tng-keyword-face:,» pure«:haskell-tng-keyword-face:,»
«:haskell-tng-keyword-face:(»<*>«:haskell-tng-keyword-face:),»
«:haskell-tng-keyword-face:(»<|>«:haskell-tng-keyword-face:))»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:Data.Foldable»
«:haskell-tng-keyword-face:(»traverse_«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:Data.Functor»
«:haskell-tng-keyword-face:((»<$>«:haskell-tng-keyword-face:))»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:Data.List»
«:haskell-tng-keyword-face:(»intercalate«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:Data.Monoid»
«:haskell-tng-keyword-face:((»<>«:haskell-tng-keyword-face:))»
+«:haskell-tng-keyword-face:import» «:haskell-tng-keyword-face:qualified»
«:haskell-tng-module-face:Options.Monad»
+«:haskell-tng-keyword-face:import» «:haskell-tng-keyword-face:qualified»
«:haskell-tng-module-face:Options.Applicative» «:haskell-tng-keyword-face:as»
«:haskell-tng-module-face:Opts»
+«:haskell-tng-keyword-face:import» «:haskell-tng-keyword-face:qualified»
«:haskell-tng-module-face:Options.Divisible» «m:-- »«x:wibble (wobble)
+» «:haskell-tng-keyword-face:as» «:haskell-tng-module-face:Div»
+«:haskell-tng-keyword-face:import» «:haskell-tng-keyword-face:qualified»
«:haskell-tng-module-face:ProfFile.App»
«:haskell-tng-keyword-face:hiding»
«:haskell-tng-keyword-face:(»as«:haskell-tng-keyword-face:,»
hiding«:haskell-tng-keyword-face:,» qualified«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:ProfFile.App»
«:haskell-tng-keyword-face:(»as«:haskell-tng-keyword-face:,»
hiding«:haskell-tng-keyword-face:,» qualified«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:ProfFile.App»
«:haskell-tng-keyword-face:hiding»
«:haskell-tng-keyword-face:(»as«:haskell-tng-keyword-face:,»
hiding«:haskell-tng-keyword-face:,» qualified«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import» «:haskell-tng-keyword-face:qualified»
«:haskell-tng-module-face:ProfFile.App»
«:haskell-tng-keyword-face:(»as«:haskell-tng-keyword-face:,»
hiding«:haskell-tng-keyword-face:,» qualified«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:System.Exit»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:ExitCode»
«:haskell-tng-keyword-face:(..),» exitFailure«:haskell-tng-keyword-face:,»
qualified«:haskell-tng-keyword-face:,»
+
«:haskell-tng-type-face:Typey»«:haskell-tng-keyword-face:,»
+ wibble«:haskell-tng-keyword-face:,»
+
«:haskell-tng-type-face:Wibble»«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:System.FilePath»
«:haskell-tng-keyword-face:(»replaceExtension«:haskell-tng-keyword-face:,»
«:haskell-tng-type-face:Foo»«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Bar»«:haskell-tng-keyword-face:,»«:haskell-tng-conid-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face::<»«:haskell-tng-keyword-face:)))»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:System.IO»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:IOMode»
«:haskell-tng-keyword-face:(..),» hClose«:haskell-tng-keyword-face:,»
hGetContents«:haskell-tng-keyword-face:,»
+ hPutStr«:haskell-tng-keyword-face:,»
hPutStrLn«:haskell-tng-keyword-face:,» openFile«:haskell-tng-keyword-face:,»
stderr«:haskell-tng-keyword-face:,»
+ stdout«:haskell-tng-keyword-face:,»
«:haskell-tng-type-face:MoarTypey»«:haskell-tng-keyword-face:)»
+«:haskell-tng-keyword-face:import»
«:haskell-tng-module-face:System.Process»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:CreateProcess»
«:haskell-tng-keyword-face:(..),» «:haskell-tng-type-face:StdStream»
«:haskell-tng-keyword-face:(..),»
+
createProcess«:haskell-tng-keyword-face:,» proc«:haskell-tng-keyword-face:,»
waitForProcess«:haskell-tng-keyword-face:)»
«m:-- »«x:some chars that should be propertized
-»chars «:haskell-tng:keyword:=»
«:haskell-tng:keyword:[»«s:'c'»«:haskell-tng:keyword:,»
«s:'\n'»«:haskell-tng:keyword:,» «s:'\''»«:haskell-tng:keyword:]»
+»chars «:haskell-tng-keyword-face:=»
«:haskell-tng-keyword-face:[»«s:'c'»«:haskell-tng-keyword-face:,»
«s:'\n'»«:haskell-tng-keyword-face:,» «s:'\''»«:haskell-tng-keyword-face:]»
-strings «:haskell-tng:keyword:=»
«:haskell-tng:keyword:[»«s:""»«:haskell-tng:keyword:,»
«s:"\"\""»«:haskell-tng:keyword:,» «s:"\n\\ "»«:haskell-tng:keyword:,»
«s:"\\"»«:haskell-tng:keyword:]»
+strings «:haskell-tng-keyword-face:=»
«:haskell-tng-keyword-face:[»«s:""»«:haskell-tng-keyword-face:,»
«s:"\"\""»«:haskell-tng-keyword-face:,» «s:"\n\\
"»«:haskell-tng-keyword-face:,» «s:"\\"»«:haskell-tng-keyword-face:]»
«m:-- »«x:knownWrongEscape = "foo"\\"bar"
»
-multiline1 «:haskell-tng:keyword:=» «s:"\
+multiline1 «:haskell-tng-keyword-face:=» «s:"\
\ "»
-multiline2 «:haskell-tng:keyword:=» «s:"\
+multiline2 «:haskell-tng-keyword-face:=» «s:"\
\"»
-difficult «:haskell-tng:keyword:=» foo' «s:'a'» 2
+difficult «:haskell-tng-keyword-face:=» foo' «s:'a'» 2
-foo «:haskell-tng:keyword:=» «s:"wobble (wibble)"»
+foo «:haskell-tng-keyword-face:=» «s:"wobble (wibble)"»
-«:haskell-tng:keyword:class»«:haskell-tng:type: Get a s
»«:haskell-tng:keyword:where»
- get «:haskell-tng:keyword:::»«:haskell-tng:type: Set s
»«:haskell-tng:keyword:->»«:haskell-tng:type: a
+«:haskell-tng-keyword-face:class»«:haskell-tng-type-face: Get a s
»«:haskell-tng-keyword-face:where»
+ get «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Set s
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: a
»
-«:haskell-tng:keyword:instance»«:haskell-tng:type: »«x:{-# OVERLAPS
#-}»«:haskell-tng:type: Get a »«:haskell-tng:keyword:(»«:haskell-tng:type:a
»«:haskell-tng:keyword:':»«:haskell-tng:type:
s»«:haskell-tng:keyword:)»«:haskell-tng:type: »«:haskell-tng:keyword:where»
- get «:haskell-tng:keyword:(»«:haskell-tng:constructor:Ext» a
«:haskell-tng:keyword:_)» «:haskell-tng:keyword:=» a
-
-«:haskell-tng:keyword:instance»«:haskell-tng:type: »«x:{-# OVERLAPPABLE
#-}»«:haskell-tng:type: Get a s »«:haskell-tng:keyword:=>»«:haskell-tng:type:
Get a »«:haskell-tng:keyword:(»«:haskell-tng:type:b
»«:haskell-tng:keyword:':»«:haskell-tng:type:
s»«:haskell-tng:keyword:)»«:haskell-tng:type: »«:haskell-tng:keyword:where»
- get «:haskell-tng:keyword:(»«:haskell-tng:constructor:Ext»
«:haskell-tng:keyword:_» xs«:haskell-tng:keyword:)» «:haskell-tng:keyword:=»
get xs
-
-«:haskell-tng:keyword:data»«:haskell-tng:type: Options
»«:haskell-tng:keyword:=» «:haskell-tng:constructor:Options»
- «:haskell-tng:keyword:{» optionsReportType
«:haskell-tng:keyword:::»«:haskell-tng:type: ReportType
-» «:haskell-tng:keyword:,» optionsProfFile
«:haskell-tng:keyword:::»«:haskell-tng:type: Maybe FilePath
-» «:haskell-tng:keyword:,» optionsOutputFile
«:haskell-tng:keyword:::»«:haskell-tng:type: Maybe FilePath
-» «:haskell-tng:keyword:,» optionsFlamegraphFlags
«:haskell-tng:keyword:::»«:haskell-tng:type:
»«:haskell-tng:keyword:[»«:haskell-tng:type:String»«:haskell-tng:keyword:]»«:haskell-tng:type:
-» «:haskell-tng:keyword:}» «:haskell-tng:keyword:deriving»
«:haskell-tng:keyword:(»«:haskell-tng:type:Eq»«:haskell-tng:keyword:,»«:haskell-tng:type:
Show»«:haskell-tng:keyword:)»
-
-«:haskell-tng:keyword:class»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:Eq
a»«:haskell-tng:keyword:)»«:haskell-tng:type:
»«:haskell-tng:keyword:=>»«:haskell-tng:type: Ord a
»«:haskell-tng:keyword:where»
- «:haskell-tng:keyword:(»<«:haskell-tng:keyword:),»
«:haskell-tng:keyword:(»<=«:haskell-tng:keyword:),»
«:haskell-tng:keyword:(»>=«:haskell-tng:keyword:),»
«:haskell-tng:keyword:(»>«:haskell-tng:keyword:)»
«:haskell-tng:keyword:::»«:haskell-tng:type: a
»«:haskell-tng:keyword:->»«:haskell-tng:type: a
»«:haskell-tng:keyword:->»«:haskell-tng:type: Bool
-» max @«:haskell-tng:constructor:Foo»«:haskell-tng:keyword:,» min
«:haskell-tng:keyword:::»«:haskell-tng:type: a
»«:haskell-tng:keyword:->»«:haskell-tng:type: a
»«:haskell-tng:keyword:->»«:haskell-tng:type: a
+«:haskell-tng-keyword-face:instance»«:haskell-tng-type-face: »«x:{-# OVERLAPS
#-}»«:haskell-tng-type-face: Get a
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:a
»«:haskell-tng-keyword-face:':»«:haskell-tng-type-face:
s»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:where»
+ get «:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Ext» a
«:haskell-tng-keyword-face:_)» «:haskell-tng-keyword-face:=» a
+
+«:haskell-tng-keyword-face:instance»«:haskell-tng-type-face: »«x:{-#
OVERLAPPABLE #-}»«:haskell-tng-type-face: Get a s
»«:haskell-tng-keyword-face:=>»«:haskell-tng-type-face: Get a
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:b
»«:haskell-tng-keyword-face:':»«:haskell-tng-type-face:
s»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:where»
+ get «:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Ext»
«:haskell-tng-keyword-face:_» xs«:haskell-tng-keyword-face:)»
«:haskell-tng-keyword-face:=» get xs
+
+«:haskell-tng-keyword-face:data»«:haskell-tng-type-face: Options
»«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Options»
+ «:haskell-tng-keyword-face:{» optionsReportType
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face: ReportType
+» «:haskell-tng-keyword-face:,» optionsProfFile
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Maybe FilePath
+» «:haskell-tng-keyword-face:,» optionsOutputFile
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Maybe FilePath
+» «:haskell-tng-keyword-face:,» optionsFlamegraphFlags
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:[»«:haskell-tng-type-face:String»«:haskell-tng-keyword-face:]»«:haskell-tng-type-face:
+» «:haskell-tng-keyword-face:}» «:haskell-tng-keyword-face:deriving»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Eq»«:haskell-tng-keyword-face:,»«:haskell-tng-type-face:
Show»«:haskell-tng-keyword-face:)»
+
+«:haskell-tng-keyword-face:class»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Eq
a»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:=>»«:haskell-tng-type-face: Ord a
»«:haskell-tng-keyword-face:where»
+ «:haskell-tng-keyword-face:(»<«:haskell-tng-keyword-face:),»
«:haskell-tng-keyword-face:(»<=«:haskell-tng-keyword-face:),»
«:haskell-tng-keyword-face:(»>=«:haskell-tng-keyword-face:),»
«:haskell-tng-keyword-face:(»>«:haskell-tng-keyword-face:)»
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face: a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Bool
+» max @«:haskell-tng-conid-face:Foo»«:haskell-tng-keyword-face:,» min
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face: a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: a
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: a
»
-«:haskell-tng:keyword:instance»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:Eq
a»«:haskell-tng:keyword:)»«:haskell-tng:type:
»«:haskell-tng:keyword:=>»«:haskell-tng:type: Eq
»«:haskell-tng:keyword:(»«:haskell-tng:type:Tree
a»«:haskell-tng:keyword:)»«:haskell-tng:type: »«:haskell-tng:keyword:where»
- «:haskell-tng:constructor:Leaf» a == «:haskell-tng:constructor:Leaf»
b «:haskell-tng:keyword:=» a == b
- «:haskell-tng:keyword:(»«:haskell-tng:constructor:Branch» l1
r1«:haskell-tng:keyword:)» ==
«:haskell-tng:keyword:(»«:haskell-tng:constructor:Branch» l2
r2«:haskell-tng:keyword:)» «:haskell-tng:keyword:=»
«:haskell-tng:keyword:(»l1==l2«:haskell-tng:keyword:)» &&
«:haskell-tng:keyword:(»r1==r2«:haskell-tng:keyword:)»
- «:haskell-tng:keyword:_» == «:haskell-tng:keyword:_»
«:haskell-tng:keyword:=» «:haskell-tng:constructor:False»
-
-«:haskell-tng:keyword:data»«:haskell-tng:type: ReportType
»«:haskell-tng:keyword:=» «:haskell-tng:constructor:Alloc» «m:-- »«x:^ Report
allocations, percent
-» «:haskell-tng:keyword:|» «:haskell-tng:constructor:Entries»
«m:-- »«x:^ Report entries, number
-» «:haskell-tng:keyword:|» «:haskell-tng:constructor:Time»
«m:-- »«x:^ Report time spent in closure, percent
-» «:haskell-tng:keyword:|» «:haskell-tng:constructor:Ticks»
«m:-- »«x:^ Report ticks, number
-» «:haskell-tng:keyword:|» «:haskell-tng:constructor:Bytes»
«m:-- »«x:^ Report bytes allocated, number
-» «:haskell-tng:keyword:deriving»
«:haskell-tng:keyword:(»«:haskell-tng:type:Eq»«:haskell-tng:keyword:,»«:haskell-tng:type:
Show»«:haskell-tng:keyword:)»
-
-«:haskell-tng:keyword:type»«:haskell-tng:type:
»«:haskell-tng:keyword:family»«:haskell-tng:type: G a
»«:haskell-tng:keyword:where»«:haskell-tng:type:
- G Int »«:haskell-tng:keyword:=»«:haskell-tng:type: Bool
- G a »«:haskell-tng:keyword:=»«:haskell-tng:type: Char
+«:haskell-tng-keyword-face:instance»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Eq
a»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:=>»«:haskell-tng-type-face: Eq
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Tree
a»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:where»
+ «:haskell-tng-conid-face:Leaf» a == «:haskell-tng-conid-face:Leaf» b
«:haskell-tng-keyword-face:=» a == b
+ «:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Branch» l1
r1«:haskell-tng-keyword-face:)» ==
«:haskell-tng-keyword-face:(»«:haskell-tng-conid-face:Branch» l2
r2«:haskell-tng-keyword-face:)» «:haskell-tng-keyword-face:=»
«:haskell-tng-keyword-face:(»l1==l2«:haskell-tng-keyword-face:)» &&
«:haskell-tng-keyword-face:(»r1==r2«:haskell-tng-keyword-face:)»
+ «:haskell-tng-keyword-face:_» == «:haskell-tng-keyword-face:_»
«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:False»
+
+«:haskell-tng-keyword-face:data»«:haskell-tng-type-face: ReportType
»«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Alloc» «m:-- »«x:^
Report allocations, percent
+» «:haskell-tng-keyword-face:|»
«:haskell-tng-conid-face:Entries» «m:-- »«x:^ Report entries, number
+» «:haskell-tng-keyword-face:|» «:haskell-tng-conid-face:Time»
«m:-- »«x:^ Report time spent in closure, percent
+» «:haskell-tng-keyword-face:|» «:haskell-tng-conid-face:Ticks»
«m:-- »«x:^ Report ticks, number
+» «:haskell-tng-keyword-face:|» «:haskell-tng-conid-face:Bytes»
«m:-- »«x:^ Report bytes allocated, number
+» «:haskell-tng-keyword-face:deriving»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Eq»«:haskell-tng-keyword-face:,»«:haskell-tng-type-face:
Show»«:haskell-tng-keyword-face:)»
+
+«:haskell-tng-keyword-face:type»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:family»«:haskell-tng-type-face: G a
»«:haskell-tng-keyword-face:where»«:haskell-tng-type-face:
+ G Int »«:haskell-tng-keyword-face:=»«:haskell-tng-type-face: Bool
+ G a »«:haskell-tng-keyword-face:=»«:haskell-tng-type-face: Char
»
-«:haskell-tng:keyword:data»«:haskell-tng:type: Flobble
»«:haskell-tng:keyword:=» «:haskell-tng:constructor:Flobble»
- «:haskell-tng:keyword:deriving»
«:haskell-tng:keyword:(»«:haskell-tng:type:Eq»«:haskell-tng:keyword:)»«:haskell-tng:type:
via »«:haskell-tng:keyword:(»«:haskell-tng:type:NonNegative
»«:haskell-tng:keyword:(»«:haskell-tng:type:Large Int»«:haskell-tng:keyword:))»
- «:haskell-tng:keyword:deriving» «:haskell-tng:keyword:stock»
«:haskell-tng:keyword:(»«:haskell-tng:type:Floo»«:haskell-tng:keyword:)»
- «:haskell-tng:keyword:deriving» «:haskell-tng:keyword:anyclass»
«:haskell-tng:keyword:(»«:haskell-tng:type:WibblyWoo»«:haskell-tng:keyword:,»«:haskell-tng:type:
OtherlyWoo»«:haskell-tng:keyword:)»
+«:haskell-tng-keyword-face:data»«:haskell-tng-type-face: Flobble
»«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Flobble»
+ «:haskell-tng-keyword-face:deriving»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Eq»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
via »«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:NonNegative
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Large
Int»«:haskell-tng-keyword-face:))»
+ «:haskell-tng-keyword-face:deriving» «:haskell-tng-keyword-face:stock»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Floo»«:haskell-tng-keyword-face:)»
+ «:haskell-tng-keyword-face:deriving» «:haskell-tng-keyword-face:anyclass»
«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:WibblyWoo»«:haskell-tng-keyword-face:,»«:haskell-tng-type-face:
OtherlyWoo»«:haskell-tng-keyword-face:)»
-«:haskell-tng:keyword:newtype»«:haskell-tng:type: Flobby
»«:haskell-tng:keyword:=» «:haskell-tng:constructor:Flobby»
+«:haskell-tng-keyword-face:newtype»«:haskell-tng-type-face: Flobby
»«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Flobby»
-foo «:haskell-tng:keyword:::»«:haskell-tng:type:
+foo «:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
Wibble »«m:-- »«x:wibble
-»«:haskell-tng:type: »«:haskell-tng:keyword:->»«:haskell-tng:type: Wobble
»«m:-- »«x:wobble
-»«:haskell-tng:type: »«:haskell-tng:keyword:->»«:haskell-tng:type: Wobble
»«m:-- »«x:wobble
-»«:haskell-tng:type: »«:haskell-tng:keyword:->»«:haskell-tng:type: Wobble
»«m:-- »«x:wobble
-»«:haskell-tng:type: »«:haskell-tng:keyword:->»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:wob
»«:haskell-tng:keyword:::»«:haskell-tng:type:
Wobble»«:haskell-tng:keyword:)»«:haskell-tng:type:
- »«:haskell-tng:keyword:->»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:Wobble »«m:-- »«x:wobble
-»«:haskell-tng:type: a b c»«:haskell-tng:keyword:)»«:haskell-tng:type:
+»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Wobble »«m:-- »«x:wobble
+»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Wobble »«m:-- »«x:wobble
+»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face: Wobble »«m:-- »«x:wobble
+»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:->»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:wob
»«:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
Wobble»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
+ »«:haskell-tng-keyword-face:->»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Wobble »«m:-- »«x:wobble
+»«:haskell-tng-type-face: a b
c»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»
-«:haskell-tng:keyword:(»foo «:haskell-tng:keyword:::»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:Wibble
Wobble»«:haskell-tng:keyword:))» foo
+«:haskell-tng-keyword-face:(»foo
«:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:Wibble
Wobble»«:haskell-tng-keyword-face:))» foo
-«:haskell-tng:keyword:newtype»«:haskell-tng:type: TestApp
- »«:haskell-tng:keyword:(»«:haskell-tng:type:logger
»«:haskell-tng:keyword:::»«:haskell-tng:type:
TestLogger»«:haskell-tng:keyword:)»«:haskell-tng:type:
- »«:haskell-tng:keyword:(»«:haskell-tng:type:scribe
»«:haskell-tng:keyword:::»«:haskell-tng:type:
TestScribe»«:haskell-tng:keyword:)»«:haskell-tng:type:
+«:haskell-tng-keyword-face:newtype»«:haskell-tng-type-face: TestApp
+ »«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:logger
»«:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
TestLogger»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
+ »«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:scribe
»«:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
TestScribe»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
config
a
- »«:haskell-tng:keyword:=» «:haskell-tng:constructor:TestApp» a
+ »«:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:TestApp» a
-optionsParser «:haskell-tng:keyword:::»«:haskell-tng:type: Opts.Parser Options
-»optionsParser «:haskell-tng:keyword:=» «:haskell-tng:constructor:Options»
- <$> «:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»flag'
«:haskell-tng:constructor:Alloc»
«:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»long «s:"alloc"» <>
«:haskell-tng:module:Opts.»help «s:"wibble"»«:haskell-tng:keyword:)»
- <|> «:haskell-tng:module:Opts.»flag' «:haskell-tng:constructor:Entries»
«:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»long «s:"entry"» <>
«:haskell-tng:module:Opts.»help «s:"wobble"»«:haskell-tng:keyword:)»
- <|> «:haskell-tng:module:Opts.»flag' «:haskell-tng:constructor:Bytes»
«:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»long «s:"bytes"» <>
«:haskell-tng:module:Opts.»help «s:"i'm a fish"»«:haskell-tng:keyword:))»
+optionsParser «:haskell-tng-keyword-face:::»«:haskell-tng-type-face:
Opts.Parser Options
+»optionsParser «:haskell-tng-keyword-face:=» «:haskell-tng-conid-face:Options»
+ <$> «:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»flag'
«:haskell-tng-conid-face:Alloc»
«:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»long «s:"alloc"»
<> «:haskell-tng-module-face:Opts.»help
«s:"wibble"»«:haskell-tng-keyword-face:)»
+ <|> «:haskell-tng-module-face:Opts.»flag'
«:haskell-tng-conid-face:Entries»
«:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»long «s:"entry"»
<> «:haskell-tng-module-face:Opts.»help
«s:"wobble"»«:haskell-tng-keyword-face:)»
+ <|> «:haskell-tng-module-face:Opts.»flag'
«:haskell-tng-conid-face:Bytes»
«:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»long «s:"bytes"»
<> «:haskell-tng-module-face:Opts.»help «s:"i'm a
fish"»«:haskell-tng-keyword-face:))»
<*> optional
- «:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»strArgument
- «:haskell-tng:keyword:(»«:haskell-tng:module:Opts.»metavar
«s:"MY-FILE"» <>
- «:haskell-tng:module:Opts.»help «s:"meh"»«:haskell-tng:keyword:))»
+
«:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»strArgument
+ «:haskell-tng-keyword-face:(»«:haskell-tng-module-face:Opts.»metavar
«s:"MY-FILE"» <>
+ «:haskell-tng-module-face:Opts.»help
«s:"meh"»«:haskell-tng-keyword-face:))»
-«:haskell-tng:keyword:type»«:haskell-tng:type: PhantomThing
+«:haskell-tng-keyword-face:type»«:haskell-tng-type-face: PhantomThing
»
-«:haskell-tng:keyword:type»«:haskell-tng:type: SomeApi
»«:haskell-tng:keyword:=»«:haskell-tng:type:
- »«s:"thing"»«:haskell-tng:type: :> Capture
»«s:"bar"»«:haskell-tng:type: Index :> QueryParam
»«s:"wibble"»«:haskell-tng:type: Text
- :> QueryParam
»«s:"wobble"»«:haskell-tng:type: Natural
+«:haskell-tng-keyword-face:type»«:haskell-tng-type-face: SomeApi
»«:haskell-tng-keyword-face:=»«:haskell-tng-type-face:
+ »«s:"thing"»«:haskell-tng-type-face: :> Capture
»«s:"bar"»«:haskell-tng-type-face: Index :> QueryParam
»«s:"wibble"»«:haskell-tng-type-face: Text
+ :> QueryParam
»«s:"wobble"»«:haskell-tng-type-face: Natural
:> Header TracingHeader
TracingId
:> ThingHeader
- :> Get
'»«:haskell-tng:keyword:[»«:haskell-tng:type:JSON»«:haskell-tng:keyword:]»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:The
ReadResult»«:haskell-tng:keyword:)»«:haskell-tng:type:
- :<|> »«s:"thing"»«:haskell-tng:type: :> ReqBody
'»«:haskell-tng:keyword:[»«:haskell-tng:type:JSON»«:haskell-tng:keyword:]»«:haskell-tng:type:
Request
+ :> Get
'»«:haskell-tng-keyword-face:[»«:haskell-tng-type-face:JSON»«:haskell-tng-keyword-face:]»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:The
ReadResult»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
+ :<|> »«s:"thing"»«:haskell-tng-type-face: :> ReqBody
'»«:haskell-tng-keyword-face:[»«:haskell-tng-type-face:JSON»«:haskell-tng-keyword-face:]»«:haskell-tng-type-face:
Request
:> Header TracingHeader TracingId
:> SpecialHeader
- :> Post
'»«:haskell-tng:keyword:[»«:haskell-tng:type:JSON»«:haskell-tng:keyword:]»«:haskell-tng:type:
»«:haskell-tng:keyword:(»«:haskell-tng:type:The
Response»«:haskell-tng:keyword:)»«:haskell-tng:type:
+ :> Post
'»«:haskell-tng-keyword-face:[»«:haskell-tng-type-face:JSON»«:haskell-tng-keyword-face:]»«:haskell-tng-type-face:
»«:haskell-tng-keyword-face:(»«:haskell-tng-type-face:The
Response»«:haskell-tng-keyword-face:)»«:haskell-tng-type-face:
»
-«:haskell-tng:keyword:deriving» «:haskell-tng:keyword:instance»
«:haskell-tng:constructor:FromJSONKey» «:haskell-tng:constructor:StateName»
-«:haskell-tng:keyword:deriving» anyclass «:haskell-tng:keyword:instance»
«:haskell-tng:constructor:FromJSON» «:haskell-tng:constructor:Base»
-«:haskell-tng:keyword:deriving» «:haskell-tng:keyword:newtype»
«:haskell-tng:keyword:instance» «:haskell-tng:constructor:FromJSON»
«:haskell-tng:constructor:Treble»
+«:haskell-tng-keyword-face:deriving» «:haskell-tng-keyword-face:instance»
«:haskell-tng-conid-face:FromJSONKey» «:haskell-tng-conid-face:StateName»
+«:haskell-tng-keyword-face:deriving» anyclass
«:haskell-tng-keyword-face:instance» «:haskell-tng-conid-face:FromJSON»
«:haskell-tng-conid-face:Base»
+«:haskell-tng-keyword-face:deriving» «:haskell-tng-keyword-face:newtype»
«:haskell-tng-keyword-face:instance» «:haskell-tng-conid-face:FromJSON»
«:haskell-tng-conid-face:Treble»
-foo «:haskell-tng:keyword:=» «:haskell-tng:keyword:do»
- bar «:haskell-tng:keyword:::»«:haskell-tng:type: Wibble
»«:haskell-tng:keyword:<-» baz
- «:haskell-tng:keyword:where» baz «:haskell-tng:keyword:=»
«:haskell-tng:keyword:_»
+foo «:haskell-tng-keyword-face:=» «:haskell-tng-keyword-face:do»
+ bar «:haskell-tng-keyword-face:::»«:haskell-tng-type-face: Wibble
»«:haskell-tng-keyword-face:<-» baz
+ «:haskell-tng-keyword-face:where» baz «:haskell-tng-keyword-face:=»
«:haskell-tng-keyword-face:_»
«m:-- »«x:checking that comments are ignored in layout
» «m:-- »«x:and that a starting syntax entry is ok
-» «:haskell-tng:keyword:(»+«:haskell-tng:keyword:)»
«:haskell-tng:keyword:=» «:haskell-tng:keyword:_»
+» «:haskell-tng-keyword-face:(»+«:haskell-tng-keyword-face:)»
«:haskell-tng-keyword-face:=» «:haskell-tng-keyword-face:_»
-test «:haskell-tng:keyword:=» 1 `shouldBe` 1
+test «:haskell-tng-keyword-face:=» 1 `shouldBe` 1
-cases «:haskell-tng:keyword:=» «:haskell-tng:keyword:\case»
- «:haskell-tng:constructor:Nothing» «:haskell-tng:keyword:->» «s:"no"» &
toUpper
- «:haskell-tng:constructor:Just» «:haskell-tng:keyword:_»
«:haskell-tng:keyword:->» toUpper $ «s:"yes"»
+cases «:haskell-tng-keyword-face:=» «:haskell-tng-keyword-face:\case»
+ «:haskell-tng-conid-face:Nothing» «:haskell-tng-keyword-face:->» «s:"no"» &
toUpper
+ «:haskell-tng-conid-face:Just» «:haskell-tng-keyword-face:_»
«:haskell-tng-keyword-face:->» toUpper $ «s:"yes"»
-bar «:haskell-tng:keyword:=» «:haskell-tng:keyword:do» «m:-- »«x:an incomplete
do block
+bar «:haskell-tng-keyword-face:=» «:haskell-tng-keyword-face:do» «m:-- »«x:an
incomplete do block
»
\ No newline at end of file
- [nongnu] elpa/haskell-tng-mode 32175c0 158/385: thots, (continued)
- [nongnu] elpa/haskell-tng-mode 32175c0 158/385: thots, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 8c2e3f7 157/385: better symid indentation, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode bc5c827 160/385: tuple indentation, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode e0acc42 156/385: better tasty error detection, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode c211672 174/385: indentation for hanging type definition, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode ef7f335 171/385: note stack compatibility, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 86bcd98 175/385: constraint indentation, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode e1c0f0a 179/385: allow indentation option to be tested, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 1cceb64 182/385: cleaner tests, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode b1122e4 188/385: allow users to use unsupported build tools, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode bd4ff6f 192/385: standardise on naming convention:,
ELPA Syncer <=
- [nongnu] elpa/haskell-tng-mode 3b5ac7f 190/385: package-lint, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode a227f7e 200/385: blank lines end a run of type definitions, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode e4ead98 201/385: thots on prettify-symbol, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 387aa18 203/385: more efficient layout algorithm, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode bfc3841 193/385: remove bind-key dependency, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 6acba95 206/385: better insertion indentation on toplevels, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 9bfc6bf 215/385: really basic imenu, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode f648cf9 212/385: fallback to current directory (e.g. for cabal scripts), ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 5bdf688 211/385: better in-line indentation of parens, ELPA Syncer, 2021/10/06
- [nongnu] elpa/haskell-tng-mode 1cdf901 120/385: better escape syntax detection, ELPA Syncer, 2021/10/06