;;; Define the translation from a type-specifier to a type structure for
;;; some particular type. Syntax is identical to DEFTYPE.
(defmacro !def-type-translator (name arglist &body body)
- (check-type name symbol)
+ (declare (type symbol name))
;; FIXME: Now that the T%CL hack is ancient history and we just use CL
;; instead, we can probably return to using PARSE-DEFMACRO here.
;;
;; named TYPE-CLASS-INFO which is an accessor for the CTYPE structure
;; even though the TYPE-CLASS structure also exists in the system.
;; Rename this slot: TYPE-CLASS or ASSOCIATED-TYPE-CLASS or something.
- (class-info (required-argument) :type type-class)
+ (class-info (missing-arg) :type type-class)
;; True if this type has a fixed number of members, and as such
;; could possibly be completely specified in a MEMBER type. This is
;; used by the MEMBER type methods.
(declare (type ctype type))
`(specifier-type ',(type-specifier type)))
\f
-;;;; utilities
-
-;;; sort of like ANY and EVERY, except:
-;;; * We handle two-VALUES predicate functions like SUBTYPEP. (And
-;;; if the result is uncertain, then we return (VALUES NIL NIL),
-;;; just like SUBTYPEP.)
-;;; * THING is just an atom, and we apply OP (an arity-2 function)
-;;; successively to THING and each element of LIST.
-(defun any/type (op thing list)
- (declare (type function op))
- (let ((certain? t))
- (dolist (i list (values nil certain?))
- (multiple-value-bind (sub-value sub-certain?) (funcall op thing i)
- (if sub-certain?
- (when sub-value (return (values t t)))
- (setf certain? nil))))))
-(defun every/type (op thing list)
- (declare (type function op))
- (let ((certain? t))
- (dolist (i list (if certain? (values t t) (values nil nil)))
- (multiple-value-bind (sub-value sub-certain?) (funcall op thing i)
- (if sub-certain?
- (unless sub-value (return (values nil t)))
- (setf certain? nil))))))
+;;;; miscellany
;;; Look for nice relationships for types that have nice relationships
;;; only when one is a hierarchical subtype of the other.