   [size]
   `(js/Array. ~size))
 
+(defmacro list
+  ([] ())
+  ([x & xs]
+    `(-conj (list ~@xs) ~x)))
+
 (defmacro vector
   [& xs]
   `[~@xs])
+
+(defmacro hash-set
+  [& xs]
+  `#{~@xs})
 
 (defmacro js-obj [& rest]
   (let [kvs-str (->> (repeat "~{}:~{}")

  ([x y & more] `(min (min ~x ~y) ~@more)))

(defmacro js-mod [num div]
  (list 'js* "(~{} % ~{})" num div))

(defmacro bit-not [x]
  (list 'js* "(~ ~{})" x))

(defmacro bit-and
  ([x y] (list 'js* "(~{} & ~{})" x y))
  ([x y & more] `(bit-and (bit-and ~x ~y) ~@more)))

;; internal do not use
(defmacro unsafe-bit-and
  ([x y] (bool-expr (list 'js* "(~{} & ~{})" x y)))
  ([x y & more] `(unsafe-bit-and (unsafe-bit-and ~x ~y) ~@more)))

(defmacro bit-or
  ([x y] (list 'js* "(~{} | ~{})" x y))
  ([x y & more] `(bit-or (bit-or ~x ~y) ~@more)))

(defmacro int [x]
  `(bit-or ~x 0))

(defmacro bit-xor
  ([x y] (list 'js* "(~{} ^ ~{})" x y))
  ([x y & more] `(bit-xor (bit-xor ~x ~y) ~@more)))

(defmacro bit-and-not
  ([x y] (list 'js* "(~{} & ~~{})" x y))
  ([x y & more] `(bit-and-not (bit-and-not ~x ~y) ~@more)))

(defmacro bit-clear [x n]
  (list 'js* "(~{} & ~(1 << ~{}))" x n))

(defmacro bit-flip [x n]
  (list 'js* "(~{} ^ (1 << ~{}))" x n))

(defmacro bit-test [x n]
  (list 'js* "((~{} & (1 << ~{})) != 0)" x n))

(defmacro bit-shift-left [x n]
  (list 'js* "(~{} << ~{})" x n))

(defmacro bit-shift-right [x n]
  (list 'js* "(~{} >> ~{})" x n))

(defmacro bit-shift-right-zero-fill [x n]
  (list 'js* "(~{} >>> ~{})" x n))

(defmacro bit-set [x n]
  (list 'js* "(~{} | (1 << ~{}))" x n))

;; internal
(defmacro mask [hash shift]
  (list 'js* "((~{} >>> ~{}) & 0x01f)" hash shift))

;; internal
(defmacro bitpos [hash shift]
  (list 'js* "(1 << ~{})" `(mask ~hash ~shift)))

;; internal
(defmacro caching-hash [coll hash-fn hash-key]

                            when when-first when-let when-not while with-bindings with-in-str
                            with-loading-context with-local-vars with-open with-out-str with-precision with-redefs
                            satisfies? identical? true? false? number? nil? instance? symbol? keyword? string? str get
                            make-array vector list hash-map array-map hash-set

                            aget aset
                            + - * / < <= > >= == zero? pos? neg? inc dec max min mod
