 ;; concrete types
 ;;
 
-(def string? (type clojure.core/integer?))
+(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 boolean? (type clojure.core/boolean?))
+(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?})

     (.write w (str "#Type"
                    (merge
                      {:pred (:form t)}
                      (if-let [info (:info t)]
                        {:info info}))))))

(defmacro type
  ([pred]
  `(->Type '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred) ~pred nil nil))
  ([pred info]
   `(->Type '~(or (->> pred #?(:clj resolve, :cljs (resolve &env)) ->sym) pred) ~pred nil ~info)))

(defn with-info [^Type t info]
  (map->Type (assoc t :info info)))

(defn info [^Type t]
  (:info t))

(ns spec-tools.core
  (:refer-clojure :exclude [type 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?])
  #?(:cljs (:require-macros [spec-tools.core :refer [type]]))
  (:require
    [clojure.spec :as s]
