Optima renamed TYPEP to TYPE to match a type. Fix exscribe.

diff --git a/bibliography.lisp b/bibliography.lisp
index fa15b51..d11815d 100644 (file)
--- a/bibliography.lisp
+++ b/bibliography.lisp
@@ -20,7 +20,7 @@
   (let ((h (make-hash-table :test 'eql)))
     (dolist (f fields)
       (ematch f
-       ((list (and fn (typep symbol)) fv)
+       ((list (and fn (type symbol)) fv)
          (setf (gethash fn h) fv))))
     h))
 (defun init-bib-entry (m kind ident fields)
@@ -39,8 +39,8 @@
        (warn "Discarding duplicate bibliography entry ~A" ident))))
 (defun bib-add! (table entry)
   (match entry
-    ((list* (and kind (typep symbol))
-           (and ident (typep (or string symbol)))
+    ((list* (and kind (type symbol))
+           (and ident (type (or string symbol)))
            fields)
      (let* ((ident (conc-string ident))
            (old (gethash ident table)))

diff --git a/exscribe-html.lisp b/exscribe-html.lisp
index d459db6..535d785 100644 (file)
--- a/exscribe-html.lisp
+++ b/exscribe-html.lisp
@@ -56,7 +56,7 @@
           ((tag :p _ _) x)
           ((tag :id _ x) (walk x))
           ((tag _ _ _) (fail))
-          ((typep string) (fail))
+          ((type string) (fail))
           ((cons x y) (or (walk x) (walk y)))
           (_ nil))))
     (walk x)))

diff --git a/exscribe-txt.lisp b/exscribe-txt.lisp
index 253db02..b7af063 100644 (file)
--- a/exscribe-txt.lisp
+++ b/exscribe-txt.lisp
@@ -36,7 +36,7 @@
            ((tag :br _ _) (space))
            ((tag :footnote _ _) nil)
            ((tag _ _ x) (walk x))
-           ((typep string) (emit x))
+           ((type string) (emit x))
            ((cons x y) (walk x) (walk y))
            (_ nil))))
     (walk node)

diff --git a/exscribe-typeset.lisp b/exscribe-typeset.lisp
index 92f12c5..860ecea 100644 (file)
--- a/exscribe-typeset.lisp
+++ b/exscribe-typeset.lisp
@@ -334,16 +334,16 @@ Also, some code stolen from com.gigamonkeys.markup, then mutilated.
      (process a)
      (process b))
 
-    ((typep character)
+    ((type character)
      (process (string x)))
 
-    ((typep string)
+    ((type string)
      (emit (if *significant-whitespace*
               `(verbatim ,x)
               `(put-string ,x))))
 
     ;; having full blown closures generated in order to print a single character  which can just be included as-is seems like a gratuitious complexity to me. or is there a deeper reason, maybe for other backends?
-    ((typep function)
+    ((type function)
      (emit `(verbatim ,(with-output-to-string (s) (funcall x s)))))
 
     ((tag :p options list)