      (.write w (str "#Type"
                     (merge
                       {:pred (:form t)}
-                      (if-let [info (:info t)]
-                        {:info info}))))))
+                      (extra-type-map t))))))
 
 (defmacro type
   ([pred]
-  `(->Type '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred) ~pred nil nil))
+   `(map->Type {:form '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred), :pred ~pred}))
   ([pred info]
-   `(->Type '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred) ~pred nil ~info)))
+   `(map->Type (merge ~info {:form '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred), :pred ~pred}))))
 
 (defn with-info [^Type t info]
-  (map->Type (assoc t :info info)))
+  (assoc t :info info))
 
 (defn info [^Type t]
   (:info t))

(defprotocol TypeLike
  (type-like [this]))

(declare ->Type)

(defrecord Type [form pred gfn info]
  #?@(:clj
      [s/Specize
       (specize* [s] s)

;; concrete types
;;

(def any? (type clojure.core/any?))
(def some? (type clojure.core/some?))
(def number? (type clojure.core/number?))
(def integer? (type clojure.core/integer?))
(def int? (type clojure.core/int?))
(def pos-int? (type clojure.core/pos-int?))
(def neg-int? (type clojure.core/neg-int?))
(def nat-int? (type clojure.core/nat-int?))
(def float? (type clojure.core/float?))
(def double? (type double-like?))
(def boolean? (type clojure.core/boolean?))
(def string? (type clojure.core/string?))
(def ident? (type clojure.core/ident?))
(def simple-ident? (type clojure.core/simple-ident?))
(def qualified-ident? (type clojure.core/qualified-ident?))
(def keyword? (type clojure.core/keyword?))
(def simple-keyword? (type clojure.core/simple-keyword?))
(def qualified-keyword? (type clojure.core/qualified-keyword?))
(def symbol? (type clojure.core/symbol?))
(def simple-symbol? (type clojure.core/simple-symbol?))
(def qualified-symbol? (type clojure.core/qualified-symbol?))
(def uuid? (type clojure.core/uuid?))
(def uri? (type clojure.core/uri?))
(def bigdec? (type clojure.core/bigdec?))
(def inst? (type clojure.core/inst?))
(def seqable? (type clojure.core/seqable?))
(def indexed? (type clojure.core/indexed?))
(def map? (type clojure.core/map?))
(def vector? (type clojure.core/vector?))
(def list? (type clojure.core/list?))
(def seq? (type clojure.core/seq?))
(def char? (type clojure.core/char?))
(def set? (type clojure.core/set?))
(def nil? (type clojure.core/nil?))
(def false? (type clojure.core/false?))
(def true? (type clojure.core/true?))
(def zero? (type clojure.core/zero?))
(def rational? (type clojure.core/rational?))
(def coll? (type clojure.core/coll?))
(def empty? (type clojure.core/empty?))
(def associative? (type clojure.core/associative?))
(def sequential? (type clojure.core/sequential?))
(def ratio? (type clojure.core/ratio?))
(def bytes? (type clojure.core/bytes?))

(comment
  #{any?
    some?
    number?
    integer?
    int?
    pos-int?
    neg-int?
    nat-int?
    float?
    double?
    boolean?
    string?
    ident?
    simple-ident?
    qualified-ident?
    keyword?
    simple-keyword?
    qualified-keyword?
    symbol?
    simple-symbol?
    qualified-symbol?
    uuid?
    uri?
    bigdec?
    inst?
    seqable?
    indexed?
    map?
    vector?
    list?
    seq?
    char?
    set?
    nil?
    false?
    true?
    zero?
    rational?
    coll?
    empty?
    associative?
    sequential?
    ratio?
    bytes?})
