path: root/src/boot.clj

;   Copyright (c) Rich Hickey. All rights reserved.
;   The use and distribution terms for this software are covered by the
;   Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
;   which can be found in the file CPL.TXT at the root of this distribution.
;   By using this software in any fashion, you are agreeing to be bound by
;   the terms of this license.
;   You must not remove this notice, or any other, from this software.

(in-ns 'clojure)

(def list (. clojure.lang.PersistentList creator))
(def cons (fn* [x seq] (. clojure.lang.RT (cons x seq))))

;during bootstrap we don't have destructuring let or fn, will redefine later
(def #^{:macro true}
	let (fn* [& decl] (cons 'let* decl)))

(def #^{:macro true}
	fn (fn* [& decl] (cons 'fn* decl))) 

(def conj (fn [coll x] (. clojure.lang.RT (conj coll x))))

(def defn (fn [name & fdecl]
              (list 'def name (cons `fn (cons name fdecl)))))

(. (var defn) (setMacro))

(defn instance? [#^Class c x]
  (. c (isInstance x)))
  
(defn vector
      ([] [])
      ([& args]
          (. clojure.lang.PersistentVector (create args))))

(defn hash-map
      ([] {})
      ([& args]
          (. clojure.lang.PersistentHashMap (create args))))

(defn sorted-map
      ([& args]
          (. clojure.lang.PersistentTreeMap (create args))))

(defn sorted-map-by
      ([comparator & args]
          (. clojure.lang.PersistentTreeMap (create comparator args))))


  
;;;;;;;;;;;;;;;;;;;;
(def defmacro (fn [name & args]
                  (list 'do
                        (cons `defn (cons name args))
                        (list '. (list 'var name) '(setMacro)))))

(. (var defmacro) (setMacro))

(defmacro when [test & body]
   (list 'if test (cons 'do body)))

(defmacro when-not [test & body]
   (list 'if test nil (cons 'do body)))

;;;;;;;;;;;;;;;;; metadata ;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defn meta [x]
  (when (instance? clojure.lang.IObj x)
    (. #^clojure.lang.IObj x (meta))))

(defn with-meta [#^clojure.lang.IObj x m]
  (. x (withMeta m)))


(defn #^Boolean nil? [x] (identical? x nil))
(defn #^Boolean false? [x] (identical? x false))
(defn #^Boolean true? [x] (identical? x true))

(defn not [x