divs1210

import java.util.*;
import java.util.concurrent.Callable;
import java.util.function.Function;

class SLIP {
    /**
     * Keywords
     */
    public static final Object
            _IF = new Object(),

divs1210

(defn event [env type val]
  (let [rc (chan)]
    (>! (:queue @env)
        {:type type :val val :rc rc :time (:now @env)})
    (<! rc)))


(defn bench []
  (time
   (let [n 100000

divs1210

Setup

• library

Channels & go

var c = chan();

go(function() {
  // async block

divs1210

(ns history)

;; AN EXCERCISE IN TIME TRAVEL
;; ===========================
(defn hatom
  "Atom that remembers previous states."
  [x]
  (atom {:value x
         :history ()}))

divs1210

;; clojure solution for https://medium.com/@bellmar/is-cobol-holding-you-hostage-with-math-5498c0eb428b
;; HN: https://news.ycombinator.com/item?id=17636029

(defn rec [y z]
  (- 108
     (/ (- 815
           (/ 1500 z))
        y)))

(defn rec-list [N]

divs1210

(defn extrapolate*
  [gen-next shrink v]
  (lazy-seq
   (let [next-item (gen-next v)
         new-v (shrink (conj v next-item))]
     (cons next-item
           (extrapolate* gen-next shrink new-v)))))

(defn extrapolate
  "Returns a lazy seq produced by extrapolating `coll` with given rules.

divs1210

(ns fork-join-recur
  (:import [java.util.concurrent ForkJoinPool
            ForkJoinWorkerThread ForkJoinTask RecursiveTask]))

;; API
;; ===
(def ^:dynamic ^ForkJoinPool *pool* (ForkJoinPool/commonPool))

(defmacro fork [& body]
  `(let [^ForkJoinTask task# (proxy [RecursiveTask] []

divs1210

(ns calculus)

(defonce ^:const dx 0.00001M)

(defn df
  "Returns the derivative of f."
  [f]
  (fn [x]
    (/ (- (f (+ x dx)) (f x))
       dx)))

divs1210

def do(*body):
    return body[-1]


# Example (Python 2)
# =======
map(lambda x: do(
        print('x =', x),
        x * x),
    range(5))

divs1210

# Abstract Class
# ==============
class ISeq
  def first
  end

  def rest
  end

  def [](idx)