root/lang/c/misc/mlisp/lib.l @ 5974

(setq list
      (lambda (nil . rest)
        rest))

(defmacro defun (fname arg body)
  (list 'setq fname
        (list 'lambda arg body)))

(defun funcall (fn . x)
  (apply fn x))

(defun null (x) (eq x nil))

(defun not (x) (eq x nil))

(defun consp (x) (not (atom x)))
(defun listp (x)
  (cond ((null x) t)
        ((consp x) t)
        (t nil)))

(defun caar (x) (car (car x)))
(defun cdar (x) (cdr (car x)))

(defun >  (x y) (< y x))
(defun >= (x y) (not (< x y)))
(defun <= (x y) (not (< y x)))
(defun =  (x y) (eq x y))
(defun /= (x y) (not (eq x y)))

; ���₵��
(defmacro all (x)
  (cond ((null x) t)
        ((car x) (list all (cdr x)))
        (t nil)))

; ���₵��
(defmacro any (x)
  (cond ((null x) nil)
        ((car x) t)
        (t (list any (cdr x)))))

(defun length (ls)
  (cond ((null ls) 0)
        (t (+ 1 (length (cdr ls))))))

(defun mapcar (fn ls)
  (cond ((eq ls nil) nil)
        (t (cons (fn (car ls))
                 (mapcar fn (cdr ls))))))


(defun zerop (x) (eq x 0))
(defun evenp (x) (eq (% x 2) 0))
(defun oddp  (x) (eq (% x 2) 1))

(defun inc (x) (+ x 1))
(defun dec (x) (- x 1))


; �Q�‚̃��X�g�������(defun concat (x y)
  (cond ((null x) y)
        (t (cons (car x)
                 (concat (cdr x) y)))))

; �C�ӌ‚̃��X�g�������(defun append (nil . x)
  (cond ((cdr x) (concat (car x)
                         (apply append (cdr x))))
        (t (car x))))



; ������

;(defmacro if (p tbody ebody)
;  (list
;   'cond (list p tbody)
;   (list t ebody)))

;(defmacro if (p tbody ebody)
;  (cond (p tbody)
;        (t ebody)))

(defmacro if (test then else)
  (cons cond (cons (list test then)
                   (cond (else (list (list t else)))))))