I was impressed by your video's. I would like to donate.

Is there a goal and a roadmap? And I noticed the last activity was more than a year ago. So it makes me to wonder if this project is still active.

Thanks in advance for your reply.

e.g:

(defun test (a b)
  (let (
         (a2 (+ a 4))
         (b2 b)
         (c (* 2 a)))
    c)) 

a2 gets no overlay

Ideas for better name welcome :)

Some objections:

• the idea wasn't invented @ light table, so we shouldn't give credit
• it's too much marketing
• it's too little marketing

Hi,

I'm aware this project isn't really active anymore but it happens I've been using it here and there and I've been missing an interactive way to remove functions from litable-pure-functions-list and litable-list.el.

Here's a basic proposal using completing-read that I've been using:

(defun litable-remove-from-pure-list ()
    "Remove a function from the pure functions list."
    (interactive)
    (if (null litable-pure-functions-list)
        (message "No function trusted to be pure.")
      (let ((symbol
             (completing-read "Pure function: "
                              litable-pure-functions-list
                              nil t)))
        (setq litable-pure-functions-list
              (delq (intern symbol) litable-pure-functions-list))
        (litable--save-lists))))

Ideally, it could also be made to match the function at point and set it as initial input but I haven't looked into that.

What do you think?

The readme mentions the possibility of a safeguard system.

Is that underway? I wouldn't mind lending a hand with that.

An initial (simple) implementation could check all functions about to be evaluated against a list of "known pure" functions, and quit evaluation if one is not there.

I seem unable to do much with litable beyond calculating expressions with arithmetic operators. It doesn't seem to be adding any of the functions as I define them, and shows the "Unsafe function" alert whenever I type "defun", or relational operators like < or =, although boolean operators seem to work fine. (I didn't try others.) I'm generally not able to duplicate any of the stuff I've seen in the videos. Any idea what I could be doing wrong?

Function in-string-p is not reliable, therefor all code relying on that is affected.
Try with cursor at last line before sdsd:

(defun asdf ()
"asdf

(defun foo1 (&optional beg end)
sdsd "

Cursor will stop at first "(defun " inside string.

Maybe get a working ar-in-string-p from here:

http://bazaar.launchpad.net/~a-roehler/s-x-emacs-werkstatt/trunk/view/head:/misc-utils.el

Debugger entered--Lisp error: (invalid-function (value (symbol-value list-symbol)))
(value (symbol-value list-symbol))()
litable--dump-list(litable-pure-functions-list)
litable--save-lists()
byte-code("\301...)
autoload-do-load((autoload "litable" "Toggle litable-mode\n\n(fn &optional ARG)" t nil) litable-mode)
#[1025 "\306...)
funcall(#[1025 "\306...)
(with-no-warnings (funcall ad--addoit-function cmd record-flag keys special))
(setq ad-return-value (with-no-warnings (funcall ad--addoit-function cmd record-flag keys special)))
(let (ad-return-value) (setq ad-return-value (with-no-warnings (funcall ad--addoit-function cmd record-flag keys special))) (when (fancy-narrow-active-p) (fancy-narrow--motion-function)) ad-return-value)
ad-Advice-command-execute(#[1025 "\306...)
apply(ad-Advice-command-execute #[1025 "\306...)
command-execute(litable-mode record)

Any idea what's going wrong?

Best regards

Now litable places the result string at the end of the line where you are editing.

However, it evaluates the entire form at point. Oftentimes this means that the result string points out from some part of the form innards, instead of at the actual form end paren.

I'm hoping to use litable in my talk in a few weeks, and I would like to forestall any confusion from this.

If you could point me to the correct place to fix this, I would be happy to contribute. Or if you know just what to do, I'd be happy to sit back and enjoy the show. :)