divs1210

Code

(import (rnrs))

(define (derive f dx)
  (lambda (x)
    (/ (- (f (+ x dx))
          (f x))
       dx)))

divs1210

(ns transducers
  "Learn transducers by implementing them."
  (:refer-clojure :exclude [map filter transduce sequence]))

(comment
  "Let's forget, for the sake of this experiment, about laziness in Clojure.
  We can implement eager versions of Clojure's `map` and `filter` functions as follows:")

(defn map
  [f coll]

divs1210

class Var(object):
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return self.name

class Lam(object):
    def __init__(self, bind, expr):
        self.bind = bind

divs1210

Futamura Projections

Insight

Name	Type
Inputs	Any
Output	Any
Program	Text
Compiler	Program => CompiledProgram

divs1210

(ns futamura
  (:require [clojure.string :as str]))

;; ========= util =====================
(defn get-source-code [var]
  (let [{:keys [file line]} (meta var)
        file (slurp file)
        lines (->> file
                   str/split-lines
                   (drop (dec line)))

divs1210

;; Implementation
;; ==============
(defn- return
  [base stack]
  (reduce (fn [acc f]
            (f acc))
          base
          stack))

(defn run-fsm

divs1210

Clojure Primer

• 0. Some Context
  • About Clojure
  • Follow and Explore!
• 1. "Fundamental" Values
  • Self Describing

• nil

divs1210

(ns pascal)

(defn step [row]
  (let [parents (partition 2 1 row)
        new-row-middle (map (fn [[x y]]
                              (+ x y))
                            parents)]
    (concat [1] new-row-middle [1])))

(defonce pascals-triangle

divs1210

def ordered_infix(*nums_and_ops)
  initial_val = nums_and_ops[0]
  op_num_pairs = nums_and_ops.drop(1).each_slice(2).to_a
  op_num_pairs.reduce(initial_val) do |accumulator, op_num_pair|
    op, num = op_num_pair
    accumulator.send(op, num)
  end
end

ordered_infix 10, '/', 2, '-', 1, '*', 2

divs1210

(defn watch-db []
  (add-watch re-frame.db/app-db :watcher
             (fn [_ _ old-state new-state]
               (let [[removed added] (clojure.data/diff old-state new-state)]
                 (when (or removed added)
                   (println "=====\nRemoved:")
                   (cljs.pprint/pprint removed)
                   (println "Added:")
                   (cljs.pprint/pprint added))))))