danownsthisspace · December 4, 2021 13:21
diff --git a/scratch.clj b/scratch.clj
 (ns scratch.core)

 ;;
 ;; x "once"
 ;; debouncer / rate limiter
 ;;   namespaces
 ;;   multiple windows
 ;;   invalidation
 ;;   peek

 (defn say-hi [username]
  (let [s (str "hello, " username)]
    (Thread/sleep (rand 100))
    (println s)
    s))

 (comment (say-hi "Steve"))

 (defn wrap-once
  "Returns a fn that wraps given function `f` so that:
    - First      call returns {:okay (apply f args)}.
    - Subsequent calls return nil, without executing `f`."
  [f]
  (let [run?_ (atom false)]
    (fn once-fn [& args]
      (when (compare-and-set! run?_ false true)
        {:okay (apply f args)}))))

 (comment
  (let [wf (wrap-once say-hi)]
    (println "---")
    [(future (wf "Steve 1"))
     (future (wf "Steve 2"))
     (future (wf "Steve 3"))]))

 (defn wrap-once-in-a-while
  "Returns a fn that wraps given function `f` so that:
    - If `f` hasn't been called in >= `msecs-period`:
      Call returns {:okay (apply f args)}.
    - Otherwise:
      Call returns nil, without executing `f`.
  `f` will never be called more than once in a given
  `msecs-period` even if wrapper is called from multiple
   threads."

  [msecs-period f]
  (let [last-executed_ (atom 0)]

    (fn wrapper [args]
      (let [now (System/currentTimeMillis)
            [old-executed new-executed]
            (swap-vals! last-executed_
              (fn [last-executed]
                (let [elapsed (- now last-executed)]
                  (if (>= elapsed msecs-period)
                    now
                    last-executed))))

            changed? (not= old-executed new-executed)]

        (when changed?
          (try
            (do                {:okay  (apply f args)})
            (catch Throwable t {:error t})))))))

 (comment
  (let [wf (wrap-once-in-a-while 100 say-hi)]
    [(wf 1) (wf 2) (wf 3)]))

 (comment
  ((wrap-once-in-a-while say-hi)
   "hello"))
	(ns scratch.core)

	;;
	;; x "once"
	;; debouncer / rate limiter
	;; namespaces
	;; multiple windows
	;; invalidation
	;; peek

	(defn say-hi [username]
	(let [s (str "hello, " username)]
	(Thread/sleep (rand 100))
	(println s)
	s))

	(comment (say-hi "Steve"))

	(defn wrap-once
	"Returns a fn that wraps given function `f` so that:
	- First call returns {:okay (apply f args)}.
	- Subsequent calls return nil, without executing `f`."
	[f]
	(let [run?_ (atom false)]
	(fn once-fn [& args]
	(when (compare-and-set! run?_ false true)
	{:okay (apply f args)}))))

	(comment
	(let [wf (wrap-once say-hi)]
	(println "---")
	[(future (wf "Steve 1"))
	(future (wf "Steve 2"))
	(future (wf "Steve 3"))]))

	(defn wrap-once-in-a-while
	"Returns a fn that wraps given function `f` so that:
	- If `f` hasn't been called in >= `msecs-period`:
	Call returns {:okay (apply f args)}.
	- Otherwise:
	Call returns nil, without executing `f`.
	`f` will never be called more than once in a given
	`msecs-period` even if wrapper is called from multiple
	threads."

	[msecs-period f]
	(let [last-executed_ (atom 0)]

	(fn wrapper [args]
	(let [now (System/currentTimeMillis)
	[old-executed new-executed]
	(swap-vals! last-executed_
	(fn [last-executed]
	(let [elapsed (- now last-executed)]
	(if (>= elapsed msecs-period)
	now
	last-executed))))

	changed? (not= old-executed new-executed)]

	(when changed?
	(try
	(do {:okay (apply f args)})
	(catch Throwable t {:error t})))))))

	(comment
	(let [wf (wrap-once-in-a-while 100 say-hi)]
	[(wf 1) (wf 2) (wf 3)]))

	(comment
	((wrap-once-in-a-while say-hi)
	"hello"))