Skip to content

Instantly share code, notes, and snippets.

View ckirkendall's full-sized avatar

Creighton Kirkendall ckirkendall

  • Blue Manta Consulting
  • Cincinnati, Ohio
View GitHub Profile
@ckirkendall
ckirkendall / clojure-match.clj
Created June 15, 2012 02:26 — forked from bkyrlach/Expression.fs
Language Compare F#, Ocaml, Scala, Clojure, Ruby and Haskell - Simple AST example
(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
ckirkendall / ExpressionTree.rb
Created June 18, 2012 15:18 — forked from jimweirich/Expression Tree
Another expression tree evaluator
Number = lambda { |env, num| num }
Variable = lambda { |env, var| env[var] }
Add = lambda { |env, a, b| evaluate(env, a) + evaluate(env, b) }
Multiply = lambda { |env, a, b| evaluate(env, a) * evaluate(env, b) }
def evaluate(env, exp)
op, *args = exp
op.(env, *args)
end
@ckirkendall
ckirkendall / Lambda.scala
Created June 18, 2012 16:09 — forked from bkyrlach/AST.cs
Lambda for Scala...
object Lambda extends App {
val number = (num: Int) => (env: Map[Symbol, Int]) => num
val variable = (id: Symbol) => (env: Map[Symbol, Int]) => env(id)
val add = (a: (Map[Symbol, Int]) => Int, b: (Map[Symbol, Int]) => Int ) => (env: Map[Symbol, Int]) => a(env) + b(env)
val multiply = (a: (Map[Symbol, Int]) => Int, b: (Map[Symbol, Int]) => Int ) => (env: Map[Symbol, Int]) => a(env) * b(env)
val environment = Map('a -> 1, 'b -> 2, 'c -> 3)
val expr_tree = add(variable('a), multiply(number(2), variable('b)))
println(expr_tree(environment))
@ckirkendall
ckirkendall / A-sum-higher-kinds.clj
Created June 19, 2012 22:12 — forked from bkyrlach/GenericVersion.scala
Polymorphism - Summation of Higher Kinds(Clojure, Ocaml, Haskell, Scala, Java).
(defrecord Tree [left elm right])
(defprotocol Monoid
(append [a b] )
(identity [a] ))
(defprotocol Foldable
(foldl [l f i])
(mfirst [l]))
@ckirkendall
ckirkendall / P26.scala
Created July 27, 2012 15:19 — forked from bkyrlach/P26.scala
Permutations of a list...
object P26 extends App {
def combinations[T](n: Int, l: List[T]): List[List[T]] = {
if(l.size < n) {
Nil
} else {
n match {
case 0 => Nil
case 1 => l.map{List(_)}
case _ => combinations(n-1,l.tail).map{ l.head :: _} ::: combinations(n, l.tail)
}
@ckirkendall
ckirkendall / cps.clj
Created July 28, 2012 19:59 — forked from fogus/cps.clj
continuation passing transform macro
(defn & [f k]
(fn [& args]
(k (apply f args))))
(defmacro cps [steps]
(if (seq steps)
`(& ~(first steps)
(cps ~(rest steps)))
`identity))
@ckirkendall
ckirkendall / A-Objective.txt
Created September 14, 2012 16:40 — forked from bkyrlach/TreeMagic.scala
Adventures in Type Theory: Parametric Polymorphism(Generics) vs Adhoc Polymophism(Type Classes) (Java,Scala,C#,F#,Nemerle,Haskell)
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
ckirkendall / Lambda.clj
Last active December 11, 2015 09:48 — forked from bkyrlach/Lambda.scala
(ns lambda-calc.core)
;; THIS MACRO CREATES A LAMBDA THAT IS COMPATABLE WITH LAMBDA AS DEFINED IN
;; LAMBDA CALCULUS -> CURRIED NON-RECURSIVE
(defmacro f* [args & body]
(let [fsym (gensym "fn")
alist (for [n (range 1 (count args))]
(take n args))
curries (map #(do `(~(vec %) (partial ~fsym ~@%))) alist)]
`(fn ~fsym ~@curries (~args ~@body))))
(ns workbench.enlive.predicate
(:require
[clojure.zip :as z]
[workbench.enlive.engine
:refer [compile-step]]
[workbench.enlive.select
:refer [zip-select]]))
;; ## Builtin predicates
;;
;; The macros
;; most macros here alias names from select.cljs
;; they will get used in regular calls
(ns lib.select
(:require
[clojure.string :as str]))
;; selector syntax
(defn intersection [preds]