favila

(ns favila.async-util
  "Some missing pieces of core.async.

   as-transducer: Make a transducer function easily without Clojure 1.7.
   go-pipe: async/pipe, but returns the go-loop.
   fast-pipeline-blocking: faster than async/pipeline-blocking, but unordered results.
   blocking-consumer: consume a channel with multiple worker threads."
  (:require [clojure.core.async :as async
             :refer [go go-loop <! >! <!! >!! close! take! put! chan]]))

ptaoussanis

(comment ; Fun with transducers, v2

  ;; Still haven't found a brief + approachable overview of Clojure 1.7's new
  ;; transducers in the particular way I would have preferred myself - so here goes:

  ;;;; Definitions
  ;; Looking at the `reduce` docstring, we can define a 'reducing-fn' as:
  (fn reducing-fn ([]) ([accumulation next-input])) -> new-accumulation
  ;; (The `[]` arity is actually optional; it's only used when calling
  ;; `reduce` w/o an init-accumulator).

brandonbloom

(in-ns 'eclj.core)

(defprotocol Fn
  :on-interface clojure.lang.Fn
  "Marker interface indicating invokeables that are explictly functions")

(defprotocol IFn
  :on-interface clojure.lang.IFn
  (^{:on :invoke} -invoke
    [this]

favila

(defn zip-partition
  "Return a sequence of length n of sequences of every nth item, each offset
  by one. Suitable for building the rows of a table with n columns where the
  sequence items flow down columns then rows. Example:
  
      (zip-partition [0 1 2 3 4] 2) -> ((0 4)
                                        (1 nil)
                                        (2 nil)
                                        (3 nil))"
  [s n]

loganlinn

(defn- debounce-future
  "Returns future that invokes f once wait-until derefs to a timestamp in the past."
  [f wait wait-until]
  (future
    (loop [wait wait]
      (Thread/sleep wait)
      (let [new-wait (- @wait-until (System/currentTimeMillis))]
        (if (pos? new-wait)
          (recur new-wait)
          (f))))))