lisp

I've heard it referred to as a stream , as an infinite list , and sometimes even as a lazy sequence . What is the correct term for the following pattern? (Clojure code shown) (def first$ first) (defn second$ [str] (cond (empty? str) () true ((first (rest str))))) (defn stream-builder [next_ n] (cons n (cons (fn [] (stream-builder next_ (next_ n))) ()))) (defn stream [str n] (cond (= 0 n) () true (cons (first$ str) (stream (second$ str) (- n 1))))) (def odd (stream-builder (fn [n] (+ 2 n))1)) (println (stream odd 23)) > (1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45) Short

I am trying to load a file in Lisp from a file in the same directory using a relative path. My file structure looks like this: repo/ subdir/ main.lisp test.lisp In main.lisp I have a number of function definitions, and in test.lisp I want to test the functions. I have tried using (load "main.lisp") and (load "main") in test.lisp , as well as a number of variations on the pathname (i.e., including ./ before the filename) but both times I get the following error (where <filename> is the filename passed to the load function): File-error in function LISP::INTERNAL-LOAD: "<filename>" does not exist

I want to define a method that will specialize on an object of array type with unsigned byte 8 elements. In sbcl, when you (make-array x :element-type '(unsigned-byte 8)) the object class is implemented by SB-KERNEL::SIMPLE-ARRAY-UNSIGNED-BYTE-8. Is there an implementation independent way of specializing on unsigned-byte array types? Use a sharpsign-dot to insert the implementation dependent object class at read-time: (defmethod foo ((v #.(class-of (make-array 0 :element-type '(unsigned-byte 8))))) :unsigned-byte-8-array) The sharpsign-dot reader macro evaluates the form at read-time,

I'm trying to write a Common Lisp function that will give me all possible permutations of a list, using each element only once. For example, the list '(1 2 3) will give the output ((1 2 3) (1 3 2) (2 1 3) (2 3 1) (3 1 2) (3 2 1)). I already wrote something that kind of works, but it's clunky, it doesn't always work and I don't even really understand it. I'm not asking for code, just maybe for some guidance on how to think about it. I don't know much about writing algorithms. Thanks, Jason Vatine As a basic approach, "all permutations" follow this recursive pattern: all permutations of a list L

Can you name languages with static type checking (like Java) and where code is data (like in LISP)? I mean both things in one language. Qi is a statically-typed Lisp dialect. Also, many other Lisp dialects have (optional) static typing. Java itself has very limited capabilities of this kind. The interesting question is not so much whether you can have metaprogramming and static typing, it's whether you can have dynamic metaprogramming be statically type-safe . There is Template Haskell which does metaprogramming and is type-safe, but it is static metaprogramming. At the moment I can not think