Изначально Олег спросил, как сложить числа одной командой. Если мы обрабатываем переполнение, то это уже в любом случае не одна команда. Я ответил на то, что спрашивали. Так-то сложение в лиспе, без вот этих вот экстремальных знаний о типах, не свойственных обычному (а не быстрому) коду, является функцией, в которой происходит диспетчеризация по тегам всех аргументов (а аргументов может быть от 0 до... ну до 100, как минимум, есть какой-то предел).

Вот что предлагает мне на выбор SBCL, когда я спрашиваю его про определение +
## Код:
```
(DEFVAR +)
(DEFUN +)
(DEFINE-METHOD-COMBINATION + GENERIC-FUNCTION (EQL +) T)
(:DEFTRANSFORM +
 ((OR RATIONAL (COMPLEX RATIONAL)) (SB-INT:CONSTANT-ARG (INTEGER 0 0)))
 "fold zero arg")
(:DEFTRANSFORM + (RATIONAL (SB-INT:CONSTANT-ARG RATIONAL))
 "associate +/(+ -) of constants")
(:DEFTRANSFORM +
 (DOUBLE-FLOAT (SB-INT:CONSTANT-ARG (OR (MEMBER 0.0 0.0f0) (INTEGER 0 0))))
 "optimize")
(:DEFTRANSFORM +
 (SINGLE-FLOAT (SB-INT:CONSTANT-ARG (OR (MEMBER 0.0f0) (INTEGER 0 0))))
 "optimize")
(:DEFTRANSFORM + (DOUBLE-FLOAT SINGLE-FLOAT) "optimize")
(:DEFTRANSFORM + (SINGLE-FLOAT DOUBLE-FLOAT) "optimize")
(:DEFTRANSFORM + (FLOAT RATIONAL) "optimize")
(:DEFTRANSFORM + (RATIONAL FLOAT) "optimize")
(:DEFTRANSFORM + "check for iteration variable reoptimization")
(:DEFOPTIMIZER + SB-C:DERIVE-TYPE)
(:DEFINE-VOP + SB-VM::FAST-+-C/FIXNUM=>FIXNUM "inline fixnum arithmetic")
(:DEFINE-VOP + SB-VM::+/DOUBLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::+/SINGLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::FAST-+/FIXNUM=>FIXNUM "inline fixnum arithmetic")
(:DEFINE-VOP + SB-VM::+/COMPLEX-REAL-SINGLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::+/COMPLEX-DOUBLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::+/COMPLEX-SINGLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::+/REAL-COMPLEX-SINGLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::FAST-+-C/UNSIGNED=>UNSIGNED
 "inline (unsigned-byte 64) arithmetic")
(:DEFINE-VOP + SB-VM::FAST-+-C/SIGNED=>SIGNED
 "inline (signed-byte 64) arithmetic")
(:DEFINE-VOP + SB-VM::+/COMPLEX-REAL-DOUBLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::+/REAL-COMPLEX-DOUBLE-FLOAT "inline float arithmetic")
(:DEFINE-VOP + SB-VM::FAST-+/SIGNED=>SIGNED
 "inline (signed-byte 64) arithmetic")
(:DEFINE-VOP + SB-VM::FAST-+/UNSIGNED=>UNSIGNED
 "inline (unsigned-byte 64) arithmetic")
(:DEFINE-VOP + SB-VM::GENERIC-+)
(:DEFINE-SOURCE-TRANSFORM +)
(DECLAIM +
         SB-C:DEFKNOWN)
```

Т.е. это много разного рода оптимизаторов и преобразователей для разных случаев жизни и для разных этапов компиляции.

Определение собственно функции +, а точнее, шаблона, который генерирует функцию + для двух аргументов, выглядит вот так:
## Код:
```
(sb!xc:defmacro two-arg-+/- (name op big-op)
  `(defun ,name (x y)
     (number-dispatch ((x number) (y number))
       (bignum-cross-fixnum ,op ,big-op)
       (float-contagion ,op x y)

       ((complex complex)
        (canonical-complex (,op (realpart x) (realpart y))
                           (,op (imagpart x) (imagpart y))))
       (((foreach bignum fixnum ratio single-float double-float
                  #!+long-float long-float) complex)
        (complex (,op x (realpart y)) (,op 0 (imagpart y))))
       ((complex (or rational float))
        (complex (,op (realpart x) y) (,op (imagpart x) 0)))

       (((foreach fixnum bignum) ratio)
        (let* ((dy (denominator y))
               (n (,op (* x dy) (numerator y))))
          (%make-ratio n dy)))
       ((ratio integer)
        (let* ((dx (denominator x))
               (n (,op (numerator x) (* y dx))))
          (%make-ratio n dx)))
       ((ratio ratio)
        (let* ((nx (numerator x))
               (dx (denominator x))
               (ny (numerator y))
               (dy (denominator y))
               (g1 (gcd dx dy)))
          (if (eql g1 1)
              (%make-ratio (,op (* nx dy) (* dx ny)) (* dx dy))
              (let* ((t2 (truncate dx g1))
                     (t1 (,op (* nx (truncate dy g1)) (* t2 ny)))
                     (g2 (gcd t1 g1)))
                (cond ((eql t1 0) 0)
                      ((eql g2 1)
                       (%make-ratio t1 (* t2 dy)))
                      (t (let* ((nn (truncate t1 g2))
                                (t3 (truncate dy g2))
                                (nd (if (eql t2 1) t3 (* t2 t3))))
                           (if (eql nd 1) nn (%make-ratio nn nd))))))))))))
```

Искать дальше, где определён + для общего случая - влом, хотя наверное, надо отмотать пару экранов. Ладно. Он генерируется этим куском кода:
## Код:
```
(macrolet ((define-arith (op init doc)
             `(defun ,op (&rest numbers)
                (declare (explicit-check))
                ,doc
                (if numbers
                    (let ((result (the number (fast-&rest-nth 0 numbers))))
                      (do-rest-arg ((n) numbers 1 result)
                        (setq result (,op result n))))
                    ,init))))
  (define-arith + 0
    "Return the sum of its arguments. With no args, returns 0.")
  (define-arith * 1
    "Return the product of its arguments. With no args, returns 1."))
```


А вот как сделать именно сложение чисел, заполняющих всё слово, с отловом переполнения - тут я затрудняюсь. В отличие от Оберона, в SBCL любое данное помещается в машинное слово, поэтому там не может быть 64-разрядных чисел в машинном слове - два бита идут на тег типа. Числа, не помещающиеся в 62 разряда, представляются уже бигнумом и их, естественно, нельзя сложить одной машинной командой. Если нужно именно слово, то их надо либо в массиве хранить, либо в записи (обращение всё равно через укль, не уверен, что выйдет за одну команду сложить), либо через FFI-указатель, но может быть есть и другие варианты.

В общем-то язык не на то заточен, но естественно, это речь конкретно про SBCL, а не про "лисп вообще". Вполне можно сделать "оберон со скобочками", правда, вопрос, насколько целесообразно перемножать два бесконечно ненужных.