Hi,

I'm new to lis[t,p] :) I'm looking for help with slime/sbcl. Slime says:

Lisp connection closed unexpectedly;

* ;; Connection to Emacs lost. ;; [ debugger invoked on a SIMPLE-ERROR in thread #<THREAD "control-thread" {9B9D269}>: #<SB-SYS:FD-STREAM for "a constant string" {9A593C9}> is closed.

debugger invoked on a SIMPLE-ERROR in thread #<THREAD "auto-flush-thread" {9B92CA1}>: #<SB-SYS:FD-STREAM for "a constant string" {9A593C9}> is closed.

when i try to compile and load my lisp examples file (see attachments). I've seen a similar bug with cmucl on the list but i'm not sure if it is the same. It was about long files, this file is 307 lines long.

I'm using slime-cvs along with emacs 22.0.50.1 on linux with nptl-only glibc.

thnx in advance. evrim.

(in-package :cl-user)

(defun fun (x) (list 3 (expt (car x) 2)))

(defmacro nil! (var) (list 'setq var nil))

(defun longer-than (x y) (> (length x) (length y)))

(defun addlength (x) (cons (length x) x))

;;(defun crank-call (caller callee) ;; '(hello callee this is caller calling))

(defun double (n) (* n 2))

(defun quad (n) (double (double n)))

(defun stooge (larry moe curly) (list larry (list moe curly) curly 'larry))

(defun ms (x) (list (second x) (first x)))

(defun if-test (x) (if (symbolp x) (list '(what the fuck?)) (list '(fuck the world!))))

(defun cond-test (x) (cond ((> x 0) x) ((< x 0) (- x))))

(defun variable-scope-test (x) (setf x (+ x 2)))

(defun intersect2 (x y) (intersection x y))

(defun union2 (x y) (union x y))

(defun diff2 (x y) (set-difference x y))

(defun export_list () (setf *assoc-list1* '((key1 . val1) (key2 . val2) (key3 . val3))))

(defun assoc1 (x) (cdr (assoc x *assoc-list1*)))

(defun rassoc1 (x) (car (rassoc x *assoc-list1*)))

(defun export_list2 () (setf *list2* '((key1 valX val10 val11) (key2 valX val20 val21))))

(defun set-xor (x y) (set-exclusive-or (rest (assoc x *list2*)) (rest (assoc y *list2*))))

;;; (remove-dups '(a a b c)) (defun remove-dups (x) (remove-duplicates x))

(defun substt (F G) (let ((y '(a b c))) (subst G F y)))

(defun let-test (x y) (let ((a 1) (b 2)) (+ a b x y)))

;;; CL-USER> (subliss '(A . X) '(B . Y)) ;;; (X Y C) (defun subliss (F G) (let ((y '(A B C)) (final-list (cons F (list G))) ) ;; (sublis '((A . X) (B . Y) (C . Z)) y))) (sublis final-list y))) ;; (listp final-list)))

;;;· EQ is the fastest equality test: It compares addresses. Experts use ;;;it to compare symbols quickly, and to test whether two cons cells ;;;are physically the same object. It should not be used to compare ;;;numbers. ;;;· EQL is like EQ except it can safely compare numbers of the same ;;;type, such as two integers or two floating point numbers. It is the ;;;default equality test in Common Lisp. ;;;· EQUAL is the predicate beginners should use. It compares lists ;;;element by element; otherwise it works like EQL. ;;;· EQUALP is more liberal than EQUAL: It ignores case distinctions ;;;in strings, among other things. ;;;· = is the most efficient way to compare numbers, and the only way ;;;to compare numbers of disparate types, such as 3 and 3.0. It only ;;;accepts numbers.

(defun member-equal (x) (let ((l '((3 kupa) (5 karo) (as maca)))) (member x l :test #'equal)))

(defun remove-equal (x) (let ((l '((3 kupa) (5 karo) (as maca)))) (remove x l :test #'equal)))

(defun squ (x) (* x x))

;; (mapcar-test #'squ) ;; (1 4 9) (defun mapcar-test (x) (let ((y '(1 2 3))) (mapcar x y)))

(defun mapcar-test2 () (mapcar #'(lambda (n) (* n n)) '(1 2 3)))

;; also, (setf fn #'cons) etc.

;; CL-USER> (my-assoc 'A) ;; (A 1) (defun my-assoc (key) (let ((y '((A 1) (B 2) (C 3)))) (find-if #'(lambda (entry) (equal key (first entry))) y)))

;;CL-USER> (my-assoc-remove-if 'A) ;;((B 2) (C 3)) ;; see also remove-if-not (defun my-assoc-remove-if (key) (let ((y '((A 1) (B 2) (C 3)))) (remove-if #'(lambda (entry) (equal key (first entry))) y)))

;; CL-USER> (reducee) ;; 6 (defun reducee () (let ((y '(1 2 3))) (reduce #'+ y)))

;; CL-USER> (everyy) ;; T (defun everyy () (let ((y '(1 2 3 4 5))) (every #'numberp y)))

;; CL-USER> (everyyy) ;; NIL ;; also, (every #'> '(10 20 30 40) '(1 2 3 4)) (defun everyyy () (let ((y '(1 2 3 4 5))) (every #'oddp y)))

;; (trace everyyy), (untrace everyyy)

;; CL-USER> (map-car2) ;; (11 22 33) (defun map-car2 () (let ((y '(1 2 3)) (x '(10 20 30))) (mapcar #'+ y x)))

;; (setf pred (make-greater-than-predicate 3)) ;; (funcall pred 2) => nil ;; (funcall pred 4) => t (defun make-greater-than-predicate (n) #'(lambda (x) (> x n)))

;; RECURSION

;; compares first if its odd, returns. ;; double-test tail recursion (defun anyoddp (x) (cond ((null x) nil) ((oddp (first x)) t) (t (anyoddp (rest x)))))

;; augmented tail recursion ;; means accumulation of recursive data ;; CL-USER> (count-slices '(A B C)) ;; 3 (defun count-slices (x) (cond ((null x) 0) (t (+ 1 (count-slices (rest x))))))

;; list-consing recursion ;; constructs(cons) list every time (defun laugh (n) (cond ((zerop n) nil) (t (cons ’ha (laugh (- n 1))))))

;; binary tree gezelim ;; CL-USER> (atoms-to-q '(A B (C D (E)))) ;; (Q Q (Q Q (Q))) (defun atoms-to-q (x) (cond ((null x) nil) ((atom x) 'q) (t (cons (atoms-to-q (car x)) (atoms-to-q (cdr x))))))

;; loop-infinitely for (rest equals nil) (defun any-7-p (x) (cond ((equal (first x) 7) t) (t (any-7-p (rest x)))))

(defun flattenn (x result) (cond ((null x) nil) ((atom x) (list x)) (t (append (flattenn (car x) result) (flattenn (cdr x) result)))))

;; INPUT/OUTPUT (defun 0utput () (progn (format t "xxx newline~&this is newline") (format t "this is a S-exp: ~S" 'cemisgezek)))

;; > (test "Hi, mom") ;; With escape characters: "Hi, mom" ;; Without escape characters: Hi, mom ;; NIL (defun 0utput2 (x) (format t "~&With escape characters: ~S" x) (format t "~&Without escape characters: ~A" x))

(defun draw-line () (format t "~&---------------------"))

(defun draw-three (x) (format t "~& ~A | ~A | ~A~%" (filter (first x)) (filter (second x)) (filter (third x))))

(defun filter (x) (cond ((equal x nil) " ") (t x)))

(defun draw-three2 (x) (format t "~& ~A | ~A | ~A~%" (first (filter2 x)) (second (filter2 x)) (filter2 (third x))))

(defun filter2 (x) (sublis '((nil . "")) x))

;; CL-USER> (draw-board '(X 0 NIL X 0 NIL X 0 NIL)) ;; X | 0 | ;;--------------------- ;; X | 0 | ;;--------------------- ;; X | 0 | (defun draw-board (x) (draw-three2 x) (draw-line) (draw-three (nthcdr 3 x)) (draw-line) (draw-three (nthcdr 6 x)))

;; read input (defun what-da () (format t "~&enter number:") (let ((x (read))) (format t "~&entered: ~A" x)))

(defun hashh() (let ((gee (make-hash-table))) ; (setf gee (make-hash-table)) (setf (gethash 'evrim gee) "i am your worst nightmare!") (format t "HASH VALUE: ~A~%" (gethash 'evrim gee)) (describe gee)))

(defmacro simple-incf (var) (list 'setq var (list '+ var 1)))

(defmacro set-zero (&rest variables) `(progn ,@(mapcar #'(lambda (var) (list 'setf var 0)) variables) '(zeroed ,@variables)))

;; DECLARE special ;; (setf x 2) ;; declaretest => 2 (defun declaretest () (let ((x 1)) (locally (declare (special x)) x)))