(defparameter *implementations*
  (list
   ;; ideone.com/g6m1EK
   (defun find-second-smallest-number-r1 (list)
     (loop for n in list
           for second = n then (if (< first n second) n second)
           minimize n into first
           finally (return (if (> second first) second nil))))
 
   (defun find-second-smallest-number-r2-UNIQ-AND-SORT (list)
     (let ((result (if (null list)
                       nil
                       (nth 1 (sort (remove-duplicates list) #'<)))))
       ;; sort 函数によって比較函数 < が適用されることで、数以外を含む
       ;; ときはエラーとなることを期待したが、要素が一つだけのときは比
       ;; 較されないためエラーも起きない。
       (when (and (eq result nil)
                  (not (null list))
                  (not (subtypep (type-of (first list)) 'real)))
         (error 'type-error :expected-type 'real :datum (first list)))
       result))
 
   (defun find-second-smallest-number-r3 (list)
     (when (eq (nth 1 list) nil)
       ;; (nth 1 list) の値が nil のとき、LIST は空リストであるか、要
       ;; 素数が 1 であるか、または先頭から二つ目の要素が nil である。
       ;; このとき LIST の要素に大小比較可能な数以外の要素が含まれる場
       ;; 合はコンディション type-error を送出する。
       (loop for x in list
             unless (subtypep (type-of x) 'real)
               do (error 'type-error :expected-type 'real :datum x)))
     (loop for n in list
           for 2nd = nil then (if (= n 1st)
                                  2nd
                                  (if (null 2nd)
                                      (max n 1st)
                                      (if (< n 1st)
                                          (max n 1st)
                                          (min n 2nd))))
           minimize n into 1st
           finally (return 2nd)))))
 
(defparameter *test-cases*
  (let ((N 100000)
        (type-error (make-condition 'type-error :datum nil :expected-type t)))
    `(((4 5 1 7 1 2 8 9 2 7) 2)
      ((2 2 2 2 2 2 2 2 2 2) nil)
      ((1) nil)
      ((2 1) 2)
      ((1 2) 2)
      ((3 2 1) 2)
      ((1/2 1/3 1/42) 1/3)
      ((,pi 3.14) ,pi)
      ((3.141592653589793d0 ,(log #c(-1 0))) ,type-error)
      ((0) nil)
      (() nil)
      ((t) ,type-error)
      ((1 nil) ,type-error)
      ((1 2 3 nil) ,type-error)
      (,(cons 2 (make-list N :initial-element 1)) 2)
      (,(cons 2 (make-list N :initial-element nil)) ,type-error))))
 
(defun run-tests (fn test-cases &optional (detailed-output-p t))
  (flet ((test (expected result)
           (if (and detailed-output-p (subtypep (type-of expected) 'condition))
               (subtypep (type-of result) (type-of expected))
               (eql result expected))))
    (loop with *print-length* = 10
          with *print-right-margin* = 5000
          for (arg expected) in test-cases
          for result = (handler-case (funcall fn arg)
                         (error (condition)
                           (if detailed-output-p
                               condition
                               (class-name (class-of condition)))))
          for all-tests-passed-p = (test expected result)
            then (and all-tests-passed-p (test expected result))
          do (format t (if detailed-output-p
                           "~:[❌~;✓~] ~:S → ~S~%"
                           "~*~:S → ~A~%")
                     (test expected result)
                     arg
                     result)
          finally (return all-tests-passed-p))))
 
(defun make-string-sink ()
  (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t))
(defun clear-string-sink (sink)
  (setf (fill-pointer sink) 0))
 
(let ((debug nil))
  (let ((fn (car (last *implementations*))))
    (run-tests fn *test-cases* nil))
  (format t "~%~50@{=~}~2%" t)
  (let ((tests-output (make-string-sink))
        all-tests-passed-p)
    (dolist (fn *implementations*)
      #+clisp (format t "~2%")
      (format t "Testing ‘~(~A~)’... " fn)
      (with-output-to-string (*standard-output* tests-output)
        (setq all-tests-passed-p (run-tests fn *test-cases*)))
      (format t "~:[FAILED~;OK~]~%" all-tests-passed-p)
      (if all-tests-passed-p
          ;; テストを通過したら速度も計測。
          (time (loop repeat 100000 do (funcall fn (caar *test-cases*))))
          (if debug
              (write-line tests-output)
              (terpri)))
      (clear-string-sink tests-output))))
 

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