stuarthalloway

;; lein settings
(defproject foo "1.0.0-SNAPSHOT"
  :description "Test App"
  :dependencies [[com.datomic/datomic "0.1.2678"]
                 [frinj "0.1.2" :exclusions [org.clojure/clojure]]])

;; load libs
(use 'frinj.core 'frinj.calc)
(frinj-init!)
(use '[datomic.api :only (q db) :as d])

cgrand

;; I could have used a closed dispatch (aka cond) but you may find this version more enjoyable
;; the spec format is the one provided by BG

(defprotocol Selector
  (-select [s m]))

(defn select [m selectors-coll]
  (reduce conj {} (map #(-select % m) selectors-coll)))

(extend-protocol Selector

domenic

This article has been given a more permanent home on my blog. Also, since it was first written, the development of the Promises/A+ specification has made the original emphasis on Promises/A seem somewhat outdated.

You're Missing the Point of Promises

Promises are a software abstraction that makes working with asynchronous operations much more pleasant. In the most basic definition, your code will move from continuation-passing style:

getTweetsFor("domenic", function (err, results) {
 // the rest of your code goes here.

cgrand

(ns net.cgrand.decay
  "Exponentially decaying lists. See http://awelonblue.wordpress.com/2013/01/24/exponential-decay-of-history-improved/
  for background and http://clj-me.cgrand.net/2013/02/12/decaying-lists-log-scale-for-lists/ for documentation")

;; PRNG, formulas straight from java.util.Random javadoc
(defn- seed ^long [^long n]
  (bit-and (unchecked-multiply n 0x5DEECE66D)
    (unchecked-dec (bit-shift-left 1 48))))

(defn- next-seed ^long [^long seed]

cgrand

(defn- balance [n f & args] 
  (if (> (count args) n)
    (apply balance n f (map #(apply f %) (partition-all n args)))
    (apply f args)))

;; optimization kicks in for N >= 4
=> (doseq [N (range 1 16)] 
     (let [++ (apply comp (repeat N inc))
           b++ (apply balance 3 comp (repeat N inc))]
       (println "N=" N)

oliyh

(deftest customisable-threading
  (is (= "hello" (->>> :a (% {:a :h}) (name %) (cons % "ello") (clojure.string/join %)))))

cgrand

;; I wrote this in the Eurostar on my way back from the last lambdanext.eu clojure course.

(ns comprehensions
  (:refer-clojure :exclude [for doseq])
  (:require [clojure.core.reducers :as r]))

;; borrowed from clojure.core
(defmacro ^{:private true} assert-args
  [& pairs]
  `(do (when-not ~(first pairs)

heathermiller

import scala.pickling._

import scala.reflect.runtime.universe._
import scala.util.parsing.json._
import scala.collection.mutable.{StringBuilder, Stack}

package object edn {
  implicit val pickleFormat: EdnPickleFormat = new EdnPickleFormat
}

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"

swannodette

(def cds (collection))

;; interact with database

(go
  (>! (:in cds)
    {:op :create
     :val {:title "Soft Machine Vol. 1"
           :artist "Soft Machine"
           :year 1969}})