                                  (map (fn [[f & meths]]
                                         `(set! ~(symbol (core/str prototype-prefix f)) (fn ~@(map adapt-params meths))))
                                       sigs))
-                               (cons `(set! ~(symbol (core/str prototype-prefix pprefix)) true)
-                                     (mapcat (fn [[f & meths]]
-                                               (if (= psym 'cljs.core.IFn)
-                                                 (let [adapt-params (fn [[[targ & args :as sig] & body]]
-                                                                      (let [tsym (gensym "tsym")]
-                                                                        `(~(with-meta (vec (cons tsym args)) (meta sig))
-                                                                          (this-as ~tsym
-                                                                                   (let [~targ ~tsym]
-                                                                                     ~@body)))))
-                                                       meths (map adapt-params meths)
-                                                       tsym (gensym "tsym")
-                                                       argsym (gensym "args")]
-                                                    [`(set! ~(symbol (core/str prototype-prefix 'call)) (fn ~@meths))
-                                                     `(set! ~(symbol (core/str prototype-prefix 'apply))
-                                                            (fn ~(with-meta [tsym argsym] (meta (first meths)))
-                                                              (.apply (.-call ~tsym) ~tsym
-                                                                      (.concat (array ~tsym) (aclone ~argsym)))))])
-                                                 (let [pf (core/str prototype-prefix pprefix f)]
-                                                   (if (vector? (first meths))
-                                                     [`(set! ~(symbol (core/str pf "$arity$" (count (first meths)))) (fn ~@meths))]
-                                                     (map (fn [[sig & body :as meth]]
-                                                            `(set! ~(symbol (core/str pf "$arity$" (count sig)))
-                                                                   (fn ~meth)))
-                                                          meths)))))
-                                             sigs)))))]
+                               (concat (when-not (skip-flag psym)
+                                         [`(set! ~(symbol (core/str prototype-prefix pprefix)) true)])
+                                       (mapcat (fn [[f & meths]]
+                                                 (if (= psym 'cljs.core.IFn)
+                                                   (let [adapt-params (fn [[[targ & args :as sig] & body]]
+                                                                        (let [tsym (gensym "tsym")]
+                                                                          `(~(with-meta (vec (cons tsym args)) (meta sig))
+                                                                            (this-as ~tsym
+                                                                              (let [~targ ~tsym]
+                                                                                ~@body)))))
+                                                         meths (map adapt-params meths)
+                                                         tsym (gensym "tsym")
+                                                         argsym (gensym "args")]
+                                                     [`(set! ~(symbol (core/str prototype-prefix 'call)) (fn ~@meths))
+                                                      `(set! ~(symbol (core/str prototype-prefix 'apply))
+                                                             (fn ~(with-meta [tsym argsym] (meta (first meths)))
+                                                               (.apply (.-call ~tsym) ~tsym
+                                                                       (.concat (array ~tsym) (aclone ~argsym)))))])
+                                                   (let [pf (core/str prototype-prefix pprefix f)]
+                                                     (if (vector? (first meths))
+                                                       [`(set! ~(symbol (core/str pf "$arity$" (count (first meths)))) (fn ~@meths))]
+                                                       (map (fn [[sig & body :as meth]]
+                                                              `(set! ~(symbol (core/str pf "$arity$" (count sig)))
+                                                                     (fn ~meth)))
+                                                            meths)))))
+                                               sigs)))))]
         `(do ~@(mapcat assign-impls impl-map))))))
 
 (defn- prepare-protocol-masks [env t impls]

    (if-let [fpp-pbs (seq (keep fast-path-protocols
                                (map resolve
                                     (keys impl-map))))]
      (let [fpp-partitions (group-by first fpp-pbs)
            fpp-partitions (into {} (map (juxt key (comp (partial map peek) val))
                                         fpp-partitions))
            fpp-partitions (into {} (map (juxt key (comp (partial reduce core/bit-or) val))
                                         fpp-partitions))]
        (reduce (fn [ps p]
                  (update-in ps [p] (fnil identity 0)))
                fpp-partitions
                (range fast-path-protocol-partitions-count))))))

(defmacro deftype [t fields & impls]
  (let [adorn-params (fn [sig]

                            (drop-while seq? (next s)))
                     ret)))
        r (:name (cljs.compiler/resolve-var (dissoc &env :locals) t))
        [fpps pmasks] (prepare-protocol-masks &env t impls)]
    (if (seq impls)
      `(do
         (deftype* ~t ~fields ~pmasks)
         (set! (.-cljs$lang$type ~t) true)
         (set! (.-cljs$lang$ctorPrSeq ~t) (fn [this#] (list ~(core/str r))))
         (extend-type ~(with-meta t {:skip-protocol-flag fpps}) ~@(dt->et impls))
         ~t)
      `(do
         (deftype* ~t ~fields ~pmasks)
