ordnungswidrig

(ns conditionals
  (:use clojure.test
        [clojure.core.match :only [match]]))

;; variation on conditionals
(defn test-conditional [f]
  (is (= (f :foo-exists) 1))
  (is (= (f :bar-is-nil) nil))
  (is (= (f :some-default) 3))
  (is (= (f :some-other-default) 3)))

ordnungswidrig

#!/bin/bash
# The logic to start up your application should be put in this
# script. The application will work only if it binds to
# $OPENSHIFT_INTERNAL_IP:8080
# save as .openshift/action_hooks/start

export HTTP_CLIENT="wget --no-check-certificate -O"
export PORT=$OPENSHIFT_INTERNAL_PORT
export HOST=$OPENSHIFT_INTERNAL_IP
export HOME=$OPENSHIFT_DATA_DIR/home

ordnungswidrig

(provide 'dedicated-2)

(defvar d2-mode-window-map ())
(defvar d2-regexp-window-map ())

(defun buffer-mode (buf)
  (with-current-buffer buf major-mode))

(defun d2-get-window-by-mode (buffer)
  (let* ((mode (buffer-mode buffer))

ordnungswidrig

(ns sandbox.live
  (:use [clojure.pprint :only (pprint)] )
  (:import [javax.swing JFrame JTextArea JScrollPane]
           [java.awt BorderLayout Font]
           [java.awt.event WindowAdapter]))

(defn schedule [interval f]
  (let [flag (atom nil)]
    (.start (Thread. #(loop [] (f)
                            (Thread/sleep interval)

ordnungswidrig

(ns actors)

(defn receive [f]
  f)

(defn send_ [f & args]
  (dosync (alter f apply args)))

(defn actor [f state]
  (ref (f state)))

ordnungswidrig

(defprotocol Foo (foo [this]))
(defrecord FooImpl [x] Foo (foo [_] (->FooImpl x)))
;; => Unable to resolve symbol: ->Foo in this context

ordnungswidrig

(def s (start-server 3000 inc false))

;; echo 10\n20\n30 | nc localhost 3000
;; => 11\n21\n31

(stop-server s)

ordnungswidrig

;; On my journey into event sourcing in clojure I'm trying different approaches
;; of modeling events and event handling in clojure.

;; A little ceremony to pay homage to the gods of clojure:
(ns handler-protocol
  (:use clojure.contrib.trace)
  (:use clojure.pprint)
  (:use clojure.test))

;; My example problem domain for this will be a very simple sketch of twitter.

ordnungswidrig

(ns state-is-a-fold
  (:use clojure.test))

;;; After all, state is a fold of events. For example let's say the events are a sequence of numbers
;;; and we are folding by addition:

(deftest simple
  (let [events [1 5 2 4 3]
	state (reduce + events)]
    (is (= 15 state))))

ordnungswidrig

(ns reify-generic
  "reify a protocol such that every method is delegated to a specified method")

(defmacro reify-generic
  "Reify the given protocols. Every method of any protocol is implemented such
   that f is called as (apply f protocol-method args)

   Example:

  (defprotocol Calculator