| (defmacro with-conditions | |
| [conditions & body] | |
| {:pre [(map? conditions)]} | |
| (if-not *assert* | |
| `(do ~@body) | |
| (let [ret (gensym "ret")] | |
| `(do ~@(for [pre (:pre conditions)] | |
| `(when-not ~pre | |
| (throw (ex-info "Precondition failed" {:pre '~pre})))) | |
| (let [~ret (do ~@body)] |
This describes how I setup Atom for an ideal Clojure development workflow. This fixes indentation on newlines, handles parentheses, etc. The keybinding settings for enter (in keymap.cson) are important to get proper newlines with indentation at the right level. There are other helpers in init.coffee and keymap.cson that are useful for cutting, copying, pasting, deleting, and indenting Lisp expressions.
The Atom documentation is excellent. It's highly worth reading the flight manual.
| (ns seagent-ui.catan | |
| (:require [reagent.core :as r])) | |
| (defn dice-roll [] | |
| (+ (rand-nth [1 2 3 4 5 6]) | |
| (rand-nth [1 2 3 4 5 6]))) | |
| (defonce roll (r/atom (dice-roll))) | |
| (defonce history (r/atom [@roll])) | |
| (defonce players (r/atom ["P 1" "P 2" "P 3" "P 4"])) |
| #!/usr/bin/env boot | |
| ;; or `BOOT_FILE=ec2query.boot boot repl' for interactive use | |
| (set-env! :dependencies '[[amazonica "0.3.23"] | |
| [com.datomic/datomic-free "0.9.5344"]]) | |
| (require '[amazonica.aws.ec2 :as ec2] | |
| '[amazonica.core :refer [defcredential]] | |
| '[boot.cli :refer [defclifn]] | |
| '[boot.util :refer [info]] |
| def get_in(data, array) | |
| if array.size > 1 | |
| key = array.shift | |
| get_in(data[key], array) | |
| else | |
| return data.values.first | |
| end | |
| end |
| (defn define-node-repl-launcher [] | |
| (fn [handler] | |
| (fn [fileset] | |
| (defn node-repl [] | |
| (require 'cemerick.piggieback 'cljs.repl.node) | |
| ((resolve 'cemerick.piggieback/cljs-repl) | |
| :repl-env ((resolve 'cljs.repl.node/repl-env)) | |
| :output-dir ".noderepl" | |
| :optimizations :none | |
| :cache-analysis true |
Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.
| FROM fedora:20 | |
| RUN yum erase -y vim-minimal &&\ | |
| yum groupinstall -y "development tools" && \ | |
| yum install -y --setopt=override_install_langs=en --setopt=tsflags=nodocs \ | |
| yum-utils \ | |
| git \ | |
| golang \ | |
| mercurial \ | |
| bzr \ |
| ;;;;;;;;;;;;;;;;;; | |
| ;; $Rev$ | |
| ;; textflow is a trivial generator of RFC like call flow (a.k.a sequence diagrams) | |
| ;; | |
| ;; Example usage: | |
| ;; (flow [Alice Bob Tzach] | |
| ;; [[mmm Tzach Bob] | |
| ;; [xxx Bob Alice] | |
| ;; [] | |
| ;; [zzz Alice Tzach]]) |
| Scratchpad: Code + everything needed to run it | |
| ——————————————————————— | |
| Scratchpad is a platform that lets you build scratchpads and run them | |
| at the REPL. A scratchpad is a self-contained clojure file that includes | |
| both code and everything needed to run it: library dependencies and | |
| infrastructure. | |
| Dependencies are expressed in lein-style and are downloaded and added | |
| into the classpath when you load the scratchpad into the REPL. You can |
