about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el1255
1 files changed, 1255 insertions, 0 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el
new file mode 100644
index 000000000000..0ab735ff2ad3
--- /dev/null
+++ b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-indentation.el
@@ -0,0 +1,1255 @@
+;;; haskell-indentation.el --- indentation module for Haskell Mode -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013  Kristof Bastiaensen, Gergely Risko
+
+;; Author: Kristof Bastiaensen <kristof.bastiaensen@vleeuwen.org>
+;; Author: Gergely Risko <errge@nilcons.com>
+;; Keywords: indentation haskell
+;; URL: https://github.com/haskell/haskell-mode
+
+;; This file is not part of GNU Emacs.
+
+;; This file is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+
+;; This file is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Installation:
+;;
+;; To turn indentation on for all Haskell buffers under Haskell mode add
+;; this to your configuration file:
+;;
+;;     (add-hook haskell-mode-hook 'haskell-indentation-mode)
+;;
+;; Otherwise, call `haskell-indentation-mode'.
+
+;;; Code:
+
+;; TODO eliminate magic number 2 where possible, use a variable
+
+;; TODO `haskell-indentation-find-indentation' — fix it, get rid of "safe"
+;; version
+
+(require 'cl-lib)
+(require 'haskell-lexeme)
+
+;;;###autoload
+(defgroup haskell-indentation nil
+  "Haskell indentation."
+  :link '(custom-manual "(haskell-mode)Indentation")
+  :group 'haskell
+  :prefix "haskell-indentation-")
+
+(defcustom haskell-indentation-layout-offset 2
+  "Extra indentation to add before expressions in a Haskell layout list."
+  :type 'integer
+  :group 'haskell-indentation)
+
+(defcustom haskell-indentation-starter-offset 2
+  "Extra indentation after an opening keyword (e.g. \"let\")."
+  :type 'integer
+  :group 'haskell-indentation)
+
+(defcustom haskell-indentation-left-offset 2
+  "Extra indentation after an indentation to the left (e.g. after \"do\")."
+  :type 'integer
+  :group 'haskell-indentation)
+
+(defcustom haskell-indentation-where-pre-offset 2
+  "Extra indentation before the keyword \"where\"."
+  :type 'integer
+  :group 'haskell-indentation)
+
+(defcustom haskell-indentation-where-post-offset 2
+  "Extra indentation after the keyword \"where\"."
+  :type 'integer
+  :group 'haskell-indentation)
+
+(defcustom haskell-indentation-electric-flag nil
+  "Non-nil means insertion of some characters may auto reindent the line.
+If the variable `electric-indent-mode' is non-nil then this variable is
+overridden."
+  :type 'symbol
+  :group 'haskell-indentation)
+(make-variable-buffer-local 'haskell-indentation-electric-flag)
+
+(defvar haskell-indentation-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "RET") #'haskell-indentation-newline-and-indent)
+    (define-key map (kbd "<backtab>") #'haskell-indentation-indent-backwards)
+    (define-key map (kbd ",") #'haskell-indentation-common-electric-command)
+    (define-key map (kbd ";") #'haskell-indentation-common-electric-command)
+    (define-key map (kbd ")") #'haskell-indentation-common-electric-command)
+    (define-key map (kbd "}") #'haskell-indentation-common-electric-command)
+    (define-key map (kbd "]") #'haskell-indentation-common-electric-command)
+    map)
+  "Keymap for `haskell-indentation-mode'.")
+
+;;;###autoload
+(define-minor-mode haskell-indentation-mode
+  "Haskell indentation mode that deals with the layout rule.
+It rebinds RET, DEL and BACKSPACE, so that indentations can be
+set and deleted as if they were real tabs."
+  :keymap haskell-indentation-mode-map
+  (kill-local-variable 'indent-line-function)
+  (kill-local-variable 'indent-region-function)
+
+  (when haskell-indentation-mode
+    (when (and (bound-and-true-p haskell-indent-mode)
+               (fboundp 'turn-off-haskell-indent))
+      (turn-off-haskell-indent))
+    (setq-local indent-line-function #'haskell-indentation-indent-line)
+    (setq-local indent-region-function #'haskell-indentation-indent-region)))
+
+;;;###autoload
+(defun turn-on-haskell-indentation ()
+  "Turn on the haskell-indentation minor mode."
+  (interactive)
+  (haskell-indentation-mode t))
+
+(make-obsolete 'turn-on-haskell-indentation
+               'haskell-indentation-mode
+               "2015-05-25")
+
+(defvar haskell-literate) ; defined in haskell-mode.el
+
+(defun haskell-indentation-bird-p ()
+  "Return t if this is a literate Haskell buffer in bird style, NIL otherwise."
+  (eq haskell-literate 'bird))
+
+;;----------------------------------------------------------------------------
+;; UI starts here
+
+(defun haskell-indentation-reindent-to (col &optional move)
+  "Reindent current line to COL, move the point there if MOVE is non-NIL."
+  (let* ((ci (haskell-indentation-current-indentation)))
+    (save-excursion
+      (move-to-column ci)
+      (if (<= ci col)
+          (insert-before-markers (make-string (- col ci) ? ))
+        (delete-char (- col ci))))
+    (when move
+      (move-to-column col))))
+
+(defun haskell-indentation-indent-rigidly (start end arg)
+  "Indent all lines starting in the region sideways by ARG columns.
+Called from a program, takes three arguments, START, END and ARG.
+You can remove all indentation from a region by giving a large
+negative ARG.  Handles bird style literate Haskell too."
+  (interactive "*r\np")
+  (save-excursion
+    (goto-char end)
+    (let ((end-marker (point-marker)))
+      (goto-char start)
+      (or (bolp) (forward-line 0))
+      (while (< (point) end-marker)
+        (let ((ci (haskell-indentation-current-indentation)))
+          (when (and t
+                     (eq (char-after) ?>))
+            (forward-char 1))
+          (skip-syntax-forward "-")
+          (unless (eolp)
+            (haskell-indentation-reindent-to (max 0 (+ ci arg))))
+          (forward-line 1)))
+      (move-marker end-marker nil))))
+
+(defun haskell-indentation-current-indentation ()
+  "Column position of first non-whitespace character in current line."
+  (save-excursion
+    (beginning-of-line)
+    (when (haskell-indentation-bird-p)
+      (forward-char))
+    (skip-syntax-forward "-")
+    (current-column)))
+
+(defun haskell-indentation-bird-outside-code-p ()
+  "Non-NIL if we are in bird literate mode, but outside of code."
+  (and (haskell-indentation-bird-p)
+       (or (< (current-column) 2)
+           (save-excursion
+             (beginning-of-line)
+             (not (eq (char-after) ?>))))))
+
+(defun haskell-indentation-newline-and-indent ()
+  "Insert newline and indent."
+  (interactive "*")
+  ;; On RET (or C-j), we:
+  ;;   - just jump to the next line if literate haskell, but outside code
+  (if (haskell-indentation-bird-outside-code-p)
+      (progn
+        (delete-horizontal-space)
+        (newline))
+    ;;  - save the current column
+    (let ((ci (haskell-indentation-current-indentation)))
+      ;; - jump to the next line and reindent to at the least same level
+      (delete-horizontal-space)
+      (newline)
+      ;; calculate indentation after newline is inserted because if we
+      ;; break an identifier we might create a keyword, for example
+      ;; "dowhere" => "do where"
+      (let ((indentations (or (haskell-indentation-find-indentations)
+                              '(0))))
+        (when (haskell-indentation-bird-p)
+          (insert "> "))
+        (haskell-indentation-reindent-to
+         (haskell-indentation-next-indentation (- ci 1) indentations 'nofail)
+         'move)))))
+
+(defun haskell-indentation-next-indentation (col indentations &optional nofail)
+  "Find the leftmost indentation which is greater than COL.
+Indentations are taken from INDENTATIONS, which should be a
+list.  Return the last indentation if there are no bigger ones and
+NOFAIL is non-NIL."
+  (when (null indentations)
+    (error "haskell-indentation-next-indentation called with empty list"))
+  (or (cl-find-if (lambda (i) (> i col)) indentations)
+      (when nofail
+        (car (last indentations)))))
+
+(defun haskell-indentation-previous-indentation (col indentations &optional nofail)
+  "Find the rightmost indentation less than COL from INDENTATIONS.
+When no indentations are less than COL, return the rightmost indentation
+if NOFAIL is non-nil, or nil otherwise."
+  (when (null indentations)
+    (error "haskell-indentation-previous-indentation called with empty list"))
+  (let ((rev (reverse indentations)))
+    (or (cl-find-if (lambda (i) (< i col)) rev)
+        (when nofail
+          (car rev)))))
+
+(defvar haskell-indentation-dyn-last-direction nil
+  "") ; FIXME
+(defvar haskell-indentation-dyn-last-indentations nil
+  "") ; FIXME
+
+(defun haskell-indentation-indent-line ()
+  "Indent current line, cycle though indentation positions.
+Do nothing inside multiline comments and multiline strings.
+Start enumerating the indentation points to the right.  The user
+can continue by repeatedly pressing TAB.  When there is no more
+indentation points to the right, we switch going to the left."
+  (interactive "*")
+  ;; try to repeat
+  (when (not (haskell-indentation-indent-line-repeat))
+    (setq haskell-indentation-dyn-last-direction nil)
+    ;; parse error is intentionally not cought here, it may come from
+    ;; `haskell-indentation-find-indentations', but escapes the scope
+    ;; and aborts the opertaion before any moving happens
+    (let* ((cc (current-column))
+           (ci (haskell-indentation-current-indentation))
+           (inds (save-excursion
+                   (move-to-column ci)
+                   (or (haskell-indentation-find-indentations)
+                       '(0))))
+           (valid (memq ci inds))
+           (cursor-in-whitespace (< cc ci)))
+
+      (if (and valid cursor-in-whitespace)
+          (move-to-column ci)
+        (haskell-indentation-reindent-to
+         (haskell-indentation-next-indentation ci inds 'nofail)
+         cursor-in-whitespace))
+      (setq haskell-indentation-dyn-last-direction 'right
+            haskell-indentation-dyn-last-indentations inds))))
+
+(defun haskell-indentation-indent-line-repeat ()
+  "Cycle though indentation positions."
+  (cond
+   ((and (memq last-command
+               '(indent-for-tab-command
+                 haskell-indentation-indent-backwards))
+         (eq haskell-indentation-dyn-last-direction 'region))
+    (let ((mark-even-if-inactive t))
+      (haskell-indentation-indent-rigidly
+       (region-beginning)
+       (region-end)
+       1))
+    t)
+   ((and (eq last-command 'indent-for-tab-command)
+         (memq haskell-indentation-dyn-last-direction '(left right))
+         haskell-indentation-dyn-last-indentations)
+    (let ((ci (haskell-indentation-current-indentation)))
+      (if (eq haskell-indentation-dyn-last-direction 'left)
+          (haskell-indentation-reindent-to
+           (haskell-indentation-previous-indentation
+            ci haskell-indentation-dyn-last-indentations 'nofail))
+        ;; right
+        (if (haskell-indentation-next-indentation
+             ci haskell-indentation-dyn-last-indentations)
+            (haskell-indentation-reindent-to
+             (haskell-indentation-next-indentation
+              ci haskell-indentation-dyn-last-indentations 'nofail))
+          ;; but failed, switch to left
+          (setq haskell-indentation-dyn-last-direction 'left)
+          (haskell-indentation-indent-line-repeat)))
+      t))
+   (t nil)))
+
+(defun haskell-indentation-indent-region (_start _end)
+  "This function does nothing.
+
+It is better to do nothing to indent region in Haskell than to
+break the semantics of indentation.  This function is used for
+`indent-region-function' because the default is to call
+`indent-line-function' on every line from START to END and that
+also produces catastrophic results.
+
+Someday we will have indent region that preserves semantics and
+fixes up only indentation."
+  nil)
+
+(defun haskell-indentation-indent-backwards ()
+  "Indent the current line to the previous indentation point."
+  (interactive "*")
+  (cond
+   ((and (memq last-command
+               '(indent-for-tab-command haskell-indentation-indent-backwards))
+         (eq haskell-indentation-dyn-last-direction 'region))
+    (let ((mark-even-if-inactive t))
+      (haskell-indentation-indent-rigidly (region-beginning) (region-end) -1)))
+   ((use-region-p)
+    (setq haskell-indentation-dyn-last-direction 'region)
+    (haskell-indentation-indent-rigidly (region-beginning) (region-end) -1)
+    (message "Press TAB or S-TAB again to indent the region more"))
+   (t
+    (setq haskell-indentation-dyn-last-direction nil)
+    (let* ((cc (current-column))
+           (ci (haskell-indentation-current-indentation))
+           (inds (save-excursion
+                   (move-to-column ci)
+                   (or (haskell-indentation-find-indentations)
+                       '(0))))
+           (cursor-in-whitespace (< cc ci))
+           (pi (haskell-indentation-previous-indentation ci inds)))
+      (if (null pi)
+          ;; if there are no more indentations to the left, just go to column 0
+          (haskell-indentation-reindent-to
+           (car (haskell-indentation-first-indentation)) cursor-in-whitespace)
+        (haskell-indentation-reindent-to pi cursor-in-whitespace))))))
+
+(defun haskell-indentation-common-electric-command (arg)
+  "Call `self-insert-command' to insert the character typed ARG times
+and indent when all of the following are true:
+1) The character is the first non-whitespace character on the line.
+2) There is only one possible indentation position.
+3) The variable `electric-indent-mode' or `haskell-indentation-electric-flag'
+   is non-nil.
+4) The point is not in a comment, string, or quasiquote."
+  (interactive "*p")
+  (let ((col (current-column))
+        ind)
+    (self-insert-command arg)
+    (when (and (or haskell-indentation-electric-flag
+                   electric-indent-mode)
+               (= (haskell-indentation-current-indentation)
+                  col)
+               (> arg 0)
+               (not (nth 8 (syntax-ppss)))
+               (= 1 (save-excursion
+                      (move-to-column col)
+                      (length (setq ind (haskell-indentation-find-indentations))))))
+      (haskell-indentation-reindent-to (car ind)))))
+
+
+;;----------------------------------------------------------------------------
+;; Parser Starts Here
+
+;; The parser is implemented as a recursive descent parser.  Each parser
+;; advances the point to after the expression it parses, and sets the
+;; dynamic scoped variables containing the information about the
+;; indentations.  The dynamic scoping allows transparent backtracking to
+;; previous states of these variables.  A new state can be set using `let'.
+;; When the scope of this function ends, the variable is automatically
+;; reverted to its old value.
+
+;; This is basicly a performance hack.  It would have been possible to
+;; thread this state using a association-list through the parsers, but it
+;; would be probably more complicated and slower due to the lack of real
+;; closures in Emacs Lisp.
+;;
+;; When finished parsing, the tokenizer returns 'end-token, and
+;; following-token is set to the token after point.  The parser adds its
+;; indentations to possible-indentations and returns to it's parent, or
+;; exits non-locally by throwing parse-end, so that the parent will not add
+;; new indentations to it.
+
+;; the parse state:
+(defvar following-token)        ;; the next token after parsing finished
+;; the token at the current parser point or a pseudo-token (see
+;; `haskell-indentation-read-next-token')
+(defvar current-token)
+(defvar previous-token)
+(defvar left-indent)            ;; most left possible indentation
+(defvar starter-indent)         ;; column at a keyword
+(defvar current-indent)         ;; the most right indentation
+(defvar layout-indent)          ;; the column of the layout list
+(defvar possible-indentations)  ;; the return value of the indentations
+(defvar indentation-point)      ;; where to stop parsing
+(defvar implicit-layout-active) ;; is "off-side" rule active?
+
+(defun haskell-indentation-goto-least-indentation ()
+  "" ; FIXME
+  (beginning-of-line)
+  (if (haskell-indentation-bird-p)
+      (catch 'return
+        (while t
+          (when (not (eq (char-after) ?>))
+            (forward-line)
+            (forward-char 2)
+            (throw 'return nil))
+          (let ((ps (nth 8 (syntax-ppss))))
+            (when ps ;; inside comment or string
+              (goto-char ps)
+              (beginning-of-line)))
+          (when (and (>= 2 (haskell-indentation-current-indentation))
+                     (not (looking-at ">\\s-*$")))
+            (forward-char 2)
+            (throw 'return nil))
+          (when (bobp)
+            (forward-char 2)
+            (throw 'return nil))
+          (forward-line -1)))
+    ;; not bird style
+    (catch 'return
+      (while (not (bobp))
+        (let ((point (point)))
+          ;; (forward-comment -1) gets lost if there are unterminated
+          ;; string constants and does not move point anywhere. We fix
+          ;; that case with (forward-line -1)
+          (forward-comment (- (buffer-size)))
+          (if (equal (point) point)
+              (forward-line -1)
+            (beginning-of-line)))
+        (let* ((ps (syntax-ppss))
+              (start-of-comment-or-string (nth 8 ps))
+              (start-of-list-expression (nth 1 ps)))
+          (cond
+           (start-of-comment-or-string
+            ;; inside comment or string
+            (goto-char start-of-comment-or-string))
+           (start-of-list-expression
+            ;; inside a parenthesized expression
+            (goto-char start-of-list-expression))
+           ((= 0 (haskell-indentation-current-indentation))
+             (throw 'return nil))))))
+    (beginning-of-line)
+    (when (bobp)
+      (forward-comment (buffer-size)))))
+
+(defun haskell-indentation-parse-to-indentations ()
+  "" ; FIXME
+  (save-excursion
+    (skip-syntax-forward "-")
+    (let ((indentation-point (point))
+          (layout-indent 0)
+          (current-indent haskell-indentation-layout-offset)
+          (starter-indent haskell-indentation-layout-offset)
+          (left-indent haskell-indentation-layout-offset)
+          (case-fold-search nil)
+          current-token
+          previous-token
+          following-token
+          possible-indentations
+          implicit-layout-active)
+      (haskell-indentation-goto-least-indentation)
+      (if (<= indentation-point (point))
+          (haskell-indentation-first-indentation)
+        (setq current-token (haskell-indentation-peek-token))
+        (catch 'parse-end
+          (haskell-indentation-toplevel))
+        possible-indentations))))
+
+(defun haskell-indentation-first-indentation ()
+  "Return column of first indentation."
+  (list (if (haskell-indentation-bird-p) 2 0)))
+
+(defun haskell-indentation-find-indentations ()
+  "Return list of indentation positions corresponding to actual cursor position."
+  (let ((ppss (syntax-ppss)))
+    (cond
+     ((nth 3 ppss)
+      (if (save-excursion
+            (and (forward-line -1)
+                 (< (nth 8 ppss) (point))))
+          ;; if this string goes over more than one line we want to
+          ;; sync with the last line, not the first one
+          (list (save-excursion
+                  (forward-line -1)
+                  (current-indentation)))
+
+        (append
+         (haskell-indentation-first-indentation)
+         (list (save-excursion
+                 (goto-char (nth 8 ppss))
+                 (current-column))))))
+     ((nth 4 ppss)
+      (if (save-excursion
+            (and (skip-syntax-forward "-")
+                 (eolp)
+                 (not (> (forward-line 1) 0))
+                 (not (nth 4 (syntax-ppss)))))
+          (haskell-indentation-parse-to-indentations)
+        (haskell-indentation-first-indentation)))
+     (t
+      (haskell-indentation-parse-to-indentations)))))
+
+(defconst haskell-indentation-unicode-tokens
+  '(("→" . "->")     ;; #x2192 RIGHTWARDS ARROW
+    ("∷" . "::")     ;; #x2237 PROPORTION
+    ("←" . "<-")     ;; #x2190 LEFTWARDS ARROW
+    ("⇒" . "=>")     ;; #x21D2 RIGHTWARDS DOUBLE ARROW
+    ("∀" . "forall") ;; #x2200 FOR ALL
+    ("⤙" . "-<")     ;; #x2919 LEFTWARDS ARROW-TAIL
+    ("⤚" . ">-")     ;; #x291A RIGHTWARDS ARROW-TAIL
+    ("⤛" . "-<<")    ;; #x291B LEFTWARDS DOUBLE ARROW-TAIL
+    ("⤜" . ">>-")    ;; #x291C RIGHTWARDS DOUBLE ARROW-TAIL
+    ("★" . "*"))     ;; #x2605 BLACK STAR
+  "Translation from UnicodeSyntax tokens to their ASCII representation.")
+
+(defconst haskell-indentation-toplevel-list
+  `(("module"    . haskell-indentation-module)
+    ("signature" . haskell-indentation-module)
+    ("data"      . haskell-indentation-data)
+    ("type"      . haskell-indentation-data)
+    ("newtype"   . haskell-indentation-data)
+    ("import"    . haskell-indentation-import)
+    ("foreign"   . haskell-indentation-foreign)
+    ("where"     . haskell-indentation-toplevel-where)
+    ("class"     . haskell-indentation-class-declaration)
+    ("instance"  . haskell-indentation-class-declaration)
+    ("deriving"  . haskell-indentation-deriving))
+  "Alist of toplevel keywords with associated parsers.")
+
+(defconst haskell-indentation-type-list
+  `(("::" .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       (apply-partially 'haskell-indentation-separated
+                                        'haskell-indentation-type '("->" "=>"))))
+    ("("  .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-type ")" ","))
+    ("["  .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-type "]" ","))
+    ("{"  .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-type "}" ",")))
+  "Alist of tokens in type declarations with associated parsers.")
+
+(defconst haskell-indentation-expression-list
+  `(("data"    . haskell-indentation-data)
+    ("type"    . haskell-indentation-data)
+    ("newtype" . haskell-indentation-data)
+    ("if"      . haskell-indentation-if)
+    ("let"     .
+     ,(apply-partially 'haskell-indentation-phrase
+                       '(haskell-indentation-declaration-layout
+                         "in" haskell-indentation-expression)))
+    ("do"      .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       'haskell-indentation-expression-layout))
+    ("mdo"     .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       'haskell-indentation-expression-layout))
+    ("rec"     .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       'haskell-indentation-expression-layout))
+    ("case"    .
+     ,(apply-partially 'haskell-indentation-phrase
+                       '(haskell-indentation-expression
+                         "of" haskell-indentation-case-layout)))
+    ("\\"      .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       'haskell-indentation-lambda-maybe-lambdacase))
+    ("proc"    .
+     ,(apply-partially 'haskell-indentation-phrase
+                       '(haskell-indentation-expression
+                         "->" haskell-indentation-expression)))
+    ("where"   .
+     ,(apply-partially 'haskell-indentation-with-starter
+                       'haskell-indentation-declaration-layout nil t))
+    ("::"      .        haskell-indentation-scoped-type)
+    ("="       .
+     ,(apply-partially 'haskell-indentation-statement-right
+                       'haskell-indentation-expression))
+    ("<-"      .
+     ,(apply-partially 'haskell-indentation-statement-right
+                       'haskell-indentation-expression))
+    ("("       .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-expression
+                       ")"
+                       '(list "," "->")))
+    ("["       .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-expression "]" "," "|"))
+    ("{"       .
+     ,(apply-partially 'haskell-indentation-list
+                       'haskell-indentation-expression "}" ",")))
+  "Alist of keywords in expressions with associated parsers.")
+
+(defun haskell-indentation-expression-layout ()
+  "Parse layout list with expressions, such as after \"do\"."
+  (haskell-indentation-layout #'haskell-indentation-expression))
+
+(defun haskell-indentation-declaration-layout ()
+  "Parse layout list with declarations, such as after \"where\"."
+  (haskell-indentation-layout #'haskell-indentation-declaration))
+
+(defun haskell-indentation-case-layout ()
+  "Parse layout list with case expressions."
+  (haskell-indentation-layout #'haskell-indentation-case))
+
+(defun haskell-indentation-lambda-maybe-lambdacase ()
+  "Parse lambda or lambda-case expression.
+After a lambda (backslash) there are two possible cases:
+
+- the new lambdacase expression, that can be recognized by the
+  next token being \"case\";
+
+- or simply an anonymous function definition in the form of
+  \"expression -> expression\"."
+  (if (string= current-token "case")
+      (haskell-indentation-with-starter
+       #'haskell-indentation-case-layout)
+    (haskell-indentation-phrase-rest
+     '(haskell-indentation-expression "->" haskell-indentation-expression))))
+
+(defun haskell-indentation-fundep ()
+  "Parse functional dependency."
+  (haskell-indentation-with-starter
+   (apply-partially #'haskell-indentation-separated
+                    #'haskell-indentation-fundep1 ",")))
+
+(defun haskell-indentation-fundep1 ()
+  "Parse an item in functional dependency declaration."
+  (let ((current-indent (current-column)))
+    (while (member current-token '(value "->"))
+      (haskell-indentation-read-next-token))
+    (when (and (eq current-token 'end-tokens)
+               (member following-token '(value "->")))
+      (haskell-indentation-add-indentation current-indent))))
+
+(defun haskell-indentation-toplevel ()
+  "Parse toplevel statements."
+  (haskell-indentation-layout
+   (lambda ()
+     (let ((parser (assoc current-token haskell-indentation-toplevel-list)))
+       (if parser
+           (funcall (cdr parser))
+         (haskell-indentation-declaration))))))
+
+(defun haskell-indentation-type ()
+  "Parse type declaration."
+  (let ((current-indent (current-column)))
+    (catch 'return
+      (while t
+        (cond
+         ((member current-token '(value operator "->" "=>"))
+          (haskell-indentation-read-next-token))
+
+         ((eq current-token 'end-tokens)
+          (when (member following-token
+                        '(value operator no-following-token
+                                "(" "[" "{" "::"))
+            (if (equal following-token "=>")
+                (haskell-indentation-add-indentation starter-indent)
+              (haskell-indentation-add-indentation current-indent))
+            (haskell-indentation-add-indentation left-indent))
+          (throw 'return nil))
+         (t (let ((parser (assoc current-token haskell-indentation-type-list)))
+              (if (not parser)
+                  (throw 'return nil)
+                (funcall (cdr parser))))))))))
+
+(defun haskell-indentation-type-1 ()
+  "Parse a single type declaration."
+  (let ((current-indent (current-column)))
+    (catch 'return
+      (cond
+       ((member current-token '(value operator "->" "=>"))
+        (haskell-indentation-read-next-token))
+
+       ((eq current-token 'end-tokens)
+        (when (member following-token
+                      '(value operator no-following-token
+                              "->" "=>" "(" "[" "{" "::"))
+          (haskell-indentation-add-indentation current-indent))
+        (throw 'return nil))
+       (t (let ((parser (assoc current-token haskell-indentation-type-list)))
+            (if (not parser)
+                (throw 'return nil)
+              (funcall (cdr parser)))))))))
+
+(defun haskell-indentation-scoped-type ()
+  "Parse scoped type declaration.
+
+For example
+   let x :: Int = 12
+   do x :: Int <- return 12"
+  (haskell-indentation-with-starter
+   (apply-partially #'haskell-indentation-separated #'haskell-indentation-type '("->" "=>")))
+  (when (member current-token '("<-" "="))
+    (haskell-indentation-statement-right #'haskell-indentation-expression)))
+
+(defun haskell-indentation-data ()
+  "Parse data or type declaration."
+  (haskell-indentation-read-next-token)
+  (when (string= current-token "instance")
+    (haskell-indentation-read-next-token))
+  (haskell-indentation-type)
+  (cond ((eq current-token 'end-tokens)
+         (when (member following-token '("=" "where"))
+           (haskell-indentation-add-indentation current-indent)
+           (throw 'parse-end nil)))
+        ((string= current-token "=")
+         (let ((starter-indent-inside (current-column)))
+           (haskell-indentation-with-starter
+            (lambda ()
+              (haskell-indentation-separated
+               #'haskell-indentation-expression "|")))
+           (cond
+            ((equal current-token 'end-tokens)
+             (when (string= following-token "deriving")
+               (haskell-indentation-push-indentation starter-indent-inside)
+               (haskell-indentation-add-left-indent)))
+            ((equal current-token "deriving")
+             (haskell-indentation-with-starter
+              #'haskell-indentation-type-1)))))
+        ((string= current-token "where")
+         (haskell-indentation-with-starter
+          #'haskell-indentation-expression-layout nil)
+         (cond
+          ((equal current-token 'end-tokens)
+           (when (string= following-token "deriving")
+             (haskell-indentation-add-left-indent)))
+          ((equal current-token "deriving")
+           (haskell-indentation-with-starter
+            #'haskell-indentation-type-1))))))
+
+(defun haskell-indentation-import ()
+  "Parse import declaration."
+  (haskell-indentation-with-starter #'haskell-indentation-expression))
+
+(defun haskell-indentation-foreign ()
+  "Parse foreign import declaration."
+  (haskell-indentation-with-starter (apply-partially #'haskell-indentation-expression '(value operator "import"))))
+
+(defun haskell-indentation-class-declaration ()
+  "Parse class declaration."
+  (haskell-indentation-with-starter
+   (lambda ()
+     (haskell-indentation-type)
+     (when (string= current-token "|")
+       (haskell-indentation-fundep))
+     (when (string= current-token "where")
+       (haskell-indentation-with-starter
+        #'haskell-indentation-declaration-layout nil)))))
+
+(defun haskell-indentation-deriving ()
+  "Parse standalone declaration."
+  (haskell-indentation-with-starter
+   (lambda ()
+     (when (string= "instance" current-token)
+       (haskell-indentation-read-next-token))
+     (when (equal current-token 'end-tokens)
+       (haskell-indentation-add-left-indent)
+       (throw 'parse-end nil))
+     (haskell-indentation-type)
+     (when (string= current-token "|")
+       (haskell-indentation-fundep)))))
+
+(defun haskell-indentation-module ()
+  "Parse module declaration."
+  (haskell-indentation-with-starter
+   (lambda ()
+     (haskell-indentation-read-next-token)
+     (when (equal current-token 'layout-item)
+       (haskell-indentation-read-next-token))
+     (when (string= current-token "(")
+       (haskell-indentation-list
+        #'haskell-indentation-module-export
+        ")" ","))
+     (if (string= current-token "where")
+         (haskell-indentation-read-next-token)
+
+       (when (eq current-token 'end-tokens)
+         (when (member following-token '(value no-following-token "("))
+           (haskell-indentation-add-indentation
+            (+ starter-indent haskell-indentation-starter-offset))
+           (haskell-indentation-add-indentation
+            (+ left-indent haskell-indentation-starter-offset))
+           (throw 'parse-end nil))
+         (haskell-indentation-add-layout-indent)
+         (throw 'parse-end nil))))))
+
+(defun haskell-indentation-toplevel-where ()
+  "Parse 'where' that we may hit as a standalone in module declaration."
+  (haskell-indentation-read-next-token)
+
+  (when (eq current-token 'end-tokens)
+    (haskell-indentation-add-layout-indent)
+    (throw 'parse-end nil)))
+
+(defun haskell-indentation-module-export ()
+  "Parse export list."
+  (cond ((string= current-token "module")
+         (let ((current-indent (current-column)))
+           (haskell-indentation-read-next-token)
+           (cond ((eq current-token 'end-tokens)
+                  (haskell-indentation-add-indentation current-indent))
+                 ((eq current-token 'value)
+                  (haskell-indentation-read-next-token)))))
+        (t (haskell-indentation-type))))
+
+(defun haskell-indentation-list (parser end sep &optional stmt-sep)
+  "Parse a list, pair or other expression containing multiple
+items parsed by PARSER, separated by SEP or STMT-SEP, and ending
+with END."
+  ;; note that we use macro expansion here to preserver Emacs 23
+  ;; compatibility and its lack of lexical binding
+  (haskell-indentation-with-starter
+   `(lambda ()
+      (let ((implicit-layout-active nil))
+        (haskell-indentation-separated
+         #',parser ,sep ,stmt-sep)))
+   end))
+
+(defun haskell-indentation-with-starter (parser &optional end where-expr?)
+  "Parse an expression starting with a keyword or parenthesis.
+Skip the keyword or parenthesis." ; FIXME: better description needed
+  (let ((starter-column (current-column))
+        (current-indent current-indent)
+        (left-indent
+         (if (= (current-column) (haskell-indentation-current-indentation))
+             (current-column)
+           left-indent)))
+    (haskell-indentation-read-next-token)
+    (when (eq current-token 'end-tokens)
+      (cond ((equal following-token end)
+             ;; indent before keyword or parenthesis
+             (haskell-indentation-add-indentation starter-column))
+            (where-expr?
+             ;; left indent + where post indent
+             (haskell-indentation-add-where-post-indent left-indent))
+            (t
+             (haskell-indentation-add-left-indent)))
+      (throw 'parse-end nil))
+    (let* ((current-indent (current-column))
+           (starter-indent (min starter-column current-indent))
+           (left-indent
+            (if end
+                (+ starter-indent haskell-indentation-starter-offset)
+              left-indent)))
+      (funcall parser)
+      (cond ((eq current-token 'end-tokens)
+             (when (equal following-token end)
+               ;; indent before keyword or parenthesis
+               (haskell-indentation-add-indentation starter-indent))
+             ;; add no more indentations if we expect a closing keyword
+             (when end
+               (throw 'parse-end nil)))
+            ((equal current-token end)
+             (haskell-indentation-read-next-token))))))
+
+(defun haskell-indentation-case-alternative ()
+  "" ; FIXME
+  (setq left-indent (current-column))
+  (haskell-indentation-separated #'haskell-indentation-expression "," nil)
+  (cond ((eq current-token 'end-tokens)
+         (haskell-indentation-add-indentation current-indent))
+        ((string= current-token "->")
+         (haskell-indentation-statement-right #'haskell-indentation-expression))
+        ;; otherwise fallthrough
+        ))
+
+(defun haskell-indentation-case ()
+  "" ; FIXME
+  (haskell-indentation-expression)
+  (cond ((eq current-token 'end-tokens)
+         (haskell-indentation-add-indentation current-indent))
+        ((string= current-token "|")
+         (haskell-indentation-with-starter
+          (apply-partially #'haskell-indentation-separated
+                           #'haskell-indentation-case-alternative "|" nil)
+          nil))
+        ((string= current-token "->")
+         (haskell-indentation-statement-right #'haskell-indentation-expression))
+        ;; otherwise fallthrough
+        ))
+
+(defun haskell-indentation-statement-right (parser)
+  "Process right side of a statement.
+Set `current-indent' to the current column and calls the given
+parser.  If parsing ends here, set indentation to left-indent."
+  (haskell-indentation-read-next-token)
+  (when (eq current-token 'end-tokens)
+    (haskell-indentation-add-left-indent)
+    (haskell-indentation-add-indentation current-indent)
+    (throw 'parse-end nil))
+  (funcall parser)
+  (when (equal current-token "where")
+    (haskell-indentation-with-starter
+     #'haskell-indentation-expression-layout nil)))
+
+(defun haskell-indentation-guard ()
+  "Parse \"guard\" statement."
+  (setq left-indent (current-column))
+  (haskell-indentation-separated
+   #'haskell-indentation-expression "," nil))
+
+(defun haskell-indentation-declaration ()
+  "Parse function or type declaration."
+  (haskell-indentation-separated #'haskell-indentation-expression "," nil)
+  (when (string= current-token "|")
+    (haskell-indentation-with-starter
+     (apply-partially #'haskell-indentation-separated
+                      #'haskell-indentation-guard "|" nil)
+     nil))
+  (when (eq current-token 'end-tokens)
+   (when (member following-token '("|" "=" "::" ","))
+     (haskell-indentation-add-indentation current-indent)
+     (throw 'parse-end nil))))
+
+(defun haskell-indentation-layout (parser)
+  "Parse layout list, where each layout item is parsed by parser."
+  (if (string= current-token "{")
+      (haskell-indentation-list parser "}" ";") ; explicit layout
+    (haskell-indentation-implicit-layout-list parser)))
+
+(defun haskell-indentation-expression-token-p (token)
+  "Return non-NIL value if TOKEN is an expression token."
+  (member token
+          '("if" "let" "do" "case" "\\" "(" "{" "[" "::"
+            value operator no-following-token)))
+
+(defun haskell-indentation-expression (&optional accepted-tokens)
+  "Parse an expression until an unknown token is encountered."
+  (catch 'return
+    (let ((current-indent (current-column)))
+      (unless accepted-tokens
+        (setq accepted-tokens '(value operator)))
+      (while t
+        (cond
+         ((memq current-token accepted-tokens)
+          (haskell-indentation-read-next-token))
+         ((eq current-token 'end-tokens)
+          (cond ((string= following-token "where")
+                 (haskell-indentation-add-where-pre-indent)) ; before a where
+                ((haskell-indentation-expression-token-p following-token)
+                 ;; a normal expression can be either continued or have
+                 ;; left indent
+                 (haskell-indentation-add-indentation
+                  current-indent)
+                 (haskell-indentation-add-indentation
+                  left-indent)))
+          (throw 'return nil))
+         (t (let ((parser (assoc current-token
+                                 haskell-indentation-expression-list)))
+              (when (null parser)
+                (throw 'return nil)) ; not expression token, so exit
+              (funcall (cdr parser)) ; run parser
+
+              ;; after an 'open' expression such as 'if', exit
+              (unless (member (car parser) '("(" "[" "{" "case"))
+                (throw 'return nil)))))))))
+
+(defun haskell-indentation-separated (parser separator &optional stmt-separator)
+  "Evaluate PARSER separated by SEPARATOR and STMT-SEPARATOR.
+If STMT-SEPARATOR is not NIL, it will be used to set a new starter-indent.
+
+For example:
+
+   [ i | i <- [1..10]
+    ,"
+  (catch 'return
+    (unless (listp separator)
+      (setq separator (list separator)))
+    (unless (listp stmt-separator)
+      (setq stmt-separator (list stmt-separator)))
+    (while t
+      (funcall parser)
+      (cond ((member current-token separator)
+             (haskell-indentation-at-separator))
+
+            ((member current-token stmt-separator)
+             (setq starter-indent (current-column))
+             (haskell-indentation-at-separator))
+
+            ((eq current-token 'end-tokens)
+             (when (or (member following-token separator)
+                       (member following-token stmt-separator))
+               ;; Set an indentation before a separator, for example:
+               ;;  [ 1   or   [ 1 | a
+               ;;  , 2            , 20
+               (haskell-indentation-add-indentation starter-indent)
+               (when (< left-indent starter-indent)
+                 (haskell-indentation-add-indentation left-indent))
+               (throw 'parse-end nil))
+             (when (equal following-token 'no-following-token)
+               ;; Set an indentation before a separator, for example:
+               ;;  [ 1   or   [ 1 | a
+               ;;  , 2            , 20
+               (haskell-indentation-add-indentation starter-indent)
+               (haskell-indentation-add-indentation left-indent))
+             (throw 'return nil))
+            (t (throw 'return nil))))))
+
+(defun haskell-indentation-at-separator ()
+  "At a separator.
+
+If at a new line, set starter-indent at the separator
+and current-indent after the separator, for example:
+
+l = [  1
+     , 2
+     ,    -- start now here."
+  (let ((separator-column
+         (and (= (current-column) (haskell-indentation-current-indentation))
+              (current-column))))
+    (haskell-indentation-read-next-token)
+    (cond ((eq current-token 'end-tokens)
+           (haskell-indentation-add-indentation current-indent)
+           (haskell-indentation-add-indentation left-indent)
+           (throw 'return nil))
+          (separator-column ; on the beginning of the line
+           (setq current-indent (current-column))
+           (setq starter-indent separator-column)
+           (setq left-indent
+            (+ starter-indent haskell-indentation-starter-offset))))))
+
+(defun haskell-indentation-implicit-layout-list (parser)
+  "An implicit layout list, elements are parsed with PARSER.
+This sets the `layout-indent' variable to the column where the
+layout starts."
+  (let* ((layout-indent (current-column))
+         (current-indent (current-column))
+         (left-indent (current-column))
+         (implicit-layout-active t))
+    (catch 'return
+      (while t
+        (let ((left-indent left-indent))
+          (funcall parser))
+        (cond ((member current-token '(layout-item ";"))
+               (haskell-indentation-read-next-token))
+              ((eq current-token 'end-tokens)
+               (when (or (and
+                          (not (member following-token '("{" operator)))
+                          (not (member previous-token '(operator)))
+                          (haskell-indentation-expression-token-p following-token))
+                         (string= following-token ";")
+                         (and (equal layout-indent 0)
+                              (member following-token (mapcar #'car haskell-indentation-toplevel-list))
+                              (not (string= following-token "where"))))
+                 (haskell-indentation-add-layout-indent))
+               (throw 'return nil))
+              (t (throw 'return nil))))))
+  ;; put `haskell-indentation-read-next-token' outside the current-indent
+  ;; definition so it will not return 'layout-end again
+  (when (eq current-token 'layout-end)
+    (let ((implicit-layout-active t))
+      ;; leave layout at 'layout-end or illegal token
+      (haskell-indentation-read-next-token))))
+
+(defun haskell-indentation-if ()
+  "" ; FIXME
+  (haskell-indentation-with-starter
+   (lambda ()
+     (if (string= current-token "|")
+         (haskell-indentation-with-starter
+          (lambda ()
+            (haskell-indentation-separated
+             #'haskell-indentation-case-alternative "|" nil))
+          nil)
+       (haskell-indentation-phrase-rest
+        '(haskell-indentation-expression
+          "then" haskell-indentation-expression
+          "else" haskell-indentation-expression))))
+   nil))
+
+(defun haskell-indentation-phrase (phrase)
+  "" ; FIXME
+  (haskell-indentation-with-starter
+   (apply-partially #'haskell-indentation-phrase-rest phrase)
+   nil))
+
+(defun haskell-indentation-phrase-rest (phrase1)
+  "" ; FIXME
+  (while phrase1
+    (let ((phrase phrase1))
+      (setq phrase1 nil)
+      (let ((current-indent (current-column))
+            (left-indent left-indent)
+            (layout-indent layout-indent))
+        (funcall (car phrase)))
+      (cond
+       ((eq current-token 'end-tokens)
+        (cond ((null (cdr phrase))) ;; fallthrough
+              ((equal following-token (cadr phrase))
+               (haskell-indentation-add-indentation starter-indent)
+               (unless (member following-token '("," ";"))
+                 ;; we want to keep comma and semicolon aligned always
+                 (haskell-indentation-add-indentation left-indent))
+               (throw 'parse-end nil))
+              ((string= (cadr phrase) "in")
+               (when (= left-indent layout-indent)
+                 (haskell-indentation-add-layout-indent)
+                 (throw 'parse-end nil)))
+              (t (throw 'parse-end nil))))
+       ((null (cdr phrase)))
+       ((equal (cadr phrase) current-token)
+        (haskell-indentation-read-next-token)
+        (when (eq current-token 'end-tokens)
+          (haskell-indentation-add-indentation
+           (+ starter-indent haskell-indentation-starter-offset))
+          (haskell-indentation-add-indentation
+           (+ left-indent haskell-indentation-starter-offset))
+          (throw 'parse-end nil))
+        (setq phrase1 (cddr phrase)))
+       ((string= (cadr phrase) "in"))))))
+
+(defun haskell-indentation-add-indentation (indent)
+  "" ; FIXME
+  (haskell-indentation-push-indentation
+   (if (<= indent layout-indent)
+       (+ layout-indent haskell-indentation-layout-offset)
+     indent)))
+
+(defun haskell-indentation-add-layout-indent ()
+  "" ; FIXME
+  (haskell-indentation-push-indentation layout-indent))
+
+(defun haskell-indentation-add-where-pre-indent ()
+  "" ; FIXME
+  (haskell-indentation-push-indentation
+   (+ layout-indent haskell-indentation-where-pre-offset))
+  (if (= layout-indent haskell-indentation-layout-offset)
+      (haskell-indentation-push-indentation
+       haskell-indentation-where-pre-offset)))
+
+(defun haskell-indentation-add-where-post-indent (indent)
+  "" ; FIXME
+  (haskell-indentation-push-indentation
+   (+ indent haskell-indentation-where-post-offset)))
+
+(defun haskell-indentation-add-left-indent ()
+  "" ; FIXME
+  (haskell-indentation-add-indentation
+   (+ left-indent haskell-indentation-left-offset)))
+
+(defun haskell-indentation-push-indentation (indent)
+  "Add INDENT to list of possible indentations.
+
+Add INDENT to `possible-indentations' if it is not there
+yet. Keep the list in ascending order."
+  (unless (member indent possible-indentations)
+    (setq possible-indentations
+          (sort (cons indent possible-indentations) #'<))))
+
+(defun haskell-indentation-read-next-token ()
+  "Go to the next token and set current-token to the next token.
+
+The following symbols are used as pseudo tokens:
+
+'layout-item: A new item in a layout list.  The next token
+              will be the first token from the item.
+
+'layout-end:  the end of a layout list.  Next token will be
+              the first token after the layout list.
+
+'end-tokens:  back at point where we started, following-token
+              will be set to the next token.
+
+Pseudo tokens are used only when implicit-layout-active is
+t. That is the case only after keywords \"do\", \"where\",
+\"let\" and \"of\".
+
+If we are at a new line, parse-line is increased, and
+current-indent and left-indent are set to the indentation of the
+line."
+  (cond ((and implicit-layout-active
+              (eq current-token 'end-tokens))
+         'end-tokens)
+        ((and implicit-layout-active
+              (eq current-token 'layout-end))
+         (cond ((> layout-indent (current-column))
+                'layout-end)
+               ((= layout-indent (current-column))
+                (setq current-token 'layout-item))
+               ((< layout-indent (current-column))
+                (setq current-token (haskell-indentation-peek-token)))))
+        ((and implicit-layout-active
+              (eq current-token 'layout-item))
+         (setq current-token (haskell-indentation-peek-token)))
+        ((and implicit-layout-active
+              (> layout-indent (current-column)))
+         (setq current-token 'layout-end))
+        (t
+         (setq previous-token (haskell-indentation-peek-token))
+         (haskell-indentation-skip-token)
+         (if (>= (point) indentation-point)
+             (progn
+               (setq following-token
+                     (if (and (not (eobp))
+                              (= (point) indentation-point))
+                         (haskell-indentation-peek-token)
+                       'no-following-token))
+               (setq current-token 'end-tokens))
+           (when (= (current-column) (haskell-indentation-current-indentation))
+             ;; on a new line
+             (setq current-indent (current-column)))
+           (cond ((and implicit-layout-active
+                       (> layout-indent (current-column)))
+                  (setq current-token 'layout-end))
+                 ((and implicit-layout-active
+                       (= layout-indent (current-column)))
+                  (setq current-token 'layout-item))
+                 (t (setq current-token (haskell-indentation-peek-token))))))))
+
+(defun haskell-indentation-peek-token ()
+  "Return token starting at point."
+  (cond ((looking-at "\\(if\\|then\\|else\\|let\\|in\\|mdo\\|rec\\|do\\|proc\\|case\\|of\\|where\\|module\\|signature\\|deriving\\|import\\|data\\|type\\|newtype\\|class\\|instance\\)\\([^[:alnum:]'_]\\|$\\)")
+         (match-string-no-properties 1))
+        ((looking-at "[][(){}[,;]")
+         (match-string-no-properties 0))
+        ((looking-at "\\(\\\\\\|->\\|<-\\|::\\|=\\||\\|=>\\)\\([^-:!#$%&*+./<=>?@\\\\^|~]\\|$\\)")
+         (match-string-no-properties 1))
+        ((looking-at "\\(→\\|←\\|∷\\|⇒\\)\\([^-:!#$%&*+./<=>?@\\\\^|~]\\|$\\)")
+         (let ((tok (match-string-no-properties 1)))
+           (or (cdr (assoc tok haskell-indentation-unicode-tokens)) tok)))
+        ((looking-at"[-:!#$%&*+./<=>?@\\\\^|~`]" )
+         'operator)
+        (t 'value)))
+
+(defun haskell-indentation-skip-token ()
+  "Skip to the next token."
+  (if (haskell-lexeme-looking-at-token)
+      (goto-char (match-end 0))
+    ;; otherwise skip until space found
+    (skip-syntax-forward "^-"))
+  ;; we have to skip unterminated string fence at the end of line
+  (skip-chars-forward "\n")
+  (forward-comment (buffer-size))
+  (while (and (haskell-indentation-bird-p)
+              (bolp)
+              (eq (char-after) ?>))
+    (forward-char)
+    (forward-comment (buffer-size))))
+
+(provide 'haskell-indentation)
+
+;; Local Variables:
+;; tab-width: 8
+;; End:
+
+;;; haskell-indentation.el ends here