From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.io!.POSTED.blaine.gmane.org!not-for-mail From: pranshu sharma Newsgroups: gmane.emacs.devel Subject: Re: Upstream haskell-ts-mode? Date: Tue, 17 Sep 2024 12:15:02 +1000 Message-ID: <8734lz9gbd.fsf@gmail.com> References: <874j6gxa3p.fsf@gmail.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" Injection-Info: ciao.gmane.io; posting-host="blaine.gmane.org:116.202.254.214"; logging-data="36210"; mail-complaints-to="usenet@ciao.gmane.io" User-Agent: Gnus/5.13 (Gnus v5.13) Cc: emacs-devel@gnu.org To: Andrea Corallo Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane-mx.org@gnu.org Tue Sep 17 04:22:11 2024 Return-path: Envelope-to: ged-emacs-devel@m.gmane-mx.org Original-Received: from lists.gnu.org ([209.51.188.17]) by ciao.gmane.io with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1sqNr1-0009FX-9J for ged-emacs-devel@m.gmane-mx.org; Tue, 17 Sep 2024 04:22:11 +0200 Original-Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1sqNqL-0000gj-4s; Mon, 16 Sep 2024 22:21:29 -0400 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1sqNkG-0000Ef-H2 for emacs-devel@gnu.org; Mon, 16 Sep 2024 22:15:12 -0400 Original-Received: from mail-pf1-x435.google.com ([2607:f8b0:4864:20::435]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1sqNkD-0007Ir-SH; Mon, 16 Sep 2024 22:15:12 -0400 Original-Received: by mail-pf1-x435.google.com with SMTP id d2e1a72fcca58-7191df6b5f5so3573657b3a.0; Mon, 16 Sep 2024 19:15:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1726539307; x=1727144107; darn=gnu.org; h=mime-version:user-agent:message-id:date:references:in-reply-to :subject:cc:to:from:from:to:cc:subject:date:message-id:reply-to; bh=Nq9KGPYzLOh7S8XBUUCx92Pkb1iDOKu2+pdSnlOsDWQ=; b=mPrfVshhqzq4qVuexzG5SDNRtcmG6iA6uQ3qXlg4u5yzdmV/cCMDZsDB0jBLjNqVf/ nTu4MJEkRjhDant2Sey2vQXZUY40fhys3TyK1Ijk54rEA388+wqjbTdHaDRyAXwHg4bg gI7zcIDRgANsMziVgE04ZT9kMXerTP3LjzI12GXhglZpBRO56pbPnfv7TFiEZqsQs7uY Rix0B9GDTFY0/KBCS/RpaPvHTmq78IBn58zhAkD9+D/iYawJW6J2L270KhHOL9R7SXkq Ry/oGqCj8sm7GN3oIERWAZZncSw+tQajtIGi4SgMQjIcrwgQ3H9elnaYgBXEeCzHhSjO 9GFw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1726539307; x=1727144107; h=mime-version:user-agent:message-id:date:references:in-reply-to :subject:cc:to:from:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=Nq9KGPYzLOh7S8XBUUCx92Pkb1iDOKu2+pdSnlOsDWQ=; b=f7vi3dKYbYGiVINXuw+ri6q0EM/3cAEcakifAs9TALhPoE6lM88Nx5BxOibnshiy0W Wg6ggAOO7cfe8vz31qQUc0HZcDtSPXLXNN/9xjcy/XFIXd1liSB3I3CMWQV1P4zRGyZx zgC4Q7A0TwNmrF6oncEaKpszuHSYJEz1g/sUVjXvYXizYC6dqFb3l8jldgNyqEHraZJe g+Lw81SNu8dL7EunYPrHMtDPbEmkQ6BV+giUDttv/7VKmyT8Y8H+ZqVjACReXGaFJblr Kyp0Vcv4khE1OPzetbA1yn10fi4LYBteMZVcuE/+SrxZqhKN5hu9ZviRTx4Made8A4WX JVOA== X-Gm-Message-State: AOJu0YyjcwmJa6+27mTnQ/KpqYdwz973LkryaIoY4GXhuu0kCcH/qFiB cqtbdCwt6gbRACT0d8iUM9rb20A2e301rVDy3chuzCO/jGPNaF7HSLJWYA== X-Google-Smtp-Source: AGHT+IEFHRU77FAMKODm3VQWuLDAFGdGjqNr0xzUaBi67LzWooc8b+ka9/ipc14RdwVpmbPdglx3uw== X-Received: by 2002:a05:6a20:d8b:b0:1cf:666c:4f79 with SMTP id adf61e73a8af0-1cf75eaeab1mr25197294637.19.1726539306913; Mon, 16 Sep 2024 19:15:06 -0700 (PDT) Original-Received: from pebl ([2001:8003:7816:8300:34aa:b499:a257:a16c]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-71944ac99fesm4353587b3a.86.2024.09.16.19.15.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Sep 2024 19:15:06 -0700 (PDT) In-Reply-To: (Andrea Corallo's message of "Mon, 16 Sep 2024 13:32:28 -0400") Received-SPF: pass client-ip=2607:f8b0:4864:20::435; envelope-from=pranshusharma366@gmail.com; helo=mail-pf1-x435.google.com X-Spam_score_int: -17 X-Spam_score: -1.8 X-Spam_bar: - X-Spam_report: (-1.8 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-Mailman-Approved-At: Mon, 16 Sep 2024 22:21:26 -0400 X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane-mx.org@gnu.org Original-Sender: emacs-devel-bounces+ged-emacs-devel=m.gmane-mx.org@gnu.org Xref: news.gmane.io gmane.emacs.devel:323676 Archived-At: --=-=-= Content-Type: text/plain Hello Andrea, I am willing to do the FSF copyright paperwork. Code: --=-=-= Content-Type: text/x-diff; charset=utf-8 Content-Disposition: inline; filename=haskell-ts-mode.patch Content-Transfer-Encoding: quoted-printable diff --git a/lisp/progmodes/haskell-ts-mode.el b/lisp/progmodes/haskell-ts-= mode.el new file mode 100644 index 00000000000..fae70f2a571 --- /dev/null +++ b/lisp/progmodes/haskell-ts-mode.el @@ -0,0 +1,461 @@ +;;; haskell-ts-mode.el --- A treesit based major mode for haskell -*- lexi= cal-binding:t -*- + +;; Copyright (C) 2024 Pranshu Sharma + + +;; Author: Pranshu Sharma +;; URL: https://codeberg.org/pranshu/haskell-ts-mode +;; Package-Requires: ((emacs "29.3")) +;; Version: 1 +;; Keywords: languages, haskell + +;; This program 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 of the License, or +;; (at your option) any later version. + +;; This program 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 . + +;;; Commentary: + +;; This is a major mode that uses treesitter to provide all the basic +;; major mode stuff, like indentation, font lock, etc... + +;;; Code: + +(require 'comint) +(require 'treesit) + +(declare-function treesit-parser-create "treesit.c") +(declare-function treesit-node-start "treesit.c") +(declare-function treesit-node-parent "treesit.c") +(declare-function treesit-node-prev-sibling "treesit.c") +(declare-function treesit-node-next-sibling "treesit.c") +(declare-function treesit-node-end "treesit.c") +(declare-function treesit-node-child "treesit.c") +(declare-function treesit-node-type "treesit.c") + +(defgroup haskell-ts-mode nil + "Group that contains haskell-ts-mode variables" + :group 'langs) + +(defcustom haskell-ts-highlight-signature t + "Set to non-nil to enable highlighting of signature names." + :type 'boolean + :group 'haskell-ts-mode) + +(defvar haskell-ts-font-lock-feature-list + `(,(funcall + (if haskell-ts-highlight-signature + (lambda (ls) (append ls '(type-sig))) + 'identity) + '(comment str pragma parens)) + (type definition function args) + (match keyword) + (otherwise signature))) + +(defcustom haskell-ts-use-indent t + "Set to non-nil to use the indentation provided by haskell-ts-mode" + :group 'haskell-ts-mode + :type 'boolean) + +(defcustom haskell-ts-font-lock-level 4 + "Level of font lock, 1 for minimum highlghting and 4 for maximum." + :group 'haskell-ts-mode + :type 'integer) + +(defvar haskell-ts-prettify-symbols-alist + '(("\\" . "=CE=BB") + ("/=3D" . "=E2=89=A0") + ("->" . "=E2=86=92") + ("=3D>" . "=E2=87=92") + ("<-" . "=E2=86=90") + ("<=3D" . "=E2=89=A5") + (">=3D" . "=E2=89=A4"))) + +(defvar haskell-ts-font-lock + (treesit-font-lock-rules + :language 'haskell + :feature 'keyword + `(["module" "import" "data" "let" "where" "case" "type" + "if" "then" "else" "of" "do" "in" "instance" "class"] + @font-lock-keyword-face) + :language 'haskell + :feature 'otherwise + :override t + `(((match (guards guard: (boolean (variable) @font-lock-keyword-face))) + (:match "otherwise" @font-lock-keyword-face))) + :language 'haskell + :feature 'type-sig + "(signature (binding_list (variable) @font-lock-doc-markup-face)) + (signature (variable) @font-lock-doc-markup-face)" + :language 'haskell + :feature 'args + :override 'keep + (concat + "(function (infix left_operand: (_) @haskell-ts--fontify-arg))" + "(function (infix right_operand: (_) @haskell-ts--fontify-arg))" + "(generator . (_) @haskell-ts--fontify-arg)" + "(bind (as (variable) . (_) @haskell-ts--fontify-arg))" + "(patterns) @haskell-ts--fontify-arg") + :language 'haskell + :feature 'type + `((type) @font-lock-type-face + (constructor) @font-lock-type-face) + :language 'haskell + :override t + :feature 'signature + `((signature (function) @haskell-ts--fontify-type) + (context (function) @haskell-ts--fontify-type)) + :language 'haskell + :feature 'match + `((match ("|" @font-lock-doc-face) ("=3D" @font-lock-doc-face)) + (list_comprehension ("|" @font-lock-doc-face + (qualifiers (generator "<-" @font-lock-doc-face)))) + (match ("->" @font-lock-doc-face))) + :language 'haskell + :feature 'comment + `(((comment) @font-lock-comment-face) + ((haddock) @font-lock-doc-face)) + :language 'haskell + :feature 'pragma + `((pragma) @font-lock-preprocessor-face + (cpp) @font-lock-preprocessor-face) + :language 'haskell + :feature 'str + :override t + `((char) @font-lock-string-face + (string) @font-lock-string-face + (quasiquote (quoter) @font-lock-type-face) + (quasiquote (quasiquote_body) @font-lock-preprocessor-face)) + :language 'haskell + :feature 'parens + :override t + `(["(" ")" "[" "]"] @font-lock-operator-face + (infix operator: (_) @font-lock-operator-face)) + :language 'haskell + :feature 'function + :override t + `((function name: (variable) @font-lock-function-name-face) + (function (infix (operator) @font-lock-function-name-face)) + (declarations (type_synomym (name) @font-lock-function-name-face)) + (bind (variable) @font-lock-function-name-face) + (function (infix (infix_id (variable) @font-lock-function-name-face))) + (bind (as (variable) @font-lock-function-name-face)))) + "A function that returns the treesit font lock lock settings for haskell= .") + +(defun haskell-ts--stand-alone-parent (_ parent bol) + (save-excursion + (goto-char (treesit-node-start parent)) + (let ((type (treesit-node-type parent))) + (if (and (looking-back "^[ \t]*" (line-beginning-position)) + (not (seq-some + (lambda (kw)=20 + (string=3D type kw)) + '("when" "where" "do" "let")))) + (treesit-node-start parent) + (haskell-ts--stand-alone-parent 1 (funcall + (if bol 'treesit-node-parent 'identity) + (treesit-node-parent parent)) + nil))))) + +(defvar haskell-ts--ignore-types + '("comment" "cpp" "haddock") + "Node types that will be ignored by indentation.") + +(defvar haskell-ts-indent-rules + (let* ((p-sib + (lambda (node arg) + (let* ((func (if arg + 'treesit-node-prev-sibling + 'treesit-node-next-sibling)) + (n (funcall func node))) + (while (and n (string-match (regexp-opt haskell-ts--ignore-types) + (treesit-node-type n))) + (setq n (funcall func n))) + n))) + (p-prev-sib + (lambda (node _ _) (treesit-node-start (funcall p-sib node t)))) + (p-n-prev (lambda (node) (funcall p-sib node t))) + (parent-first-child (lambda (_ parent _) + (treesit-node-start (treesit-node-child parent 0))))) + `((haskell + ((node-is "cpp") column-0 0) + ((parent-is "comment") column-0 0) + ((parent-is "haddock") column-0 0) + ((parent-is "imports") column-0 0) + ;; Infix + ((parent-is "infix") ,parent-first-child 0) + ((node-is "infix") standalone-parent 1) + ;; Lambda + ((parent-is "lambda") standalone-parent 2) + + ((parent-is "class_declarations") prev-sibling 0) +=20=20=20=20=20=20=20 + ;; in + ((node-is "^in$") parent 0) +=20=20=20=20=20=20=20 + ;; list + ((node-is "]") parent 0) + ((parent-is "list") standalone-parent 2) +=20=20=20=20=20=20=20 + ;; If then else + ((node-is "then") parent 2) + ((node-is "^else$") parent 2) + + ((parent-is "apply") haskell-ts--stand-alone-parent 1) +=20=20=20=20=20=20=20 + ((node-is "quasiquote") grand-parent 2) + ((parent-is "quasiquote_body") (lambda (_ _ c) c) 0) + ((lambda (node parent bol) + (when-let ((n (treesit-node-prev-sibling node))) + (while (string=3D "comment" (treesit-node-type n)) + (setq n (treesit-node-prev-sibling n))) + (string=3D "do" (treesit-node-type n)))) + haskell-ts--stand-alone-parent + 3) + ((parent-is "do") ,p-prev-sib 0) + + ((parent-is "alternatives") ,p-prev-sib 0) + + ;; prev-adaptive-prefix is broken sometimes + (no-node + (lambda (_ _ _) + (save-excursion + (goto-char (line-beginning-position 0)) + (back-to-indentation) + (point))) + 0) +=20=20=20=20=20=20=20 + ((parent-is "data_constructors") parent 0) + + ;; where + ((lambda (node _ _) + (let ((n (treesit-node-prev-sibling node))) + (while (string=3D "comment" (treesit-node-type n)) + (setq n (treesit-node-prev-sibling n))) + (string=3D "where" (treesit-node-type n)))) +=09 + (lambda (_ b _) + (+ 1 (treesit-node-start (treesit-node-prev-sibling b)))) + 3) + ((parent-is "local_binds\\|instance_declarations") ,p-prev-sib 0) + ((node-is "^where$") parent 2) +=09 + ;; Match + ((lambda (node _ _) + (and (string=3D "match" (treesit-node-type node)) + (string=3D "variable" (treesit-node-type (funcall ,p-n-prev node))= ) )) + ,parent-first-child 1) + ((node-is "match") ,p-prev-sib 0) + ((parent-is "match") standalone-parent 2) + ((parent-is "haskell") column-0 0) + ((parent-is "declarations") column-0 0) + + ((parent-is "record") standalone-parent 2) + + ((parent-is "exports") + (lambda (_ b _) (treesit-node-start (treesit-node-prev-sibling b))) + 0) + ((n-p-gp nil "signature" "foreign_import") grand-parent 3) + ((parent-is "case") standalone-parent 4) + ((node-is "alternatives") + (lambda (_ b _) + (treesit-node-start (treesit-node-child b 0))) + 2) + ((node-is "comment") + ;; Indenting comments by priorites: + ;; 1. next relevent sibling if exists + ;; 2. previous relevent sibling if exists + ;; 3. parent + ;; (relevent means type not it haskell-ts--ignore-types) + (lambda (node parent _) + (if-let ((next-sib (funcall ,p-sib node nil))) + (treesit-node-start next-sib) + (if-let ((prev-sib (funcall ,p-prev-sib node nil nil))) + prev-sib + (treesit-node-start parent)))) + 0) + ;; Backup + (catch-all parent 2))))) + +;; Copied from haskell-tng-mode, changed a bit +(defvar haskell-ts-mode-syntax-table + (let ((table (make-syntax-table))) + (map-char-table + (lambda (k v) + ;; reset the (surprisingly numerous) defaults + (let ((class (syntax-class v))) + (when (seq-contains-p '(1 4 5 6 9) class) + (modify-syntax-entry k "_" table)))) + (char-table-parent table)) + ;; whitechar + (mapc + (lambda (it) (modify-syntax-entry it " " table)) + (string-to-list "\r\n\f\v \t")) + ;; ascSymbol + (mapc + (lambda (it) (modify-syntax-entry it "_" table)) + (string-to-list "!#$%&*+./<=3D>?\\^|-~:")) + (modify-syntax-entry ?_ "_" table) + ;; some special (treated like punctuation) + (mapc + (lambda (it) (modify-syntax-entry it "." table)) + (string-to-list ",;@")) + ;; apostrophe as a word, not delimiter + (modify-syntax-entry ?\' "w" table) + ;; string delimiter + (modify-syntax-entry ?\" "\"" table) + ;; parens and pairs (infix functions) + (modify-syntax-entry ?\( "()" table) + (modify-syntax-entry ?\) ")(" table) + (modify-syntax-entry ?\[ "(]" table) + (modify-syntax-entry ?\] ")[" table) + (modify-syntax-entry ?\` "$`" table) + + ;; comments (subsuming pragmas) + (modify-syntax-entry ?\{ "(}1nb" table) + (modify-syntax-entry ?\} "){4nb" table) + (modify-syntax-entry ?- "_ 123" table) + (mapc + (lambda (it) (modify-syntax-entry it ">" table)) + (string-to-list "\r\n\f\v")) + table)) + +(defmacro haskell-ts-imenu-name-function (check-func) + `(lambda (node) + (let ((nn (treesit-node-child node 0 node))) + (if (funcall ,check-func node) + (if (string=3D (treesit-node-type nn) "infix") + (treesit-node-text (treesit-node-child nn 1)) + (haskell-ts-defun-name node)) + nil)))) + +(defun haskell-ts-indent-defun (pos) + "Indent the current function." + (interactive "d") + (let ((node (treesit-node-at pos))) + (while (not (string-match + "^declarations$\\|haskell" + (treesit-node-type (treesit-node-parent node)))) + (setq node (treesit-node-parent node))) + (indent-region (treesit-node-start node) (treesit-node-end node)))) + +(defvar haskell-ts-mode-map + (let ((km (make-sparse-keymap))) + (define-key km (kbd "C-c C-c") 'haskell-ts-compile-region-and-go) + (define-key km (kbd "C-c C-r") 'haskell-ts-run-haskell) + (define-key km (kbd "C-M-q") 'haskell-ts-indent-defun) ; For those who= don't have emacs 30 + km) + "Map for haskell-ts-mode.") + +;;;###autoload +(define-derived-mode haskell-ts-mode prog-mode "haskell ts mode" + "Major mode for Haskell files using tree-sitter." + (unless (treesit-ready-p 'haskell) + (error "Tree-sitter for Haskell is not available")) + (treesit-parser-create 'haskell) + (setq-local treesit-defun-type-regexp "\\(?:\\(?:function\\|struct\\)_de= finition\\)") + ;; Indent + (when haskell-ts-use-indent + (setq-local treesit-simple-indent-rules haskell-ts-indent-rules) + (setq-local indent-tabs-mode nil)) + ;; Comment + (setq-local comment-start "-- ") + (setq-local comment-use-syntax t) + (setq-local comment-start-skip "\\(?: \\|^\\)-+") + ;; Elecric + (setq-local electric-pair-pairs + '((?` . ?`) (?\( . ?\)) (?{ . ?}) (?\" . ?\") (?\[ . ?\]))) + ;; Nav + (setq-local treesit-defun-name-function 'haskell-ts-defun-name) + (setq-local treesit-defun-type-regexp + ;; Since haskell is strict functional, any 2nd level + ;; entity is defintion + (cons ".+" + (lambda (node) + (string=3D "declarations" (treesit-node-type (treesit-node-parent = node)))))) + (setq-local prettify-symbols-alist haskell-ts-prettify-symbols-alist) + ;; Imenu + (setq-local treesit-simple-imenu-settings + `((nil haskell-ts-imenu-func-node-p nil + ,(haskell-ts-imenu-name-function #'haskell-ts-imenu-func-node-p)) + ("Signatures.." haskell-ts-imenu-sig-node-p nil + ,(haskell-ts-imenu-name-function #'haskell-ts-imenu-sig-node-p)) + ("Data..." haskell-ts-imenu-data-type-p nil + (lambda (node) + (treesit-node-text (treesit-node-child node 1)))))) + ;; font-lock + (setq-local treesit-font-lock-level haskell-ts-font-lock-level) + (setq-local treesit-font-lock-settings haskell-ts-font-lock) + (setq-local treesit-font-lock-feature-list + haskell-ts-font-lock-feature-list) + (treesit-major-mode-setup)) + +(defun haskell-ts--fontify-arg (node &optional _ _ _) + (if (string=3D "variable" (treesit-node-type node)) + (put-text-property + (treesit-node-start node) + (treesit-node-end node) + 'face font-lock-variable-name-face) + (mapc 'haskell-ts--fontify-arg (treesit-node-children node)))) + +(defun haskell-ts--fontify-type (node &optional _ _ _) + (let ((last-child (treesit-node-child node -1))) + (if (string=3D (treesit-node-type last-child) "function") + (haskell-ts--fontify-type last-child) + (put-text-property + (treesit-node-start last-child) + (treesit-node-end last-child) + 'face font-lock-variable-name-face)))) + +(defun haskell-ts-imenu-node-p (regex node) + (and (string-match-p regex (treesit-node-type node)) + (string=3D (treesit-node-type (treesit-node-parent node)) "declarat= ions"))) + +(defun haskell-ts-imenu-func-node-p (node) + (haskell-ts-imenu-node-p "function\\|bind" node)) + +(defun haskell-ts-imenu-sig-node-p (node) + (haskell-ts-imenu-node-p "signature" node)) + +(defun haskell-ts-imenu-data-type-p (node) + (haskell-ts-imenu-node-p "data_type" node)) + +(defun haskell-ts-defun-name (node) + (treesit-node-text (treesit-node-child node 0))) + +(defun haskell-ts-compile-region-and-go (start end) + "Compile the text from START to END in the haskell proc." + (interactive "r") + (let ((hs (haskell-ts-haskell-session))) + (comint-send-region hs start end) + (comint-send-string hs "\n"))) + +(defun haskell-ts-run-haskell() + (interactive) + (pop-to-buffer-same-window + (if (comint-check-proc "*haskell*") + "*haskell*" + (make-comint "haskell" "ghci" nil buffer-file-name)))) + +(defun haskell-ts-haskell-session () + (get-buffer-process "*haskell*")) + +(defvar eglot-server-programs) + +(defun haskell-ts-setup-eglot() + (add-to-list 'eglot-server-programs + '(haskell-ts-mode . ("haskell-language-server-wrapper" "--lsp")))) + +(when (treesit-ready-p 'haskell) + (add-to-list 'auto-mode-alist '("\\.hs\\'" . haskell-ts-mode))) + +(provide 'haskell-ts-mode) + +;;; haskell-ts-mode.el ends here --=-=-=--