'((:buffer . "*ob-term*")

  '((:session . "*ob-term*")
    ;; The value of `:create' must be a list of a function and its
    ;; arguments.  As the first argument the buffer-name (from the
    ;; `:session' parameter) will be spliced into the list.  You can
    ;; provide your own function but make sure that they adhere to
    ;; this convention.  See the functions `ob-term-term',
    ;; `ob-term-serial-term' and `ob-term-comint' as an example.

    ;; Pause between each line the given number of seconds.  The only
    ;; times I needed this is when communicating with ulisp via
    ;; serial-term.

         (buffer (cdr (assoc :buffer params)))

         (buffer (cdr (assoc :session params)))

        (if (cdr (assoc :create params))
            (eval (cdr (assoc :create params)))
          (error "buffer '%s' not found and no create function specified" buffer)))

        (let ((form (cdr (assoc :create params))))
          (if form
              (apply (car form) buffer (cdr form))
            (error "buffer '%s' not found and no create function specified" buffer))))

(defun ob-term-term (program &optional buffer-name)

(defun ob-term-term (buffer-name program &rest args)

  (let ((buf (make-term (or buffer-name program) program)))
    (with-current-buffer buf
      (term-mode)
      (term-char-mode))

  (let ((buf (get-buffer-create buffer-name)))
    (unless (term-check-proc buf)
      (with-current-buffer buf
	(term-mode)
	(term-exec buf buffer-name program nil args)
        (term-char-mode)))

(defun ob-term-serial-term (port speed)

(defun ob-term-serial-term (_buffer-name port speed)

(defun ob-term-shell (program &optional buffer-name)

(defun ob-term-comint (buffer-name program &rest args)

  (cl-letf (((symbol-function 'pop-to-buffer-same-window) #'pop-to-buffer))
    (let ((explicit-shell-file-name program)
          (prevbuf (current-buffer)))
      (shell (or buffer-name (format "*%s*" program)))
      (pop-to-buffer prevbuf))))

  (apply #'make-comint-in-buffer buffer-name buffer-name program nil args)
  (display-buffer buffer-name))

** serial term to ulisp

** Serial term to ulisp

#+header: :buffer /dev/ttyACM0

#+header: :session /dev/ttyACM0

** bash shell in term-mode
#+header: :create '(ob-term-term "bash" "term-bash")
#+header: :buffer *term-bash*

** Bash shell in term-mode
#+header: :create '(ob-term-term "bash")
#+header: :session *term-bash*

#+header: :buffer *term-bash*

#+header: :session *term-bash*

** ghci in term-mode

** Ghci in term-mode

#+header: :buffer *ghci*

#+header: :session *term-ghci*

** a shell in comint-mode
#+header: :create '(ob-term-shell "bash" "*shell*")
#+header: :buffer *shell*

** A shell in comint-mode
#+header: :create '(ob-term-comint "bash")
#+header: :session *comint-bash*

#+header: :buffer *shell*

#+header: :session *comint-bash*

** ghci in comint-mode
#+header: :create '(ob-term-shell "ghci")
#+header: :buffer *ghci*
#+begin_src term:haskell

** Ghci in comint-mode
#+header: :create '(ob-term-comint "ghci")
#+header: :session *comint-ghci*
#+begin_src term:haskell :results silent

#+header: :buffer *ghci*

#+header: :session *comint-ghci*

** Windows Subsystem for Linux (wsl) bash in comint-mode
#+header: :create '(ob-term-comint "wsl" "bash")
#+header: :session *comint-wsl-bash*
#+begin_src term:haskell :results silent
  PS1=""
  echo ""
#+end_src
#+header: :session *comint-wsl-bash*
#+begin_src term:haskell
  uname -a
#+end_src