The extensible-compound-types Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The extensible-compound-types Reference Manual

This is the extensible-compound-types Reference Manual, version 0.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:31:20 2022 GMT+0.

Table of Contents


1 Introduction


* Motivation

#+BEGIN_QUOTE
=extensible-compound-types= allows for the definition of user-defined [[http://www.lispworks.com/documentation/lw70/CLHS/Body/26_glo_c.htm#compound_type_specifier][compound-types]]. Built-in compound types include =(vector &optional element-type)= or =(integer &optional lower-limit higher-limit)=. I do not know what exactly parametric types are, but I do know that these are not identical to parametric types. If it works for you, great! But don't say "it works" until you get things working on a large enough project.

This is an alpha-stage experimental library. Use at your own risk.
#+END_QUOTE

Common Lisp has a rich (although not the richest :/) type system allowing for the combination of types using NOT AND OR MEMBER VALUES, specifying EQL types, or even completely arbitrary types using SATISFIES. 

Through [[http://www.lispworks.com/documentation/lw70/CLHS/Body/26_glo_c.htm#compound_type_specifier][compound-types]], it even allows for specification of the exact integer or float through (NUM-TYPE LOW HIGH), or the exact dimensions of a vector or array through (ARRAY-TYPE ELEMENT-TYPE RANK/DIMENSIONS). This allows compilers to type-check and optimize the code, besides also enhancing readability for the developer reading the code. 

However, CLHS does not provide facilities for cleanly defining user-defined compound-types. Such types could include a (EQUALP OBJECT) type, a (TYPE= TYPE), or a (PAIR TYPE-1 TYPE-2) type, or (CUSTOM-ARRAY ELEMENT-TYPE DIMENSIONS).

While it might seem like [[http://clhs.lisp.se/Body/m_deftp.htm][CL:DEFTYPE]] allows for the definition of compound types, these types are what CLHS calls [[http://clhs.lisp.se/Body/26_glo_d.htm#derived_type][derived type]] specifiers, mere abbreviations and simple combinations of existing types. The most one can do is play around with SATISFIES types. However, not only do SATISFIES types not integrate well into rest of the type system, but they are also restricted to single argument functions that only take the object to be type-checked as their argument and no more parameters or arguments than that. See the [[#example-code][Example Code]] for an example of a type that is non-trivial (if not impossible!) to define using CL:DEFTYPE.

Recommended usage is:

#+BEGIN_SRC lisp
(cl:pushnew :extensible-compound-types cl:*features*)
(ql:quickload "extensible-compound-types-cl")
(defpackage your-package (:use :extensible-compound-types-cl))
#+END_SRC

Libraries that provide extensible-compound-types compatible versions:

- [[https://github.com/digikar99/polymorphic-functions/][polymorphic-functions]]
- [[https://github.com/digikar99/trivial-coerce][trivial-coerce]]
- [[https://github.com/digikar99/dense-arrays][dense-arrays]]
- [[https://github.com/digikar99/numericals][numericals]]
- [[https://github.com/alex-gutev/cl-form-types/][cl-form-types]] ([[https://github.com/digikar99/cl-form-types/][my fork]])

The end goal is indeed that extensible-compound-types-cl should be useable as a drop-in without special modifications, but the above projects have been explicitly tested.

** extensible-compound-types-cl: yet another shadowing CL package

=extensible-compound-types= allow for the definition of user-defined compound types. Unfortunately, this requires shadowing the symbols in the CL package. We start out with a user-defined declaration (CLTL2) EXTYPE or EXTENSIBLE-COMPOUND-TYPES:TYPE. However, to actually use the compiler's built-in type safety and optimization, one needs to modify the CL:TYPE declarations, but while doing so:

#+BEGIN_QUOTE
The consequences are undefined if decl-name is a symbol that can appear as the car of any standard declaration specifier.

The consequences are also undefined if the return value from a declaration handler defined with define-declaration includes a key name that is used by the corresponding accessor to return information about any standard declaration specifier. (For example, if the first return value from the handler is :variable, the second return value may not use the symbols dynamic-extent, ignore, or type as key names.)

-- [[https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html][8.5 Environments, Common Lisp the Language, 2nd Edition]]
#+END_QUOTE

[[https://github.com/numcl/specialized-function][gtype]] does expect that implementations will do the right thing with CL:TYPE being passed as the return values of user defined declarations. However, we do not rely on the implementation for this activity. A second reason for not relying on implementation support is that one needs to convert the declarations into a type-check statement for purposes of correctness. These type checks are beyond the scope of CL:TYPE declarations. 

Towards this, a =extensible-compound-types-cl= system and package is also provided that shadows symbols that incorporate declarations. The goal is to make this system so that it can be used as a drop-in for COMMON-LISP package - or at least with minimal modifications such as qualifying symbols with =CL:= prefix where necessary. If you want to use it, and it doesn't work as a drop-in, feel free to raise an [[https://github.com/digikar99/extensible-compound-types/issues][issue]]!

** #+EXTENSIBLE-COMPOUND-TYPES

If CL:*FEATURES* contains :EXTENSIBLE-COMPOUND-TYPES, then we also shadow CL:TYPE itself using EXTENSIBLE-COMPOUND-TYPES:TYPE. Otherwise, one needs to use EXTENSIBLE-COMPOUND-TYPES:EXTYPE. The goal for doing this is to allow for both side-by-side usage, as well as a complete replacement. FIXME: Flexible usage is problematic, also depends on what choices the systems that depend on extensible-compound-types make.

* Contents
:PROPERTIES:
:TOC:      :include all
:END:

:CONTENTS:
- [[#motivation][Motivation]]
  - [[#extensible-compound-types-cl-yet-another-shadowing-cl-package][extensible-compound-types-cl: yet another shadowing CL package]]
  - [[#extensible-compound-types][#+EXTENSIBLE-COMPOUND-TYPES]]
- [[#contents][Contents]]
- [[#example-code][Example Code]]
- [[#limitations-and-caveats][Limitations and Caveats]]
- [[#core-api-for-using-as-a-shadowing-package][Core API for using as a shadowing package]]
- [[#additional-tools][Additional tools]]
- [[#extensible-compound-types-api][Extensible Compound Types API]]
- [[#parametric-types][Parametric Types]]
- [[#using-cl-form-types-for-better-compile-time-checks][Using cl-form-types for better compile-time checks]]
- [[#needs-more-work][Needs more work]]
- [[#internal-discussion][Internal Discussion]]
  - [[#usage-api][Usage API]]
  - [[#shadowing-cl-package][Shadowing CL package]]
  - [[#subtypep][subtypep]]
    - [[#if-two-types-are-such-that-one-type-has-a-greater-number-of-specified-parameters-than-another-then-should-that-mean-first-is-more-specialized-than-second][If two types are such that one type has a greater number of specified parameters than another, then should that mean first is more specialized than second?]]
    - [[#what-should-the-relations-between-two-compound-types-corresponding-to-subclass-and-superclass][What should the relations between two compound types corresponding to subclass and superclass?]]
  - [[#only-specialized-types-or-more-general-compound-types-like-type-type][Only specialized types, or more general compound types like (type= type)?]]
  - [[#comparison-with-cl-parametric-types][Comparison with cl-parametric-types]]
  - [[#comparison-with-ctype][Comparison with ctype]]
  - [[#comments-by-more-experienced-lispers][Comments by more experienced lispers]]
:END:

* Example Code

Compound Types can be defined by first defining the =typep= part using =define-compound-type=.

To use this type in a =(declare (extype ...))= declaration, one also needs to define the ANSI CL counterpart of the closest supertype of the given by specializing the =%upgraded-cl-type= generic-function. To play nice with =subtypep=, one needs to specialize the =%subtypep= generic-function. 

#+BEGIN_SRC lisp
  (defpackage extensible-compound-types-demo
    (:use :extensible-compound-types-cl))

  (in-package :extensible-compound-types-demo)

  ;;; PS: This isn't the best way to achieve this; since to play nice
  ;;; with SUBTYPEP, one will need to define quite a few %SUBTYPEP
  ;;; methods.  A better way is left as an exercise for the reader.
  ;;; Hint: Abstract out the "multiples" part from integer-multiples
  ;;; single-float-multiplesrational-multiples etc.
  (define-compound-type integer-multiples (object n)
    "A user-defined compound-type that denotes integers that are multiples of N"
    (and (numberp object)
         (zerop (rem object n))))

  (typep 5 '(integer-multiples 3)) ;=> NIL
  (typep 6 '(integer-multiples 3)) ;=> T

  (cl:defmethod %upgraded-cl-type ((name (eql 'integer-multiples)) type &optional env)
    (declare (ignore name env))
    'integer)

  #|
  (disassemble (lambda (x)
                 (declare (optimize speed)
                          (extype (integer-multiples 3) x))
                 x))
  ; disassembly for (COMMON-LISP:LAMBDA (X) :IN "/tmp/slime4RHup6")
  ; Size: 8 bytes. Origin: #x53AC4830                           ; (COMMON-LISP:LAMBDA
                                                                      (X)
                                                                    :IN
                                                                    "/tmp/slime4RHup6")
  ; 0:       488BE5           MOV RSP, RBP
  ; 3:       F8               CLC
  ; 4:       5D               POP RBP
  ; 5:       C3               RET
  ; 6:       CC10             INT3 16                           ; Invalid argument count trap

  (describe 'integer-multiples)
  EXTENSIBLE-COMPOUND-TYPES-DEMO::INTEGER-MULTIPLES
    [symbol]

  INTEGER-MULTIPLES is bound in namespace TYPE:
    Value: (N)
    Documentation:
      A user-defined compound-type that denotes integers that are multiples of N
  |#
  ;; TODO: Add SUBTYPEP example
#+END_SRC

More examples for this can be found in the [[file:src/cl-compound-types.lisp][src/cl-compound-types.lisp]].

* Limitations and Caveats

- It doesn't give you truly parametric types in the sense of ML-like languages; the most you can get is one level of parametric-ism
- Getting %subtypep and %intersect-type-p working correctly for non-trivial types can be difficult if not impossible. For instance, consider the case of character-designator: one could certainly define it as:

#+BEGIN_SRC lisp
(define-compound-type character-designator (o)
  (or (characterp o)
      (and (stringp o)
           (= 1 (length o)))
      (and (symbolp o)
           (= 1 (length (symbol-name o))))))
#+END_SRC

  However, now, getting all and more of the following to hold seems non-trivial:

#+BEGIN_SRC lisp
(subtypep 'character-designator 'character) ;=> NIL T, because it can also be a symbol
(subtypep 'character-designator 'symbol) ;=> NIL T
(subtypep 'character-designator 'string) ;=> NIL T
(subtypep 'character-designator '(or character symbol string)) ;=> T T
(subtypep 'character 'character-designator) ;=> T T
(subtypep '(or character string) 'character-designator) ;=> NIL T
(subtypep '(or character (string 1)) 'character-designator) ;=> T T
#+END_SRC

  That is why, =define-compound-type= should be used only as a last resort when =deftype= does not let you do what you want.

- extensible-compound-types is also not infinitely powerful. In an attempt to keep the API simpler (compared to CTYPE), no explicit methods have been provided for conjunction and disjunction. One of the implications of this is that it is not always possible to tell whether or not (and ...) is NIL or not, for instance =(subtypep '(and listp (not null) symbol) nil) ;=> NIL NIL=.

  To understand this, consider that I have three types t1, t2, t3 denoting the set of elements (a b c), (c d e), (e f a) respectively. In actuality, the programming language won't allow us to literally list the elements a b c d e f etc, but I'm assuming this literal listing for purposes of understanding.

  Now, I want to check for (subtypep '(and t1 t2 t3) nil) in a way that will allow extending the algorithm to beyond 2 or 3 types; so, the algorithm should work even when there is a t4 or t5. The current approach reduces the 3-types case to whether the intersection of any two of these is null. However, this is incomplete, since as in the example above, it is possible that even if any two of these have a non-nil intersection, all the three (or more) of them taken together have a nil intersection.

  SBCL and CTYPE handle this this by reducing (and list (not null)) to cons; but that involves the implementation of disjunction and conjunctions for *every* pair of (user-defined) primitive types. And I want to avoid this since this seems to complicate the API quite a bit. PS: I'd be glad to know if there is a better way out!
  
* Core API for using as a shadowing package

- type-specifier-p
- typep
- subtypep
- deftype
- check-type
- the
- unknown-type-specifier
- =*excluded-packages-for-cl-deftype*=

* Additional tools

- undeftype
- typexpand-1
- typexpand
- typexpand-all
- type=
- supertypep
- intersect-type-p
- intersection-null-p
- =*the-skip-predicates*=

* Extensible Compound Types API

- define-compound-type
- undefine-compound-type
- %upgraded-cl-type
- %subtypep
- %intersect-type-p
- extype

* Parametric Types

Combined with [[https://github.com/digikar99/polymorphic-functions/][polymorphic-functions]], one /can/ create a wrapper around =extensible-compound-types= as follows. Note that this does not give you truly parametric types in the sense of ML-like languages. Instead, this is more akin to C++ templates.

#+BEGIN_SRC lisp
(push :extensible-compound-types cl:*features*)
(ql:quickload "polymorphic-functions+extensible-compound-types")

(cl:defpackage parametric-types-demo
  (:use :extensible-compound-types-cl :polymorphic-functions))

(in-package :parametric-types-demo)

(defstruct pair a b)

(define-compound-type pair (o &optional (type-a 'cl:*) (type-b 'cl:*))
  "A user-defined compound-type that allows the specification of the
types of the values stored in slots A and B of the structure-class
PAIR."
  (and (cl:typep o 'pair)
       (with-slots (a b) o
         (and (if (eq 'cl:* type-a)
                  t
                  (cl:typep a type-a))
              (if (eq 'cl:* type-b)
                  t
                  (cl:typep b type-b))))))

(defmethod %upgraded-cl-type ((name (eql 'pair)) type &optional env)
  (declare (ignore type env))
  name)

(defmethod %subtypep ((t1 (eql 'pair)) (t2 (eql 'pair)) type1 type2 &optional env)
  (declare (ignore t1 t2 env))
  (destructuring-bind (&optional (t1a 'cl:*) (t1b 'cl:*)) (rest type1)
    (destructuring-bind (&optional (t2a 'cl:*) (t2b 'cl:*)) (rest type2)
      ;; FIXME: This does not look exhaustive
      (cond ((and (eq t2a 'cl:*) (eq t2b 'cl:*))
             (values t t))
            ((and (eq t1a 'cl:*) (eq t2b 'cl:*))
             ;; t2a is specified, but t1a is not
             (values nil t))))))

(defmethod %deparameterize-type ((car (eql 'pair)) type-specifier &optional env)
  (declare (ignore type-specifier env))
  car)

(defmethod parametric-type-run-time-lambda-body ((type-car (eql 'pair)) type-cdr parameter)
  (let ((accessor (cond ((eq parameter (first type-cdr))
                         'pair-a)
                        ((eq parameter (second type-cdr))
                         'pair-b))))
    `(cl:lambda (pair)
       (declare (optimize speed)
                (type pair pair))
       ;; FIXME: One needs a wrapper around TYPE-OF, since TYPE-OF may not
       ;; return what one expects; example:
       ;; (TYPE-OF 1) ;=> BIT
       (type-of (,accessor pair)))))

(defmethod parametric-type-compile-time-lambda-body
    ((type-car (eql 'pair)) type-cdr parameter)
  `(cl:lambda (elt-type)
     (destructuring-bind (&optional (type-a t) (type-b t)) (rest elt-type)
       (declare (ignorable type-a type-b))
       (when (eq cl:* type-a) (setq type-a t))
       (when (eq cl:* type-b) (setq type-b t))
       ,(cond ((eq parameter (first type-cdr))
               `type-a)
              ((eq parameter (second type-cdr))
               `type-b)
              (t
               (error "Unknown case"))))))

(let ((*parametric-type-symbol-predicates*
        (list (lambda (s)
                (let* ((name (symbol-name s))
                       (len  (length name)))
                  (and (char= #\< (elt name 0))
                       (char= #\> (elt name (1- len)))))))))
  (eval `(progn
           (define-polymorphic-function slot-a (object) :overwrite t)
           (defpolymorph slot-a ((o (pair  ))) 
             (pair-a o))
           (define-polymorphic-function slot-b (object) :overwrite t)
           (defpolymorph slot-b ((o (pair  ))) 
             (pair-b o)))))

;;; Exercise for the reader: Write a compiler-macro that emits appropriate compiler-notes
(disassemble (lambda (o)
               (declare (extype (pair fixnum fixnum) o)
                        (optimize speed))
               (cl:+ (pair-a o)
                     (pair-b o))))
;=> On SBCL: contains a call to GENERIC-+
; Size: 28 bytes. Origin: #x53ACFD74                          ; (COMMON-LISP:LAMBDA
;                                                                   (O))
; 74:       488B4205         MOV RAX, [RDX+5]
; 78:       488B7A0D         MOV RDI, [RDX+13]
; 7C:       488BD0           MOV RDX, RAX
; 7F:       FF1425F000A052   CALL QWORD PTR [#x52A000F0]      ; GENERIC-+
; 86:       488BE5           MOV RSP, RBP
; 89:       F8               CLC
; 8A:       5D               POP RBP
; 8B:       C3               RET
; 8C:       CC10             INT3 16                          ; Invalid argument count trap
; 8E:       CC10             INT3 16                          ; Invalid argument count trap

(disassemble (lambda (o)
               (declare (extype (pair fixnum fixnum) o)
                        (optimize speed))
               (cl:+ (slot-a o)
                     (slot-b o))))
;=> On SBCL: direct addition, without a call to GENRIC-+
; Size: 61 bytes. Origin: #x53ACFC34                          ; (COMMON-LISP:LAMBDA
;                                                                   (O))
; 34:       488B4A05         MOV RCX, [RDX+5]
; 38:       F6C101           TEST CL, 1
; 3B:       752D             JNE L2
; 3D:       48D1F9           SAR RCX, 1
; 40:       488B520D         MOV RDX, [RDX+13]
; 44:       F6C201           TEST DL, 1
; 47:       751E             JNE L1
; 49:       48D1FA           SAR RDX, 1
; 4C:       4801D1           ADD RCX, RDX
; 4F:       48D1E1           SHL RCX, 1
; 52:       710A             JNO L0
; 54:       48D1D9           RCR RCX, 1
; 57:       FF14254801A052   CALL QWORD PTR [#x52A00148]      ; ALLOC-SIGNED-BIGNUM-IN-RCX
; 5E: L0:   488BD1           MOV RDX, RCX
; 61:       488BE5           MOV RSP, RBP
; 64:       F8               CLC
; 65:       5D               POP RBP
; 66:       C3               RET
; 67: L1:   CC4F             INT3 79                          ; OBJECT-NOT-FIXNUM-ERROR
; 69:       08               BYTE #X08                        ; RDX(d)
; 6A: L2:   CC4F             INT3 79                          ; OBJECT-NOT-FIXNUM-ERROR
; 6C:       04               BYTE #X04                        ; RCX(d)
; 6D:       CC10             INT3 16                          ; Invalid argument count trap
; 6F:       CC10             INT3 16                          ; Invalid argument count trap

(disassemble (lambda (o)
               (declare (extype (pair single-float single-float) o)
                        (optimize speed))
               (cl:+ (slot-a o)
                     (slot-b o))))
;=> On SBCL: direct addition, without a call to GENRIC-+
; Size: 65 bytes. Origin: #x53ACFAE4                          ; (COMMON-LISP:LAMBDA
;                                                                   (O))
; AE4:       488B4205         MOV RAX, [RDX+5]
; AE8:       3C19             CMP AL, 25
; AEA:       7532             JNE L1
; AEC:       66480F6EC8       MOVQ XMM1, RAX
; AF1:       0FC6C9FD         SHUFPS XMM1, XMM1, #4r3331
; AF5:       488B420D         MOV RAX, [RDX+13]
; AF9:       3C19             CMP AL, 25
; AFB:       751E             JNE L0
; AFD:       66480F6ED0       MOVQ XMM2, RAX
; B02:       0FC6D2FD         SHUFPS XMM2, XMM2, #4r3331
; B06:       F30F58D1         ADDSS XMM2, XMM1
; B0A:       660F7ED2         MOVD EDX, XMM2
; B0E:       48C1E220         SHL RDX, 32
; B12:       80CA19           OR DL, 25
; B15:       488BE5           MOV RSP, RBP
; B18:       F8               CLC
; B19:       5D               POP RBP
; B1A:       C3               RET
; B1B: L0:   CC4C             INT3 76                         ; OBJECT-NOT-SINGLE-FLOAT-ERROR
; B1D:       00               BYTE #X00                       ; RAX(d)
; B1E: L1:   CC4C             INT3 76                         ; OBJECT-NOT-SINGLE-FLOAT-ERROR
; B20:       00               BYTE #X00                       ; RAX(d)
; B21:       CC10             INT3 16                         ; Invalid argument count trap
; B23:       CC10             INT3 16                         ; Invalid argument count trap
#+END_SRC

* Using cl-form-types for better compile-time checks

cl-form-types can also be used to provide better compile time checks for the extended-types. TODO: Think about where to put this in, perhaps in cl-form-types?

#+begin_src lisp
(in-package :extensible-compound-types.impl)
(defun cl-form-types-check (value-type form env)
  (let ((optimize-decl (declaration-information 'optimize env)))
    (when (> (second (assoc 'speed optimize-decl))
             (second (assoc 'safety optimize-decl)))
      (return-from cl-form-types-check t))
    (let ((form-type (cl-form-types:form-type form env)))
      (when (and (member :sbcl cl:*features*)
                 (type= (upgraded-cl-type form-type env)
                        form-type
                        env)
                 (type= (upgraded-cl-type value-type env)
                        value-type
                        env))
        (return-from cl-form-types-check t))
      (multiple-value-bind (intersectp knownp)
          (intersect-type-p form-type value-type env)
        (when (and knownp (not intersectp) (not (type= form-type t)))
          (warn "Type declarations for~%  ~S~%conflict:~%  ~S~%does not intersect with~%  ~S"
                form form-type value-type)))
      nil)))
(pushnew 'cl-form-types-check *the-skip-predicates*)
#+end_src

* TODO Needs more work 

- typelet
- typelet*
- Specifying better predicates for =*the-skip-predicates*=

- Creating a wrapper for CL:LOOP
  
* Internal Discussion

** Usage API

- cl-shadowing package: This should not do type-declaration-upgradation. This was an option earlier, because "why not". However, this cannot be done, because the part on type-declaration-upgradation can wreak havoc on user's expectations. For instance, below, one might expect =foo-caller= to compile successfully, but it does not:

  #+BEGIN_SRC lisp
    (define-polymorphic-function foo (a) :overwrite t)

    (defpolymorph foo ((x number)) number
      (setq x (coerce x 'single-float))
      (cl:+ x x))

    (defun foo-caller (b)
      (declare (optimize speed)
               (type fixnum b))
      (foo b))
  #+END_SRC

** Shadowing CL package

DEFAULT-THE-SKIP-PREDICATE

- Call a function TYPE-SAFE, if its guaranteed that at runtime, its arguments are of the type given by the compile time declarations, as well as the return values are of the appropriate types declared at compile time.
- Such TYPE-SAFE functions do not need a runtime type check, if its arguments are pre-tested to be of the appropriate types.
- Functions made by composing type-safe functions are type-safe. That is they do not require type checks. /(What is composing?)/

- Suppose we have a core set of type-safe functions. Then, functions that call these functions need not do any type checking of the return-values of the type-safe functions, if the declared return-types are a subtype of the caller's arguments parameter-type declarations.

** subtypep

*** If two types are such that one type has a greater number of specified parameters than another, then should that mean first is more specialized than second?

No, because we also want to allow for types like ~(type= /type/)~.

*** What should the relations between two compound types corresponding to subclass and superclass?

Nothing. We are not implementing parametric types. We are implementing compound types.

** Only specialized types, or more general compound types like ~(type= /type/)~?

Allow for more general compound types.

** Comparison with cl-parametric-types

https://github.com/cosmos72/cl-parametric-types

We allow for more general types like ~(type= /type/)~.

** Comparison with ctype

Faster =typep= due to avoidance of =specifier-type=. TODO: Measure

** Comments by more experienced lispers

- https://www.reddit.com/r/lisp/comments/qmrycl/comment/hjkn7qr/?utm_source=share&utm_medium=web2x&context=3
  - stylewarning does say that PF (or derivatives?) is useful for describing concrete values, which is the primary goal of this library.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 extensible-compound-types

EXTENSIBLE-COMPOUND-TYPES for user-defined compound-types like (array &optional element-type dimension-spec)

Author

Shubhamkar B. Ayare (digikar)

License

MIT

Version

0.0.0

Dependencies
  • alexandria (system).
  • cl-environments (system).
  • compiler-macro-notes (system).
  • fiveam (system).
  • in-nomine (system).
  • trivial-types (system).
Source

extensible-compound-types.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


3.1.1 extensible-compound-types/extensible-compound-types.asd

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

ASDF Systems

extensible-compound-types.


3.1.2 extensible-compound-types/package.lisp

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Packages
Public Interface
Internals

3.1.3 extensible-compound-types/typep.lisp

Dependency

package.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface
Internals

3.1.4 extensible-compound-types/others.lisp

Dependency

typep.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface
Internals

speed-more-safety-less-p (function).


3.1.5 extensible-compound-types/cl-compound-types.lisp

Dependency

others.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface
Internals

equivalent-num-type-form (function).


3.1.6 extensible-compound-types/compound-only-type-specifiers.lisp

Dependency

cl-compound-types.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface

3.1.7 extensible-compound-types/intersect-type-p.lisp

Dependency

compound-only-type-specifiers.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface

3.1.8 extensible-compound-types/subtypep.lisp

Dependency

intersect-type-p.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Public Interface
Internals

3.1.9 extensible-compound-types/designators.lisp

Dependency

subtypep.lisp (file).

Source

extensible-compound-types.asd.

Parent Component

extensible-compound-types (system).

Internals

4 Packages

Packages are listed by definition order.


4.1 extensible-compound-types.impl

Source

package.lisp.

Use List
Internals

4.2 extensible-compound-types

Source

package.lisp.

Used By List

extensible-compound-types.impl.

Public Interface

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *excluded-packages-for-cl-deftype*

EXTENSIBLE-COMPOUND-TYPES:DEFTYPE avoids adding a CL:DEFTYPE if the NAME is a symbol in package excluded in this list.

Package

extensible-compound-types.

Source

package.lisp.

Special Variable: *the-skip-predicates*

A list of function-designators. THE avoids checking the VALUE-TYPE of FORM if at least one of the predicates returns a non-NIL value. This is useful for optimization purposes.

Each predicate should take three arguments: VALUE-TYPE FORM ENV

Package

extensible-compound-types.

Source

others.lisp.


5.1.2 Macros

Macro: check-type (place type &optional type-string)
Package

extensible-compound-types.

Source

others.lisp.

Macro: define-compound-type (name-spec (object-name &rest lambda-list) &body body)

EXTENSIBLE-COMPOUND-TYPES:TYPEP relies on these whenever TYPE supplied is non-atomic and non-class.

NAME-SPEC can be either NAME or (NAME &KEY (NON-NULL T) (CL-TYPE T))

NON-NULL being non-NIL indicates that no matter what the arguments
in lambda-list the type is always not nil.
DEFINE-COMPOUND-TYPE also automatically creates a CL:DEFTYPE using UPGRADED-CL-TYPE. However, if the NAME is a symbol in one of the packages *EXCLUDED-PACKAGES-FOR-CL-DEFTYPE*, then a CL:DEFTYPE is not created. This
can be overriden by supplying the value of CL-TYPE.

Note: Whenever possible, it is recommended to use EXTENSIBLE-COMPOUND-TYPES:DEFTYPE and only use EXTENSIBLE-COMPOUND-TYPES:DEFINE-COMPOUND-TYPE as a last resort. Use of DEFINE-COMPOUND-TYPE also entails getting the %SUBTYPEP and %INTERSECT-TYPE-P methods correct.

Package

extensible-compound-types.

Source

typep.lisp.

Macro: define-compound-type-compiler-macro (name (object-name &rest lambda-list) &body body)

EXTENSIBLE-COMPOUND-TYPES:TYPEP relies on these whenever TYPE supplied is non-atomic.

Package

extensible-compound-types.

Source

typep.lisp.

Macro: define-mutually-exclusive-types (&body types)
Package

extensible-compound-types.

Source

intersect-type-p.lisp.

Macro: deftype (name lambda-list &body body)

Useful for defining type aliases, example: (DEFTYPE INT32 () ’(SIGNED-BYTE 32))

Depending on the value of *EXCLUDED-PACKAGES-FOR-CL-DEFTYPE*,
also adds a CL:DEFTYPE with the expansion being determined by UPGRADED-CL-TYPE

Package

extensible-compound-types.

Source

package.lisp.

Macro: the (value-type form)

At runtime, signals a TYPE-ERROR unless (TYPEP FORM VALUE-TYPE) holds.

Necessary: A check has to be present at the "top-level". The runtime check can be avoided for optimization purposes if at least one predicate in *THE-SKIP-PREDICATES* returns non-NIL.

Package

extensible-compound-types.

Source

others.lisp.

Macro: undeftype (name)
Package

extensible-compound-types.

Source

package.lisp.


5.1.3 Compiler macros

Compiler Macro: typep (object-form type-form &optional env-form)
Package

extensible-compound-types.

Source

typep.lisp.


5.1.4 Ordinary functions

Function: intersect-type-p (type1 type2 &optional env)

Usually, intersection can be tested for by calling (SUBTYPEP ’(AND TYPE1 TYPE2) NIL). However, this itself requires knowing whether or not TYPE1 and TYPE2 intersect. For instance, the types
- (OR STRING NUMBER) and (OR STRING SYMBOL)
- (ARRAY * 1) and (ARRAY SINGLE-FLOAT *)

TODO: Improve documentation for this.

Package

extensible-compound-types.

Source

others.lisp.

Function: intersection-null-p (env &rest type-specifiers)
Package

extensible-compound-types.

Source

others.lisp.

Function: subtypep (type1 type2 &optional environment)

Behaves like CL:SUBTYPEP when type1 and type2 are atomic type specifiers, corresponding to a CLASS; but when either is a list, calls the generic-function %SUBTYPEP to determine the SUBTYPEP relation.

Package

extensible-compound-types.

Source

others.lisp.

Function: supertypep (type1 type2 &optional environment)
Package

extensible-compound-types.

Source

others.lisp.

Function: type-specifier-p (object &optional env)
Package

extensible-compound-types.

Source

package.lisp.

Function: type= (type1 type2 &optional environment)
Package

extensible-compound-types.

Source

others.lisp.

Function: typep (object type &optional environment)

Like CL:TYPEP if TYPE is an ATOM; but otherwise uses COMPOUND-TYPE-LAMBDA to determine TYPEP.

Package

extensible-compound-types.

Source

typep.lisp.

Function: typexpand (type &optional env)
Package

extensible-compound-types.

Source

package.lisp.

Function: typexpand-1 (type &optional env)

Returns two values: EXPANSION and EXPANDEDP

Package

extensible-compound-types.

Source

package.lisp.

Function: undefine-compound-type (name)
Package

extensible-compound-types.

Source

typep.lisp.

Function: undefine-compound-type-compiler-macro (name)
Package

extensible-compound-types.

Source

typep.lisp.

Function: upgraded-cl-type (type-specifier &optional environment)

If TYPE-SPECIFIER is a non-ATOM, uses %UPGRADED-CL-TYPE to upgraded to a CL type. The default unspecialized method corresponding to (T T) returns the type as it is.

Package

extensible-compound-types.

Source

others.lisp.


5.1.5 Generic functions

Generic Function: %intersect-type-p (type1-name type2-name type1 type2 &optional env)

INTERSECT-TYPE-P guarantees that this generic function is called only after both TYPE1 and TYPE2 are expanded.

Package

extensible-compound-types.

Source

others.lisp.

Methods
Method: %intersect-type-p ((t1 (eql null)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql float)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql null)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql null)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql integer)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql integer)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql function)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql function)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql complex)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql complex)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql double-float)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql double-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql single-float)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql single-float)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql character)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql character)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql symbol)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql symbol)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql cons)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql cons)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql rational)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql rational)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (t1 (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) t2 type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (t1 (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) t2 type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql simple-array)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1 (eql array)) (t2 (eql array)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (n1 (n2 (eql eql)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((n1 (eql eql)) n2 t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (n1 (n2 (eql not)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((n1 (eql not)) n2 t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (t2-name (t1-name (eql and)) type2 type1 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((n1 (eql and)) n2 t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (t2-name (t1-name (eql or)) type2 type1 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1-name (eql or)) t2-name type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p ((t1-name (eql or)) (t2-name (eql or)) type1 type2 &optional env)
Source

intersect-type-p.lisp.

Method: %intersect-type-p (type1-name type2-name type1 type2 &optional env)
Generic Function: %subtypep (t1-name t2-name type1 type2 &optional env)
Package

extensible-compound-types.

Source

others.lisp.

Methods
Method: %subtypep ((n1 (eql character)) (n2 (eql base-char)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql base-char)) (n2 (eql character)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql standard-char)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql standard-char)) (n2 (eql character)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql base-char)) (n2 (eql standard-char)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql standard-char)) (n2 (eql base-char)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql rational)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (n1 (n2 (eql long-float)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql long-float)) n2 t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (n1 (n2 (eql short-float)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql short-float)) n2 t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (n1 (n2 (eql complex)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql complex)) n2 t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql complex)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql sequence)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql sequence)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1 (eql simple-array)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1 (eql simple-array)) (t2 (eql array)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1 (eql array)) (t2 (eql simple-array)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1 (eql array)) (t2 (eql array)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql eql)) t2-name type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql eql)) (t2-name (eql eql)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (t1-name (t2-name (eql not)) t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql not)) t2-name t1 t2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (t1-name (t2-name (eql or)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql or)) t2-name type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql and)) (t2-name (eql nil)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep (t1-name (t2-name (eql and)) type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((t1-name (eql and)) t2-name type1 type2 &optional env)
Source

subtypep.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql float)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql null)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql null)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql integer)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql function)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql function)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql complex)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql complex)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql double-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql single-float)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql character)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql character)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql symbol)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql symbol)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql simple-array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql simple-array)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql cons)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql cons)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql array)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((n1 (eql array)) (n2 (eql rational)) t1 t2 &optional env)
Source

intersect-type-p.lisp.

Method: %subtypep ((t1-name (eql values)) (t2-name (eql nil)) type1 type2 &optional env)
Source

compound-only-type-specifiers.lisp.

Method: %subtypep ((t1-name (eql satisfies)) (t2-name (eql nil)) type1 type2 &optional env)
Source

compound-only-type-specifiers.lisp.

Method: %subtypep ((n1 (eql double-float)) (n2 (eql double-float)) t1 t2 &optional env)
Source

cl-compound-types.lisp.

Method: %subtypep ((n1 (eql single-float)) (n2 (eql single-float)) t1 t2 &optional env)
Source

cl-compound-types.lisp.

Method: %subtypep ((n1 (eql rational)) (n2 (eql rational)) t1 t2 &optional env)
Source

cl-compound-types.lisp.

Method: %subtypep ((n1 (eql integer)) (n2 (eql integer)) t1 t2 &optional env)
Source

cl-compound-types.lisp.

Method: %subtypep (t1-name t2-name type1 type2 &optional env)
Generic Function: %upgraded-cl-type (type-name type &optional env)
Package

extensible-compound-types.

Source

others.lisp.

Methods
Method: %upgraded-cl-type (type-name type &optional env)

5.1.6 Conditions

Condition: unknown-type-specifier
Package

extensible-compound-types.

Source

package.lisp.

Direct superclasses

error.

Direct slots
Slot: type-specifier
Package

extensible-compound-types.impl.

Initargs

:type


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Special variables

Special Variable: *compound-type-compiler-macros*
Package

extensible-compound-types.impl.

Source

typep.lisp.

Special Variable: *compound-type-lambda-expressions*
Package

extensible-compound-types.impl.

Source

typep.lisp.

Special Variable: *compound-type-lambdas*
Package

extensible-compound-types.impl.

Source

typep.lisp.

Special Variable: *type-expanders*
Package

extensible-compound-types.impl.

Source

package.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.2 Ordinary functions

Function: atomic-type-specifier-p (type)
Package

extensible-compound-types.impl.

Source

package.lisp.

Function: character-designator-p (object)
Package

extensible-compound-types.impl.

Source

designators.lisp.

Function: compound-type-compiler-macro (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: (setf compound-type-compiler-macro) (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: compound-type-lambda (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: (setf compound-type-lambda) (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: compound-type-lambda-expression (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: (setf compound-type-lambda-expression) (type)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: compound-type-nonexpander (expr env)
Package

extensible-compound-types.impl.

Source

typep.lisp.

Function: equivalent-num-type-form (num-type low high)
Package

extensible-compound-types.impl.

Source

cl-compound-types.lisp.

Function: extype-boundp (name)

Automatically defined boundp function.

Package

extensible-compound-types.impl.

Source

package.lisp.

Function: extype-makunbound (name)

Automatically defined makunbound function.

Package

extensible-compound-types.impl.

Source

package.lisp.

Function: find-class (name &optional errorp environment)
Package

extensible-compound-types.impl.

Source

package.lisp.

Function: flatten-type-specifier-combination (combination type-specifier &optional env)
Package

extensible-compound-types.impl.

Source

subtypep.lisp.

Function: function-designator-p (object)
Package

extensible-compound-types.impl.

Source

designators.lisp.

Function: ignore-all-form-from-lambda-list (lambda-list)
Package

extensible-compound-types.impl.

Source

package.lisp.

Function: simplify-and-type (and-type-specifier &optional env)
Package

extensible-compound-types.impl.

Source

subtypep.lisp.

Function: simplify-or-type (or-type-specifier &optional env)
Package

extensible-compound-types.impl.

Source

subtypep.lisp.

Function: speed-more-safety-less-p (value-type form env)
Package

extensible-compound-types.impl.

Source

others.lisp.

Function: symbol-extype (name &optional default)

Automatically defined reader function.
Signals UNBOUND-EXTYPE if the value is not found in the namespace.
When DEFAULT is supplied and the symbol is not bound, the default value is automatically set.

Package

extensible-compound-types.impl.

Source

package.lisp.

Function: (setf symbol-extype) (name &optional default)

Automatically defined writer function.

Package

extensible-compound-types.impl.

Source

package.lisp.

Function: type-expander (name)
Package

extensible-compound-types.impl.

Source

package.lisp.

Function: (setf type-expander) (name)
Package

extensible-compound-types.impl.

Source

package.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Conditions

Condition: unbound-extype
Package

extensible-compound-types.impl.

Source

package.lisp.

Direct superclasses

cell-error.


Previous: , Up: Internals   [Contents][Index]

5.2.4 Types

Type: extype-type ()
Package

extensible-compound-types.impl.

Source

package.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   C   D   E   F   G   I   M   S   T   U  
Index Entry  Section

%
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%intersect-type-p: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%subtypep: Public generic functions
%upgraded-cl-type: Public generic functions
%upgraded-cl-type: Public generic functions

(
(setf compound-type-compiler-macro): Private ordinary functions
(setf compound-type-lambda): Private ordinary functions
(setf compound-type-lambda-expression): Private ordinary functions
(setf symbol-extype): Private ordinary functions
(setf type-expander): Private ordinary functions

A
atomic-type-specifier-p: Private ordinary functions

C
character-designator-p: Private ordinary functions
check-type: Public macros
Compiler Macro, typep: Public compiler macros
compound-type-compiler-macro: Private ordinary functions
compound-type-lambda: Private ordinary functions
compound-type-lambda-expression: Private ordinary functions
compound-type-nonexpander: Private ordinary functions

D
define-compound-type: Public macros
define-compound-type-compiler-macro: Public macros
define-mutually-exclusive-types: Public macros
deftype: Public macros

E
equivalent-num-type-form: Private ordinary functions
extype-boundp: Private ordinary functions
extype-makunbound: Private ordinary functions

F
find-class: Private ordinary functions
flatten-type-specifier-combination: Private ordinary functions
Function, (setf compound-type-compiler-macro): Private ordinary functions
Function, (setf compound-type-lambda): Private ordinary functions
Function, (setf compound-type-lambda-expression): Private ordinary functions
Function, (setf symbol-extype): Private ordinary functions
Function, (setf type-expander): Private ordinary functions
Function, atomic-type-specifier-p: Private ordinary functions
Function, character-designator-p: Private ordinary functions
Function, compound-type-compiler-macro: Private ordinary functions
Function, compound-type-lambda: Private ordinary functions
Function, compound-type-lambda-expression: Private ordinary functions
Function, compound-type-nonexpander: Private ordinary functions
Function, equivalent-num-type-form: Private ordinary functions
Function, extype-boundp: Private ordinary functions
Function, extype-makunbound: Private ordinary functions
Function, find-class: Private ordinary functions
Function, flatten-type-specifier-combination: Private ordinary functions
Function, function-designator-p: Private ordinary functions
Function, ignore-all-form-from-lambda-list: Private ordinary functions
Function, intersect-type-p: Public ordinary functions
Function, intersection-null-p: Public ordinary functions
Function, simplify-and-type: Private ordinary functions
Function, simplify-or-type: Private ordinary functions
Function, speed-more-safety-less-p: Private ordinary functions
Function, subtypep: Public ordinary functions
Function, supertypep: Public ordinary functions
Function, symbol-extype: Private ordinary functions
Function, type-expander: Private ordinary functions
Function, type-specifier-p: Public ordinary functions
Function, type=: Public ordinary functions
Function, typep: Public ordinary functions
Function, typexpand: Public ordinary functions
Function, typexpand-1: Public ordinary functions
Function, undefine-compound-type: Public ordinary functions
Function, undefine-compound-type-compiler-macro: Public ordinary functions
Function, upgraded-cl-type: Public ordinary functions
function-designator-p: Private ordinary functions

G
Generic Function, %intersect-type-p: Public generic functions
Generic Function, %subtypep: Public generic functions
Generic Function, %upgraded-cl-type: Public generic functions

I
ignore-all-form-from-lambda-list: Private ordinary functions
intersect-type-p: Public ordinary functions
intersection-null-p: Public ordinary functions

M
Macro, check-type: Public macros
Macro, define-compound-type: Public macros
Macro, define-compound-type-compiler-macro: Public macros
Macro, define-mutually-exclusive-types: Public macros
Macro, deftype: Public macros
Macro, the: Public macros
Macro, undeftype: Public macros
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %intersect-type-p: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %subtypep: Public generic functions
Method, %upgraded-cl-type: Public generic functions

S
simplify-and-type: Private ordinary functions
simplify-or-type: Private ordinary functions
speed-more-safety-less-p: Private ordinary functions
subtypep: Public ordinary functions
supertypep: Public ordinary functions
symbol-extype: Private ordinary functions

T
the: Public macros
type-expander: Private ordinary functions
type-specifier-p: Public ordinary functions
type=: Public ordinary functions
typep: Public compiler macros
typep: Public ordinary functions
typexpand: Public ordinary functions
typexpand-1: Public ordinary functions

U
undefine-compound-type: Public ordinary functions
undefine-compound-type-compiler-macro: Public ordinary functions
undeftype: Public macros
upgraded-cl-type: Public ordinary functions

Jump to:   %   (  
A   C   D   E   F   G   I   M   S   T   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   D   E   F   I   O   P   S   T   U  
Index Entry  Section

C
cl-compound-types.lisp: The extensible-compound-types/cl-compound-types․lisp file
compound-only-type-specifiers.lisp: The extensible-compound-types/compound-only-type-specifiers․lisp file
Condition, unbound-extype: Private conditions
Condition, unknown-type-specifier: Public conditions

D
designators.lisp: The extensible-compound-types/designators․lisp file

E
extensible-compound-types: The extensible-compound-types system
extensible-compound-types: The extensible-compound-types package
extensible-compound-types.asd: The extensible-compound-types/extensible-compound-types․asd file
extensible-compound-types.impl: The extensible-compound-types․impl package
extype-type: Private types

F
File, cl-compound-types.lisp: The extensible-compound-types/cl-compound-types․lisp file
File, compound-only-type-specifiers.lisp: The extensible-compound-types/compound-only-type-specifiers․lisp file
File, designators.lisp: The extensible-compound-types/designators․lisp file
File, extensible-compound-types.asd: The extensible-compound-types/extensible-compound-types․asd file
File, intersect-type-p.lisp: The extensible-compound-types/intersect-type-p․lisp file
File, others.lisp: The extensible-compound-types/others․lisp file
File, package.lisp: The extensible-compound-types/package․lisp file
File, subtypep.lisp: The extensible-compound-types/subtypep․lisp file
File, typep.lisp: The extensible-compound-types/typep․lisp file

I
intersect-type-p.lisp: The extensible-compound-types/intersect-type-p․lisp file

O
others.lisp: The extensible-compound-types/others․lisp file

P
Package, extensible-compound-types: The extensible-compound-types package
Package, extensible-compound-types.impl: The extensible-compound-types․impl package
package.lisp: The extensible-compound-types/package․lisp file

S
subtypep.lisp: The extensible-compound-types/subtypep․lisp file
System, extensible-compound-types: The extensible-compound-types system

T
Type, extype-type: Private types
typep.lisp: The extensible-compound-types/typep․lisp file

U
unbound-extype: Private conditions
unknown-type-specifier: Public conditions

Jump to:   C   D   E   F   I   O   P   S   T   U