- (and
- (if (atom hairy-spec)
- (values t t)
- (dolist (spec (cdr hairy-spec) (values t t))
- (multiple-value-bind (res win)
- (ctypep obj (specifier-type spec))
- (unless win (return (values nil nil)))
- (unless res (return (values nil t)))))))
- (not
- (multiple-value-bind (res win)
- (ctypep obj (specifier-type (cadr hairy-spec)))
- (if win
- (values (not res) t)
- (values nil nil))))
- (satisfies
- (let ((predicate-name (second hairy-spec)))
- (declare (type symbol predicate-name)) ; by ANSI spec of SATISFIES
- (if (fboundp predicate-name)
- (let* (;; "Is OBJ of the SATISFIES type?" represented
- ;; as a generalized boolean.
- ;;
- ;; (Why IGNORE-ERRORS? This code is used to try to
- ;; check type relationships at compile time.
- ;; Passing only-slightly-twisted types like
- ;; (AND INTEGER (SATISFIES ODDP)) into the
- ;; rather-significantly-twisted type dispatch
- ;; system can easily give rise to oddities like
- ;; calling predicates like ODDP on values they
- ;; don't like. (E.g. on OBJ=#\NEWLINE when the
- ;; above type is tested for TYPE= against
- ;; STANDARD-CHAR, represented as a
- ;; MEMBER-TYPE.) In such cases, NIL seems to be
- ;; an appropriate answer to "is OBJ of the
- ;; SATISFIES type?")
- (gbool (ignore-errors (funcall predicate-name obj)))
- ;; RAW coerced to a pure BOOLEAN value
- (bool (not (not gbool))))
- (values bool t))
- (values nil nil)))))))))
+ (and
+ (if (atom hairy-spec)
+ (values t t)
+ (dolist (spec (cdr hairy-spec) (values t t))
+ (multiple-value-bind (res win)
+ (ctypep obj (specifier-type spec))
+ (unless win (return (values nil nil)))
+ (unless res (return (values nil t)))))))
+ (not
+ (multiple-value-bind (res win)
+ (ctypep obj (specifier-type (cadr hairy-spec)))
+ (if win
+ (values (not res) t)
+ (values nil nil))))
+ (satisfies
+ (let ((predicate-name (second hairy-spec)))
+ (declare (type symbol predicate-name)) ; by ANSI spec of SATISFIES
+ (if (fboundp predicate-name)
+ (let* (;; "Is OBJ of the SATISFIES type?" represented
+ ;; as a generalized boolean.
+ ;;
+ ;; (Why IGNORE-ERRORS? This code is used to try to
+ ;; check type relationships at compile time.
+ ;; Passing only-slightly-twisted types like
+ ;; (AND INTEGER (SATISFIES ODDP)) into the
+ ;; rather-significantly-twisted type dispatch
+ ;; system can easily give rise to oddities like
+ ;; calling predicates like ODDP on values they
+ ;; don't like. (E.g. on OBJ=#\NEWLINE when the
+ ;; above type is tested for TYPE= against
+ ;; STANDARD-CHAR, represented as a
+ ;; MEMBER-TYPE.) In such cases, NIL seems to be
+ ;; an appropriate answer to "is OBJ of the
+ ;; SATISFIES type?")
+ (gbool (ignore-errors (funcall predicate-name obj)))
+ ;; RAW coerced to a pure BOOLEAN value
+ (bool (not (not gbool))))
+ (values bool t))
+ (values nil nil)))))))))