tonsky

(defn end? [[x1 x2 x3 x4 x5 x6 x7 x8 x9]]
  (or
    (and (some? x1) (= x1 x2 x3))
    (and (some? x4) (= x4 x5 x6))
    (and (some? x7) (= x7 x8 x9))
    (and (some? x1) (= x1 x4 x7))
    (and (some? x2) (= x2 x5 x8))
    (and (some? x3) (= x3 x6 x9))
    (and (some? x1) (= x1 x5 x9))
    (and (some? x3) (= x3 x5 x7))

tonsky

package com.example.onair

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.*
import androidx.ui.core.Text
import androidx.ui.core.dp
import androidx.ui.core.setContent
import androidx.ui.foundation.Clickable
import androidx.ui.foundation.ColoredRect

tonsky

(ns datomicdemo.core
  (:require
    [clojure.edn]
    [clojure.string :as str]
    [datomic.api :as d]))

(def url "datomic:free://localhost:4334/datomicdemo")

(d/create-database url)

tonsky

;; I have this

(def routes ["/" [["" :ui/index]
                  ["api/query" :api/query]
                  ["api/data-init" :api/data-init]]])

;; And I want to make api/data-init only accesible through POST
;; I tried

(def routes ["/" [["" :ui/index]

tonsky

(let [a 1, a  2,  a 3]
  (and (= a 1) (= a  2) (=  a 3)))

tonsky

(defn bench-btset []
  (doseq [distinct    [:distinct :duplicates]
          size        [20000]
          [tn target] [["sorted-set" (sorted-set)]
                       ["btset"      (btset/btset)]
                       ["vector"     []]]
          :let [range          (if (= :distinct distinct)
                                 (shuffle (range size))
                                 (repeatedly size #(rand-int size)))
                shuffled-range (shuffle range)

tonsky

(defn digits [x]
  (loop [r x, digits []]
    (if (== 0 r)
      digits
      (recur (quot r 10) (conj digits (rem r 10))))))

(defn double-odd-digits [digits]
  (map-indexed (fn [i d] (if (odd? i) (* 2 d) d)) digits))

(defn valid? [x]

tonsky

(defn quick-benchmark [fun]  
  (let [t0 (js/performance.now)]
    (loop []
      (dotimes [_ 10] (fun))
      (when (< (- (js/performance.now) t0) 1000) (recur)))
    (let [t0      (js/performance.now)
          steps   (loop [steps 0]
                    (dotimes [_ 10] (fun))
                    (if (< (- (js/performance.now) t0) 5000)
                      (recur (+ steps 10))

tonsky

(defn race
  "Runs two fns in tight loops in two parallel threads for 1 second"
  [publish-fn check-fn]
  (println "---")
  (let [*run?     (volatile! true)
        *failures (volatile! 0)
        thread!   #(future
                     (loop [i 0]
                       (% i)
                       (if @*run? (recur (inc i)) i)))

tonsky

(require '[criterium.core :as c])

(defn format-time [estimate]
  (let [mean (first estimate)
        [factor unit] (c/scale-time mean)]
    (c/format-value mean factor unit)))


(defmacro race [body1 body2]
 `(let [_#        (assert (= ~body1 ~body2))