swannodette

(declare numbero*)
 
(defn symbolo* [x]
  (reify
    IConstraintStep
    (-step [this s]
      (reify
        clojure.lang.IFn
        (invoke [_ s]
          (let [x (walk s x)]

swannodette

;; based on core.logic 0.8-alpha2 or core.logic master branch

(ns sudoku
  (:refer-clojure :exclude [==])
  (:use clojure.core.logic))

(defn get-square [rows x y]
  (for [x (range x (+ x 3))
        y (range y (+ y 3))]
    (get-in rows [x y])))

swannodette

Externs Inference

Integrating third party JavaScript libraries not written with Google Closure Compiler in mind continues to both be a source of error for users when going to production, and significant vigilance and effort for the the broader community (CLJSJS libraries must provide up-to-date and accurate externs).

In truth writing externs is far simpler than most users imagine. You only need externs for the parts of the library you actually intend to use from ClojureScript. However this isn't so easy to determine from Closure's own documentation. Still in the process of writing your code it's easy to miss a case. In production you will see the much dreaded error that some mangled name does not exist. Fortunately it's possible to enable some compiler flags :pretty-print true :pseudo-names true to generate an advanced build with human readable names. However debugging missing externs means compiling your production build for each missed case. So much time wasted for such simple mistakes damages our sen

swannodette

var data = [0,1,2,3,4,5,6,7,8,9];

function test() {
  var result = [];
  for(var i = 0; i < data.length; i++) {
    if(data[i] % 2 == 0) {
      result.push(data[i]*2);
    }
  }

swannodette

Function.implement({
  partial: function(bind, args) {
    var self = this;
    args = $splat(args);
    return function() {
      return self.apply(bind, args.concat($A(arguments)));
    };
  }
});

swannodette

(defn debounce 
  ([c ms] (debounce (chan) c ms))
  ([c' c ms]
    (go
      (loop [start nil loc (<! c)]
        (if (nil? start)
          (do
            (>! c' loc)
            (recur (js/Date.) nil))
          (let [loc (<! c)]

swannodette

(ns lucenalog.core
    "Lucenalog = Datalog interface to Lucene in 10 lines.

Simple but powerful.

Use

  (db/add (index) {:a \"foo\" :b \"bar\"})

to index a map with Lucene.  Then you can use the relation

swannodette

;; list comprehensions are often used as a poor man's Prolog
;; consider the following, it has only one solution 
;; [1 1 1 1 1 1 1 1 1 1] yet we actually consider 10^10 possibilities

(for [a (range 1 11)
      b (range 1 11)
      c (range 1 11)
      d (range 1 11)
      e (range 1 11)
      f (range 1 11)

swannodette

(ns async-test.timeout.core
  (:require [cljs.core.async :refer [chan close!]])
  (:require-macros
    [cljs.core.async.macros :as m :refer [go]]))
 
(defn timeout [ms]
  (let [c (chan)]
    (js/setTimeout (fn [] (close! c)) ms)
    c))
 

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"