News for hackers. Stuff that matters.
Re:Practical Emacs Lisp by agumonkey on Friday September 11, 2015 @03:09PM (#10205590)
Using lisp to while/set... sigh. This is old age emacs lisp. We need more dash.el. Unfortunately we'd need a more stream/functional buffer API ? I was thinking of porting scheme regexp SRFI because it felt a better fit than re-search-*.
Re:Practical Emacs Lisp by PuercoPop on Friday September 11, 2015 @03:28PM (#10205685)
As far as dash.el goes, I find lispm's critique of dash.el pretty convincing[0]. However a more profilic emacs coder fried of mine is undeterred and keeps using modern emacs lisp. I think much of the community does as well.

[0]: https://www.reddit.com/r/lisp/comments/29ufoc/it_is_not_hard...

About Scheme's regexp SRFI, have you seen rx.el? Not quite but I like it myself.

Re:Practical Emacs Lisp by agumonkey on Friday September 11, 2015 @04:18PM (#10205938)
IIUC rx.el is a sexp dsl/interface to build vanilla regex down the line right ? from what I remember about scheme SRFI is not the 'syntax' but the return values, you get streams of match, then you can leverage, folds and maps.

lispm point is nice (and no one can argue about evaluation order and count), but beside the battle-tested aspect, `loop` scares the crap out of me. That's even more a reason to prefer things that avoids it in my mind, mentally small building blocks and patterns versus huge macro-based sublanguages. Yes general and probably super-efficiently implemented, but .. nah.

Re:Practical Emacs Lisp by lispm on Friday September 11, 2015 @06:36PM (#10206516)
See this Xah Lee Elisp code:

    (defvar xah-left-brackets '("(" "{" "[" "<" "〔" "【" "〖" "〈" "《" "「" "『" "“" "‘" "‹" "«" )
      "List of left bracket chars.")
    (progn
    ;; make xah-left-brackets based on xah-brackets
      (setq xah-left-brackets '())
      (dotimes (x (- (length xah-brackets) 1))
        (when (= (% x 2) 0)
          (push (char-to-string (elt xah-brackets x))
                xah-left-brackets)))
      (setq xah-left-brackets (reverse xah-left-brackets)))

    (defvar xah-right-brackets '(")" "]" "}" ">" "〕" "】" "〗" "〉" "》" "」" "』" "”" "’" "›" "»")
      "list of right bracket chars.")
    (progn
      (setq xah-right-brackets '())
      (dotimes (x (- (length xah-brackets) 1))
        (when (= (% x 2) 1)
          (push (char-to-string (elt xah-brackets x))
                xah-right-brackets)))
      (setq xah-right-brackets (reverse xah-right-brackets)))
In CL this is just:

    (defun every-nth (seq start n &aux (len (length seq)))
      (loop for i = start then (+ i n)
            while (< i len)
            collect (elt seq i)))

    (defvar xah-left-brackets  (every-nth xah-brackets 0 2))
    (defvar xah-right-brackets (every-nth xah-brackets 1 2))
Write useful building blocks. Don't duplicate code. Get rid of low level imperative code.

Bonus points for a more efficient version for lists.

Re:Practical Emacs Lisp by kazinator on Friday September 11, 2015 @09:04PM (#10206888)
In TXR Lisp:

  $ txr -i
  1> (defvarl brackets '("(" ")" "[" "]" "<" ">")))
  brackets
  2> [brackets (range 0 : 2)]
  ("(" "[" "<")
  3> [brackets (range 1 : 2)]
  (")" "]" ">")
range generates lazy list of integers with a step size (the colon symbol defaults the second upper bound argument so the list is infinite). A list of integers can be used in the brackets notation to select elements. Put the two together and you have spaced selection.

Regarding defvarl, there is defvar too; defvarl means that the symbol is not marked special and so rebindings are lexical. Often, it is overkill for a global variable to support rebinding. We just pollute the symbol with the special marker and then have to namespace it or put earmuffs on it just in case, even though it is ever used that way.

Re:Practical Emacs Lisp by agumonkey on Friday September 11, 2015 @08:29PM (#10206819)
Oh I wasn't arguing that CL loop was a far better solution than while loops (unless you process too long lists). I just became very very+ fond of academic recursive style. Here's a singly-linear variant for fixed steps.

    (defun ab (l)
      "I'm too lazy to reverse the result back."
      (defun _ (l a b f)
	(if (null l)
	    (if f (list a b) (list b a))
	  (_ (cdr l) b (cons (car l) a) (not f))))
      (_ l nil nil t))

    (ab '())
    (ab '(1))
    (ab '(1 2))
    (ab '(1 2 3 4 5 6 7 8 9 10))
    ;; ((9 7 5 3 1) (10 8 6 4 2))
    (ab '(1 2 3 4 5 6 7 8 9 10 11))
    ;; ((11 9 7 5 3 1) (10 8 6 4 2))

I don't know how cute or ugly a solution for variable step could be though. `ab` is a nice partitioning building block, less general than every-nth surely.

ps: Straight from the land of wishful lisping

    (defun abn (l n)
      (defun ono (n)
	"builds a cons oo cycle of size n"
	'unicorn)
      (defun noo (c)
	"rotates a cons cycle by one"
	'unicorn)
      (defun cooons (c v)
	"cons v to the head of c"
	'unicorn)
      (defun _ (l c)
	(if (null l)
	    c
	  (_ (cdr l) (noo (cooons c (car l))))))
      (_ l (ono n)))
Re:Practical Emacs Lisp by klibertp on Saturday September 12, 2015 @06:00AM (#10207711)
Some Schemes - most notably Racket, which I use the most - allow for nested defines. Your code actually is a valid Racket code after polishing the differences in naming and syntax a bit:

    #lang racket

    (define-syntax-rule (defun name (arg ...) . body)
      (define (name arg ...) . body))
    (define nil null)
    (define t #t)

    (defun ab (l)
      ;; "I'm too lazy to reverse the result back."
      (defun _ (l a b f)
        (if (null? l)
            (if f (list a b) (list b a))
            (_ (cdr l) b (cons (car l) a) (not f))))
      (_ l nil nil t))

    (ab '())
    (ab '(1))
    (ab '(1 2))
    (ab '(1 2 3 4 5 6 7 8 9 10))
    ;; ((9 7 5 3 1) (10 8 6 4 2))
    (ab '(1 2 3 4 5 6 7 8 9 10 11))
    ;; ((11 9 7 5 3 1) (10 8 6 4 2))
...and you don't need to worry about recursion limits thanks to mandatory TCO.
Re:Practical Emacs Lisp by agumonkey on Saturday September 12, 2015 @06:40AM (#10207763)
Yeah, I spent too much time on scheme classes about recursive logic while using emacs lisp at the same time, hence the code above.
Re:Practical Emacs Lisp by lispm on Friday September 11, 2015 @11:56PM (#10207169)
Nested DEFUNs? Not in Lisp. In Common Lisp use LABELS for recursive local functions.

I'd avoid recursive code like that as much as possible.

I'd write:

    (defun ab (l)
      (loop while l collect (pop l) into a
            while l collect (pop l) into b
            finally (return (list a b))))
Re:Practical Emacs Lisp by agumonkey on Saturday September 12, 2015 @06:41AM (#10207765)
Oops, I forgot defun affected the global namespace.

Your last example is nice. I had to read the CLHS loop to have a clue about linearity of multiple termination clauses though :)

ps: funny, while googling I even found some lisp checker with a rule about nested defuns (## define-lisp-pattern nested-defuns)

http://www.cs.northwestern.edu/academics/courses/325/program...