ckirkendall

(use '[clojure.core.match :only [match]])

(defn evaluate [env [sym x y]]
  (match [sym]
    ['Number]   x
    ['Add]      (+ (evaluate env x) (evaluate env y))
    ['Multiply] (* (evaluate env x) (evaluate env y))
    ['Variable] (env x)))
    
(def environment {"a" 3, "b" 4, "c" 5})

ckirkendall

The Objective

This language experiment was designed to show how parametric polymorphism and type classes are
implemented in different languages. The implementation languages where chosen out of personal
preference. I am well aware it's not complete and would love for you to help me with that.  If
you don't see your favorite language please add it as a comment.  I am also not an expert in all
of these languages but did try to make them as idiomatic as possible. If you believe there is a
better solution please leave a comment with the implementation.

The Code

ckirkendall

(defrecord Tree [left elm right])

(defprotocol Monoid
   (append [a b] )
   (identity [a] ))

(defprotocol Foldable
  (foldl [l f i])
  (mfirst [l]))
  

ckirkendall

(ns sim-cincyfp.core)

(def min (* 1000 60))
(def min5 (* 5 min))
(def min10 (* 10 min))
(def min15 (* 15 min))
(def min30 (* 30 min))

;; ---------------------------------------------------------------------
;; Generating Events

ckirkendall

{"nodes":[
  {"x":80, "r":40, "label":"Node 1"}, 
  {"x":200, "r":60, "label":"Node 2"}, 
  {"x":380, "r":80, "label":"Node 3"}
]}

ckirkendall

(ns wine-fun.data
  (:require [clojure.java.io :as io]
            [clojure.data.csv :as csv]))


(def training-data
  (let [data (with-open [in-file (io/reader "data/winequality-data.csv")]
               (drop 1 (doall
                        (csv/read-csv in-file))))
        control-count (int (/ (count data) 10))

ckirkendall

 <security-domain name="other" cache-type="default">
      <authorization>
        <policy-module code="Delegating" flag="required"/>
      </authorization>
</security-domain>

ckirkendall

(ns bouncy.core
  (:require [goog.math :as math :refer [Vec2]]
            [goog.math.Vec2 :as vec]))

(declare step draw-circle)

(def app {:elems [{:pos (Vec2. 100 100) :speed (Vec2. -3 5) :radius 20}
                  {:pos (Vec2. 200 200) :speed (Vec2. 5 3) :radius 30}
                  {:pos (Vec2. 300 200) :speed (Vec2. 7 6) :radius 5}
                  {:pos (Vec2. 400 200) :speed (Vec2. -5 -6) :radius 10}

ckirkendall

##Sketch for Enliven Component Model

This design page is a sketch of how I see enliven being used for dynamic templates in the browser.

Design Principles

1. All state is in an application state object.
2. State is scoped through lenses.
3. Users should not have to manage lenses manually.
4. There is no tree walking; paths/lenses, for dom manipulation, are determined at compile time.

ckirkendall

(defn bind-view-watch-fn [id render-func]
  (let [ky (str "EVB:" nid)]
    (fn [ctx ref oval nval]
      (let [node (.getElementById js/document id)]
        (if node
          (render-func node nval)
          (remove-watch ref ky))))))