lisp

I was trying to install SLIME. I downloaded the zipped package and according to the README file, I have to put this piece of code in my Emacs configuration file: (add-to-list 'load-path "~/hacking/lisp/slime/") ; your SLIME directory (setq inferior-lisp-program "/opt/sbcl/bin/sbcl") ; your Lisp system (require 'slime) (slime-setup) Setting the SLIME directory is straightforward, but what about the Lisp "system"? How do I find it? Some Linuxes come with CMUCL preinstalled, but since you seem to want to use SBCL, you would need to install it. In terminal, or in Emacs M-x shell . If you are using

what's the typical way to add an item to the end of the list? I have a list (1 2 3) and want to add 4 to it (where 4 is the result of an evaluation (+ 2 2)) (setf nlist '(1 2 3)) (append nlist (+ 2 2)) This says that append expects a list, not a number. How would I accomplish this? You could use append , but beware that it can lead to bad performance if used in a loop or on very long lists. (append '(1 2 3) (list (+ 2 2))) If performance is important, the usual idiom is building lists by prepending (using cons ), then reverse (or nreverse ). If the "cons at the front, finish by reversing"

I am trying to build a Lisp grammar. Easy, right? Apparently not. I present these inputs and receive errors... ( 1 1) 23 23 23 ui ui This is the grammar... %% sexpr: atom {printf("matched sexpr\n");} | list ; list: '(' members ')' {printf("matched list\n");} | '('')' {printf("matched empty list\n");} ; members: sexpr {printf("members 1\n");} | sexpr members {printf("members 2\n");} ; atom: ID {printf("ID\n");} | NUM {printf("NUM\n");} | STR {printf("STR\n");} ; %% As near as I can tell, I need a single non-terminal defined as a program, upon which the whole parse tree can hang. But I tried it

How do you emulate Python style generators in your favorite language? I found this one in Scheme. It must be interesting to see other implementations, especially in those languages that don't have first-class continuations. Here is an example in C++ that simulates generators using fibers: Yield Return Iterator for Native C++ Using Fibers The "yield return" iterator is a language feature that was created for one reason: simplicity. It is generally much easier to iterate across whole collectionl, storing all context needed in local variables, rather than crafting a complicated, custom iterator

Main question: I view the most significant application of tail call optimization (TCO) as a translation of a recursive call into a loop (in cases in which the recursive call has a certain form). More precisely, when translated into a machine language, this would usually be translation into some sort of series of jumps. Some Common Lisp and Scheme compilers that compile to native code (e.g. SBCL) can identify tail-recursive code and perform this translation. JVM-based Lisps such as Clojure and ABCL have trouble doing this. What is it about the JVM as a machine that prevents or makes this

I've seen several Scala questions recently (e.g. here , here , and here ) that called for the use of proxies, and it's come up more than once in my own work. The Scala library has a number of proxy traits (14, if I counted correctly). Proxy classes/traits usually contain lots of boilerplate: class FooProxy(val self: Foo) extends Foo { // added behavior def mymethod = ... // forwarding methods def method1 = self.method1 def method2(arg: String) = self.method2(arg) ... } trait Foo { def method1: Unit def method2(arg: String): Unit } My first thought was to define a Proxy[T] trait that could be

I'm reading Clojure Programming book by O'Reilly.. I came over an example of head retention. First example retains reference to d (I presume), so it doesnt get garbage collected: (let [[t d] (split-with #(< % 12) (range 1e8))] [(count d) (count t)]) ;= #<OutOfMemoryError java.lang.OutOfMemoryError: Java heap space> While second example doesnt retain it, so it goes with no problem: (let [[t d] (split-with #(< % 12) (range 1e8))] [(count t) (count d)]) ;= [12 99999988] What I don't get here is what exactly is retained in which case and why. If I try to return just [(count d)] , like this: (let [

I am reading the book 'Practical Common Lisp' by Peter Seibel. In Chapter 6, "Variables" sections "Lexical Variables and Closures" and "Dynamic, a.k.a. Special, Variables". http://www.gigamonkeys.com/book/variables.html My problem is that the examples in both sections show how (let ...) can shadow global variables and doesn't really tell the difference between the Dynamic and Lexical vars. I understand how closures work but I don't really get whats so special about let in this example: (defvar *x* 10) (defun foo () (format t "Before assignment~18tX: ~d~%" *x*) (setf *x* (+ 1 *x*)) (format t