;;; SINGLE-FLOAT DOUBLE-FLOAT RATIONAL)". We ideally want all of the
;;; defined-by-ANSI types to unparse as themselves or at least
;;; something similar (e.g. CHARACTER can unparse to BASE-CHAR, since
-;;; the types are equivalent in current SBCL).
+;;; the types are equivalent in current SBCL, and EXTENDED-CHAR can
+;;; unparse to NIL, since there are no EXTENDED-CHARs currently).
(let ((standard-types '(;; from table 4-2 in section 4.2.3 in the
;; CLHS.
arithmetic-error
array
generic-function
simple-error
- ;; (NOT CONS)
+ ;; so it might seem easy to change the HAIRY
+ ;; :UNPARSE method to recognize that (NOT
+ ;; CONS) should unparse as ATOM. However, we
+ ;; then lose the nice (SUBTYPEP '(NOT ATOM)
+ ;; 'CONS) => T,T behaviour that we get from
+ ;; simplifying (NOT ATOM) -> (NOT (NOT CONS))
+ ;; -> CONS. So, for now, we leave this
+ ;; commented out.
+ ;;
;; atom
hash-table
simple-string
single-float
bit-vector
long-float
- ;; MEMBER-TYPE #\a #\b ...
- ;; standard-char
+ standard-char
broadcast-stream
method
standard-class
string
condition
pathname
- ;; OR STRING-INPUT-STREAM STRING-OUTPUT-STREAM
- ;; FILL-POINTER-OUTPUT-STREAM
- ;; string-stream
+ string-stream
cons
print-not-readable
structure-class
error
readtable
two-way-stream
- ;; This one's hard: (AND BASE-CHAR (NOT BASE-CHAR))
- ;;
- ;; This is because it looks like
- ;; (AND CHARACTER (NOT BASE-CHAR))
- ;; but CHARACTER is equivalent to
- ;; BASE-CHAR. So if we fix intersection of
- ;; obviously disjoint types and then do (the
- ;; extended-char foo), we'll get back FOO is
- ;; not a NIL. -- CSR, 2002-09-16.
- ;; extended-char
+ extended-char
real
type-error
file-error
restart
unbound-slot
file-stream
- ;; (OR CONS NULL VECTOR)
- ;; sequence
+ sequence
unbound-variable
fixnum
serious-condition
(format t "~&~S~%" type)
(assert (not (sb-kernel:unknown-type-p (sb-kernel:specifier-type type))))
(assert (atom (sb-kernel:type-specifier (sb-kernel:specifier-type type))))))
+
+;;; a bug underlying the reported bug #221: The SB-KERNEL type code
+;;; signalled an error on this expression.
+(subtypep '(function (fixnum) (values package boolean))
+ '(function (t) (values package boolean)))
+
+;;; bug reported by Valtteri Vuorik
+(compile nil '(lambda () (member (char "foo" 0) '(#\. #\/) :test #'char=)))
+(assert (not (equal (multiple-value-list
+ (subtypep '(function ()) '(function (&rest t))))
+ '(nil t))))
+
+(assert (not (equal (multiple-value-list
+ (subtypep '(function (&rest t)) '(function ())))
+ '(t t))))
+
+(assert (subtypep '(function)
+ '(function (&optional * &rest t))))
+(assert (equal (multiple-value-list
+ (subtypep '(function)
+ '(function (t &rest t))))
+ '(nil t)))
+(assert (and (subtypep 'function '(function))
+ (subtypep '(function) 'function)))
+
+;;; Absent any exciting generalizations of |R, the type RATIONAL is
+;;; partitioned by RATIO and INTEGER. Ensure that the type system
+;;; knows about this. [ the type system is permitted to return NIL,
+;;; NIL for these, so if future maintenance breaks these tests that
+;;; way, that's fine. What the SUBTYPEP calls are _not_ allowed to
+;;; return is NIL, T, because that's completely wrong. ]
+(assert (subtypep '(or integer ratio) 'rational))
+(assert (subtypep 'rational '(or integer ratio)))
+;;; Likewise, these are allowed to return NIL, NIL, but shouldn't
+;;; return NIL, T:
+(assert (subtypep t '(or real (not real))))
+(assert (subtypep t '(or keyword (not keyword))))
+(assert (subtypep '(and cons (not (cons symbol integer)))
+ '(or (cons (not symbol) *) (cons * (not integer)))))
+(assert (subtypep '(or (cons (not symbol) *) (cons * (not integer)))
+ '(and cons (not (cons symbol integer)))))
+(assert (subtypep '(or (eql 0) (rational (0) 10))
+ '(rational 0 10)))
+(assert (subtypep '(rational 0 10)
+ '(or (eql 0) (rational (0) 10))))
+;;; Until sbcl-0.7.13.7, union of CONS types when the CDRs were the
+;;; same type gave exceedingly wrong results
+(assert (null (subtypep '(or (cons fixnum single-float)
+ (cons bignum single-float))
+ '(cons single-float single-float))))
+(assert (subtypep '(cons integer single-float)
+ '(or (cons fixnum single-float) (cons bignum single-float))))
+
+(assert (not (nth-value 1 (subtypep '(and null some-unknown-type)
+ 'another-unknown-type))))