emacs-orgmode@gnu.org archives
 help / color / mirror / code / Atom feed
From: Bruno Barbier <brubar.cs@gmail.com>
To: Ihor Radchenko <yantar92@posteo.net>
Cc: emacs-orgmode@gnu.org
Subject: Re: [PATCH] Add tests for ob-haskell (GHCi)
Date: Thu, 07 Sep 2023 16:21:44 +0200	[thread overview]
Message-ID: <64f9dc79.050a0220.194d1.9020@mx.google.com> (raw)
In-Reply-To: <87a5xi5k47.fsf@localhost>

[-- Attachment #1: Type: text/plain, Size: 4826 bytes --]


Hi Ihor,

Sorry for the delay, thanks again for the ping.



Ihor Radchenko <yantar92@posteo.net> writes:

> Bruno Barbier <brubar.cs@gmail.com> writes:
>
>>>> +              (when (bufferp "*haskell*") (error "Conflicting buffer '*haskell*', rename it or kill it."))
>>>> +              (with-current-buffer session (rename-buffer "*haskell*")))
>>>
>>> So, you are now renaming the unique session buffer back to "*haskell*".
>>> And never rename it back to expected :session <value>. Users might be confused.
>>
>> I do rename it back once inf-haskell has initialized the buffer (after
>> run-haskell in the last version).
>
> A comment would help to clarify things for the readers.

Right. I've improved the comment. Thanks.


>>>> +            (save-window-excursion
>>>> +              ;; We don't use `run-haskell' to not popup the buffer.
>>>> +              ;; And we protect default-directory.
>>>> +              (let ((default-directory default-directory))
>>>> +                (inferior-haskell-start-process))
>>>




>> About 'default-directory', I'm not sure. Maybe the side effect is done
>> on purpose in inf-haskell.
>
> I can see the haskell-mode overrides default-directory with
> `inferior-haskell-root-dir', running ghci in that directory, if it is
> non-nil. Even with your let binding, it is calling for trouble when
> source block uses :dir header argument.
>
> Maybe we can bind `inferior-haskell-root-dir' to `default-directory'
> instead? `default-directory' is modified according to :dir by ob-core.el
> when necessary.

You may be right that we should use `inferior-haskell-root-dir' to
tell haskell-mode where to run the interpreter.  Done.



>> The function 'putStr' output the string without a newline on stdout
>> (as opposed to the function putStrLn that does add a newline).
>>
>> So, in GHCi, entering:
>>
>>     putStr("4")
>>     
>> outputs "4" on stdout, then GHCi outputs the prompt, so we get:
>>
>>     4ghci> 
>>
>> In the end, 'org-babel-comint-with-output' gets this
>>     1ghci> 2ghci> 3ghci> 
>>     ghci> org-babel-haskell-eoe
>>     ghci> ghci>
>>     
>> and filters out everything as being GHCi prompts and the EOE.
>>
>> I'm not really expecting this to be fixed; I just wanted to record the
>> fact.
>
> We actually might be able to deal with this if we change the prompt and
> update comint-prompt-regexp to something more accurate.

I couldn't make it work by simply restricting the prompt.  I think
it's OK if character by character output doesn't work; ghci is about
line based interaction afterall.



>>>> Subject: [PATCH 11/13] lisp/ob-haskell.el: Fix how to use sessions
>>>>
>>>> +  (org-babel-haskell-with-session
>>>
>>> This kind of names are usually dedicated to macro calls. But
>>> `org-babel-haskell-with-session' is instead a function. I think a macro
>>> will be better. And you will be able to get rid of unnecessary lambda.
>>
>> That looks kind of complicated just to avoid one lambda in one call.
>> But, as I couldn't find a better name, I've translated it into a
>> macro.
>
> I think you misunderstood what I meant.
> See the attached diff on top of your patches that simplifies things a
> bit.
> diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el
...
>  (defmacro org-babel-haskell-with-session (session-symbol params &rest body)
>    "Get the session identified by PARAMS and run BODY with it.
.. 
> +  `(let* ((params ,params)
> +          (sn (cdr (assq :session params)))
> +          (session (org-babel-haskell-initiate-session sn params))
> +          (,session-symbol session)
> +          (one-shot (equal sn "none")))
> +     (unwind-protect
> +         (progn ,@body)

I don't think it's correct to create local variables like this in a
macro: we need to use uninterned symbols, else we may capture caller
variables (params, sn, session and one-shot).

I personnaly find it easier when I keep my macros as short as
possible, and, to do any non-trivial work in a function: easier to
read, to modify and to debug.




>>>> -    (let ((buffer (org-babel-haskell-initiate-session session)))
>>>> +    (let ((buffer (org-babel-haskell-initiate-session session params)))
>>>
>>> PARAMS argument is ignored by `org-babel-haskell-initiate-session'. I am
>>> not sure why you are trying to pass it here.
>>
>> We have the PARAMS, and, org-babel-haskell-initiate-session has a
>> PARAMS arguments. So, at the API level, I think it's better to
>> propagate it than to ignore it.  But you're right that, today, the
>> current implementation ignores it.
>>
>> I'm fine with dropping that change if you so prefer.
>
> I am mostly neutral here. Slightly in favour of keeping things unchanged.

I've removed my change. The function `org-babel-load-session:haskell`
now ignores the parameter PARAMS, as before.


Thanks for the review.


Bruno


[-- Attachment #2: 0001-ob-haskell-Add-tests-for-GHCi.patch --]
[-- Type: text/x-patch, Size: 13747 bytes --]

From 86a5443948fc84a6a412ccf49d0c537608f465a7 Mon Sep 17 00:00:00 2001
From: Bruno BARBIER <brubar.cs@gmail.com>
Date: Fri, 18 Nov 2022 20:14:20 +0100
Subject: [PATCH 1/7] ob-haskell: Add tests for GHCi

testing/lisp/test-ob-haskell-ghci.el: New file.
---
 testing/lisp/test-ob-haskell-ghci.el | 430 +++++++++++++++++++++++++++
 1 file changed, 430 insertions(+)
 create mode 100644 testing/lisp/test-ob-haskell-ghci.el

diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
new file mode 100644
index 000000000..920103858
--- /dev/null
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -0,0 +1,430 @@
+;;; test-ob-haskell-ghci.el --- tests for ob-haskell.el GHCi  -*- lexical-binding: t; -*-
+
+;; Copyright (c) 2023 Free Software Foundation, Inc.
+;; Authors: Bruno BARBIER <brubar.cs@gmail.com>
+
+;; This file is part of GNU Emacs.
+
+;; 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 <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+
+;;;; Useful references
+;;
+;;  - https://orgmode.org/worg/org-contrib/babel/languages/lang-compat.html
+;;  - GHCi manual: https://downloads.haskell.org/ghc/latest/docs/users_guide/ghci.html
+
+;;; Code:
+;;
+
+(require 'org-test "../testing/org-test")
+(org-test-for-executable "ghci")
+(unless (featurep 'haskell-mode)
+  (signal 'missing-test-dependency "haskell-mode"))
+(unless (featurep 'haskell)
+  (signal 'missing-test-dependency "haskell"))
+
+
+;;; Helpers
+;;
+
+(defun test-ob-haskell-ghci-checking-buffers (todo)
+  "Check some buffer related invariants.."
+  (when (get-buffer "*haskell*")
+    (error "A buffer named '*haskell*' exists.  Can't safely test haskell blocks"))
+  (prog1 (funcall todo)
+    (when-let ((hb (get-buffer "*haskell*")))
+      ;; We created a "*haskell*" buffer. That shouldn't happen.
+      (error "'ob-haskell' created a buffer named '*haskell*'"))))
+
+
+
+(defun test-ob-haskell-ghci (args content &optional preamble unprotected)
+  "Execute the code block CONTENT in a new GHCi session; return the result.
+Add ARGS to the code block argument line.  Insert PREAMBLE
+before the code block.  When UNPROTECTED is non-nil, check pre/post conditions."
+  (when (listp content)
+    (setq content (string-join content "\n")))
+  (unless preamble
+    (setq preamble ""))
+  (let ((todo (lambda ()
+                (prog1 (org-test-with-temp-text
+                           (concat preamble "\n" "#+begin_src haskell :compile no "
+                                   args "\n" "<point>" content "\n#+end_src")
+                         (org-babel-execute-src-block))))))
+    (if unprotected (funcall todo)
+      (test-ob-haskell-ghci-checking-buffers todo))))
+
+
+
+;;; Tests
+
+
+;;;; Hello Worlds.
+;;
+
+(ert-deftest ob-haskell/hello-world-value-pure ()
+  (should (equal "Hello World!"
+                 (test-ob-haskell-ghci "" "\"Hello World!\""))))
+
+(ert-deftest ob-haskell/hello-world-value-IO ()
+  (should (equal "Hello World!"
+                 (test-ob-haskell-ghci "" "return \"Hello World!\""))))
+
+(ert-deftest ob-haskell/hello-world-output ()
+  (should (equal "Hello World!"
+                 (test-ob-haskell-ghci ":results output" "putStrLn \"Hello World!\""))))
+
+(ert-deftest ob-haskell/hello-world-output-nothing ()
+  :expected-result :failed
+  (should (equal ""
+                 (test-ob-haskell-ghci ":results output" "return \"Hello World!\""))))
+
+(ert-deftest ob-haskell/hello-world-output-multilines ()
+  :expected-result :failed
+  (should (equal "Hello World!"
+                 (test-ob-haskell-ghci ":results output" "
+:{
+main :: IO ()
+main = putStrLn \"Hello World!\"
+:}
+
+main
+"))))
+
+;;;; Sessions
+;;
+
+(ert-deftest ob-haskell/sessions-must-not-share-variables ()
+  "Sessions must not share variables."
+  :expected-result :failed
+  (test-ob-haskell-ghci-with-global-session
+   (test-ob-haskell-ghci ":session s1" "x=2" nil :unprotected)
+   (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected)))
+   (test-ob-haskell-ghci ":session s2" "x=3" nil :unprotected)
+   (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected)))
+   ))
+
+(ert-deftest ob-haskell/no-session-means-one-shot-sessions ()
+  "When no session, use a new session."
+  :expected-result :failed
+  (test-ob-haskell-ghci-with-global-session
+   (test-ob-haskell-ghci "" "x=2" nil :unprotected)
+   (should-not (equal 2 (test-ob-haskell-ghci "" "x" nil :unprotected)))))
+
+
+;;;; Values
+;;
+
+(ert-deftest ob-haskell/value-is-the-last-expression ()
+  "Return the value of the last expression."
+  (should (equal 3 (test-ob-haskell-ghci "" '("1" "1+1" "1+1+1"))))
+  (should (equal 3 (test-ob-haskell-ghci "" '("x=1" "y=1+1" "x+y")))))
+
+(ert-deftest ob-haskell/value-is-the-last-expression-2 ()
+  "Return the value of the last expression."
+  (should (equal 7 (test-ob-haskell-ghci "" "
+putStrLn \"a string\"
+return \"useless\"
+3+4
+"))))
+
+
+
+(ert-deftest ob-haskell/eval-numbers ()
+  "Evaluation of numbers."
+  (should (equal 7 (test-ob-haskell-ghci "" "7")))
+  (should (equal 7.5 (test-ob-haskell-ghci "" "7.5")))
+  (should (equal 10.0 (test-ob-haskell-ghci "" "10::Double")))
+  (should (equal 10   (test-ob-haskell-ghci "" "10::Int"))))
+
+
+(ert-deftest ob-haskell/eval-strings ()
+  "Evaluation of strings."
+  (should (equal "a string" (test-ob-haskell-ghci "" "\"a string\""))))
+
+
+;;;; Local variables
+(ert-deftest ob-haskell/let-one-line ()
+  "Local definitions on one line."
+  (should (equal 6 (test-ob-haskell-ghci "" "let { x=2; y=3 } in x*y"))))
+
+(ert-deftest ob-haskell/let-multilines-1 ()
+  "Local definitions on multiple lines."
+  :expected-result :failed
+  (should (equal 6 (test-ob-haskell-ghci "" "
+:{
+ let { x=2
+     ; y=3
+     }
+ in x*y
+:}
+"))))
+
+(ert-deftest ob-haskell/let-multilines-2 ()
+  "Local definitions on multiple lines, relying on indentation."
+  :expected-result :failed
+  (should (equal 6 (test-ob-haskell-ghci "" "
+:{
+  let x=2
+      y=3
+  in x*y
+:}
+"))))
+
+;;;; Declarations with multiple lines.
+(ert-deftest ob-haskell/decl-multilines-1 ()
+  "A multiline declaration, then use it."
+  (should (equal 3 (test-ob-haskell-ghci "" "
+:{
+let length' []    = 0
+    length' (_:l) = 1 + length' l
+:}
+length' [1,2,3]
+"))))
+
+(ert-deftest ob-haskell/decl-multilines-2 ()
+  "A multiline declaration, then use it."
+  (should (equal 5 (test-ob-haskell-ghci "" "
+:{
+length'       :: [a] -> Int
+length' []    =  0
+length' (_:l) =  1 + length' l
+:}
+
+length' [1..5]
+"))))
+
+
+(ert-deftest ob-haskell/primes ()
+  "From haskell.org."""
+  :expected-result :failed
+  (should (equal '(2 3 5 7 11 13 17 19 23 29)
+                 (test-ob-haskell-ghci "" "
+:{
+primes = filterPrime [2..] where
+  filterPrime (p:xs) =
+    p : filterPrime [x | x <- xs, x `mod` p /= 0]
+:}
+
+take 10 primes
+"))))
+
+;;;; Lists
+;;
+
+(ert-deftest ob-haskell/a-simple-list ()
+  "Evaluation of list of values."
+  (should (equal '(1 2 3) (test-ob-haskell-ghci "" "[1,2,3]"))))
+
+
+(ert-deftest ob-haskell/2D-lists ()
+  "Evaluation of nested lists into a table."
+  (should (equal '((1 2 3) (4 5 6))
+                 (test-ob-haskell-ghci "" "[[1..3], [4..6]]"))))
+
+(ert-deftest ob-haskell/2D-lists-multilines ()
+  "Evaluation of nested lists into a table, as multilines."
+  :expected-result :failed
+  (should (equal '((1 2 3) (4 5 6))
+                 (test-ob-haskell-ghci "" "
+:{
+[ [1..3]
+, [4..6]
+, [7..9]
+]
+:}
+"))))
+
+
+;;;; Tuples
+;;
+
+(ert-deftest ob-haskell/a-simple-tuple ()
+  "Evaluation of tuple of values."
+  (should (equal '(1 2 3) (test-ob-haskell-ghci "" "(1,2,3)"))))
+
+
+(ert-deftest ob-haskell/2D-tuples ()
+  "Evaluation of nested tuples into a table."
+  (should (equal '((1 2 3) (4 5 6))
+                 (test-ob-haskell-ghci "" "((1,2,3), (4,5,6))"))))
+
+(ert-deftest ob-haskell/2D-tuples-multilines ()
+  "Evaluation of nested tuples into a table, as multilines."
+  (should (equal '((1 2 3) (4 5 6) (7 8 9))
+                 (test-ob-haskell-ghci "" "
+:{
+( (1,2,3)
+, (4,5,6)
+, (7,8,9)
+)
+:}
+"))))
+
+
+;;;; Data tables
+;;
+
+(ert-deftest ob-haskell/int-table-data ()
+  "From worg: int-table-data."
+  (should (equal 10 (test-ob-haskell-ghci ":var t=int-table-data"
+                                          "sum [sum r | r <- t]"
+                                          "#+name: int-table-data
+    | 1 | 2 |
+    | 3 | 4 |"))))
+
+(ert-deftest ob-haskell/float-table-data ()
+  "From worg: float-table-data."
+  (should (equal 11.0 (test-ob-haskell-ghci ":var t=float-table-data"
+                                            "sum [sum r | r <- t]"
+                                            "#+name: float-table-data
+    | 1.1 | 2.2 |
+    | 3.3 | 4.4 |"))))
+
+(ert-deftest ob-haskell/string-table-data ()
+  "From worg: string-table-data."
+  (should (equal "abcd" (test-ob-haskell-ghci ":var t=string-table-data"
+                                              "concat [concat r | r <- t]"
+                                              "#+name: string-table-data
+    | a | b |
+    | c | d |"))))
+
+;;;; Reuse results
+;;
+(ert-deftest ob-haskell/reuse-table ()
+  "Reusing a computed tables."
+  (should (equal 78 (test-ob-haskell-ghci ":var t=a-table"
+                                          "sum [sum r | r <- t]"
+                                          "#+name: a-table
+#+begin_src haskell
+   [ [x..x+2] | x <- [1,4 .. 12] ]
+#+end_src
+"))))
+
+
+;;;; Not defined errors
+;;
+
+(ert-deftest ob-haskell/not-defined ()
+  "Evaluation of undefined variables."
+  :expected-result :failed
+  (should-error (test-ob-haskell-ghci "" "notDefined :: IO Int")))
+
+
+(ert-deftest ob-haskell/not-defined-then-defined-1 ()
+  "Evaluation of undefined variables.
+This is a valid haskell source, but, invalid when entered one
+line at a time in GHCi."
+  :expected-result :failed
+  (should-error (test-ob-haskell-ghci "" "
+v :: Int
+v = 4
+")))
+
+
+(ert-deftest ob-haskell/not-defined-then-defined-1-fixed ()
+  "Like not-defined-then-defined-1, but using the mutiline marks."
+  :expected-result :failed
+  (let ((r (test-ob-haskell-ghci "" "
+:{
+  v :: Int
+  v = 4
+:}
+")))
+    (should (eq nil r))))
+
+(ert-deftest ob-haskell/not-defined-then-defined-1-fixed-2 ()
+  "Like not-defined-then-defined-1, but using one line."
+  (should (eq nil (test-ob-haskell-ghci "" "v = 4 :: Int"))))
+
+
+
+(ert-deftest ob-haskell/not-defined-then-defined-2 ()
+  "Evaluation of undefined variables, followed by a correct one."
+  ;; ghci output is:
+  ;;  | <interactive>:2:1-4: error:
+  ;;  |     • Variable not in scope: main :: IO ()
+  ;;  |     • Perhaps you meant ‘min’ (imported from Prelude)
+  ;;  | Hello, World!
+  ;; and ob-haskell just reports the last line "Hello, World!".
+  (should (string-match "Variable not in scope"
+                        (test-ob-haskell-ghci ":results output" "
+main :: IO ()
+main = putStrLn \"Hello, World!\"
+main
+"))))
+
+;;;; Imports
+;;
+
+(ert-deftest ob-haskell/import ()
+  "Import and use library."
+  (should (equal 65 (test-ob-haskell-ghci "" "
+import Data.IORef
+r <- newIORef 65
+readIORef r
+"))))
+
+(ert-deftest ob-haskell/import-with-vars ()
+  "Import and use library with vars."
+  (should (equal 65 (test-ob-haskell-ghci ":var x=65" "
+import Data.IORef
+r <- newIORef x
+readIORef r
+"))))
+
+;;;; What is the result?
+;;
+
+(ert-deftest ob-haskell/results-value-1 ()
+  "Don't confuse output and values: nothing."
+  (should (equal nil (test-ob-haskell-ghci ":results value" "return ()"))))
+
+(ert-deftest ob-haskell/results-value-2 ()
+  "Don't confuse output and values: a list."
+  (should (equal '(1 2) (test-ob-haskell-ghci ":results value" "return [1,2]"))))
+
+(ert-deftest ob-haskell/results-value-3 ()
+  "Don't confuse output and values: nothing."
+  :expected-result :failed
+  (should (equal nil (test-ob-haskell-ghci ":results value" "putStrLn \"3\""))))
+
+(ert-deftest ob-haskell/results-value-4 ()
+  "Don't confuse output and values: nothing."
+  :expected-result :failed
+  (should (equal nil (test-ob-haskell-ghci ":results value" "
+putStrLn \"3\"
+return ()
+"))))
+
+
+;;;; GHCi commands
+;;
+
+(ert-deftest ob-haskell/ghci-type ()
+  "The ghci meta command ':type'."
+  (should (equal "n :: Int"
+                 (test-ob-haskell-ghci ":results output" "let n=3::Int\n:type n"))))
+
+(ert-deftest ob-haskell/ghci-info ()
+  "The ghci meta command ':info' ."
+  (should (equal "repeat :: a -> [a]    -- Defined in ‘GHC.List’"
+                 (test-ob-haskell-ghci ":results output" ":info repeat"))))
+
+
+(provide 'test-ob-haskell-ghci)
+
+;;; test-ob-haskell-ghci.el ends here
-- 
2.41.0


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #3: 0002-org-babel-haskell-initiate-session-Remove-secondary-.patch --]
[-- Type: text/x-patch, Size: 1402 bytes --]

From b0e162a4238be505844a460bea7e4b42a72402ad Mon Sep 17 00:00:00 2001
From: Ihor Radchenko <yantar92@posteo.net>
Date: Fri, 24 Mar 2023 11:20:22 +0100
Subject: [PATCH 2/7] org-babel-haskell-initiate-session: Remove secondary
 prompt

* lisp/ob-haskell.el (org-babel-haskell-initiate-session): Set
secondary prompt to "".  If we do not do this, org-comint may treat
secondary prompts as a part of output.
---
 lisp/ob-haskell.el | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el
index 5babb2bb9..7e36c29e6 100644
--- a/lisp/ob-haskell.el
+++ b/lisp/ob-haskell.el
@@ -169,7 +169,16 @@ (defun org-babel-haskell-initiate-session (&optional _session _params)
 then create one.  Return the initialized session."
   (org-require-package 'inf-haskell "haskell-mode")
   (or (get-buffer "*haskell*")
-      (save-window-excursion (run-haskell) (sleep-for 0.25) (current-buffer))))
+      (save-window-excursion
+        (run-haskell)
+        (sleep-for 0.25)
+        ;; Disable secondary prompt: If we do not do this,
+        ;; org-comint may treat secondary prompts as a part of
+        ;; output.
+        (org-babel-comint-input-command
+         (current-buffer)
+         ":set prompt-cont \"\"")
+        (current-buffer))))
 
 (defun org-babel-load-session:haskell (session body params)
   "Load BODY into SESSION."
-- 
2.41.0


[-- Attachment #4: 0003-testing-lisp-test-ob-haskell-ghci.el-Fix-some-tests.patch --]
[-- Type: text/x-patch, Size: 1508 bytes --]

From 5164ef6db8e9d722536b0dbb00523202f1ae917c Mon Sep 17 00:00:00 2001
From: Ihor Radchenko <yantar92@posteo.net>
Date: Fri, 24 Mar 2023 11:25:19 +0100
Subject: [PATCH 3/7] * testing/lisp/test-ob-haskell-ghci.el: Fix some tests

(ob-haskell/2D-lists-multilines):
(ob-haskell/ghci-info): Fix incorrect test assertions.
---
 testing/lisp/test-ob-haskell-ghci.el | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
index 920103858..e34dfacd9 100644
--- a/testing/lisp/test-ob-haskell-ghci.el
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -237,8 +237,7 @@ (ert-deftest ob-haskell/2D-lists ()
 
 (ert-deftest ob-haskell/2D-lists-multilines ()
   "Evaluation of nested lists into a table, as multilines."
-  :expected-result :failed
-  (should (equal '((1 2 3) (4 5 6))
+  (should (equal '((1 2 3) (4 5 6) (7 8 9))
                  (test-ob-haskell-ghci "" "
 :{
 [ [1..3]
@@ -421,8 +420,9 @@ (ert-deftest ob-haskell/ghci-type ()
 
 (ert-deftest ob-haskell/ghci-info ()
   "The ghci meta command ':info' ."
-  (should (equal "repeat :: a -> [a]    -- Defined in ‘GHC.List’"
-                 (test-ob-haskell-ghci ":results output" ":info repeat"))))
+  (should (string-match-p
+           "repeat :: a -> \\[a\\][ \t]+-- Defined in ‘GHC.List’"
+           (test-ob-haskell-ghci ":results output" ":info repeat"))))
 
 
 (provide 'test-ob-haskell-ghci)
-- 
2.41.0


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #5: 0004-testing-lisp-test-ob-haskell-ghci.el-Enable-fixed-te.patch --]
[-- Type: text/x-patch, Size: 2122 bytes --]

From 5bf5f05f1d76d6128d56d48b9b23a767ba458a2d Mon Sep 17 00:00:00 2001
From: Ihor Radchenko <yantar92@posteo.net>
Date: Fri, 24 Mar 2023 11:26:00 +0100
Subject: [PATCH 4/7] * testing/lisp/test-ob-haskell-ghci.el: Enable fixed
 tests

(ob-haskell/hello-world-output-multilines):
(ob-haskell/let-multilines-1):
(ob-haskell/let-multilines-2):
(ob-haskell/primes):
(ob-haskell/not-defined-then-defined-1-fixed): Re-enable tests.
---
 testing/lisp/test-ob-haskell-ghci.el | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
index e34dfacd9..c56ad8f51 100644
--- a/testing/lisp/test-ob-haskell-ghci.el
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -93,7 +93,6 @@ (ert-deftest ob-haskell/hello-world-output-nothing ()
                  (test-ob-haskell-ghci ":results output" "return \"Hello World!\""))))
 
 (ert-deftest ob-haskell/hello-world-output-multilines ()
-  :expected-result :failed
   (should (equal "Hello World!"
                  (test-ob-haskell-ghci ":results output" "
 :{
@@ -163,7 +162,6 @@ (ert-deftest ob-haskell/let-one-line ()
 
 (ert-deftest ob-haskell/let-multilines-1 ()
   "Local definitions on multiple lines."
-  :expected-result :failed
   (should (equal 6 (test-ob-haskell-ghci "" "
 :{
  let { x=2
@@ -175,7 +173,6 @@ (ert-deftest ob-haskell/let-multilines-1 ()
 
 (ert-deftest ob-haskell/let-multilines-2 ()
   "Local definitions on multiple lines, relying on indentation."
-  :expected-result :failed
   (should (equal 6 (test-ob-haskell-ghci "" "
 :{
   let x=2
@@ -210,7 +207,6 @@ (ert-deftest ob-haskell/decl-multilines-2 ()
 
 (ert-deftest ob-haskell/primes ()
   "From haskell.org."""
-  :expected-result :failed
   (should (equal '(2 3 5 7 11 13 17 19 23 29)
                  (test-ob-haskell-ghci "" "
 :{
@@ -336,7 +332,6 @@ (ert-deftest ob-haskell/not-defined-then-defined-1 ()
 
 (ert-deftest ob-haskell/not-defined-then-defined-1-fixed ()
   "Like not-defined-then-defined-1, but using the mutiline marks."
-  :expected-result :failed
   (let ((r (test-ob-haskell-ghci "" "
 :{
   v :: Int
-- 
2.41.0


[-- Attachment #6: 0005-lisp-ob-haskell-Request-the-last-value-from-GHCi.patch --]
[-- Type: text/x-patch, Size: 6772 bytes --]

From cb35845d9b85ad37a90e6858651ac826679e41ae Mon Sep 17 00:00:00 2001
From: Bruno BARBIER <brubar.cs@gmail.com>
Date: Sat, 25 Mar 2023 09:59:31 +0100
Subject: [PATCH 5/7] lisp/ob-haskell: Request the last value from GHCi

* lisp/ob-haskell.el (org-babel-interpret-haskell): When the result
type is 'value, use the last value as defined by GHCi.
(org-babel-haskell-eoe): New default value.
(org-babel-interpret-haskell): Update for the new value of `org-babel-haskell-eoe'.

* testing/lisp/test-ob-haskell-ghci.el: Update tests related to output/value.
---
 lisp/ob-haskell.el                   | 80 ++++++++++++++++++----------
 testing/lisp/test-ob-haskell-ghci.el |  6 +--
 2 files changed, 53 insertions(+), 33 deletions(-)

diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el
index 7e36c29e6..55687769f 100644
--- a/lisp/ob-haskell.el
+++ b/lisp/ob-haskell.el
@@ -61,7 +61,7 @@ (defvar org-babel-default-header-args:haskell
 
 (defvar org-babel-haskell-lhs2tex-command "lhs2tex")
 
-(defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
+(defvar org-babel-haskell-eoe "org-babel-haskell-eoe")
 
 (defvar haskell-prompt-regexp)
 
@@ -127,34 +127,56 @@ (defun org-babel-interpret-haskell (body params)
             (lambda ()
               (setq-local comint-prompt-regexp
                           (concat haskell-prompt-regexp "\\|^λ?> "))))
-  (let* ((session (cdr (assq :session params)))
-         (result-type (cdr (assq :result-type params)))
-         (full-body (org-babel-expand-body:generic
-		     body params
-		     (org-babel-variable-assignments:haskell params)))
-         (session (org-babel-haskell-initiate-session session params))
-	 (comint-preoutput-filter-functions
-	  (cons 'ansi-color-filter-apply comint-preoutput-filter-functions))
-         (raw (org-babel-comint-with-output
-		  (session org-babel-haskell-eoe nil full-body)
-                (insert (org-trim full-body))
-                (comint-send-input nil t)
-                (insert org-babel-haskell-eoe)
-                (comint-send-input nil t)))
-         (results (mapcar #'org-strip-quotes
-			  (cdr (member org-babel-haskell-eoe
-                                       (reverse (mapcar #'org-trim raw)))))))
-    (org-babel-reassemble-table
-     (let ((result
-            (pcase result-type
-              (`output (mapconcat #'identity (reverse results) "\n"))
-              (`value (car results)))))
-       (org-babel-result-cond (cdr (assq :result-params params))
-	 result (when result (org-babel-script-escape result))))
-     (org-babel-pick-name (cdr (assq :colname-names params))
-			  (cdr (assq :colname-names params)))
-     (org-babel-pick-name (cdr (assq :rowname-names params))
-			  (cdr (assq :rowname-names params))))))
+  (org-babel-haskell-with-session session params
+    (cl-labels
+        ((send-txt-to-ghci (txt)
+           (insert txt) (comint-send-input nil t))
+         (send-eoe ()
+           (send-txt-to-ghci (concat "putStrLn \"" org-babel-haskell-eoe "\"\n")))
+         (comint-with-output (todo)
+           (let ((comint-preoutput-filter-functions
+                  (cons 'ansi-color-filter-apply
+                        comint-preoutput-filter-functions)))
+             (org-babel-comint-with-output
+                 (session org-babel-haskell-eoe nil nil)
+               (funcall todo)))))
+      (let* ((result-type (cdr (assq :result-type params)))
+             (full-body (org-babel-expand-body:generic
+                         body params
+                         (org-babel-variable-assignments:haskell params)))
+             (raw (pcase result-type
+                    (`output
+                     (comint-with-output
+                      (lambda () (send-txt-to-ghci (org-trim full-body)) (send-eoe))))
+                    (`value
+                      ;; We first compute the value and store it,
+                      ;; ignoring any output.
+                     (comint-with-output
+                      (lambda ()
+                        (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__=()::()\n")
+                        (send-txt-to-ghci (org-trim full-body))
+                        (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__=it\n")
+                        (send-eoe)))
+                      ;; We now display and capture the value.
+                     (comint-with-output
+                      (lambda()
+                        (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__\n")
+                        (send-eoe))))))
+             (results (mapcar #'org-strip-quotes
+                              (cdr (member org-babel-haskell-eoe
+                                           (reverse (mapcar #'org-trim raw)))))))
+        (org-babel-reassemble-table
+         (let ((result
+                (pcase result-type
+                  (`output (mapconcat #'identity (reverse results) "\n"))
+                  (`value (car results)))))
+           (org-babel-result-cond (cdr (assq :result-params params))
+	     result (when result (org-babel-script-escape result))))
+         (org-babel-pick-name (cdr (assq :colname-names params))
+			      (cdr (assq :colname-names params)))
+         (org-babel-pick-name (cdr (assq :rowname-names params))
+			      (cdr (assq :rowname-names params))))))))
+
 
 (defun org-babel-execute:haskell (body params)
   "Execute a block of Haskell code."
diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
index c56ad8f51..9cdc763d9 100644
--- a/testing/lisp/test-ob-haskell-ghci.el
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -88,8 +88,8 @@ (ert-deftest ob-haskell/hello-world-output ()
                  (test-ob-haskell-ghci ":results output" "putStrLn \"Hello World!\""))))
 
 (ert-deftest ob-haskell/hello-world-output-nothing ()
-  :expected-result :failed
-  (should (equal ""
+  ;; GHCi prints the value on standard output.  So, the last value is part of the output.
+  (should (equal "Hello World!"
                  (test-ob-haskell-ghci ":results output" "return \"Hello World!\""))))
 
 (ert-deftest ob-haskell/hello-world-output-multilines ()
@@ -393,12 +393,10 @@ (ert-deftest ob-haskell/results-value-2 ()
 
 (ert-deftest ob-haskell/results-value-3 ()
   "Don't confuse output and values: nothing."
-  :expected-result :failed
   (should (equal nil (test-ob-haskell-ghci ":results value" "putStrLn \"3\""))))
 
 (ert-deftest ob-haskell/results-value-4 ()
   "Don't confuse output and values: nothing."
-  :expected-result :failed
   (should (equal nil (test-ob-haskell-ghci ":results value" "
 putStrLn \"3\"
 return ()
-- 
2.41.0


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #7: 0006-ob-haskell-Implement-sessions.patch --]
[-- Type: text/x-patch, Size: 8393 bytes --]

From 4beb4e6c1abe2c5a560662903f236a6c1ab3d44f Mon Sep 17 00:00:00 2001
From: Bruno BARBIER <brubar.cs@gmail.com>
Date: Sat, 25 Mar 2023 10:06:44 +0100
Subject: [PATCH 6/7] ob-haskell: Implement sessions

* lisp/ob-haskell.el (org-babel-haskell-initiate-session): Implement
sessions.
(org-babel-haskell-with-session): New macro to manage sessions.
(org-babel-interpret-haskell): Refactor code.  Use
`org-babel-haskell-with-session` to manage sessions.

* testing/lisp/test-ob-haskell-ghci.el: Update tests related to
sessions.
---
 lisp/ob-haskell.el                   | 96 ++++++++++++++++++++++++----
 testing/lisp/test-ob-haskell-ghci.el | 47 ++++++++++----
 2 files changed, 115 insertions(+), 28 deletions(-)

diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el
index 55687769f..8f6d5aebd 100644
--- a/lisp/ob-haskell.el
+++ b/lisp/ob-haskell.el
@@ -77,6 +77,32 @@ (defcustom org-babel-haskell-compiler "ghc"
 (defconst org-babel-header-args:haskell '((compile . :any))
   "Haskell-specific header arguments.")
 
+
+(defun org-babel-haskell-with-session--worker (params todo)
+  "See `org-babel-haskell-with-session'."
+  (let* ((sn (cdr (assq :session params)))
+         (session (org-babel-haskell-initiate-session sn params))
+         (one-shot (equal sn "none")))
+    (unwind-protect
+        (funcall todo session)
+      (when (and one-shot (buffer-live-p session))
+        ;; As we don't control how the session temporary buffer is
+        ;; created, we need to explicitly work around the hooks and
+        ;; query functions.
+        (with-current-buffer session
+          (let ((kill-buffer-query-functions nil)
+                (kill-buffer-hook nil))
+            (kill-buffer session)))))))
+
+(defmacro org-babel-haskell-with-session (session-symbol params &rest body)
+  "Get the session identified by PARAMS and run BODY with it.
+
+Get or create a session, as needed to match PARAMS.  Assign the session to
+SESSION-SYMBOL.  Execute BODY.  Destroy the session if needed.
+Return the value of the last form of BODY."
+  (declare (indent 2) (debug (symbolp form body)))
+  `(org-babel-haskell-with-session--worker ,params (lambda (,session-symbol) ,@body)))
+
 (defun org-babel-haskell-execute (body params)
   "This function should only be called by `org-babel-execute:haskell'."
   (let* ((tmp-src-file (org-babel-temp-file "Haskell-src-" ".hs"))
@@ -185,22 +211,64 @@ (defun org-babel-execute:haskell (body params)
 	(org-babel-interpret-haskell body params)
       (org-babel-haskell-execute body params))))
 
-(defun org-babel-haskell-initiate-session (&optional _session _params)
+
+
+
+;; Variable defined in inf-haskell (haskell-mode package).
+(defvar inferior-haskell-buffer)
+
+(defun org-babel-haskell-initiate-session (&optional session-name _params)
   "Initiate a haskell session.
-If there is not a current inferior-process-buffer in SESSION
-then create one.  Return the initialized session."
+Return the initialized session, i.e. the buffer for this session.
+When SESSION-NAME is nil, use a global session named
+\"*ob-haskell*\".  When SESSION-NAME is the string \"none\", use
+a temporary buffer.  Else, (re)use the session named
+SESSION-NAME.  The buffer name is the session name.  See also
+`org-babel-haskell-with-session'."
   (org-require-package 'inf-haskell "haskell-mode")
-  (or (get-buffer "*haskell*")
-      (save-window-excursion
-        (run-haskell)
-        (sleep-for 0.25)
-        ;; Disable secondary prompt: If we do not do this,
-        ;; org-comint may treat secondary prompts as a part of
-        ;; output.
-        (org-babel-comint-input-command
-         (current-buffer)
-         ":set prompt-cont \"\"")
-        (current-buffer))))
+  (cond
+   ((equal "none" session-name)
+    ;; Temporary buffer name.
+    (setq session-name (generate-new-buffer-name " *ob-haskell-tmp*")))
+   ((eq nil session-name)
+    ;; The global default session. As haskell-mode is using the buffer
+    ;; named "*haskell*", we stay away from it.
+    (setq session-name "*ob-haskell*"))
+   ((not (stringp session-name))
+    (error "session-name must be a string")))
+  (let ((session (get-buffer session-name)))
+    ;; NOTE: By construction, as SESSION-NAME is a string, session is
+    ;; either nil or a live buffer.
+    (save-window-excursion
+      (or (org-babel-comint-buffer-livep session)
+          (let ((inferior-haskell-buffer session))
+            ;; As inferior-haskell expects the buffer to be named
+            ;; "*haskell*", we temporarily rename it while executing
+            ;; `run-haskell' (unless the user explicitly requested to
+            ;; use the name "*haskell*").
+            (when (not (equal "*haskell*" session-name))
+              (when (bufferp session)
+                (when (bufferp "*haskell*")
+                  (user-error "Conflicting buffer '*haskell*', rename it or kill it"))
+                (with-current-buffer session (rename-buffer "*haskell*"))))
+            (unwind-protect
+                (let ((inferior-haskell-root-dir default-directory))
+                  (run-haskell)
+                  (sleep-for 0.25)
+                  (setq session inferior-haskell-buffer))
+              (when (and (not (equal "*haskell*" session-name))
+                         (bufferp session))
+                (with-current-buffer session (rename-buffer session-name))))
+            ;; Disable secondary prompt: If we do not do this,
+            ;; org-comint may treat secondary prompts as a part of
+            ;; output.
+            (org-babel-comint-input-command
+             session
+             ":set prompt-cont \"\"")
+            session)
+          ))
+    session))
+
 
 (defun org-babel-load-session:haskell (session body params)
   "Load BODY into SESSION."
diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
index 9cdc763d9..9ccc60e90 100644
--- a/testing/lisp/test-ob-haskell-ghci.el
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -108,20 +108,39 @@ (ert-deftest ob-haskell/hello-world-output-multilines ()
 
 (ert-deftest ob-haskell/sessions-must-not-share-variables ()
   "Sessions must not share variables."
-  :expected-result :failed
-  (test-ob-haskell-ghci-with-global-session
-   (test-ob-haskell-ghci ":session s1" "x=2" nil :unprotected)
-   (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected)))
-   (test-ob-haskell-ghci ":session s2" "x=3" nil :unprotected)
-   (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected)))
-   ))
-
-(ert-deftest ob-haskell/no-session-means-one-shot-sessions ()
-  "When no session, use a new session."
-  :expected-result :failed
-  (test-ob-haskell-ghci-with-global-session
-   (test-ob-haskell-ghci "" "x=2" nil :unprotected)
-   (should-not (equal 2 (test-ob-haskell-ghci "" "x" nil :unprotected)))))
+  (test-ob-haskell-ghci ":session s1" "x=2" nil)
+  (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil)))
+  (test-ob-haskell-ghci ":session s2" "x=3" nil)
+  (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil)))
+  )
+
+(ert-deftest ob-haskell/session-named-none-means-one-shot-sessions ()
+  "When no session, use a new session.
+\"none\" is a special name that means `no session'."
+  (test-ob-haskell-ghci ":session none" "x=2" nil)
+  (should-not (equal 2 (test-ob-haskell-ghci ":session \"none\"" "x" nil)))
+  (test-ob-haskell-ghci ":session none" "x=2" nil)
+  (should-not (equal 2 (test-ob-haskell-ghci ":session \"none\"" "x" nil))))
+
+(ert-deftest ob-haskell/reuse-variables-in-same-session ()
+  "Reuse variables between blocks using the same session."
+  (test-ob-haskell-ghci ":session s1" "x=2" nil)
+  (should (equal 2 (test-ob-haskell-ghci ":session s1" "x"))))
+
+(ert-deftest ob-haskell/may-use-the-*haskell*-session ()
+  "The user may use the special *haskell* buffer."
+  (when (get-buffer "*haskell*")
+    (error "A buffer named '*haskell*' exists.  Can't run this test"))
+  (unwind-protect
+      (progn
+        (test-ob-haskell-ghci ":session *haskell*" "x=2" nil :unprotected)
+        (should (equal 2 (test-ob-haskell-ghci ":session *haskell*" "x" nil :unprotected))))
+    (with-current-buffer "*haskell*"
+      (let ((kill-buffer-query-functions nil)
+            (kill-buffer-hook nil))
+        (kill-buffer "*haskell*")))))
+
+
 
 
 ;;;; Values
-- 
2.41.0


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #8: 0007-testing-lisp-test-ob-haskell-ghci.el-Test-output-wit.patch --]
[-- Type: text/x-patch, Size: 1815 bytes --]

From d0f0d40d570a6b63aa0b4ad3ae6f1b67a32e99a3 Mon Sep 17 00:00:00 2001
From: Bruno BARBIER <brubar.cs@gmail.com>
Date: Sat, 29 Apr 2023 10:27:57 +0200
Subject: [PATCH 7/7] * testing/lisp/test-ob-haskell-ghci.el: Test output
 without EOL

(ob-haskell/output-without-eol-1):
(ob-haskell/output-without-eol-2):
(ob-haskell/output-without-eol-3): New tests.
---
 testing/lisp/test-ob-haskell-ghci.el | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el
index 9ccc60e90..e64e87203 100644
--- a/testing/lisp/test-ob-haskell-ghci.el
+++ b/testing/lisp/test-ob-haskell-ghci.el
@@ -173,6 +173,38 @@ (ert-deftest ob-haskell/eval-strings ()
   "Evaluation of strings."
   (should (equal "a string" (test-ob-haskell-ghci "" "\"a string\""))))
 
+;;;; Output without EOL
+;;
+
+(ert-deftest ob-haskell/output-without-eol-1 ()
+  "Cannot get output from incomplete lines, when entered line by line."
+  :expected-result :failed
+  (should (equal "123"
+                 (test-ob-haskell-ghci ":results output" "
+  putStr(\"1\")
+  putStr(\"2\")
+  putStr(\"3\")
+  putStr(\"\\n\")
+"))))
+
+(ert-deftest ob-haskell/output-without-eol-2 ()
+  "Incomplete output lines are OK when using a multiline block."
+  (should (equal "123"
+                 (test-ob-haskell-ghci ":results output" "
+:{
+  do putStr(\"1\")
+     putStr(\"2\")
+     putStr(\"3\")
+     putStr(\"\\n\")
+:}
+"))))
+
+(ert-deftest ob-haskell/output-without-eol-3 ()
+  "Incomplete output lines are OK on one line."
+  (should (equal "123"
+                 (test-ob-haskell-ghci ":results output" "
+do { putStr(\"1\"); putStr(\"2\"); putStr(\"3\"); putStr(\"\\n\") }
+"))))
 
 ;;;; Local variables
 (ert-deftest ob-haskell/let-one-line ()
-- 
2.41.0


  parent reply	other threads:[~2023-09-07 14:22 UTC|newest]

Thread overview: 26+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2023-03-19  9:12 [PATCH] Add tests for ob-haskell (GHCi) Bruno Barbier
2023-03-19 10:20 ` Ihor Radchenko
2023-03-19 10:28   ` Ihor Radchenko
2023-03-19 10:32   ` Bruno Barbier
2023-03-22 10:16     ` Ihor Radchenko
2023-03-24 10:36       ` Ihor Radchenko
2023-03-25 10:01         ` Bruno Barbier
2023-03-26  9:09           ` Ihor Radchenko
2023-03-26  9:40             ` Bruno Barbier
2023-03-26  9:46               ` Ihor Radchenko
     [not found]             ` <notmuch-sha1-0807e1720f829950d42ef560bc30e56bd152766c>
2023-05-07  8:50               ` Bruno Barbier
2023-05-07  9:18                 ` Ruijie Yu via General discussions about Org-mode.
2023-05-07 11:15                   ` Bruno Barbier
2023-05-08 10:59                 ` Ihor Radchenko
2023-05-21  7:40                   ` Bruno Barbier
2023-06-02  8:44                     ` Ihor Radchenko
2023-08-10 12:51                       ` Ihor Radchenko
2023-08-25 19:10                         ` Bruno Barbier
2023-09-07 14:21                       ` Bruno Barbier [this message]
2023-09-08  8:23                         ` Ihor Radchenko
2023-09-08  9:49                           ` Bruno Barbier
2023-03-23 10:35 ` Ihor Radchenko
2023-03-23 21:01   ` ParetoOptimalDev
2023-03-23 21:30     ` ParetoOptimalDev
2023-03-24 10:40     ` Ihor Radchenko
2023-03-26  3:27       ` ParetoOptimalDev

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://www.orgmode.org/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=64f9dc79.050a0220.194d1.9020@mx.google.com \
    --to=brubar.cs@gmail.com \
    --cc=emacs-orgmode@gnu.org \
    --cc=yantar92@posteo.net \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).