laurentpetit

(ns mutabots
  "Reimplementation of transducers, in terms of processing functions instead
   of reducing functions.

   tl;dr: reducing-fn based transducers are a special case, influenced by reducers,
          of processing-fn based transducers.

   In Clojure 1.7.0-alpha2, transducers are expressed in terms of the existing
   concept of reducing functions.
   To sum it up, a transducer has currently the signature :

swannodette

(ns async-test.throttle.core
   (:require [cljs.core.async :refer [chan close!o sliding-buffer]]
            [clojure.string :as string])
  (:require-macros
    [cljs.core.async.macros :as m :refer [go alts!]]))

(def c (chan (sliding-buffer 1)))
(def loc-div (.getElementById js/document "location"))

(.addEventListener js/window "mousemove"

wavejumper

;; Example courtesy of @wavejumper

(ns sente-ring-jetty9-adapter-example
  (:require [compojure.core :refer :all]
            [compojure.route :as route]
            [ring.middleware.defaults :as ring.defaults :refer [wrap-defaults]]
            [ring.middleware.session.memory :as mem]
            [ring.adapter.jetty9 :as jetty]
            [taoensso.sente :as sente]
            [taoensso.sente.server-adapters.jetty9 :as adapters.jetty9]))

field-theory

Tutorial

This is a tutorial for https://github.com/ptaoussanis/tempura, a Clojurescript library for i18n.

Add the necessary dependency to your project:

[com.taoensso/tempura "1.2.1"]

The following walk-through assumes that you are using a REPL and have required tempura as follows:

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).

ptaoussanis

;; (require '[clojure.string :as str] '[clojure.java.shell :as shell] '[taoensso.timbre :as timbre])

(defn with-free-port!
  "Attempts to kill any current port-binding process, then repeatedly executes
  nullary `bind-port!-fn` (which must return logical true on successful
  binding). Returns the function's result when successful, else throws an
  exception. *nix only.

  This idea courtesy of Feng Shen, Ref. http://goo.gl/kEolu."
  [port bind-port!-fn & {:keys [max-attempts sleep-ms]

cemerick

(ns whatever.cljs
  (:require [cljs.compiler :refer (munge)])
  (:refer-clojure :exclude (munge defonce)))

(defmacro defonce
  [vname expr]
  (let [ns (-> &env :ns :name name munge)
        mname (munge (str vname))]
    `(when-not (.hasOwnProperty ~(symbol "js" ns) ~mname)
       (def ~vname ~expr))))