ray1729

(ns rollup.core
  (:require [clojure.core.async :refer [go chan <! put! timeout alt! alts!]]))


(def ch (chan))

(go
 (loop [stash []]
   (let [[v c] (alts! [ch (timeout 3000)])]
     (if (= c ch)

ray1729

(ns playground.explode
(:require [clojure.math.combinatorics :refer [cartesian-product]]
          [clojure.string :as str]))

(def ambiguous-chars [#{\O \0} #{\I \L \1}])

(defn ambiguate
  [c]
  (or (first (filter #(contains? % c) ambiguous-chars))
      [c]))

ray1729

(ns titanium-demo.core
  (:require [clojure.java.io :as io]
            [clojurewerkz.titanium.graph :as tg]
            [clojurewerkz.titanium.schema :as scm]
            [clojurewerkz.titanium.vertices :as tv]))

(defn generate-config
  "Generate a configuration map to use BerkeleyDB and Lucene
   with data stored in the given directory."
  [dir]

ray1729

(def xs (sort (repeatedly 30 #(rand-int 20))))

(def ys (sort (repeatedly 25 #(rand-int 20))))

(defn merge-sorted-seqs
  [xs ys]
  (lazy-seq (cond
             (empty? xs) (seq ys)
             (empty? ys) (seq xs)
             :else (let [x (first xs) y (first ys)]

ray1729

(ns hornetq-test.core
  (:require [immutant.messaging :as msg]
            [immutant.util])
  (:gen-class))

(def running? (atom true))

(def uniq (rand-int 1000000))

(defn do-stuff []

ray1729

;; This is a suggested improvement for processing SNP data, in response
;; to Jan Aerts' blog post <http://saaientist.blogspot.com/2010/06/encounter-with-incanter-about-clojure.html>.
;; Note that this example is for Clojure 1.1.0; if you're using Clojure 1.2, change the ns definition
;; to use clojure.contrib.io instead of duck-streams.

(ns ray1729.clojure.bio.snps
  (:use [clojure.contrib.duck-streams :only (read-lines)]))

(defn parse-line
  [s]

ray1729

#!/usr/bin/env perl

use strict;
use warnings FATAL => 'all';

my ( $key, @values ) = next_record();

while ( defined $key ) {
    my ( $next_key, @next_values ) = next_record();    
    if ( defined $next_key and $next_key eq $key ) {

ray1729

(defn secret-santa
  [names]
  (let [s (shuffle names)]
    (partition 2 1 (cons (last s) s))))

ray1729

(defn keep-only
  [n bucket-fn s]
  (letfn [(my-filter
           [s seen]
           (when (seq s)
             (let [e (first s)
                   b (bucket-fn e)
                   c (inc (get seen b 0))]
               (if (> c n)
                 (recur (rest s) seen)

ray1729

;; Perl: $RE{num}{-base => 2}{real}{-group => 3}{-sep => ','}

(re-seq (re :real {:base 2 :group 3 :sep \,} ) "1.345")