LISP

There was a thread in comp.emacs.xemacs and alt.religion.emacs in which the idea of embedding Perl into Emacs was proposed. (My first-thoughts comment on this idea is that it's fairly silly, since Emacs already has a powerful lisp interpreter in it. Lisp is odd, though, in that it's a vastly more regular language than Perl, yet arguably less readable. But I digress...).

I disagree. Perl is a regular expression.

ED! ED!

they should have just used munger¹ instead.

_{References:
1: http://www.mammothcheese.ca/man.html}

>>4
HOLY SHIT.
BEST. LANGUAGE. EVER.
It's like perl, but much more evil.
     Munger is a simple, statically-scoped, naively-implemented, interpreted
     lisp, specialized for writing text processors for 8-bit text.
     Munger can manipulate strings with regular expressions, perform limited
     magnitude integer arithmetic, and communicate with child processes and
     remote hosts.
   eval_buffer: (eval_buffer)
     The "eval_buffer" intrinsic evaluates Munger lisp in the current buffer.
     The function accepts no arguments.  The buffer is evaluated in the cur-
     rent lexical context.  Recursive invocations of "eval_buffer" are not
     permitted, which is to say the code in the current buffer (or any other
     code it invokes) may not itself invoke "eval_buffer" while "eval_buffer"
     is running.  If the code in the current buffer messes with itself by
     altering the content of the current buffer, disaster may result; however,
     the code in the current buffer may open new buffers as it likes without
     fear.  The "eval_buffer" function will continue to parse the code in the
     buffer which was current when it was invoked.  The function returns the
     result of evaluating the last expression in the buffer upon success, or 0
     if a recursive invocation is attempted or if the current buffer is empty.
     Any errors encountered during evaluation of the code in the buffer will
     stop evaluation.

   eval_string: (eval_string expr)
   blind_eval_string: (blind_eval_string expr)
     Both the "eval_string" and "blind_eval_string" accept one argument which
     must evaluate to a string, and attempt to execute the string as lisp.
     Any error encountered will stop evaluation of the string, but the inter-
     preter will attempt to carry on interpreting the rest of your program.
     Your program may be in a "messed-up" state from the badly-behaved code
     parsed from the string, which may cause the interpreter to encounter
     another error which stops evaluation when it attempts to continue inter-
     preting your program.  Both functions return the result of evaluating the
     last successfully-evaluated expression parsed from the string.  If no
     expressions are successfully-evaluated, then the original string will be
     returned.

Lain.