Remove def+

Author: arohner

project.clj

@@ -1,4 +1,4 @@
-(defproject manifold "0.4.3"
+(defproject griffinbank/manifold "0.4.4-20250811"
   :description "A compatibility layer for event-driven abstractions"
   :license {:name "MIT License"
             :url "http://opensource.org/licenses/MIT"}
@@ -10,7 +10,7 @@
                  [org.clj-commons/primitive-math "1.0.0"]
                  [riddley "0.2.0"]
                  [org.clojure/core.async "1.6.673" :scope "provided"]
-                 [potemkin "0.4.6"]]
+                 [griffinbank/potemkin "0.4.9-20250811"]]
   :profiles {:dev {:dependencies [[criterium "0.4.6"]]
                    :global-vars {*warn-on-reflection* true
                                  *unchecked-math* :warn-on-boxed}}

src/manifold/bus.clj

@@ -4,8 +4,7 @@
   (:require
     [manifold
      [stream :as s]
-     [deferred :as d]
-     [utils :refer [definterface+]]]
+     [deferred :as d]]
     [potemkin.types :refer [deftype+]]
     [clj-commons.primitive-math :as p])
   (:import
@@ -16,7 +15,7 @@
 
 (set! *unchecked-math* true)
 
-(definterface+ IEventBus
+(definterface IEventBus
   (snapshot [])
   (subscribe [topic])
   (downstream [topic])

src/manifold/deferred.clj

@@ -8,8 +8,8 @@
     [manifold.debug :as debug]
     [manifold.executor :as ex]
     [manifold.time :as time]
-    [manifold.utils :as utils :refer [assert-some definterface+]]
-    [potemkin.types :refer [def-abstract-type reify+ defprotocol+ deftype+]]
+    [manifold.utils :as utils :refer [assert-some]]
+    [potemkin.types :refer [def-abstract-type reify+ deftype+]]
     [clj-commons.primitive-math :as p]
     [riddley.compiler :as compiler]
     [riddley.walk :as walk])
@@ -44,11 +44,11 @@
 (set! *warn-on-reflection* true)
 (set! *unchecked-math* true)
 
-(defprotocol+ Deferrable
+(defprotocol Deferrable
   (^:private to-deferred [_] "Provides a conversion mechanism to manifold deferreds."))
 
 ;; implies IDeref, IBlockingDeref, IPending
-(definterface+ IDeferred
+(definterface IDeferred
   (executor [])
   (^boolean realized [])
   (onRealized [on-success on-error])
@@ -336,7 +336,7 @@
 
 ;;;
 
-(definterface+ IDeferredListener
+(definterface IDeferredListener
   (onSuccess [x])
   (onError [err]))
 
@@ -354,7 +354,7 @@
   ([on-success on-error]
    (Listener. on-success on-error)))
 
-(definterface+ IMutableDeferred
+(definterface IMutableDeferred
   (success [x])
   (success [x claim-token])
   (error [x])

src/manifold/stream/core.clj

@@ -1,30 +1,29 @@
 (ns manifold.stream.core
   {:no-doc true}
-  (:require [manifold.utils :refer [definterface+]]
-            [potemkin.types :refer [deftype+ defprotocol+]]))
+  (:require [potemkin.types :refer [deftype+]]))
 
-(defprotocol+ Sinkable
+(defprotocol Sinkable
   (to-sink [_] "Provides a conversion mechanism to Manifold sinks."))
 
-(defprotocol+ Sourceable
+(defprotocol Sourceable
   (to-source [_] "Provides a conversion mechanism to Manifold source."))
 
-(definterface+ IEventStream
+(definterface IEventStream
   (description [])
   ; Is the underlying class synchronous by default? NB: async usage is still possible, but requires wrapping
   (isSynchronous [])
   (downstream [])
   (weakHandle [reference-queue])
   (close []))
 
-(definterface+ IEventSink
+(definterface IEventSink
   (put [x blocking?])
   (put [x blocking? timeout timeout-val])
   (markClosed [])
   (isClosed [])
   (onClosed [callback]))
 
-(definterface+ IEventSource
+(definterface IEventSource
   (take [default-val blocking?])
   (take [default-val blocking? timeout timeout-val])
   (markDrained [])

src/manifold/stream/default.clj

@@ -10,7 +10,7 @@
      [graph :as g]
      [core :as s]]
     [manifold.time :as time]
-    [potemkin.types :refer [deftype+ defrecord+]]
+    [potemkin.types :refer [deftype+]]
     [clj-commons.primitive-math :as p])
   (:import
     [java.util
@@ -35,8 +35,8 @@
 
 (deftype+ Production [deferred message token])
 (deftype+ Consumption [message deferred token])
-(defrecord+ Producer [message deferred])
-(defrecord+ Consumer [deferred default-val])
+(defrecord Producer [message deferred])
+(defrecord Consumer [deferred default-val])
 
 (defn de-nil [x]
   (if (nil? x)

src/manifold/time.clj

@@ -5,8 +5,6 @@
     [clojure.tools.logging :as log]
     [manifold.executor :as ex]
     [clojure.string :as str]
-    [manifold.utils :refer [definterface+]]
-    [potemkin.types :refer [defprotocol+]]
     [clj-commons.primitive-math :as p])
   (:import
     [java.util
@@ -130,11 +128,11 @@
 
 ;;;
 
-(definterface+ IClock
+(definterface IClock
   (in [^double interval-millis ^Runnable f])
   (every [^double delay-millis ^double period-millis ^Runnable f]))
 
-(defprotocol+ IMockClock
+(defprotocol IMockClock
   (now [clock] "Returns the current time for the clock")
   (advance [clock time]
     "Advances the mock clock by the specified interval of `time`.

src/manifold/utils.clj

@@ -131,12 +131,6 @@
 
 ;;;
 
-(defmacro definterface+ [name & body]
-  (when-not (resolve name)
-    `(definterface ~name ~@body)))
-
-;;;
-
 (defn fn->Function [f]
   (reify java.util.function.Function
     (apply [_ x] (f x))))