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:

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

ptaoussanis

(defn oget
  "Like `aget` for JS objects, Ref. https://goo.gl/eze8hY. Unlike `aget`,
  returns nil for missing keys instead of throwing."
  ([o k] (when o (gobj/get o k nil)))
  ([o k1 k2] (when-let [o (oget o k1)] (gobj/get o k2 nil))) ; Optimized common case
  ([o k1 k2 & ks] (when-let [o (oget o k1 k2)] (apply oget o ks)))) ; Can also lean on optimized 2-case

ptaoussanis

;;
;; LATEST UPDATE: 25 July 2015
;;
;; ****************************************************************
;; ** NB false alarm! My original benchmarks showing large perf  **
;; ** improvements with tuples turned out to be noise,           **
;; ** unfortunately. Current (+more reliable) numbers seem[1] to **
;; ** show no consistent significant advantage using currently   **
;; ** available tuple implementations against real-world code.   **
;; **                                                            **

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 :

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

favila

(ns murmur3
 "Implementation of clojure.lang.Murmur3 in clojurescript (assuming javascript numerics).
  by Francis Avila 2014-02-24")

(def imul
  "32-bit signed integer multiply with overflow; alias of js/Math.imul.
  Does not follow unchecked-multiply-int semantics! Only two args accepted; if
  args are missing returns 0."
  (if (exists? (aget js/Math "imul"))
    (aget js/Math "imul")

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

ptaoussanis

(defmacro iff [test & {:keys [then else]}] `(if ~test ~then ~else))
(comment (iff false
              :then (println "true")
              :else (println "false")))

(defmacro iff-let [bindings & {:keys [then else]}] `(if-let ~bindings ~then ~else))
(comment (iff-let [x true] :else "false" :then x))

(defmacro if-lets
  "Like `if-let` but binds multiple values iff all tests are true."

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"