Emacs Lisp

鐃緒申鐃殉まに書き誌申鐃初か鐃緒申鐃緒申鐃緒申鐃述￥申

鐃緒申鐃�:

fold (鐃所ス鐃夙の常申鐃淳刻申鐃緒申)

Scheme 鐃塾高階鐃舜随申 fold 鐃緒申撞鐃緒申納鐃緒申鐃緒申鐃緒申討澆茲�申鐃�kons 鐃緒申2鐃緒申鐃緒申鐃塾関随申鐃夙わ申鐃緒申knil 鐃熟緒申鐃緒申諭鐃�ls 鐃熟リス鐃夙でわ申鐃暑。鐃所ス鐃夙の鰹申鐃緒申鐃叔わ申 e1,e2,e3...en 鐃夙わ申鐃緒申函鐃緒申鐃獣種申鐃緒申鐃緒申鐃� e1 鐃緒申鐃緒申鐃緒申 knil 鐃緒申 kons 鐃緒申鐃緒申鐃緒申鐃祝削申鐃緒申鐃緒申鐃祝とわ申譴随申鐃緒申任鐃緒申鐃緒申鐃重�申鐃� kons 鐃緒申鐃銃行わ申(鐃緒申鐃淳刻申鐃緒申嚢圓鐃�)鐃緒申fold 鐃熟種申鐃塾件申未鐃緒申屬鐃緒申鐃�

(kons en (kons 鐃緒申 (kons e3 (kons e2 (kons e1 knil))) 鐃緒申 ))

fold-right 鐃熟￥申鐃緒申端鐃緒申鐃緒申鐃緒申 en 鐃緒申鐃緒申鐃緒申 knil 鐃緒申 kons 鐃緒申鐃緒申鐃緒申鐃祝縁申鐃緒申鐃緒申鐃祝とわ申譴随申鐃緒申任鐃緒申鐃緒申鐃重�申鐃� kons 鐃緒申鐃銃行わ申鐃緒申

(kons e1 (kons e2 (kons e3 鐃緒申 (kons en knil) 鐃緒申 )))

foldl 鐃塾種申鐃緒申(鐃緒申鐃緒申鐃塾リス鐃夙わ申1鐃緒申)

(defun foldl (kons knil ls)
  (if (null ls)
      knil
    (foldl kons (funcall kons (car ls) knil) (cdr ls))))

(foldl 'cons nil '(1 2 3))
=>(3 2 1)

;; trace
1 -> foldl: kons=cons knil=nil ls=(1 2 3)
| 2 -> foldl: kons=cons knil=(1) ls=(2 3)
| | 3 -> foldl: kons=cons knil=(2 1) ls=(3)
| | | 4 -> foldl: kons=cons knil=(3 2 1) ls=nil
| | | 4 <- foldl: (3 2 1)
| | 3 <- foldl: (3 2 1)
| 2 <- foldl: (3 2 1)
1 <- foldl: (3 2 1)

foldr 鐃塾種申鐃緒申(鐃緒申鐃緒申鐃塾リス鐃夙わ申1鐃緒申)

(defun foldr (kons knil ls)
  (if (null ls)
      knil
    (funcall kons (car ls) (foldr kons knil (cdr ls)))))

(foldr 'cons nil '(1 2 3))
=>(1 2 3)

;; trace
1 -> foldr: kons=cons knil=nil ls=(1 2 3)
| 2 -> foldr: kons=cons knil=nil ls=(2 3)
| | 3 -> foldr: kons=cons knil=nil ls=(3)
| | | 4 -> foldr: kons=cons knil=nil ls=nil
| | | 4 <- foldr: nil
| | 3 <- foldr: (3)
| 2 <- foldr: (2 3)
1 <- foldr: (1 2 3)

foldr 鐃塾再居申鐃緒申鐃緒申鐃祝わ申鐃緒申鐃緒申鐃緒申鐃塾わ申覆鐃緒申鐃緒申鐃緒申佑泙任鐃銃縁申鐃緒申茲�申丙撞鐃緒申廛鐃緒申鐃緒申鐃緒申鐃獣�申鐃盾階鐃舜随申鐃緒申佑鐃緒申討澆襦ｏ申螢刻申箸留鐃渋�申鐃緒申鐃舜随申鐃緒申適鐃術わ申鐃銃行わ申鐃塾わ申名鐃緒申鐃緒申 mapc-right 鐃夙わ申鐃緒申鐃緒申鐃緒申鐃塾関随申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申的鐃淑ので￥申kons 鐃塾よう鐃緒申鐃瞬わ申鐃粛わ申貼鐃緒申鐃緒せ鐃緒申劼鐃緒申覆鐃緒申鐃�

(defun mapc-right (func ls)
  (unless (null ls)
    (mapc-right func (cdr ls))
    (funcall func (car ls))))

(mapc-right 'insert '("a" "b" "c"))
cba
=>nil

;; trace
1 -> mapc-right: func=insert ls=("a" "b" "c")
| 2 -> mapc-right: func=insert ls=("b" "c")
| | 3 -> mapc-right: func=insert ls=("c")
| | | 4 -> mapc-right: func=insert ls=nil
| | | 4 <- mapc-right: nil
| | 3 <- mapc-right: nil
| 2 <- mapc-right: nil
1 <- mapc-right: nil

;; 鐃緒申鐃緒申
(mapc 'insert '("a" "b" "c"))
abc
=>("a" "b" "c")

fold 鐃塾誌申鐃緒申鐃緒申

(foldl '+ 0 '(1 2 3 4 5 6 7 8 9 10))
=>55

(foldl '* 1 '(1 2 3 4 5 6 7 8 9 10))
=>3628800

;; reverse
(foldl 'cons nil '(1 2 3 4 5 6 7 8 9 10))
=>(10 9 8 7 6 5 4 3 2 1)

;; 鐃春緒申暴鐃緒申鐃�
(foldr (lambda (x k) (princ x (current-buffer))) nil '(1 2 3))
321

fold (反鐃緒申)

鐃緒申鐃獣わ申鐃緒申鐃銃居申鐃緒申 fold 鐃緒申鐃緒申鐃緒申鐃緒申討鐃� Emacs Lisp 鐃叔は再居申鐃緒申鐃夙わ申鐃緒申鐃緒申未聾造鐃緒申襦ｏ申竸鐃� max-lisp-eval-depth 鐃叔再居申鐃塾随申鐃緒申鐃緒申鐃緒申鐃渋わ申鐃緒申討鐃緒申襦ｏ申鐃緒申鐃緒申討喀个鐃緒申鐃緒申鐃重�申鐃緒申鐃緒申鐃暑こ鐃夙わ申覆鐃緒申鐃緒申鐃緒申鐃叔わ申 fold 鐃熟使わ申鐃淑わ申鐃緒申反鐃緒申鐃緒申文鐃緒申箸辰鐃� fold 鐃緒申鐃縦常申鐃緒申鐃緒申鐃�

foldl 鐃塾種申鐃緒申(鐃緒申鐃緒申鐃塾リス鐃夙わ申1鐃緒申)

;; cl-do 1
(defun foldl (kons knil ls)
  (do ((ls ls (cdr ls))
       (knil knil (funcall kons (car ls) knil)))
      ((null ls) knil)))

;; cl-do 2
(defun foldl (kons knil ls)
  (do ((ls ls (cdr ls)))
      ((null ls) knil)
    (setq knil (funcall kons (car ls) knil))))

;; while
(defun foldl (kons knil ls)
  (while ls
    (setq knil (funcall kons (car ls) knil))
    (pop ls))
  knil)

;; dolist
(defun foldl (kons knil ls)
  (dolist (x ls knil)
    (setq knil (funcall kons x knil))))

;; mapc
(defun foldl (kons knil ls)
  (mapc (lambda (x) (setq knil (funcall kons x knil))) ls)
  knil)

foldr 鐃塾種申鐃緒申

(defun foldr (kons knil ls)
  (foldl kons knil (reverse ls)))

iota

Scheme 鐃緒申 iota 鐃舜随申鐃緒申撞鐃緒申鐃緒申鐃緒申鐃緒申鐃銃みよう鐃緒申

(defun iota (count &optional start step)
  (let ((start (or start 0))
        (step (or step 1)))
    (if (<= count 0)
        nil
      (cons start (iota (- count 1) (+ start step) step)))))

CL 鐃緒申 defun* 鐃緒申箸鐃緒申弌鐃緒申鐃緒申廛鐃緒申鐃淑ワ申鐃緒申鐃緒申縫妊侫鐃緒申鐃緒申鐃粛わ申鐃緒申蠅刻申襪鰹申箸鐃緒申任鐃緒申襦�

(defun* iota (count &optional (start 0) (step 1))
  (if (<= count 0)
      nil
    (cons start (iota (- count 1) (+ start step) step))))

;; cl-labels
(defun* iota (count &optional (start 0) (step 1))
  (labels ((rec (count start)
             (if (= count 0)
                 nil
               (cons start (rec (- count 1) (+ start step))))))
    (rec count start)))

鐃緒申鐃�3鐃縦は再居申鐃淑のわ申 Emacs 鐃叔は使わ申鐃淑わ申鐃緒申鐃緒申鐃緒申鐃獣ワ申鐃緒申鐃緒申鐃出￥申鐃春ワ申鐃緒申鐃緒申発鐃緒申鐃緒申鐃緒申鐃緒申鐃祝ワ申鐃初ー鐃叔止まってわ申鐃殉わ申鐃緒申max-lisp-eval-depth 鐃塾緒申鐃緒申佑鐃� 300 鐃叔わ申鐃暑。

(iota 100)
Debugger entered--Lisp error: (error "Lisp nesting exceeds `max-lisp-eval-depth'")

反鐃緒申鐃緒申文鐃緒申箸辰討鐃緒申鐃緒申弔鐃緒申颪い討澆鐃緒申鐃�

;; while
(defun iota (count &optional start step)
  (let ((start (or start 0))
        (step (or step 1))
        (result nil))
    (while (> count 0)
      (setq result (cons start result)
            start (+ start step)
            count (- count 1)))
    (nreverse result)))

;; dotimes
(defun iota (count &optional start step)
  (let ((start (or start 0))
        (step (or step 1))
        (ans nil))
    (dotimes (x count (nreverse ans))
      (push start ans)
      (setq start (+ start step)))))

;; cl-do
(defun* iota (count &optional (start 0) (step 1))
  (do ((count count (- count 1))
       (start start (+ start step))
       (acc nil (cons start acc)))
      ((<= count 0) (nreverse acc))))

;; foldl
(defun* iota (count &optional (start 0) (step 1))
  (nreverse
   (foldl (lambda (x k) (cons (+ (car k) step) k))
          (list start)
          (make-list (- count 1) nil))))

Scheme 鐃緒申 SLIB 鐃緒申鐃緒申鐃緒申鐃緒申鐃銃わ申鐃緒申鐃塾￥申list-tabulate 鐃緒申箸辰討鐃緒申襦�

(defun list-tabulate (len proc)
  (do ((i (- len 1) (- i 1))
       (ans '() (cons (funcall proc i) ans)))
      ((< i 0) ans)))

(defun iota (count &rest args)
  (let ((start (if (null args) 0 (car args)))
        (step (if (or (null args) (null (cdr args))) 1 (cadr args))))
    (list-tabulate count (lambda (idx) (+ start (* step idx))))))

(list-tabulate 10 (lambda (i) (sqrt (1+ i))))
=>(1.0 1.4142135623730951 1.7320508075688772 2.0 2.23606797749979 ...)

factorial (鐃緒申鐃緒申)

鐃緒申鐃緒申鐃竣誌申鐃緒申鐃緒申撞鐃緒申愎鐃� factorial 鐃熟種申鐃塾よう鐃淑わ申里鐃緒申鐃�Emacs Lisp 鐃叔わ申動鐃庶す鐃暑。

(defun factorial (n)
  (if (= n 1)
      1
    (* n (factorial (- n 1)))))

鐃緒申鐃緒申鐃緒申鐃緒申Emacs Lisp 鐃塾常申隋�申撞鐃緒申鐃緒申鐃緒申造鐃緒申鐃緒申飽鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申楼呂鐃縦駈申鐃緒申討鐃緒申泙鐃緒申里如鐃�11鐃塾鰹申鐃緒申泙任鐃緒申鐃緒申彁鐃緒申任鐃緒申覆鐃緒申辰鐃緒申鐃�12鐃塾鰹申鐃緒申鐃� 479001600 鐃祝なわ申覆鐃緒申箸鐃緒申鐃緒申覆鐃緒申鐃�

(factorial 11)
=>39916800

(factorial 12)
=>-57869312

29鐃俊ットわ申2鐃緒申鐃緒申鐃緒申鐃塾削申鐃緒申鐃粛わ申10鐃淑わ申268435455鐃祝なる。鐃緒申鐃緒申鐃�1鐃緒申足鐃緒申鐃緒申-268435456鐃祝なり、鐃殉ニュア鐃緒申砲鐃緒申个鐃緒申譴� Emacs 鐃塾逸申鐃緒申鐃緒申鐃緒申鐃緒申鐃塾最常申鐃緒申鐃熟囲でわ申鐃暑。(GNU Emacs 22.1.1)

;; 鐃緒申鐃緒申鐃緒申
(1- (expt 2 28))
=>268435455

#b01111111111111111111111111111
=>268435455

(foldl (lambda (x k) (+ (expt 2 x) k)) 0 (iota 28 0))
=>268435455

;; 鐃叔常申鐃緒申
(expt 2 28)
=>-268435456

#b10000000000000000000000000000
=>-268435456

(1+ (foldl (lambda (x k) (+ (expt 2 x) k)) 0 (iota 28 0)))
=>-268435456

const (鐃緒申鐃緒申鐃緒申屬鐃緒申愎鐃緒申鐃緒申屬鐃�)

(defun const (x) (lexical-let ((x x)) (lambda (i) x)))

(defun const (x) `(lambda (i) ,x))

(list-tabulate 10 (const 1))
=>(1 1 1 1 1 1 1 1 1 1)

compose (鐃舜随申鐃塾刻申鐃緒申)

鐃緒申鐃塾わ申 f 鐃緒申 g 鐃塾刻申鐃緒申鐃舜随申鐃緒申鐃瞬わ申鐃緒申f 鐃緒申 g 鐃緒申1鐃緒申鐃緒申鐃舜随申鐃叔￥申鐃瞬わ申鐃曙た鐃舜随申鐃緒申1鐃緒申鐃緒申鐃舜随申鐃緒申

(defun compose (f g)
  (lexical-let ((f f) (g g))
    (lambda (x) (funcall f (funcall g x)))))

(defun compose (f g)
  `(lambda (x) (funcall #',f (funcall #',g x))))

(defun compose (f g)
  `(lambda (x) (funcall (function ,f) (funcall (function ,g) x))))

(list-tabulate 10 (compose 'sqrt '1+))
=>(1.0 1.4142135623730951 1.7320508075688772 2.0 2.23606797749979 ...)

鐃緒申鐃駿は￥申On Lisp 鐃緒申鐃緒申鐃緒申鐃緒申鐃銃わ申鐃緒申 compose 鐃緒申 foldr 鐃叔種申鐃緒申鐃緒申鐃銃みわ申鐃緒申鐃緒申鐃緒申蓮鐃緒申埜鐃塾関随申鐃淑鰹申鐃緒申1鐃緒申鐃緒申鐃舜随申鐃緒申任鐃春の随申鐃塾関随申鐃緒申鐃緒申鐃緒申任鐃緒申襦ｏ申屬鐃緒申佑隆愎鐃緒申琉鐃緒申鐃緒申郎埜鐃塾関随申鐃塾逸申鐃緒申鐃緒申同鐃緒申鐃緒申

(defun compose (&rest fns)
  (if fns
      (lexical-let ((fns fns))
        (lambda (&rest args)
          (foldr #'funcall (apply (car (last fns)) args) (butlast fns))))
    #'identity))

鐃緒申鐃祝￥申compose 鐃緒申箸辰鐃� complement 鐃緒申鐃緒申鐃緒申鐃緒申討澆襦�

(defun complement (pred)
  (compose #'not pred))

(mapcar (complement 'evenp) '(1 2 3))       ;=> (t nil t)
(mapcar* (complement '=) '(1 2 3) '(1 1 3)) ;=> (nil t nil)

any-pred

Scheme 鐃緒申 any-pred 鐃緒申鐃緒申鐃緒申鐃緒申討澆鐃緒申鐃�

(defun any-pred (&rest pred)
  (lexical-let ((pred pred))
    (lambda (&rest args)
      (block nil
        (mapc (lambda (f)
                (let ((r (apply f args)))
                  (and r (return r))))
              pred)
        nil))))

(fset 'string-or-symbol? (any-pred 'stringp 'symbolp))

(string-or-symbol? "abc")                 ;=>t
(string-or-symbol? 'abc)                  ;=>t
(string-or-symbol? 3)                     ;=>nil

(fset '<> (any-pred '< '>))

(<> 3 4)                            ;=>t
(<> 3 3)                            ;=>nil

(funcall (any-pred (lambda (x) (memq x '(a b c)))
                   (lambda (x) (memq x '(1 2 3))))
         'b)
=>(b c)

every-pred

同鐃緒申鐃緒申 every-pred 鐃緒申

(defun every-pred (&rest pred)
  (lexical-let ((pred pred))
    (lambda (&rest args)
      (block nil
        (let (ans)
          (mapc (lambda (f)
                  (or (setq ans (apply f args))
                      (return ans)))
                pred)
          ans)))))

(defun positive? (x) (> x 0))
(defun negative? (x) (< x 0))

(funcall (every-pred 'oddp 'positive?) 3)  ;=> t
(funcall (every-pred 'oddp 'positive?) 4)  ;=> nil
(funcall (every-pred 'oddp 'positive?) -3) ;=>nil

(fset 'my-safe-length (every-pred 'listp 'length)) ;safe-length 鐃緒申 Emacs 鐃祝わ申鐃暑。
(my-safe-length '(a b c))                 ;=> 3
(my-safe-length "aaa")                    ;=> nil

and=>

鐃緒申鐃暑式鐃緒申評鐃緒申鐃緒申鐃緒申鐃緒申未鐃緒申鐃緒申里箸鐃緒申砲鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申佑鐃夙って駕申鐃初か鐃塾緒申鐃緒申鐃薯しわ申鐃緒申鐃緒申腓�申鐃緒申襦�Emacs Lisp 鐃叔は￥申評鐃緒申鐃粛で局緒申鐃術随申鐃緒申束鐃緒申鐃緒申鐃銃わ申鐃緒申鐃銃￥申鐃緒申鐃緒申鐃緒申鐃渋�申鐃緒申竸鐃緒申鐃夙っわ申分鐃緒申鐃緒申鐃緒申鐃緒申颪�鐃緒申箸砲覆鐃夙思わ申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申scheme 鐃淑わ申 cond 鐃緒申鐃緒申鐃夙わ申鐃暑。

(cond (expr => func))

Emacs Lisp 鐃塾常申隋�

(let ((var expr))
  (and var
       (funcall func var)))

鐃殉ワ申鐃緒申鐃緒申颪い討澆鐃緒申鐃�expr 鐃緒申評鐃緒申鐃粛わ申鐃緒申鐃塾常申鐃�*鐃塾わ申*鐃緒申鐃緒申鐃緒申鐃粛わ申 func 鐃緒申討鐃緒申鐃緒申未鐃� and=> 鐃緒申評鐃緒申鐃粛となる。expr 鐃緒申鐃粛わ申 nil 鐃淑わ申 nil 鐃緒申鐃瞬わ申鐃緒申

(defmacro and=> (expr func)
  (let ((var (make-symbol "var")))
    `(let ((,var ,expr))
       (and ,var (funcall ,func ,var)))))

(and=> t (const 1))                ;=> 1
(and=> nil (const 1))              ;=> nil

and=> 鐃緒申箸辰鐃� any-pred 鐃緒申

(defun any-pred (&rest pred)
  (lexical-let ((pred pred))
    (lambda (&rest args)
      (block nil
        (mapc (lambda (f)
                (and=> (apply f args) (lambda (r) (return r))))
              pred)
        nil))))

let=>

and=> 鐃熟種申鐃緒申評鐃緒申鐃粛わ申愎鐃緒申鐃緒申呂鐃緒申鐃緒申鐃緒申鐃緒申鐃� let=> 鐃淑どわ申佑鐃緒申鐃緒申鐃夙思わ申鐃緒申鐃術随申 var 鐃緒申 expr 鐃緒申評鐃緒申鐃粛わ申束鐃緒申鐃緒申鐃銃￥申鐃緒申鐃塾常申鐃�*鐃塾わ申* body 鐃緒申評鐃緒申鐃緒申鐃暑。

(defmacro let=> (var expr &rest body)
  `(let ((,var ,expr))
     (when ,var
       ,@body)))

let=> 鐃緒申箸辰鐃� any-pred 鐃緒申

(defun any-pred (&rest pred)
  (lexical-let ((pred pred))
    (lambda (&rest args)
      (block nil
        (mapc (lambda (f) (let=> r (apply f args) (return r)))
              pred)
        nil))))

for-each

Scheme 鐃緒申 for-each 鐃緒申 Emacs Lisp 鐃緒申 mapc 鐃塾よう鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申的鐃叔使わ申鐃舜随申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃塾リス鐃夙わ申複鐃緒申鐃夙るこ鐃夙わ申鐃叔わ申鐃暑。TSPL 鐃緒申鐃緒申鐃緒申鐃緒申鐃銃わ申鐃緒申鐃塾わ申 Emacs Lisp 鐃叔書いてみわ申鐃緒申

(defun for-each (f ls &rest more)
  (do ((ls ls (cdr ls)) (more more (mapcar #'cdr more)))
      ((null ls))
    (apply f (car ls) (mapcar #'car more))))

鐃渋刻申鐃緒申

(let ((same-count 0))
  (for-each
   (lambda (x y)
     (if (= x y)
         (setq same-count (+ same-count 1))))
   '(1 2 3 4 5 6)
   '(2 3 3 4 7 6))
  same-count)
=>3

鐃緒申鐃緒申鐃緒申鐃緒申鐃� mapcar 鐃緒申動鐃緒申鐃熟っわ申鐃緒申肇鐃緒申瓠種申鐃緒申鐃緒申鐃緒申鐃宿わ申鐃緒申鐃緒申任鐃緒申襦�

(for-each (compose 'print '+) '(1 2 3) '(4 5 6) '(7 8 9))
12
15
18

ls = (1 2 3) : more = ((4 5 6) (7 8 9)) ;ls = ls       : more  = more
(apply f 1 (4 7))                       ;1  = (car ls) : (4 7) = (mapcar 'car more)
(f 1 4 7) =>12

ls = (2 3) : more = ((5 6) (8 9))       ;ls = (cdr ls) : more  = (mapcar 'cdr more)
(apply f 2 (5 8))                       ;2  = (car ls) : (5 8) = (mapcar 'car more)
(f 2 5 8) =>15

ls = (3) : more = ((6) (9))             ;ls = (cdr ls) : more  = (mapcar 'cdr more)
(apply f 3 (6 9))                       ;3  = (car ls) : (6 9) = (mapcar 'car more)
(f 3 6 9) =>18

map

鐃緒申鐃駿わ申 map 鐃緒申鐃緒申鐃緒申鐃緒申討澆茲�申鐃緒申泙鐃緒申楼鐃緒申鐃緒申離螢刻申箸鐃�1鐃縦の再居申鐃叔￥申

(defun map1 (f ls)
  (if (null ls)
      '()
    (cons (funcall f (car ls)) (map1 f (cdr ls)))))

(map1 (lambda (x) (* x x)) '(1 2 3))  ;=>(1 4 9)

反鐃緒申鐃緒申文鐃緒申箸辰討鐃緒申単鐃祝種申鐃緒申鐃叔わ申鐃暑。

(defun map1 (f ls)
  (do ((ls ls (cdr ls))
       (a nil (cons (funcall f (car ls)) a)))
      ((null ls) (nreverse a))))

(defun map1 (f ls)
  (let (a)
    (while ls
      (push (funcall f (car ls)) a)
      (pop ls))
    (nreverse a)))

(defun map1 (f ls)
  (let (a)
    (dolist (x ls (nreverse a))
      (push (funcall f x) a))))

複鐃緒申鐃塾リス鐃夙わ申箸鐃� map 鐃熟￥申鐃舜随申鐃緒申適鐃術わ申鐃緒申鐃緒申未鐃所ス鐃夙に緒申鐃緒申鐃出よい鐃塾で￥申for-each 鐃緒申鐃緒申鐃緒申鐃緒申蕕刻申鐃緒申鐃緒申鐃緒申任鐃緒申襦�CL 鐃緒申同名鐃塾関随申鐃緒申鐃緒申鐃緒申里如鐃縮常申鐃緒申鐃� map* 鐃夙わ申鐃緒申鐃緒申

(defun map* (f ls &rest more)
  (do ((ls ls (cdr ls)) (more more (mapcar #'cdr more))
       (a nil (cons (apply f (car ls) (mapcar #'car more)) a)))
      ((null ls) (nreverse a))))

鐃渋刻申鐃緒申

(map* 'car '((a b) (c d) (e f)))                       ;=>(a c e)
(map* 'cadr '((a b) (c d) (e f)))                      ;=>(b d f)
(map* 'cons '(a b c) '(d e f))                         ;=>((a . d) (b . e) (c . f))
(map* '+ '(1 2 3) '(4 5 6) '(7 8 9))                   ;=>(12 15 18)

fold (鐃所ス鐃夙の常申鐃淳刻申鐃緒申) 2

鐃緒申鐃緒申鐃塾リス鐃夙わ申複鐃緒申鐃夙るこ鐃夙わ申鐃叔わ申鐃緒申 fold 鐃緒申鐃緒申鐃緒申鐃緒申茲�申鐃�for-each 鐃緒申 map 鐃夙誌申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申任鐃緒申覆鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申塙佑鐃緒申鐃緒申鐃�knil 鐃緒申 kons 鐃緒申鐃淑わ申鐃緒申鐃緒申鐃術わ申鐃銃行わ申鐃夙わ申鐃緒申鐃緒申鐃緒申鐃緒申悩鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申粒謄螢刻申箸鐃縦刻申鐃緒申鐃銃縁申鐃緒申任鐃緒申鐃夙わ申鐃暑。

(defun fold (kons knil ls &rest more)
  (do ((ls ls (cdr ls)) (more more (mapcar #'cdr more))
       (knil knil (apply
                   kons
                   (apply #'list (car ls) (append (mapcar #'car more) (list knil))))))
      ((null ls) knil)))

quasiquote, unquote, unquote-splicing 鐃緒申箸鐃緒申个鐃緒申辰鐃緒申鐃書ける。

(defun fold (kons knil ls &rest more)
  (do ((ls ls (cdr ls)) (more more (mapcar #'cdr more))
       (knil knil (apply kons `(,(car ls) ,@(mapcar #'car more) ,knil))))
      ((null ls) knil)))

鐃渋刻申鐃緒申

(fold 'cons '() '(1 2 3))               ;=>(3 2 1)
(fold 'list '() '(1 2 3) '(4 5 6))      ;=>(3 6 (2 5 (1 4 nil)))
(fold '+ 0 '(1 2 3) '(4 5 6) '(7 8 9))  ;=>45
(fold 'acons '() '(1 2 3) '(4 5 6))     ;=>((3 . 6) (2 . 5) (1 . 4))

鐃緒申鐃緒申 fold-right 鐃緒申鐃緒申鐃緒申鐃緒申鐃潤、apply 鐃緒申箸鐃緒申鐃緒申箸鐃緒申廚鐃緒申發�申个鐃緒申鐃緒申鐃緒申鐃叔削申鐃緒申鐃緒申

(defun fold-right (kons knil ls &rest more)
  (apply #'fold kons knil (reverse ls) (mapcar #'reverse more)))

鐃渋刻申鐃緒申

(fold-right 'cons '() '(a b c d e))           ;=>(a b c d e)
(fold-right 'list '() '(1 2 3) '(4 5 6))      ;=>(1 4 (2 5 (3 6 nil)))
(fold-right '+ 0 '(1 2 3) '(4 5 6) '(7 8 9))  ;=>45
(fold-right 'acons '() '(1 2 3) '(4 5 6))     ;=>((1 . 4) (2 . 5) (3 . 6))

鐃淑常申鐃緒申鐃緒申鐃叔￥申mapcar 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃術みわ申 map* 鐃緒申箸辰討鐃緒申蠅�申圓鐃緒申鐃�

let1

Gauche 鐃緒申 let1 鐃緒申鐃夙てわ申鐃緒申鐃緒申鐃緒申鐃緒申Emacs Lisp 鐃叔わ申箸鐃緒申鐃緒申鐃緒申鐃�

(defmacro let1 (var expr &rest body)
  `(let ((,var ,expr))
     ,@body))

let 鐃緒申 lambda 鐃緒申鐃叔書けわ申里納鐃緒申里茲�申砲鐃緒申鐃緒申鐃叔わ申鐃暑。

(defmacro let1 (var expr &rest body)
  `((lambda (,var) ,@body) ,expr))

circular-list

鐃循環リス鐃夙わ申鐃循わ申鐃緒申 circular-list 鐃緒申鐃緒申鐃緒申鐃緒申討澆鐃緒申鐃�1鐃縦以常申離鐃緒申屮鐃緒申鐃緒申鐃緒申箸鐃緒申鐃緒申鐃祝とる。

(defun circular-list (obj &rest args)
  (let1 cl (cons obj args)
    (setcdr (last cl) cl)
    cl))

(let1 cl (circular-list 1 2 3 4 5)
  cl)
=>(1 2 3 4 5 1 2 3 4 . #4)

(let1 cl (circular-list 1 2 3 4 5)
  (nth 9 cl))
=>5

鐃循環リス鐃夙わ申鐃宿わ申鐃緒申鐃緒申調鐃駿わ申 circular-list-p 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�

(defun circular-list-p (ls)
  (do ((fast (cddr ls) (cddr fast))
       (slow (cdr ls) (cdr slow)))
      ((null fast))
    (and (equal fast slow) (return t))))

(let1 cl (apply 'circular-list (iota 10))
  (circular-list-p cl))
=>t

(let1 cl (iota 10)
  (circular-list-p cl))
=>nil

filter

filter 鐃熟￥申鐃所ス鐃夙わ申 pred 鐃緒申適鐃術わ申鐃緒申鐃緒申漫鐃緒申鐃緒申鐃緒申屬鐃緒申鐃緒申任鮟犬鐃暑。

(defun filter (pred ls)
  (if (null ls)
      nil
    (let1 o (car ls)
      (if (funcall pred o)
          (cons o (filter pred (cdr ls)))
        (filter pred (cdr ls))))))

(defun filter (pred ls)
  (do ((ls ls (cdr ls))
       (a nil (let1 o (car ls)
                (if (funcall pred o) (cons o a) a))))
      ((null ls) (nreverse a))))

(defun filter (pred ls)
  (let (a)
    (while ls
      (let1 o (car ls)
        (when (funcall pred o) (push o a)))
      (pop ls))
    (nreverse a)))

(defun filter (pred ls)
  (let (a)
    (dolist (x ls (nreverse a))
      (and (funcall pred x) (push x a)))))

(filter 'evenp (iota 10))
=>(0 2 4 6 8)

append-map

append-map 鐃緒申 map 鐃塾件申未鐃淑臣鰹申鐃緒申鐃緒申襦ｏ申鐃緒申鐃術みわ申 map* 鐃緒申 CL 鐃緒申 mapcar* 鐃緒申箸鐃�(CL 鐃緒申 mapcan 鐃緒申同鐃緒申鐃処う鐃淑わ申痢鐃�)鐃緒申SICP 鐃叔は￥申flatmap 鐃夙わ申鐃緒申鐃緒申鐃緒申鐃緒申鐃銃わ申鐃暑。Haskell 鐃緒申 OCaml 鐃叔わ申 concatMap 鐃夙わ申鐃緒申鐃初し鐃緒申鐃緒申

(defun append-map (f ls &rest more)
  (apply 'append (apply 'map* f ls more)))

fringe

append-map 鐃緒申箸辰董鐃�fringe 鐃緒申鐃緒申鐃緒申鐃緒申襦�fringe 鐃熟￥申鐃緒申鐃緒申鐃夙わ申鐃緒申鐃准わ申箸蝓�申擇里鐃緒申戮討鐃緒申鐃緒申任鮑犬鐃緒申蕷�申僚鐃緒申鐃渋べわ申鐃所ス鐃夙わ申鐃瞬わ申(SICP Exercise 2.28)鐃緒申

(defun fringe (tree)
  (if (listp tree)
      (append-map 'fringe tree)
    (list tree)))

count-leaves

count-leaves (SICP Exercise 2.35) 鐃緒申鐃准の￥申鐃春の随申鐃薯すべて随申鐃緒申鐃暑。鐃緒申鐃緒申僂澆鐃� fold 鐃緒申箸辰鐃緒申鐃�

(defun count-leaves (tree)
  (foldl (lambda (x y)
	  (if (consp x)
	      (+ (count-leaves x) y)
	    (+ 1 y)))
	0
	tree))

(defun count-leaves (tree)
  (foldl '+
	 0
	 (mapcar (lambda (s)
		   (if (consp s)
		       (count-leaves s)
		     1))
		 tree)))

count

count 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�CL 鐃緒申同名鐃塾関随申鐃緒申鐃緒申鐃緒申里鐃� count* 鐃夙わ申鐃緒申鐃緒申

(defun count* (pred ls &rest more)
  (let* ((x (cons ls more))
	 (n (apply 'min (mapcar 'length (cons ls more)))))
    (do ((n n (- n 1))
	 (x x (mapcar 'cdr x))
	 (ans 0 (if (apply pred (mapcar 'car x)) (+ ans 1) ans)))
	((= n 0) ans))))

鐃舜随申名鐃緒申鐃術刻申

Emacs Lisp 鐃叔わ申名鐃緒申鐃緒申鐃瞬わ申鐃緒申有鐃緒申鐃緒申鐃塾で￥申鐃舜随申名鐃祝プワ申侫鐃緒申奪鐃緒申鐃緒申鐃緒申佞鐃緒申鐃縮常申鐃緒申鐃緒申法鐃緒申鐃緒申砲鐃緒申鐃塾わ申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃縮に￥申鐃竣ワ申侫鐃緒申奪鐃緒申鐃緒申隼弔鐃塾ワ申鐃緒申椒鐃緒申 `-' 鐃緒申分鐃緒申鐃緒申里鐃緒申鐃緒申鐃�`-' 鐃緒申鐃叔わ申鐃祝わ申鐃緒申鐃塾で￥申`:' 鐃緒申分鐃緒申鐃緒申 Scheme 鐃緒申 `s' 鐃塾逸申文鐃緒申鐃緒申廛鐃春ワ申鐃獣ワ申鐃緒申鐃祝わ申鐃暑こ鐃夙にわ申鐃緒申(鐃緒申鐃緒申僖鐃緒申鐃緒申鐃緒申展鐃緒申鐃緒申鐃緒申鐃殉ワ申鐃緒申鐃熟わ申鐃塾ままにわ申鐃緒申)鐃緒申CL 鐃塾関随申名鐃夙常申鐃粛わ申鐃緒申里鐃緒申鬚韻襪随申鐃緒申鐃春わ申鐃緒申 `*' 鐃緒申鐃暑こ鐃夙にわ申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃獣て￥申count* 鐃緒申鐃獣わ申鐃緒申 s:count 鐃祝なる。

count 鐃叔は￥申鐃緒申与鐃緒申鐃緒申譴随申螢刻申箸里鐃緒申鐃緒申任鐃獣誌申鐃緒申螢刻申函廚箸鐃緒申鐃緒申鐃緒申佑鐃緒申鐃緒申鐃緒申鐃緒申茲�申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申他鐃塾関随申鐃緒申鐃緒せ鐃銃緒申鐃緒申鐃緒申鐃暑。

filter-map

filter-map 鐃熟￥申filter 鐃緒申 map 鐃緒申鐃夙み刻申錣誌申鐃緒申鐃塾￥申鐃緒申鐃祝なわ申鐃緒申侶鐃縮を集わ申襦�

(defun s:filter-map (f ls &rest more)
  (let* ((x (cons ls more))
	 (n (apply 'min (mapcar 'length x))))
    (do ((n n (- n 1))
	 (x x (mapcar 'cdr x))
	 (ans nil (let1 r (apply f (mapcar 'car x))
		    (if r (cons r ans) ans))))
	((= n 0) (nreverse ans)))))

(s:filter-map (lambda (x) (and (numberp x) (* x x)))
	      '(a 1 b 3 c 7))
=>(1 9 49)

take / drop / split-at

take 鐃緒申 drop 鐃緒申 split-at 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�

(defun s:take (x i)
  (do ((i (- i 1) (- i 1)) (x x (cdr x))
       (ans nil (cons (car x) ans)))
      ((or (< i 0) (null x)) (nreverse ans))))

(defun s:drop (x i) (nthcdr i x))

(defun s:split-at (x i)
  (if (or (> i (length x))
	  (< i 0))
      (error "Given list is too short: %S" x)
    (list (s:take x i) (s:drop x i))))

(s:take '(a b c d e) 2)       => (a b)

(s:drop '(a b c d e) 2)       => (c d e)

(s:split-at '(a b c d e) 2)   => ((a b) (c d e))

find / list-index / last

find 鐃緒申 list-index 鐃緒申 last 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�find 鐃緒申 pred 鐃緒申鐃緒申鐃緒申鐃瞬わ申鐃叔緒申鐃緒申鐃緒申任鐃緒申屬鐃緒申鐃�

(defun s:find (pred ls)
  (do ((ls ls (if (funcall pred (car ls))
		  (return (car ls))
		(cdr ls))))
      ((null ls) nil)))

(defun s:list-index (pred ls)
  (do ((i 0 (+ i 1))
       (ls ls (if (funcall pred (car ls))
		  (return i)
		(cdr ls))))
      ((null ls) nil)))

(defun s:last (ls) (car (last ls)))

partition

partition 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�

(defun s:partition (pred ls)
  (do ((ls ls (cdr ls))
       (drop nil)
       (take nil (if (funcall pred (car ls))
		     (cons (car ls) take)
		   (push (car ls) drop)
		   take)))
      ((null ls) (list (nreverse take) (nreverse drop)))))

(s:partition 'oddp '(3 1 4 5 9 2 6))	=>((3 1 5 9) (4 2 6))

take-while / drop-while

take-while 鐃緒申 drop-while 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�

(defun s:take-while (pred ls)
  (do ((ls ls (cdr ls))
       (ans nil (if (funcall pred (car ls))
		    (cons (car ls) ans)
		  (return (nreverse ans)))))
      ((null ls) (nreverse ans))))

(defun s:drop-while (pred ls)
  (do ((ls ls (if (funcall pred (car ls))
		  (cdr ls)
		(return ls))))
      ((null ls) ls)))

any / every

any 鐃緒申 every 鐃緒申鐃緒申鐃緒申鐃緒申鐃緒申鐃�

(defun s:any (pred ls &rest more)
  (let* ((x (cons ls more))
	 (n (apply 'min (mapcar 'length x))))
    (do ((n n (- n 1))
	 (x x (mapcar 'cdr x))
	 (ans (apply pred (mapcar 'car x))
	      (apply pred (mapcar 'car x))))
	((= n 0) ans)
      (when ans (return ans)))))

(defun s:every (pred ls &rest more)
  (let* ((x (cons ls more))
	 (n (apply 'min (mapcar 'length x))))
    (do ((n n (- n 1))
	 (x x (mapcar 'cdr x))
	 (ans (apply pred (mapcar 'car x))
	      (apply pred (mapcar 'car x))))
	((= n 0) ans)
      (unless ans (return nil)))))