;;;; tinyclos-primitive-objects-incl.scm

;convenience routines to elide an argument

(define (make-immediate-class name . supers)
  (apply make-primitive-class name <immediate> supers) )

(define (make-sequence-class name . supers)
  (apply make-primitive-class name <sequence> supers) )

(define (make-port-class name . supers)
  (apply make-primitive-class name <port> supers) )

(define (make-vector-class name . supers)
  (apply make-primitive-class name <vector> supers) )

(define (make-pointer-class name . supers)
  (apply make-primitive-class name <pointer> supers) )

(define (make-structure-class name . supers)
  (apply make-primitive-class name <structure> supers) )

;the primitives

(define <immediate>             (make-primitive-class "immediate"))
(define <void>                  (make-immediate-class "void"))
(define <end-of-file>           (make-immediate-class "end-of-file"))
(define <boolean>               (make-immediate-class "boolean"))
(define <char>                  (make-immediate-class "char"))

(define <symbol>                (make-primitive-class "symbol"))

(define <sequence>              (make-primitive-class "sequence"))
(define <null>                  (make-immediate-class "null" <sequence>))
(define <vector>                (make-sequence-class "vector"))
(define <pair>                  (make-sequence-class "pair"))
(define <string>                (make-sequence-class "string"))

(define <number>                (make-primitive-class "number"))
(define <integer>               (make-primitive-class "integer" <number>))
(define <exact>                 (make-primitive-class "exact" <integer>))
(define <inexact>               (make-primitive-class "inexact" <number>))

(define <port>                  (make-primitive-class "port"))
(define <input-port>            (make-port-class "input-port"))
(define <output-port>           (make-port-class "output-port"))

(define <blob>                  (make-primitive-class "blob"))

(define <locative>              (make-primitive-class "locative"))

(define <pointer>               (make-primitive-class "pointer"))
(define <swig-pointer>          (make-pointer-class "swig-pointer"))
(define <tagged-pointer>        (make-pointer-class "tagged-pointer"))

(define <structure>             (make-primitive-class "structure"))
(define <environment>           (make-structure-class "environment" <sequence>))
(define <promise>               (make-structure-class "promise"))
(define <condition>             (make-structure-class "condition"))
(define <condition-variable>    (make-structure-class "condition-variable"))
(define <continuation>          (make-structure-class "continuation"))
(define <read-table>            (make-structure-class "read-table"))
(define <queue>                 (make-structure-class "queue" <sequence>))
(define <hash-table>            (make-structure-class "hash-table" <sequence>))
(define <char-set>              (make-structure-class "char-set" <sequence>))
(define <time>                  (make-structure-class "time"))
(define <thread>                (make-structure-class "thread"))
(define <mutex>                 (make-structure-class "mutex"))
(define <lock>                  (make-structure-class "lock"))
(define <mmap>                  (make-structure-class "mmap"))
(define <tcp-listener>          (make-structure-class "tcp-listener"))
(define <regexp>                (make-structure-class "regexp"))

(define <u8vector>              (make-vector-class "u8vector"))
(define <s8vector>              (make-vector-class "s8vector"))
(define <u16vector>             (make-vector-class "u16vector"))
(define <s16vector>             (make-vector-class "s16vector"))
(define <u32vector>             (make-vector-class "u32vector"))
(define <s32vector>             (make-vector-class "s32vector"))
#;(define <u64vector>             (make-vector-class "u64vector"))
#;(define <s64vector>             (make-vector-class "s64vector"))
(define <f32vector>             (make-vector-class "f32vector"))
(define <f64vector>             (make-vector-class "f64vector"))

(define <array>                 (make-structure-class "array" <sequence>))