Remove reflection.

src/fell/core.cljc

@@ -16,7 +16,7 @@
 
 (defn request-eff
   "Wrap the effect `request` into an Eff."
-  [request]
+  ^Impure [request]
   (Impure. request (singleton-queue pure)))
 
 ;; TODO: Improve `weave` nomenclature:
@@ -34,7 +34,8 @@
   [tag ret handle eff]
   (condp instance? eff
     Pure (ret (extract eff))
-    Impure (let [request (.-request eff)
+    Impure (let [^Impure eff eff
+                 request (.-request eff)
                  cont (.-cont eff)
                  cont (append-handler cont (partial handle-relay tag ret handle))]
              (if (= (first request) tag)
@@ -46,5 +47,6 @@
   [eff]
   (condp instance? eff
     Pure (extract eff)
-    Impure (throw (#?(:clj RuntimeException., :cljs js/Error.)
-                    (str "unhandled effect " (pr-str (.-request eff)))))))
+    Impure (let [^Impure eff eff]
+             (throw (#?(:clj RuntimeException., :cljs js/Error.)
+                      (str "unhandled effect " (pr-str (.-request eff))))))))

src/fell/error.cljc

@@ -32,11 +32,13 @@
 (defn run-error [eff]
   (condp instance? eff
     Pure (pure (right (extract eff)))
-    Impure (let [request (.-request eff)
+    Impure (let [^Impure eff eff
+                 request (.-request eff)
                  k (partial q/apply-queue (.-cont eff))]
              (condp instance? request
-               Raise (pure (left (.-error request)))
-               Handle (mlet [status (run-error (.-body request))]
+               Raise (pure (left (.-error ^Raise request)))
+               Handle (mlet [^Handle request request
+                             status (run-error (.-body request))]
                         (condp instance? status
                           Left (mlet [status (run-error ((.-on_error request) (extract status)))]
                                  (condp instance? status

src/fell/lift.cljc

@@ -3,11 +3,12 @@
 
   It is impossible to have more than one lifted monad, so there is no `make` function here."
   (:require [cats.core :refer [return bind extract]]
-            [cats.data :refer [pair]]
+            [cats.data :refer [pair #?(:cljs Pair)]]
             [fell.eff :refer [Effect #?@(:cljs [Pure Impure])]]
             [fell.queue :as q]
             [fell.core :refer [request-eff]])
-  #?(:clj (:import [fell.eff Pure Impure])))
+  #?(:clj (:import [cats.data Pair]
+                   [fell.eff Pure Impure])))
 
 (defrecord Lift [lifted-mv]
   Effect
@@ -17,14 +18,15 @@
 
 (declare run-lift)
 
-(defn- resume-lift [suspension] (run-lift (.-fst suspension) (.-snd suspension)))
+(defn- resume-lift [^Pair suspension] (run-lift (.-fst suspension) (.-snd suspension)))
 
 (defn run-lift [ctx eff]
   (condp instance? eff
     Pure (return ctx (extract eff))
-    Impure (let [request (.-request eff)
+    Impure (let [^Impure eff eff
+                 request (.-request eff)
                  k (partial q/apply-queue (.-cont eff))]
              (condp instance? request
-               Lift (bind (.-lifted_mv request) (q/weave-fn k (pair ctx nil) resume-lift))
+               Lift (bind (.-lifted_mv ^Lift request) (q/weave-fn k (pair ctx nil) resume-lift))
                (throw (#?(:clj RuntimeException., :cljs js/Error.)
                         (str "unhandled effect " (pr-str (.-request eff)))))))))

src/fell/queue.cljc

@@ -21,7 +21,8 @@
     (if (seq queue*)
       (condp instance? eff
         Pure (recur queue* (extract eff))
-        Impure (Impure. (.-request eff) (into (.-cont eff) queue*)))
+        Impure (let [^Impure eff eff]
+                 (Impure. (.-request eff) (into (.-cont eff) queue*))))
       eff)))
 
 (defn append-handler

src/fell/reader.cljc

@@ -1,11 +1,12 @@
 (ns fell.reader
   "Reader effect."
   (:require [cats.core :refer [mlet fmap]]
-            [cats.data :refer [pair]]
+            [cats.data :refer [pair #?(:cljs Pair)]]
             [fell.core :refer [request-eff]]
             [fell.eff :refer [Effect #?@(:cljs [Pure Impure])]]
             [fell.queue :as q])
-  #?(:clj (:import [fell.eff Pure Impure])))
+  #?(:clj (:import [cats.data Pair]
+                   [fell.eff Pure Impure])))
 
 (defrecord Ask []
   Effect
@@ -22,16 +23,18 @@
 
 (declare run-reader)
 
-(defn- resume-reader [suspension] (run-reader (.-snd suspension) (.-fst suspension)))
+(defn- resume-reader [^Pair suspension] (run-reader (.-snd suspension) (.-fst suspension)))
 
 (defn run-reader [eff env]
   (loop [eff eff]
     (condp instance? eff
       Pure eff
-      Impure (let [request (.-request eff)
+      Impure (let [^Impure eff eff
+                   request (.-request eff)
                    k (partial q/apply-queue (.-cont eff))]
                (condp instance? request
                  Ask (recur (k env))
-                 Local (mlet [v (run-reader (.-body request) ((.-f request) env))]
-                         (run-reader (qk v) env))
+                 Local (mlet [:let [^Local request request]
+                              v (run-reader (.-body request) ((.-f request) env))]
+                         (run-reader (k v) env))
                  (fell.core/weave eff (pair env nil) resume-reader))))))

src/fell/state.cljc

@@ -2,11 +2,12 @@
   "State effect."
   (:refer-clojure :exclude [get set])
   (:require [cats.core :refer [extract]]
-            [cats.data :refer [pair]]
+            [cats.data :refer [pair #?(:cljs Pair)]]
             [fell.eff :refer [Effect weave #?@(:cljs [Pure Impure])]]
             [fell.queue :as q]
             [fell.core :refer [pure impure request-eff #?@(:cljs [Pure Impure])]])
-  #?(:clj (:import [fell.eff Pure Impure])))
+  #?(:clj (:import [cats.data Pair]
+                   [fell.eff Pure Impure])))
 
 (declare run-state)
 
@@ -27,17 +28,18 @@
   [value*]
   (request-eff (Set. value*)))
 
-(defn- resume-state [suspension] (run-state (.-snd suspension) (.-fst suspension)))
+(defn- resume-state [^Pair suspension] (run-state (.-snd suspension) (.-fst suspension)))
 
 (defn run-state
   "`(run-state eff state)` runs the State effect in Eff `eff` using `state` as the initial state value."
   [eff state]
   (loop [state state, eff eff]
     (condp instance? eff
       Pure (pure (pair state (extract eff)))
-      Impure (let [request (.-request eff)
+      Impure (let [^Impure eff eff
+                   request (.-request eff)
                    k (partial q/apply-queue (.-cont eff))]
                (condp instance? request
                  Get (recur state (k state))
-                 Set (recur (.-new_value request) (k nil))
+                 Set (recur (.-new_value ^Set request) (k nil))
                  (fell.core/weave eff (pair state nil) resume-state))))))

src/fell/writer.cljc

@@ -1,11 +1,12 @@
 (ns fell.writer
   (:require [cats.core :refer [mlet fmap mempty mappend extract]]
             [cats.context :as ctx]
-            [cats.data :refer [pair]]
+            [cats.data :refer [pair #?(:cljs Pair)]]
             [fell.core :refer [pure request-eff]]
             [fell.eff :refer [Effect #?@(:cljs [Pure Impure])]]
             [fell.queue :as q])
-  #?(:clj (:import [fell.eff Pure Impure])))
+  #?(:clj (:import [cats.data Pair]
+                   [fell.eff Pure Impure])))
 
 (defrecord Tell [message]
   Effect
@@ -32,20 +33,22 @@
 (defn- resume* [output eff]
   (condp instance? eff
     Pure (pure (pair output (extract eff)))
-    Impure (let [request (.-request eff)
+    Impure (let [^Impure eff eff
+                 request (.-request eff)
                  k (partial q/apply-queue (.-cont eff))]
              (condp instance? request
-               Tell (recur (mappend output (.-message request)) (k nil))
-               Listen (mlet [result (run (ctx/infer output) (.-body request))
+               Tell (recur (mappend output (.-message ^Tell request)) (k nil))
+               Listen (mlet [^Pair result (run (ctx/infer output) (.-body ^Listen request))
                              :let [output* (.-fst result)]]
                         (resume* (mappend output output*) (k result)))
-               Pass (mlet [result (run (ctx/infer output) (.-body request))
+               Pass (mlet [^Pair result (run (ctx/infer output) (.-body ^Pass request))
                            :let [output* (.-fst result)
-                                 f (.-fst (.-snd result))
-                                 v (.-snd (.-snd result))]]
+                                 ^Pair vs (.-snd result)
+                                 f (.-fst vs)
+                                 v (.-snd vs)]]
                       (resume* (mappend output (f output*)) (k v)))
                (fell.core/weave eff (pair output nil) resume)))))
 
-(defn- resume [suspension] (resume* (.-fst suspension) (.-snd suspension)))
+(defn- resume [^Pair suspension] (resume* (.-fst suspension) (.-snd suspension)))
 
 (defn run [ctx eff] (resume* (mempty ctx) eff))

test/fell/core_test.clj

@@ -4,22 +4,22 @@
             [cats.core :refer [return bind]]
             [fell.eff :refer [context]]
             [fell.core :refer :all])
-  (:import [fell.eff Pure]))
+  (:import [fell.eff Pure Impure]))
 
 (deftest monad-test
   (testing "return"
     (let [eff (return context 23)]
       (is (instance? Pure eff))
-      (is (= (.-v eff) 23))))
+      (is (= (.-v ^Pure eff) 23))))
 
   (testing "bind"
     (testing "pure"
       (let [eff (bind (pure 23) return)]
-        (is (= (.-v eff) 23))))
+        (is (= (.-v ^Pure eff) 23))))
 
     (testing "impure"
       (let [eff (bind (request-eff [::foo 23]) return)]
-        (is (= (.-request eff) [::foo 23]))))))
+        (is (= (.-request ^Impure eff) [::foo 23]))))))
 
 (deftest request-eff-test
   (let [eff (request-eff [::foo 23])]

test/fell/eff_test.cljc

@@ -4,7 +4,8 @@
             [cats.core :refer [extract]]
             [cats.protocols :refer [-get-context]]
             [fell.queue :refer [empty-queue]]
-            [fell.eff :refer :all]))
+            [fell.eff :refer :all])
+  #?(:clj (:import [fell.eff Pure Impure])))
 
 (deftest get-context-test
   (are [eff] (= (-get-context eff) context)
@@ -16,10 +17,10 @@
 
 (deftest flat-map-test
   (testing "->Pure"
-    (let [eff (-flat-map (->Pure 23) ->Pure)]
+    (let [^Pure eff (-flat-map (->Pure 23) ->Pure)]
       (is (= (.-v eff) 23))))
 
   (testing "->Impure"
-    (let [eff (-flat-map (->Impure [::foo 23] empty-queue) ->Pure)]
+    (let [^Impure eff (-flat-map (->Impure [::foo 23] empty-queue) ->Pure)]
       (is (= (.-request eff) [::foo 23]))
       (is (= (.-cont eff) (conj empty-queue ->Pure))))))