macro_name: REM-BOPS

library: binfix

call_form: (rem-bops)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop 'nil) (assign-properties)))

status: verified


call_form: (rem-bops nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop '(nil)) (assign-properties)))


call_form: (rem-bops nil nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop '(nil nil)) (assign-properties)))


call_form: (rem-bops nil (progn))

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop '(nil (progn))) (assign-properties)))


call_form: (rem-bops nil :key nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop '(nil :key nil)) (assign-properties)))


call_form: (rem-bops 'lol-gen::some-name)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (save-binfix)
   (mapc 'rmbop '('lol-gen::some-name))
   (assign-properties)))


macro_name: SET-BOP

call_form: (set-bop)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO SET-BOP:
  too few elements in
    ()
  to satisfy lambda list
    (OP LISP-OP &REST PROPS):
  at least 2 expected, but got 0


call_form: (set-bop nil)

error:
Error while parsing arguments to DEFMACRO SET-BOP:
  too few elements in
    (NIL)
  to satisfy lambda list
    (OP LISP-OP &REST PROPS):
  at least 2 expected, but got 1


call_form: (set-bop nil nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (save-binfix)
   (mapc
    (lambda (ops)
      (mapc
       (lambda (op1)
         (when (eq (car op1) 'nil)
           (setf (cadr op1) 'nil)
           (unless t (setf (cddr op1) 'nil))))
       ops))
    *binfix*)
   (assign-properties)))


call_form: (set-bop nil (progn))

error:
The value
  (PROGN)
is not of type
  SYMBOL
when binding LISP-OP


call_form: (set-bop nil :key nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (save-binfix)
   (mapc
    (lambda (ops)
      (mapc
       (lambda (op1)
         (when (eq (car op1) 'nil)
           (setf (cadr op1) ':key)
           (unless nil (setf (cddr op1) '(nil)))))
       ops))
    *binfix*)
   (assign-properties)))


call_form: (set-bop 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO SET-BOP:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (OP LISP-OP &REST PROPS):
  at least 2 expected, but got 1


macro_name: DEF-BOP

call_form: (def-bop)

error:
Error while parsing arguments to DEFMACRO DEF-BOP:
  too few elements in
    ()
  to satisfy lambda list
    (BOP &OPTIONAL (LISP-OP) (P) &REST PROP):
  at least 1 expected, but got 0


call_form: (def-bop nil (progn))

expanded: t


call_form: (def-bop nil :key nil)

error:
NIL fell through ECASE expression.
Wanted one of (:FIRST :LAST :EARLIER :LATER :BEFORE :AS :AFTER :SAME-AS).


call_form: (def-bop 'lol-gen::some-name)

error:
The value
  'LOL-GEN::SOME-NAME
is not of type
  SYMBOL
from the function type declaration.


macro_name: KEEP-BOPS

call_form: (keep-bops)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless t
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless (member (car b) 'nil)
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))


call_form: (keep-bops nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless nil
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless (member (car b) '(nil))
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))


call_form: (keep-bops nil nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless nil
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless (member (car b) '(nil nil))
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))


call_form: (keep-bops nil (progn))

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless nil
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless (member (car b) '(nil (progn)))
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))


call_form: (keep-bops nil :key nil)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless nil
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless (member (car b) '(nil :key nil))
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))


call_form: (keep-bops 'lol-gen::some-name)

expanded:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn
   (init-binfix)
   (unless nil
     (setq *binfix*
             (delete nil
                     (mapcar
                      (lambda (bs)
                        (setq bs
                                (delete-if
                                 (lambda (b)
                                   (unless
                                       (member (car b) '('lol-gen::some-name))
                                     (remprop (car b) 'properties)
                                     t))
                                 bs)))
                      *binfix*)))
     (assign-properties))))