Common Lisp: Do not prefix symbols with package name unnecessarily

diff --git a/common-lisp/src/core.lisp b/common-lisp/src/core.lisp
index e8a4efc..06c7a03 100644 (file)
--- a/common-lisp/src/core.lisp
+++ b/common-lisp/src/core.lisp
@@ -10,7 +10,7 @@
 
 (in-package :core)
 
-(define-condition index-error (types:mal-error)
+(define-condition index-error (mal-error)
   ((size :initarg :size :reader index-error-size)
    (index :initarg :index :reader index-error-index)
    (sequence :initarg :sequence :reader index-error-sequence))
@@ -87,16 +87,16 @@
   (make-mal-list values))
 
 (defmal list? (value)
-  (wrap-boolean (or (types:mal-nil-p value) (types:mal-list-p value))))
+  (wrap-boolean (or (mal-nil-p value) (mal-list-p value))))
 
 (defmal empty? (value)
-  (wrap-boolean (zerop (length (types:mal-data-value value)))))
+  (wrap-boolean (zerop (length (mal-data-value value)))))
 
 (defmal count (value)
   (make-mal-number (length (mal-data-value value))))
 
 (defmal = (value1 value2)
-  (wrap-boolean (types:mal-data-value= value1 value2)))
+  (wrap-boolean (mal-data-value= value1 value2)))
 
 (defmal < (value1 value2)
   (wrap-boolean (< (mal-data-value value1) (mal-data-value value2))))
@@ -111,114 +111,114 @@
   (wrap-boolean (>= (mal-data-value value1) (mal-data-value value2))))
 
 (defmal read-string (value)
-  (reader:read-str (types:mal-data-value value)))
+  (reader:read-str (mal-data-value value)))
 
 (defmal slurp (filename)
   (make-mal-string (read-file-string (mal-data-value filename))))
 
 (defmal atom (value)
-  (types:make-mal-atom value))
+  (make-mal-atom value))
 
 (defmal atom? (value)
-  (wrap-boolean (types:mal-atom-p value)))
+  (wrap-boolean (mal-atom-p value)))
 
 (defmal deref (atom)
-  (types:mal-data-value atom))
+  (mal-data-value atom))
 
 (defmal reset! (atom value)
-  (setf (types:mal-data-value atom) value))
+  (setf (mal-data-value atom) value))
 
 (defmal swap! (atom fn &rest args)
-  (setf (types:mal-data-value atom)
-        (apply (types:mal-data-value fn)
-               (append (list (types:mal-data-value atom)) args))))
+  (setf (mal-data-value atom)
+        (apply (mal-data-value fn)
+               (append (list (mal-data-value atom)) args))))
 
 (defmal cons (element list)
-  (types:make-mal-list (cons element (listify (types:mal-data-value list)))))
+  (make-mal-list (cons element (listify (mal-data-value list)))))
 
 (defmal concat (&rest lists)
-  (types:make-mal-list (apply #'concatenate 'list (mapcar #'types:mal-data-value lists))))
+  (make-mal-list (apply #'concatenate 'list (mapcar #'mal-data-value lists))))
 
 (defmal nth (sequence index)
-  (or (nth (types:mal-data-value index)
-           (listify (types:mal-data-value sequence)))
+  (or (nth (mal-data-value index)
+           (listify (mal-data-value sequence)))
       (error 'index-error
-             :size (length (types:mal-data-value sequence))
-             :index (types:mal-data-value index)
+             :size (length (mal-data-value sequence))
+             :index (mal-data-value index)
              :sequence sequence)))
 
 (defmal first (sequence)
-  (or (first (listify (types:mal-data-value sequence))) mal-nil))
+  (or (first (listify (mal-data-value sequence))) mal-nil))
 
 (defmal rest (sequence)
-  (types:make-mal-list (rest (listify (types:mal-data-value sequence)))))
+  (make-mal-list (rest (listify (mal-data-value sequence)))))
 
 (defmal throw (value)
-  (error 'types:mal-user-exception :data value))
+  (error 'mal-user-exception :data value))
 
 (defmal apply (fn &rest values)
-  (let ((last (listify (types:mal-data-value (car (last values)))))
+  (let ((last (listify (mal-data-value (car (last values)))))
         (butlast (butlast values)))
-    (apply (types:mal-data-value fn) (append butlast last))))
+    (apply (mal-data-value fn) (append butlast last))))
 
 (defmal map (fn sequence)
-  (let ((applicants (listify (types:mal-data-value sequence))))
-    (types:make-mal-list (mapcar (types:mal-data-value fn) applicants))))
+  (let ((applicants (listify (mal-data-value sequence))))
+    (make-mal-list (mapcar (mal-data-value fn) applicants))))
 
 (defmal nil? (value)
-  (wrap-boolean (types:mal-nil-p value)))
+  (wrap-boolean (mal-nil-p value)))
 
 (defmal true? (value)
-  (wrap-boolean (and (types:mal-boolean-p value) (types:mal-data-value value))))
+  (wrap-boolean (and (mal-boolean-p value) (mal-data-value value))))
 
 (defmal false? (value)
-  (wrap-boolean (and (types:mal-boolean-p value) (not (types:mal-data-value value)))))
+  (wrap-boolean (and (mal-boolean-p value) (not (mal-data-value value)))))
 
 (defmal symbol (string)
-  (types:make-mal-symbol (types:mal-data-value string)))
+  (make-mal-symbol (mal-data-value string)))
 
 (defmal symbol? (value)
-  (wrap-boolean (types:mal-symbol-p value)))
+  (wrap-boolean (mal-symbol-p value)))
 
 (defmal keyword (keyword)
-  (if (types:mal-keyword-p keyword)
+  (if (mal-keyword-p keyword)
       keyword
-      (types:make-mal-keyword (format nil ":~a" (types:mal-data-value keyword)))))
+      (make-mal-keyword (format nil ":~a" (mal-data-value keyword)))))
 
 (defmal keyword? (value)
-  (wrap-boolean (types:mal-keyword-p value)))
+  (wrap-boolean (mal-keyword-p value)))
 
 (defmal vector (&rest elements)
-  (types:make-mal-vector (map 'vector #'identity elements)))
+  (make-mal-vector (map 'vector #'identity elements)))
 
 (defmal vector? (value)
-  (wrap-boolean (types:mal-vector-p value)))
+  (wrap-boolean (mal-vector-p value)))
 
 (defmal hash-map (&rest elements)
-  (let ((hash-map (types:make-mal-value-hash-table)))
+  (let ((hash-map (make-mal-value-hash-table)))
    (loop for (key value) on elements
        by #'cddr
-       do (setf (genhash:hashref key hash-map) value))
-    (types:make-mal-hash-map hash-map)))
+       do (setf (hashref key hash-map) value))
+    (make-mal-hash-map hash-map)))
 
 (defmal map? (value)
-  (wrap-boolean (types:mal-hash-map-p value)))
+  (wrap-boolean (mal-hash-map-p value)))
 
 (defmal assoc (hash-map &rest elements)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-map (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-map (make-mal-value-hash-table)))
 
-    (genhash:hashmap (lambda (key value)
-                       (declare (ignorable value))
-                       (setf (genhash:hashref key new-hash-map)
-                             (genhash:hashref key hash-map-value)))
-                     hash-map-value)
+    (hashmap (lambda (key value)
+               (declare (ignorable value))
+               (setf (hashref key new-hash-map)
+                     (hashref key hash-map-value)))
+             hash-map-value)
 
     (loop for (key value) on elements
        by #'cddr
-       do (setf (genhash:hashref key new-hash-map) value))
+       do (setf (hashref key new-hash-map) value))
 
-    (types:make-mal-hash-map new-hash-map)))
+    (make-mal-hash-map new-hash-map)))
 
 (defmal dissoc (hash-map &rest elements)
   (let ((hash-map-value (mal-data-value hash-map))
@@ -234,14 +234,14 @@
     (make-mal-hash-map new-hash-map)))
 
 (defmal get (hash-map key)
-  (or (and (types:mal-hash-map-p hash-map) (genhash:hashref key (types:mal-data-value hash-map)))
+  (or (and (mal-hash-map-p hash-map) (hashref key (mal-data-value hash-map)))
       types:mal-nil))
 
 (defmal contains? (hash-map key)
   (if (genhash:hashref key (types:mal-data-value hash-map)) types:mal-true types:mal-false))
 
 (defmal keys (hash-map)
-  (let ((hash-map-value (types:mal-data-value hash-map))
+  (let ((hash-map-value (mal-data-value hash-map))
         keys)
 
     (hashmap (lambda (key value)
@@ -252,7 +252,7 @@
     (make-mal-list (nreverse keys))))
 
 (defmal vals (hash-map)
-  (let ((hash-map-value (types:mal-data-value hash-map))
+  (let ((hash-map-value (mal-data-value hash-map))
         values)
 
     (hashmap (lambda (key value)
@@ -263,30 +263,30 @@
     (make-mal-list (nreverse values))))
 
 (defmal sequential? (value)
-  (wrap-boolean (or (types:mal-vector-p value) (types:mal-list-p value))))
+  (wrap-boolean (or (mal-vector-p value) (mal-list-p value))))
 
 (defmal readline (prompt)
-  (format *standard-output* (types:mal-data-value prompt))
+  (format *standard-output* (mal-data-value prompt))
   (force-output *standard-output*)
   (make-mal-string (read-line *standard-input* nil)))
 
 (defmal string? (value)
-  (wrap-boolean (types:mal-string-p value)))
+  (wrap-boolean (mal-string-p value)))
 
 (defmal time-ms ()
-  (types:make-mal-number (round (/ (get-internal-real-time)
-                                   (/ internal-time-units-per-second
-                                      1000)))))
+  (make-mal-number (round (/ (get-internal-real-time)
+                             (/ internal-time-units-per-second
+                                1000)))))
 
 (defmal conj (value &rest elements)
-  (cond ((types:mal-list-p value)
-         (types:make-mal-list (append (nreverse elements)
-                                      (types:mal-data-value value))))
-        ((types:mal-vector-p value)
-         (types:make-mal-vector (concatenate 'vector
-                                             (types:mal-data-value value)
-                                             elements)))
-        (t (error 'types:mal-user-exception))))
+  (cond ((mal-list-p value)
+         (make-mal-list (append (nreverse elements)
+                                (mal-data-value value))))
+        ((mal-vector-p value)
+         (make-mal-vector (concatenate 'vector
+                                       (mal-data-value value)
+                                       elements)))
+        (t (error 'mal-user-exception))))
 
 (defmal seq (value)
   (if (zerop (length (mal-data-value value)))
@@ -301,16 +301,16 @@
 
 (defmal with-meta (value meta)
   (funcall (switch-mal-type value
-                            (types:string #'types:make-mal-string)
-                            (types:symbol #'types:make-mal-symbol)
-                            (types:list #'types:make-mal-list)
-                            (types:vector #'types:make-mal-vector)
-                            (types:hash-map #'types:make-mal-hash-map)
-                            (types:fn #'types:make-mal-fn)
-                            (types:builtin-fn #'types:make-mal-builtin-fn))
-           (types:mal-data-value value)
+             (types:string #'make-mal-string)
+             (types:symbol #'make-mal-symbol)
+             (types:list #'make-mal-list)
+             (types:vector #'make-mal-vector)
+             (types:hash-map #'make-mal-hash-map)
+             (types:fn #'make-mal-fn)
+             (types:builtin-fn #'make-mal-builtin-fn))
+           (mal-data-value value)
            :meta meta
-           :attrs (types:mal-data-attrs value)))
+           :attrs (mal-data-attrs value)))
 
 (defmal meta (value)
   (or (types:mal-data-meta value) types:mal-nil))

diff --git a/common-lisp/src/env.lisp b/common-lisp/src/env.lisp
index b28d984..0a2ff05 100644 (file)
--- a/common-lisp/src/env.lisp
+++ b/common-lisp/src/env.lisp
@@ -9,14 +9,14 @@
 
 (in-package :env)
 
-(define-condition undefined-symbol (types:mal-runtime-exception)
+(define-condition undefined-symbol (mal-runtime-exception)
   ((symbol :initarg :symbol :reader symbol))
   (:report (lambda (condition stream)
              (format stream
                      "'~a' not found"
                      (symbol condition)))))
 
-(define-condition arity-mismatch (types:mal-runtime-exception)
+(define-condition arity-mismatch (mal-runtime-exception)
   ((required :initarg :required :reader required)
    (provided :initarg :provided :reader provided))
   (:report (lambda (condition stream)
@@ -41,9 +41,7 @@
              :symbol (format nil "~a" (mal-data-value symbol)))))
 
 (defun set-env (env symbol value)
-  (setf (gethash (types:mal-data-value symbol)
-                 (mal-env-bindings env))
-        value))
+  (setf (gethash (mal-data-value symbol) (mal-env-bindings env)) value))
 
 (defun create-mal-env (&key parent binds exprs)
   (let ((env (make-mal-env :parent parent))

diff --git a/common-lisp/src/printer.lisp b/common-lisp/src/printer.lisp
index a6833d0..e6c8de6 100644 (file)
--- a/common-lisp/src/printer.lisp
+++ b/common-lisp/src/printer.lisp
@@ -18,36 +18,36 @@
           start-delimiter
           (mapcar (lambda (value)
                     (pr-str value print-readably))
-                  (utils:listify (types:mal-data-value sequence)))
+                  (listify (mal-data-value sequence)))
           end-delimiter))
 
 (defun pr-mal-hash-map (hash-map &optional (print-readably t) &aux repr)
-  (genhash:hashmap (lambda (key value)
-                     (push (pr-str value print-readably) repr)
-                     (push (pr-str key   print-readably) repr))
-                   (types:mal-data-value hash-map))
+  (hashmap (lambda (key value)
+             (push (pr-str value print-readably) repr)
+             (push (pr-str key   print-readably) repr))
+           (mal-data-value hash-map))
   (format nil "{~{~a ~a~^ ~}}" repr))
 
 (defun pr-string (ast &optional (print-readably t))
-    (if print-readably
-      (utils:replace-all (prin1-to-string (types:mal-data-value ast))
-                         "
+  (if print-readably
+      (replace-all (prin1-to-string (mal-data-value ast))
+                   "
 "
-                         "\\n")
-      (types:mal-data-value ast)))
+                   "\\n")
+      (mal-data-value ast)))
 
 (defun pr-str (ast &optional (print-readably t))
   (when ast
     (switch-mal-type ast
-      (types:number (format nil "~d" (types:mal-data-value ast)))
-      (types:boolean (if (types:mal-data-value ast) "true" "false"))
+      (types:number (format nil "~d" (mal-data-value ast)))
+      (types:boolean (if (mal-data-value ast) "true" "false"))
       (types:nil "nil")
       (types:string (pr-string ast print-readably))
-      (types:symbol (format nil "~a" (types:mal-data-value ast)))
-      (types:keyword (format nil "~a" (types:mal-data-value ast)))
+      (types:symbol (format nil "~a" (mal-data-value ast)))
+      (types:keyword (format nil "~a" (mal-data-value ast)))
       (types:list (pr-mal-sequence "(" ast ")" print-readably))
       (types:vector (pr-mal-sequence "[" ast "]" print-readably))
       (types:hash-map (pr-mal-hash-map ast print-readably))
-      (types:atom (format nil "(atom ~a)" (pr-str (types:mal-data-value ast))))
+      (types:atom (format nil "(atom ~a)" (pr-str (mal-data-value ast))))
       (types:builtin-fn "#<func>")
       (types:builtin-fn "#<builtin-func>"))))

diff --git a/common-lisp/src/step0_repl.lisp b/common-lisp/src/step0_repl.lisp
index c881dd5..79d1800 100644 (file)
--- a/common-lisp/src/step0_repl.lisp
+++ b/common-lisp/src/step0_repl.lisp
@@ -27,7 +27,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step1_read_print.lisp b/common-lisp/src/step1_read_print.lisp
index b16578b..1c0bd24 100644 (file)
--- a/common-lisp/src/step1_read_print.lisp
+++ b/common-lisp/src/step1_read_print.lisp
@@ -20,12 +20,9 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           (make-hash-table :test #'equal)))
+      (mal-print (mal-eval (mal-read string) (make-hash-table :test #'equal)))
     (reader:eof (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (defvar *use-readline-p* nil)
 
@@ -36,7 +33,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step2_eval.lisp b/common-lisp/src/step2_eval.lisp
index 70fbf4d..ecfaedb 100644 (file)
--- a/common-lisp/src/step2_eval.lisp
+++ b/common-lisp/src/step2_eval.lisp
@@ -13,25 +13,25 @@
 
 (in-package :mal)
 
-(defvar *repl-env* (types:make-mal-value-hash-table))
+(defvar *repl-env* (make-mal-value-hash-table))
 
-(setf (genhash:hashref (types:make-mal-symbol "+") *repl-env*)
-      (types:make-mal-builtin-fn (lambda (value1 value2)
+(setf (genhash:hashref (make-mal-symbol "+") *repl-env*)
+      (make-mal-builtin-fn (lambda (value1 value2)
                                    (make-mal-number (+ (mal-data-value value1)
                                                        (mal-data-value value2))))))
 
-(setf (genhash:hashref (types:make-mal-symbol "-") *repl-env*)
-      (types:make-mal-builtin-fn (lambda (value1 value2)
+(setf (genhash:hashref (make-mal-symbol "-") *repl-env*)
+      (make-mal-builtin-fn (lambda (value1 value2)
                                    (make-mal-number (- (mal-data-value value1)
                                                        (mal-data-value value2))))))
 
-(setf (genhash:hashref (types:make-mal-symbol "*") *repl-env*)
-      (types:make-mal-builtin-fn (lambda (value1 value2)
+(setf (genhash:hashref (make-mal-symbol "*") *repl-env*)
+      (make-mal-builtin-fn (lambda (value1 value2)
                                    (make-mal-number (* (mal-data-value value1)
                                                        (mal-data-value value2))))))
 
-(setf (genhash:hashref (types:make-mal-symbol "/") *repl-env*)
-      (types:make-mal-builtin-fn (lambda (value1 value2)
+(setf (genhash:hashref (make-mal-symbol "/") *repl-env*)
+      (make-mal-builtin-fn (lambda (value1 value2)
                                    (make-mal-number (/ (mal-data-value value1)
                                                        (mal-data-value value2))))))
 
@@ -40,21 +40,21 @@
     (if value
         value
         (error 'env:undefined-symbol
-               :symbol (format nil "~a" (types:mal-data-value symbol))))))
+               :symbol (format nil "~a" (mal-data-value symbol))))))
 
 (defun eval-sequence (sequence env)
   (map 'list
        (lambda (ast) (mal-eval ast env))
-       (types:mal-data-value sequence)))
+       (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -69,11 +69,11 @@
 
 (defun mal-eval (ast env)
   (cond
-    ((not (types:mal-list-p ast)) (eval-ast ast env))
-    ((zerop (length (types:mal-data-value ast))) ast)
+    ((not (mal-list-p ast)) (eval-ast ast env))
+    ((zerop (length (mal-data-value ast))) ast)
     (t (progn
          (let ((evaluated-list (eval-ast ast env)))
-           (apply (types:mal-data-value (car evaluated-list))
+           (apply (mal-data-value (car evaluated-list))
                   (cdr evaluated-list)))))))
 
 (defun mal-print (expression)
@@ -81,12 +81,9 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (defvar *use-readline-p* nil)
 
@@ -97,7 +94,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step3_env.lisp b/common-lisp/src/step3_env.lisp
index d988f12..ff34662 100644 (file)
--- a/common-lisp/src/step3_env.lisp
+++ b/common-lisp/src/step3_env.lisp
@@ -17,28 +17,28 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "+")
-             (types:make-mal-builtin-fn (lambda (value1 value2)
-                                          (make-mal-number (+ (mal-data-value value1)
-                                                              (mal-data-value value2))))))
+             (make-mal-symbol "+")
+             (make-mal-builtin-fn (lambda (value1 value2)
+                                    (make-mal-number (+ (mal-data-value value1)
+                                                        (mal-data-value value2))))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "-")
-             (types:make-mal-builtin-fn (lambda (value1 value2)
-                                          (make-mal-number (- (mal-data-value value1)
-                                                              (mal-data-value value2))))))
+             (make-mal-symbol "-")
+             (make-mal-builtin-fn (lambda (value1 value2)
+                                    (make-mal-number (- (mal-data-value value1)
+                                                        (mal-data-value value2))))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "*")
-             (types:make-mal-builtin-fn (lambda (value1 value2)
-                                          (make-mal-number (* (mal-data-value value1)
-                                                              (mal-data-value value2))))))
+             (make-mal-symbol "*")
+             (make-mal-builtin-fn (lambda (value1 value2)
+                                    (make-mal-number (* (mal-data-value value1)
+                                                        (mal-data-value value2))))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "/")
-             (types:make-mal-builtin-fn (lambda (value1 value2)
-                                          (make-mal-number (/ (mal-data-value value1)
-                                                              (mal-data-value value2))))))
+             (make-mal-symbol "/")
+             (make-mal-builtin-fn (lambda (value1 value2)
+                                    (make-mal-number (/ (mal-data-value value1)
+                                                        (mal-data-value value2))))))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -46,16 +46,16 @@
 (defun eval-sequence (sequence env)
   (map 'list
        (lambda (ast) (mal-eval ast env))
-       (types:mal-data-value sequence)))
+       (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -67,13 +67,13 @@
 
 (defun eval-let* (forms env)
   (let ((new-env (env:create-mal-env :parent env))
-        (bindings (utils:listify (types:mal-data-value (second forms)))))
+        (bindings (utils:listify (mal-data-value (second forms)))))
 
     (mapcar (lambda (binding)
               (env:set-env new-env
                            (car binding)
                            (mal-eval (or (cdr binding)
-                                         types:mal-nil)
+                                         mal-nil)
                                      new-env)))
             (loop
                for (symbol value) on bindings
@@ -90,7 +90,7 @@
       ((mal-data-value= mal-let* (first forms))
        (eval-let* forms env))
       (t (let ((evaluated-list (eval-ast ast env)))
-           (apply (types:mal-data-value (car evaluated-list))
+           (apply (mal-data-value (car evaluated-list))
                   (cdr evaluated-list)))))))
 
 (defun mal-read (string)
@@ -98,8 +98,8 @@
 
 (defun mal-eval (ast env)
   (cond
-    ((null ast) types:mal-nil)
-    ((not (types:mal-list-p ast)) (eval-ast ast env))
+    ((null ast) mal-nil)
+    ((not (mal-list-p ast)) (eval-ast ast env))
     ((zerop (length (mal-data-value ast))) ast)
     (t (eval-list ast env))))
 
@@ -108,12 +108,9 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (defvar *use-readline-p* nil)
 
@@ -124,7 +121,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step4_if_fn_do.lisp b/common-lisp/src/step4_if_fn_do.lisp
index 52b3a93..99fca65 100644 (file)
--- a/common-lisp/src/step4_if_fn_do.lisp
+++ b/common-lisp/src/step4_if_fn_do.lisp
@@ -18,9 +18,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -34,13 +32,13 @@
        (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -52,13 +50,13 @@
 
 (defun eval-let* (forms env)
   (let ((new-env (env:create-mal-env :parent env))
-        (bindings (utils:listify (types:mal-data-value (second forms)))))
+        (bindings (utils:listify (mal-data-value (second forms)))))
 
     (mapcar (lambda (binding)
               (env:set-env new-env
                            (car binding)
                            (mal-eval (or (cdr binding)
-                                         types:mal-nil)
+                                         mal-nil)
                                      new-env)))
             (loop
                for (symbol value) on bindings
@@ -79,19 +77,17 @@
                           (cdr forms)))))
       ((mal-data-value= mal-if (first forms))
        (let ((predicate (mal-eval (second forms) env)))
-         (mal-eval (if (or (mal-data-value= predicate types:mal-nil)
-                           (mal-data-value= predicate types:mal-false))
+         (mal-eval (if (or (mal-data-value= predicate mal-nil)
+                           (mal-data-value= predicate mal-false))
                        (fourth forms)
                        (third forms))
                    env)))
       ((mal-data-value= mal-fn* (first forms))
-       (types:make-mal-fn (let ((arglist (second forms))
+       (make-mal-fn (let ((arglist (second forms))
                                 (body (third forms)))
                             (lambda (&rest args)
                               (mal-eval body (env:create-mal-env :parent env
-                                                                 :binds (map 'list
-                                                                             #'identity
-                                                                             (mal-data-value arglist))
+                                                                 :binds (listify (mal-data-value arglist))
                                                                  :exprs args))))))
       (t (let* ((evaluated-list (eval-ast ast env))
                (function (car evaluated-list)))
@@ -104,8 +100,8 @@
 
 (defun mal-eval (ast env)
   (cond
-    ((null ast) types:mal-nil)
-    ((not (types:mal-list-p ast)) (eval-ast ast env))
+    ((null ast) mal-nil)
+    ((not (mal-list-p ast)) (eval-ast ast env))
     ((zerop (length (mal-data-value ast))) ast)
     (t (eval-list ast env))))
 
@@ -114,12 +110,9 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
 
@@ -132,7 +125,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step5_tco.lisp b/common-lisp/src/step5_tco.lisp
index 181bfab..18150d6 100644 (file)
--- a/common-lisp/src/step5_tco.lisp
+++ b/common-lisp/src/step5_tco.lisp
@@ -18,9 +18,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -34,13 +32,13 @@
        (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -56,8 +54,8 @@
 (defun mal-eval (ast env)
   (loop
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
           ((zerop (length (mal-data-value ast))) (return ast))
           (t (let ((forms (mal-data-value ast)))
                (cond
@@ -66,13 +64,13 @@
 
                  ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -88,31 +86,29 @@
 
                  ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (mal-data-value= predicate types:mal-nil)
-                                      (mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
                  ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
-                                                 (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (mal-data-value arglist))
-                                                                                    :exprs args)))
-                                               :attrs (list (cons 'params arglist)
-                                                            (cons 'ast body)
-                                                            (cons 'env env))))))
+                            (make-mal-fn (lambda (&rest args)
+                                           (mal-eval body (env:create-mal-env :parent env
+                                                                              :binds (listify (mal-data-value arglist))
+                                                                              :exprs args)))
+                                         :attrs (list (cons 'params arglist)
+                                                      (cons 'ast body)
+                                                      (cons 'env env))))))
 
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (if (not (types:mal-fn-p function))
+                      (if (not (mal-fn-p function))
                           (return (apply (mal-data-value function)
                                          (cdr evaluated-list)))
-                          (let* ((attrs (types:mal-data-attrs function)))
+                          (let* ((attrs (mal-data-attrs function)))
                             (setf ast (cdr (assoc 'ast attrs))
                                   env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                           :binds (map 'list
@@ -125,12 +121,9 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
 
@@ -143,7 +136,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))

diff --git a/common-lisp/src/step6_file.lisp b/common-lisp/src/step6_file.lisp
index e9585c6..152a9af 100644 (file)
--- a/common-lisp/src/step6_file.lisp
+++ b/common-lisp/src/step6_file.lisp
@@ -18,9 +18,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -34,13 +32,13 @@
        (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -56,8 +54,8 @@
 (defun mal-eval (ast env)
   (loop
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
           ((zerop (length (mal-data-value ast))) (return ast))
           (t (let ((forms (mal-data-value ast)))
                (cond
@@ -66,13 +64,13 @@
 
                  ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -88,19 +86,17 @@
 
                  ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (mal-data-value= predicate types:mal-nil)
-                                      (mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
                  ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
+                            (make-mal-fn (lambda (&rest args)
                                                  (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (mal-data-value arglist))
+                                                                                    :binds (listify (mal-data-value arglist))
                                                                                     :exprs args)))
                                                :attrs (list (cons 'params arglist)
                                                             (cons 'ast body)
@@ -109,10 +105,10 @@
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (if (not (types:mal-fn-p function))
+                      (if (not (mal-fn-p function))
                           (return (apply (mal-data-value function)
                                          (cdr evaluated-list)))
-                          (let* ((attrs (types:mal-data-attrs function)))
+                          (let* ((attrs (mal-data-attrs function)))
                             (setf ast (cdr (assoc 'ast attrs))
                                   env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                           :binds (map 'list
@@ -125,16 +121,13 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "eval")
-             (types:make-mal-builtin-fn (lambda (ast)
+             (make-mal-symbol "eval")
+             (make-mal-builtin-fn (lambda (ast)
                                           (mal-eval ast *repl-env*))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
@@ -149,7 +142,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))
@@ -189,7 +182,7 @@
                   argv
                   (cdr (utils:raw-command-line-arguments)))))
     (env:set-env *repl-env*
-                 (types:make-mal-symbol "*ARGV*")
+                 (make-mal-symbol "*ARGV*")
                  (make-mal-list (mapcar #'make-mal-string (cdr args))))
     (if (null args)
         (repl)

diff --git a/common-lisp/src/step7_quote.lisp b/common-lisp/src/step7_quote.lisp
index 46ab36c..956b0bc 100644 (file)
--- a/common-lisp/src/step7_quote.lisp
+++ b/common-lisp/src/step7_quote.lisp
@@ -18,9 +18,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -40,13 +38,13 @@
        (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -59,11 +57,11 @@
 (defun is-pair (value)
   (and (or (mal-list-p value)
            (mal-vector-p value))
-       (< 0 (length (types:mal-data-value value)))))
+       (< 0 (length (mal-data-value value)))))
 
 (defun quasiquote (ast)
   (if (not (is-pair ast))
-      (types:make-mal-list (list mal-quote ast))
+      (make-mal-list (list mal-quote ast))
       (let ((forms (map 'list #'identity (mal-data-value ast))))
         (cond
           ((mal-data-value= mal-unquote (first forms))
@@ -71,14 +69,14 @@
 
           ((and (is-pair (first forms))
                 (mal-data-value= mal-splice-unquote
-                            (first (mal-data-value (first forms)))))
-           (types:make-mal-list (list mal-concat
-                                      (second (mal-data-value (first forms)))
-                                      (quasiquote (make-mal-list (cdr forms))))))
+                                 (first (mal-data-value (first forms)))))
+           (make-mal-list (list mal-concat
+                                (second (mal-data-value (first forms)))
+                                (quasiquote (make-mal-list (cdr forms))))))
 
-          (t (types:make-mal-list (list mal-cons
-                                        (quasiquote (first forms))
-                                        (quasiquote (make-mal-list (cdr forms))))))))))
+          (t (make-mal-list (list mal-cons
+                                  (quasiquote (first forms))
+                                  (quasiquote (make-mal-list (cdr forms))))))))))
 
 (defun mal-read (string)
   (reader:read-str string))
@@ -86,8 +84,8 @@
 (defun mal-eval (ast env)
   (loop
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
           ((zerop (length (mal-data-value ast))) (return ast))
           (t (let ((forms (mal-data-value ast)))
                (cond
@@ -102,13 +100,13 @@
 
                  ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -124,31 +122,29 @@
 
                  ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (mal-data-value= predicate types:mal-nil)
-                                      (mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
                  ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
-                                                 (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (mal-data-value arglist))
-                                                                                    :exprs args)))
-                                               :attrs (list (cons 'params arglist)
-                                                            (cons 'ast body)
-                                                            (cons 'env env))))))
+                            (make-mal-fn (lambda (&rest args)
+                                           (mal-eval body (env:create-mal-env :parent env
+                                                                              :binds (listify (mal-data-value arglist))
+                                                                              :exprs args)))
+                                         :attrs (list (cons 'params arglist)
+                                                      (cons 'ast body)
+                                                      (cons 'env env))))))
 
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (if (not (types:mal-fn-p function))
+                      (if (not (mal-fn-p function))
                           (return (apply (mal-data-value function)
                                          (cdr evaluated-list)))
-                          (let* ((attrs (types:mal-data-attrs function)))
+                          (let* ((attrs (mal-data-attrs function)))
                             (setf ast (cdr (assoc 'ast attrs))
                                   env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                           :binds (map 'list
@@ -161,17 +157,14 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
     (error (condition)
-      (format nil
-              "~a"
-              condition))))
+      (format nil "~a" condition))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "eval")
-             (types:make-mal-builtin-fn (lambda (ast)
-                                          (mal-eval ast *repl-env*))))
+             (make-mal-symbol "eval")
+             (make-mal-builtin-fn (lambda (ast)
+                                    (mal-eval ast *repl-env*))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
 (rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
@@ -185,7 +178,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))
@@ -225,7 +218,7 @@
                   argv
                   (cdr (utils:raw-command-line-arguments)))))
     (env:set-env *repl-env*
-                 (types:make-mal-symbol "*ARGV*")
+                 (make-mal-symbol "*ARGV*")
                  (make-mal-list (mapcar #'make-mal-string (cdr args))))
     (if (null args)
         (repl)

diff --git a/common-lisp/src/step8_macros.lisp b/common-lisp/src/step8_macros.lisp
index 805de19..0c2c214 100644 (file)
--- a/common-lisp/src/step8_macros.lisp
+++ b/common-lisp/src/step8_macros.lisp
@@ -15,7 +15,7 @@
 
 (in-package :mal)
 
-(define-condition invalid-function (types:mal-runtime-exception)
+(define-condition invalid-function (mal-runtime-exception)
   ((form :initarg :form :reader form)
    (context :initarg :context :reader context))
   (:report (lambda (condition stream)
@@ -30,9 +30,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -51,16 +49,16 @@
 (defun eval-sequence (sequence env)
   (map 'list
        (lambda (ast) (mal-eval ast env))
-       (types:mal-data-value sequence)))
+       (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -73,42 +71,42 @@
 (defun is-pair (value)
   (and (or (mal-list-p value)
            (mal-vector-p value))
-       (< 0 (length (types:mal-data-value value)))))
+       (< 0 (length (mal-data-value value)))))
 
 (defun quasiquote (ast)
   (if (not (is-pair ast))
-      (types:make-mal-list (list mal-quote ast))
-      (let ((forms (map 'list #'identity (types:mal-data-value ast))))
+      (make-mal-list (list mal-quote ast))
+      (let ((forms (map 'list #'identity (mal-data-value ast))))
         (cond
-          ((types:mal-data-value= mal-unquote (first forms))
+          ((mal-data-value= mal-unquote (first forms))
            (second forms))
 
           ((and (is-pair (first forms))
-                (types:mal-data-value= mal-splice-unquote
-                            (first (types:mal-data-value (first forms)))))
-           (types:make-mal-list (list mal-concat
-                                      (second (types:mal-data-value (first forms)))
-                                      (quasiquote (make-mal-list (cdr forms))))))
+                (mal-data-value= mal-splice-unquote
+                                 (first (mal-data-value (first forms)))))
+           (make-mal-list (list mal-concat
+                                (second (mal-data-value (first forms)))
+                                (quasiquote (make-mal-list (cdr forms))))))
 
-          (t (types:make-mal-list (list mal-cons
-                                        (quasiquote (first forms))
-                                        (quasiquote (make-mal-list (cdr forms))))))))))
+          (t (make-mal-list (list mal-cons
+                                  (quasiquote (first forms))
+                                  (quasiquote (make-mal-list (cdr forms))))))))))
 
 (defun is-macro-call (ast env)
-  (when (types:mal-list-p ast)
-    (let* ((func-symbol (first (types:mal-data-value ast)))
-           (func (when (types:mal-symbol-p func-symbol)
+  (when (mal-list-p ast)
+    (let* ((func-symbol (first (mal-data-value ast)))
+           (func (when (mal-symbol-p func-symbol)
                    (env:find-env env func-symbol))))
       (and func
-           (types:mal-fn-p func)
-           (cdr (assoc 'is-macro (types:mal-data-attrs func)))))))
+           (mal-fn-p func)
+           (cdr (assoc 'is-macro (mal-data-attrs func)))))))
 
 (defun mal-macroexpand (ast env)
   (loop
      while (is-macro-call ast env)
-     do (let* ((forms (types:mal-data-value ast))
+     do (let* ((forms (mal-data-value ast))
                (func (env:get-env env (first forms))))
-          (setf ast (apply (types:mal-data-value func)
+          (setf ast (apply (mal-data-value func)
                            (cdr forms)))))
   ast)
 
@@ -119,44 +117,44 @@
   (loop
      do (setf ast (mal-macroexpand ast env))
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
-          ((zerop (length (types:mal-data-value ast))) (return ast))
-          (t (let ((forms (types:mal-data-value ast)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
+          ((zerop (length (mal-data-value ast))) (return ast))
+          (t (let ((forms (mal-data-value ast)))
                (cond
-                 ((types:mal-data-value= mal-quote (first forms))
+                 ((mal-data-value= mal-quote (first forms))
                   (return (second forms)))
 
-                 ((types:mal-data-value= mal-quasiquote (first forms))
+                 ((mal-data-value= mal-quasiquote (first forms))
                   (setf ast (quasiquote (second forms))))
 
-                 ((types:mal-data-value= mal-macroexpand (first forms))
+                 ((mal-data-value= mal-macroexpand (first forms))
                   (return (mal-macroexpand (second forms) env)))
 
-                 ((types:mal-data-value= mal-def! (first forms))
+                 ((mal-data-value= mal-def! (first forms))
                   (return (env:set-env env (second forms) (mal-eval (third forms) env))))
 
-                 ((types:mal-data-value= mal-defmacro! (first forms))
+                 ((mal-data-value= mal-defmacro! (first forms))
                   (let ((value (mal-eval (third forms) env)))
-                    (return (if (types:mal-fn-p value)
+                    (return (if (mal-fn-p value)
                                 (env:set-env env
                                              (second forms)
                                              (progn
-                                               (setf (cdr (assoc 'is-macro (types:mal-data-attrs value))) t)
+                                               (setf (cdr (assoc 'is-macro (mal-data-attrs value))) t)
                                                value))
                                 (error 'invalid-function
                                        :form value
                                        :context "macro")))))
 
-                 ((types:mal-data-value= mal-let* (first forms))
+                 ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -165,45 +163,43 @@
                     (setf ast (third forms)
                           env new-env)))
 
-                 ((types:mal-data-value= mal-do (first forms))
+                 ((mal-data-value= mal-do (first forms))
                   (mapc (lambda (form) (mal-eval form env))
                         (butlast (cdr forms)))
                   (setf ast (car (last forms))))
 
-                 ((types:mal-data-value= mal-if (first forms))
+                 ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (types:mal-data-value= predicate types:mal-nil)
-                                      (types:mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
-                 ((types:mal-data-value= mal-fn* (first forms))
+                 ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
-                                                 (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (types:mal-data-value arglist))
-                                                                                    :exprs args)))
-                                               :attrs (list (cons 'params arglist)
-                                                            (cons 'ast body)
-                                                            (cons 'env env)
-                                                            (cons 'is-macro nil))))))
+                            (make-mal-fn (lambda (&rest args)
+                                           (mal-eval body (env:create-mal-env :parent env
+                                                                              :binds (listify (mal-data-value arglist))
+                                                                              :exprs args)))
+                                         :attrs (list (cons 'params arglist)
+                                                      (cons 'ast body)
+                                                      (cons 'env env)
+                                                      (cons 'is-macro nil))))))
 
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (cond ((types:mal-fn-p function)
-                             (let* ((attrs (types:mal-data-attrs function)))
+                      (cond ((mal-fn-p function)
+                             (let* ((attrs (mal-data-attrs function)))
                                (setf ast (cdr (assoc 'ast attrs))
                                      env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                              :binds (map 'list
                                                                          #'identity
-                                                                         (types:mal-data-value (cdr (assoc 'params attrs))))
+                                                                         (mal-data-value (cdr (assoc 'params attrs))))
                                                              :exprs (cdr evaluated-list)))))
-                            ((types:mal-builtin-fn-p function)
-                             (return (apply (types:mal-data-value function)
+                            ((mal-builtin-fn-p function)
+                             (return (apply (mal-data-value function)
                                             (cdr evaluated-list))))
                             (t (error 'invalid-function
                                       :form function
@@ -214,21 +210,16 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
-    (types:mal-error (condition)
-      (format nil
-              "~a"
-              condition))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
+    (mal-error (condition)
+      (format nil "~a" condition))
     (error (condition)
-      (format nil
-              "Internal error: ~a"
-              condition))))
+      (format nil "Internal error: ~a" condition))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "eval")
-             (types:make-mal-builtin-fn (lambda (ast)
-                                          (mal-eval ast *repl-env*))))
+             (make-mal-symbol "eval")
+             (make-mal-builtin-fn (lambda (ast)
+                                    (mal-eval ast *repl-env*))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
 (rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
@@ -244,7 +235,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))
@@ -284,7 +275,7 @@
                   argv
                   (cdr (utils:raw-command-line-arguments)))))
     (env:set-env *repl-env*
-                 (types:make-mal-symbol "*ARGV*")
+                 (make-mal-symbol "*ARGV*")
                  (make-mal-list (mapcar #'make-mal-string (cdr args))))
     (if (null args)
         (repl)

diff --git a/common-lisp/src/step9_try.lisp b/common-lisp/src/step9_try.lisp
index ecccf8e..bc36001 100644 (file)
--- a/common-lisp/src/step9_try.lisp
+++ b/common-lisp/src/step9_try.lisp
@@ -15,7 +15,7 @@
 
 (in-package :mal)
 
-(define-condition invalid-function (types:mal-runtime-exception)
+(define-condition invalid-function (mal-runtime-exception)
   ((form :initarg :form :reader form)
    (context :initarg :context :reader context))
   (:report (lambda (condition stream)
@@ -30,9 +30,7 @@
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -54,16 +52,16 @@
 (defun eval-sequence (sequence env)
   (map 'list
        (lambda (ast) (mal-eval ast env))
-       (types:mal-data-value sequence)))
+       (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -76,42 +74,42 @@
 (defun is-pair (value)
   (and (or (mal-list-p value)
            (mal-vector-p value))
-       (< 0 (length (types:mal-data-value value)))))
+       (< 0 (length (mal-data-value value)))))
 
 (defun quasiquote (ast)
   (if (not (is-pair ast))
-      (types:make-mal-list (list mal-quote ast))
-      (let ((forms (map 'list #'identity (types:mal-data-value ast))))
+      (make-mal-list (list mal-quote ast))
+      (let ((forms (map 'list #'identity (mal-data-value ast))))
         (cond
-          ((types:mal-data-value= mal-unquote (first forms))
+          ((mal-data-value= mal-unquote (first forms))
            (second forms))
 
           ((and (is-pair (first forms))
-                (types:mal-data-value= mal-splice-unquote
-                            (first (types:mal-data-value (first forms)))))
-           (types:make-mal-list (list mal-concat
-                                      (second (types:mal-data-value (first forms)))
-                                      (quasiquote (make-mal-list (cdr forms))))))
+                (mal-data-value= mal-splice-unquote
+                                 (first (mal-data-value (first forms)))))
+           (make-mal-list (list mal-concat
+                                (second (mal-data-value (first forms)))
+                                (quasiquote (make-mal-list (cdr forms))))))
 
-          (t (types:make-mal-list (list mal-cons
-                                        (quasiquote (first forms))
-                                        (quasiquote (make-mal-list (cdr forms))))))))))
+          (t (make-mal-list (list mal-cons
+                                  (quasiquote (first forms))
+                                  (quasiquote (make-mal-list (cdr forms))))))))))
 
 (defun is-macro-call (ast env)
-  (when (types:mal-list-p ast)
-    (let* ((func-symbol (first (types:mal-data-value ast)))
-           (func (when (types:mal-symbol-p func-symbol)
+  (when (mal-list-p ast)
+    (let* ((func-symbol (first (mal-data-value ast)))
+           (func (when (mal-symbol-p func-symbol)
                    (env:find-env env func-symbol))))
       (and func
-           (types:mal-fn-p func)
-           (cdr (assoc 'is-macro (types:mal-data-attrs func)))))))
+           (mal-fn-p func)
+           (cdr (assoc 'is-macro (mal-data-attrs func)))))))
 
 (defun mal-macroexpand (ast env)
   (loop
      while (is-macro-call ast env)
-     do (let* ((forms (types:mal-data-value ast))
+     do (let* ((forms (mal-data-value ast))
                (func (env:get-env env (first forms))))
-          (setf ast (apply (types:mal-data-value func)
+          (setf ast (apply (mal-data-value func)
                            (cdr forms)))))
   ast)
 
@@ -122,44 +120,44 @@
   (loop
      do (setf ast (mal-macroexpand ast env))
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
-          ((zerop (length (types:mal-data-value ast))) (return ast))
-          (t (let ((forms (types:mal-data-value ast)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
+          ((zerop (length (mal-data-value ast))) (return ast))
+          (t (let ((forms (mal-data-value ast)))
                (cond
-                 ((types:mal-data-value= mal-quote (first forms))
+                 ((mal-data-value= mal-quote (first forms))
                   (return (second forms)))
 
-                 ((types:mal-data-value= mal-quasiquote (first forms))
+                 ((mal-data-value= mal-quasiquote (first forms))
                   (setf ast (quasiquote (second forms))))
 
-                 ((types:mal-data-value= mal-macroexpand (first forms))
+                 ((mal-data-value= mal-macroexpand (first forms))
                   (return (mal-macroexpand (second forms) env)))
 
-                 ((types:mal-data-value= mal-def! (first forms))
+                 ((mal-data-value= mal-def! (first forms))
                   (return (env:set-env env (second forms) (mal-eval (third forms) env))))
 
-                 ((types:mal-data-value= mal-defmacro! (first forms))
+                 ((mal-data-value= mal-defmacro! (first forms))
                   (let ((value (mal-eval (third forms) env)))
-                    (return (if (types:mal-fn-p value)
+                    (return (if (mal-fn-p value)
                                 (env:set-env env
                                              (second forms)
                                              (progn
-                                               (setf (cdr (assoc 'is-macro (types:mal-data-attrs value))) t)
+                                               (setf (cdr (assoc 'is-macro (mal-data-attrs value))) t)
                                                value))
                                 (error 'invalid-function
                                        :form value
                                        :context "macro")))))
 
-                 ((types:mal-data-value= mal-let* (first forms))
+                 ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -168,62 +166,60 @@
                     (setf ast (third forms)
                           env new-env)))
 
-                 ((types:mal-data-value= mal-do (first forms))
+                 ((mal-data-value= mal-do (first forms))
                   (mapc (lambda (form) (mal-eval form env))
                         (butlast (cdr forms)))
                   (setf ast (car (last forms))))
 
-                 ((types:mal-data-value= mal-if (first forms))
+                 ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (types:mal-data-value= predicate types:mal-nil)
-                                      (types:mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
-                 ((types:mal-data-value= mal-fn* (first forms))
+                 ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
-                                                 (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (types:mal-data-value arglist))
-                                                                                    :exprs args)))
-                                               :attrs (list (cons 'params arglist)
-                                                            (cons 'ast body)
-                                                            (cons 'env env)
-                                                            (cons 'is-macro nil))))))
-
-                 ((types:mal-data-value= mal-try* (first forms))
+                            (make-mal-fn (lambda (&rest args)
+                                           (mal-eval body (env:create-mal-env :parent env
+                                                                              :binds (listify (mal-data-value arglist))
+                                                                              :exprs args)))
+                                         :attrs (list (cons 'params arglist)
+                                                      (cons 'ast body)
+                                                      (cons 'env env)
+                                                      (cons 'is-macro nil))))))
+
+                 ((mal-data-value= mal-try* (first forms))
                   (handler-case
                       (return (mal-eval (second forms) env))
-                    ((or types:mal-exception types:mal-error) (condition)
+                    ((or mal-exception mal-error) (condition)
                       (when (third forms)
-                        (let ((catch-forms (types:mal-data-value (third forms))))
-                          (when (types:mal-data-value= mal-catch*
-                                            (first catch-forms))
+                        (let ((catch-forms (mal-data-value (third forms))))
+                          (when (mal-data-value= mal-catch*
+                                                 (first catch-forms))
                             (return (mal-eval (third catch-forms)
                                               (env:create-mal-env :parent env
                                                                   :binds (list (second catch-forms))
-                                                                  :exprs (list (if (or (typep condition 'types:mal-runtime-exception)
-                                                                                       (typep condition 'types:mal-error))
-                                                                                   (types:make-mal-string (format nil "~a" condition))
-                                                                                   (types::mal-exception-data condition)))))))))
+                                                                  :exprs (list (if (or (typep condition 'mal-runtime-exception)
+                                                                                       (typep condition 'mal-error))
+                                                                                   (make-mal-string (format nil "~a" condition))
+                                                                                   (mal-exception-data condition)))))))))
                      (error condition))))
 
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (cond ((types:mal-fn-p function)
-                             (let* ((attrs (types:mal-data-attrs function)))
+                      (cond ((mal-fn-p function)
+                             (let* ((attrs (mal-data-attrs function)))
                                (setf ast (cdr (assoc 'ast attrs))
                                      env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                              :binds (map 'list
                                                                          #'identity
-                                                                         (types:mal-data-value (cdr (assoc 'params attrs))))
+                                                                         (mal-data-value (cdr (assoc 'params attrs))))
                                                              :exprs (cdr evaluated-list)))))
-                            ((types:mal-builtin-fn-p function)
-                             (return (apply (types:mal-data-value function)
+                            ((mal-builtin-fn-p function)
+                             (return (apply (mal-data-value function)
                                             (cdr evaluated-list))))
                             (t (error 'invalid-function
                                       :form function
@@ -234,29 +230,20 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
-    (types:mal-error (condition)
-      (format nil
-              "Error: ~a"
-              condition))
-    (types:mal-runtime-exception (condition)
-      (format nil
-              "Exception: ~a"
-              condition))
-    (types:mal-user-exception (condition)
-      (format nil
-              "Exception: ~a"
-              (pr-str (types::mal-exception-data condition))))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
+    (mal-error (condition)
+      (format nil "Error: ~a" condition))
+    (mal-runtime-exception (condition)
+      (format nil "Exception: ~a" condition))
+    (mal-user-exception (condition)
+      (format nil "Exception: ~a" (pr-str (mal-exception-data condition))))
     (error (condition)
-      (format nil
-              "Internal error: ~a"
-              condition))))
+      (format nil "Internal error: ~a" condition))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "eval")
-             (types:make-mal-builtin-fn (lambda (ast)
-                                          (mal-eval ast *repl-env*))))
+             (make-mal-symbol "eval")
+             (make-mal-builtin-fn (lambda (ast)
+                                    (mal-eval ast *repl-env*))))
 
 (rep "(def! not (fn* (a) (if a false true)))")
 (rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
@@ -272,7 +259,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))
@@ -312,7 +299,7 @@
                   argv
                   (cdr (utils:raw-command-line-arguments)))))
     (env:set-env *repl-env*
-                 (types:make-mal-symbol "*ARGV*")
+                 (make-mal-symbol "*ARGV*")
                  (make-mal-list (mapcar #'make-mal-string (cdr args))))
     (if (null args)
         (repl)

diff --git a/common-lisp/src/stepA_mal.lisp b/common-lisp/src/stepA_mal.lisp
index 628e675..82c6c7f 100644 (file)
--- a/common-lisp/src/stepA_mal.lisp
+++ b/common-lisp/src/stepA_mal.lisp
@@ -15,7 +15,7 @@
 
 (in-package :mal)
 
-(define-condition invalid-function (types:mal-runtime-exception)
+(define-condition invalid-function (mal-runtime-exception)
   ((form :initarg :form :reader form)
    (context :initarg :context :reader context))
   (:report (lambda (condition stream)
@@ -26,13 +26,10 @@
                          "applying"
                          "defining macro")))))
 
-
 (defvar *repl-env* (env:create-mal-env))
 
 (dolist (binding core:ns)
-  (env:set-env *repl-env*
-               (car binding)
-               (cdr binding)))
+  (env:set-env *repl-env* (car binding) (cdr binding)))
 
 (defvar mal-def! (make-mal-symbol "def!"))
 (defvar mal-let* (make-mal-symbol "let*"))
@@ -54,16 +51,16 @@
 (defun eval-sequence (sequence env)
   (map 'list
        (lambda (ast) (mal-eval ast env))
-       (types:mal-data-value sequence)))
+       (mal-data-value sequence)))
 
 (defun eval-hash-map (hash-map env)
-  (let ((hash-map-value (types:mal-data-value hash-map))
-        (new-hash-table (types:make-mal-value-hash-table)))
+  (let ((hash-map-value (mal-data-value hash-map))
+        (new-hash-table (make-mal-value-hash-table)))
     (genhash:hashmap (lambda (key value)
                        (setf (genhash:hashref (mal-eval key env) new-hash-table)
                              (mal-eval value env)))
                      hash-map-value)
-    (types:make-mal-hash-map new-hash-table)))
+    (make-mal-hash-map new-hash-table)))
 
 (defun eval-ast (ast env)
   (switch-mal-type ast
@@ -76,42 +73,42 @@
 (defun is-pair (value)
   (and (or (mal-list-p value)
            (mal-vector-p value))
-       (< 0 (length (types:mal-data-value value)))))
+       (< 0 (length (mal-data-value value)))))
 
 (defun quasiquote (ast)
   (if (not (is-pair ast))
-      (types:make-mal-list (list mal-quote ast))
-      (let ((forms (map 'list #'identity (types:mal-data-value ast))))
+      (make-mal-list (list mal-quote ast))
+      (let ((forms (map 'list #'identity (mal-data-value ast))))
         (cond
-          ((types:mal-data-value= mal-unquote (first forms))
+          ((mal-data-value= mal-unquote (first forms))
            (second forms))
 
           ((and (is-pair (first forms))
-                (types:mal-data-value= mal-splice-unquote
-                            (first (types:mal-data-value (first forms)))))
-           (types:make-mal-list (list mal-concat
-                                      (second (types:mal-data-value (first forms)))
-                                      (quasiquote (make-mal-list (cdr forms))))))
+                (mal-data-value= mal-splice-unquote
+                                 (first (mal-data-value (first forms)))))
+           (make-mal-list (list mal-concat
+                                (second (mal-data-value (first forms)))
+                                (quasiquote (make-mal-list (cdr forms))))))
 
-          (t (types:make-mal-list (list mal-cons
-                                        (quasiquote (first forms))
-                                        (quasiquote (make-mal-list (cdr forms))))))))))
+          (t (make-mal-list (list mal-cons
+                                  (quasiquote (first forms))
+                                  (quasiquote (make-mal-list (cdr forms))))))))))
 
 (defun is-macro-call (ast env)
-  (when (types:mal-list-p ast)
-    (let* ((func-symbol (first (types:mal-data-value ast)))
-           (func (when (types:mal-symbol-p func-symbol)
+  (when (mal-list-p ast)
+    (let* ((func-symbol (first (mal-data-value ast)))
+           (func (when (mal-symbol-p func-symbol)
                    (env:find-env env func-symbol))))
       (and func
-           (types:mal-fn-p func)
-           (cdr (assoc 'is-macro (types:mal-data-attrs func)))))))
+           (mal-fn-p func)
+           (cdr (assoc 'is-macro (mal-data-attrs func)))))))
 
 (defun mal-macroexpand (ast env)
   (loop
      while (is-macro-call ast env)
-     do (let* ((forms (types:mal-data-value ast))
+     do (let* ((forms (mal-data-value ast))
                (func (env:get-env env (first forms))))
-          (setf ast (apply (types:mal-data-value func)
+          (setf ast (apply (mal-data-value func)
                            (cdr forms)))))
   ast)
 
@@ -122,44 +119,44 @@
   (loop
      do (setf ast (mal-macroexpand ast env))
      do (cond
-          ((null ast) (return types:mal-nil))
-          ((not (types:mal-list-p ast)) (return (eval-ast ast env)))
-          ((zerop (length (types:mal-data-value ast))) (return ast))
-          (t (let ((forms (types:mal-data-value ast)))
+          ((null ast) (return mal-nil))
+          ((not (mal-list-p ast)) (return (eval-ast ast env)))
+          ((zerop (length (mal-data-value ast))) (return ast))
+          (t (let ((forms (mal-data-value ast)))
                (cond
-                 ((types:mal-data-value= mal-quote (first forms))
+                 ((mal-data-value= mal-quote (first forms))
                   (return (second forms)))
 
-                 ((types:mal-data-value= mal-quasiquote (first forms))
+                 ((mal-data-value= mal-quasiquote (first forms))
                   (setf ast (quasiquote (second forms))))
 
-                 ((types:mal-data-value= mal-macroexpand (first forms))
+                 ((mal-data-value= mal-macroexpand (first forms))
                   (return (mal-macroexpand (second forms) env)))
 
-                 ((types:mal-data-value= mal-def! (first forms))
+                 ((mal-data-value= mal-def! (first forms))
                   (return (env:set-env env (second forms) (mal-eval (third forms) env))))
 
-                 ((types:mal-data-value= mal-defmacro! (first forms))
+                 ((mal-data-value= mal-defmacro! (first forms))
                   (let ((value (mal-eval (third forms) env)))
-                    (return (if (types:mal-fn-p value)
+                    (return (if (mal-fn-p value)
                                 (env:set-env env
                                              (second forms)
                                              (progn
-                                               (setf (cdr (assoc 'is-macro (types:mal-data-attrs value))) t)
+                                               (setf (cdr (assoc 'is-macro (mal-data-attrs value))) t)
                                                value))
                                 (error 'invalid-function
                                        :form value
                                        :context "macro")))))
 
-                 ((types:mal-data-value= mal-let* (first forms))
+                 ((mal-data-value= mal-let* (first forms))
                   (let ((new-env (env:create-mal-env :parent env))
-                        (bindings (utils:listify (types:mal-data-value (second forms)))))
+                        (bindings (utils:listify (mal-data-value (second forms)))))
 
                     (mapcar (lambda (binding)
                               (env:set-env new-env
                                            (car binding)
                                            (mal-eval (or (cdr binding)
-                                                         types:mal-nil)
+                                                         mal-nil)
                                                      new-env)))
                             (loop
                                for (symbol value) on bindings
@@ -168,62 +165,60 @@
                     (setf ast (third forms)
                           env new-env)))
 
-                 ((types:mal-data-value= mal-do (first forms))
+                 ((mal-data-value= mal-do (first forms))
                   (mapc (lambda (form) (mal-eval form env))
                         (butlast (cdr forms)))
                   (setf ast (car (last forms))))
 
-                 ((types:mal-data-value= mal-if (first forms))
+                 ((mal-data-value= mal-if (first forms))
                   (let ((predicate (mal-eval (second forms) env)))
-                    (setf ast (if (or (types:mal-data-value= predicate types:mal-nil)
-                                      (types:mal-data-value= predicate types:mal-false))
+                    (setf ast (if (or (mal-data-value= predicate mal-nil)
+                                      (mal-data-value= predicate mal-false))
                                   (fourth forms)
                                   (third forms)))))
 
-                 ((types:mal-data-value= mal-fn* (first forms))
+                 ((mal-data-value= mal-fn* (first forms))
                   (return (let ((arglist (second forms))
                                 (body (third forms)))
-                            (types:make-mal-fn (lambda (&rest args)
-                                                 (mal-eval body (env:create-mal-env :parent env
-                                                                                    :binds (map 'list
-                                                                                                #'identity
-                                                                                                (types:mal-data-value arglist))
-                                                                                    :exprs args)))
-                                               :attrs (list (cons 'params arglist)
-                                                            (cons 'ast body)
-                                                            (cons 'env env)
-                                                            (cons 'is-macro nil))))))
-
-                 ((types:mal-data-value= mal-try* (first forms))
+                            (make-mal-fn (lambda (&rest args)
+                                           (mal-eval body (env:create-mal-env :parent env
+                                                                              :binds (listify (mal-data-value arglist))
+                                                                              :exprs args)))
+                                         :attrs (list (cons 'params arglist)
+                                                      (cons 'ast body)
+                                                      (cons 'env env)
+                                                      (cons 'is-macro nil))))))
+
+                 ((mal-data-value= mal-try* (first forms))
                   (handler-case
                       (return (mal-eval (second forms) env))
-                    ((or types:mal-exception types:mal-error) (condition)
+                    ((or mal-exception mal-error) (condition)
                       (when (third forms)
-                        (let ((catch-forms (types:mal-data-value (third forms))))
-                          (when (types:mal-data-value= mal-catch*
-                                            (first catch-forms))
+                        (let ((catch-forms (mal-data-value (third forms))))
+                          (when (mal-data-value= mal-catch*
+                                                 (first catch-forms))
                             (return (mal-eval (third catch-forms)
                                               (env:create-mal-env :parent env
                                                                   :binds (list (second catch-forms))
-                                                                  :exprs (list (if (or (typep condition 'types:mal-runtime-exception)
-                                                                                       (typep condition 'types:mal-error))
-                                                                                   (types:make-mal-string (format nil "~a" condition))
-                                                                                   (types::mal-exception-data condition)))))))))
+                                                                  :exprs (list (if (or (typep condition 'mal-runtime-exception)
+                                                                                       (typep condition 'mal-error))
+                                                                                   (make-mal-string (format nil "~a" condition))
+                                                                                   (mal-exception-data condition)))))))))
                      (error condition))))
 
                  (t (let* ((evaluated-list (eval-ast ast env))
                            (function (car evaluated-list)))
                       ;; If first element is a mal function unwrap it
-                      (cond ((types:mal-fn-p function)
-                             (let* ((attrs (types:mal-data-attrs function)))
+                      (cond ((mal-fn-p function)
+                             (let* ((attrs (mal-data-attrs function)))
                                (setf ast (cdr (assoc 'ast attrs))
                                      env (env:create-mal-env :parent (cdr (assoc 'env attrs))
                                                              :binds (map 'list
                                                                          #'identity
-                                                                         (types:mal-data-value (cdr (assoc 'params attrs))))
+                                                                         (mal-data-value (cdr (assoc 'params attrs))))
                                                              :exprs (cdr evaluated-list)))))
-                            ((types:mal-builtin-fn-p function)
-                             (return (apply (types:mal-data-value function)
+                            ((mal-builtin-fn-p function)
+                             (return (apply (mal-data-value function)
                                             (cdr evaluated-list))))
                             (t (error 'invalid-function
                                       :form function
@@ -234,36 +229,27 @@
 
 (defun rep (string)
   (handler-case
-      (mal-print (mal-eval (mal-read string)
-                           *repl-env*))
-    (types:mal-error (condition)
-      (format nil
-              "Error: ~a"
-              condition))
-    (types:mal-runtime-exception (condition)
-      (format nil
-              "Exception: ~a"
-              condition))
-    (types:mal-user-exception (condition)
-      (format nil
-              "Exception: ~a"
-              (pr-str (types::mal-exception-data condition))))
+      (mal-print (mal-eval (mal-read string) *repl-env*))
+    (mal-error (condition)
+      (format nil "Error: ~a" condition))
+    (mal-runtime-exception (condition)
+      (format nil "Exception: ~a" condition))
+    (mal-user-exception (condition)
+      (format nil "Exception: ~a" (pr-str (mal-exception-data condition))))
     (error (condition)
-      (format nil
-              "Internal error: ~a"
-              condition))))
+      (format nil "Internal error: ~a" condition))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "eval")
-             (types:make-mal-builtin-fn (lambda (ast)
-                                          (mal-eval ast *repl-env*))))
+             (make-mal-symbol "eval")
+             (make-mal-builtin-fn (lambda (ast)
+                                    (mal-eval ast *repl-env*))))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "*cl-implementation*")
+             (make-mal-symbol "*cl-implementation*")
              (make-mal-string (lisp-implementation-type)))
 
 (env:set-env *repl-env*
-             (types:make-mal-symbol "*cl-version*")
+             (make-mal-symbol "*cl-version*")
              (make-mal-string (lisp-implementation-version)))
 
 (rep "(def! not (fn* (a) (if a false true)))")
@@ -283,7 +269,7 @@
 
 (defun mal-readline (prompt)
   (if *use-readline-p*
-      (cl-readline:readline :prompt prompt
+      (rl:readline :prompt prompt
                             :add-history t
                             :novelty-check (lambda (old new)
                                              (not (string= old new))))
@@ -324,7 +310,7 @@
                   argv
                   (cdr (utils:raw-command-line-arguments)))))
     (env:set-env *repl-env*
-                 (types:make-mal-symbol "*ARGV*")
+                 (make-mal-symbol "*ARGV*")
                  (make-mal-list (mapcar #'make-mal-string (cdr args))))
     (if (null args)
         (repl)

diff --git a/common-lisp/src/types.lisp b/common-lisp/src/types.lisp
index a6c3830..57e5e6b 100644 (file)
--- a/common-lisp/src/types.lisp
+++ b/common-lisp/src/types.lisp
@@ -68,6 +68,7 @@
            :make-mal-value-hash-table
            ;; Error types
            :mal-exception
+           :mal-exception-data
            ;; Exceptions raised by the runtime
            :mal-runtime-exception
            ;; Exception raised by user code
@@ -77,14 +78,11 @@
 
 (in-package :types)
 
-(define-condition mal-error (error)
-  nil)
+(define-condition mal-error (error) nil)
 
-(define-condition mal-exception (error)
-  nil)
+(define-condition mal-exception (error) nil)
 
-(define-condition mal-runtime-exception (mal-exception)
-  nil)
+(define-condition mal-runtime-exception (mal-exception) nil)
 
 (define-condition mal-user-exception (mal-exception)
   ((data :accessor mal-exception-data :initarg :data)))
@@ -136,35 +134,33 @@
   `(let ((type (mal-data-type ,ast)))
      (cond
        ,@(mapcar (lambda (form)
-                   (list (if (or (equal (car form) t)
-                                 (equal (car form) 'any))
-                             t
+                   (list (or (equal (car form) t)
+                             (equal (car form) 'any)
                              (list 'equal (list 'quote (car form)) 'type))
                          (cadr form)))
                  forms))))
 
 (defun mal-sequence= (value1 value2)
-  (let ((sequence1 (utils:listify (mal-data-value value1)))
-        (sequence2 (utils:listify (mal-data-value value2))))
+  (let ((sequence1 (listify (mal-data-value value1)))
+        (sequence2 (listify (mal-data-value value2))))
+
     (when (= (length sequence1) (length sequence2))
-      (every #'identity
-             (loop
-                for x in sequence1
-                for y in sequence2
-                collect (mal-data-value= x y))))))
+      (every #'identity (loop for x in sequence1
+                           for y in sequence2
+                           collect (mal-data-value= x y))))))
 
 (defun mal-hash-map= (value1 value2)
   (let ((map1 (mal-data-value value1))
         (map2 (mal-data-value value2))
         (identical t))
-    (when (= (genhash:generic-hash-table-count map1)
-             (genhash:generic-hash-table-count map2))
-      (genhash:hashmap (lambda (key value)
-                         (declare (ignorable value))
-                         (setf identical
-                               (and identical (mal-data-value= (genhash:hashref key map1)
-                                                               (genhash:hashref key map2)))))
-                       map1)
+    (when (= (generic-hash-table-count map1)
+             (generic-hash-table-count map2))
+      (hashmap (lambda (key value)
+                 (declare (ignorable value))
+                 (setf identical
+                       (and identical (mal-data-value= (hashref key map1)
+                                                       (hashref key map2)))))
+               map1)
       identical)))
 
 (defun mal-data-value= (value1 value2)
@@ -191,7 +187,7 @@
     ;; instead
     (let ((hash-function #+(or ecl abcl) #'mal-sxhash
                          #-(or ecl abcl) #'sxhash))
-      (genhash:register-test-designator 'mal-data-value-hash
-                                        hash-function
-                                        #'mal-data-value=)))
-  (genhash:make-generic-hash-table :test 'mal-data-value-hash))
+      (register-test-designator 'mal-data-value-hash
+                                hash-function
+                                #'mal-data-value=)))
+  (make-generic-hash-table :test 'mal-data-value-hash))