nasser

(defmacro doarray [[variable array] & body]
  (let [i (with-meta (gensym "i") {:tag Int64})
        var-type (or (-> variable meta :tag) 'Object)
        arr-type (symbol->array-type var-type)
        arr (with-meta (gensym "array") {:tag arr-type})]
    `(let [~arr ~array]
       (loop [~i 0]
         (if (= ~i (.Length ~arr))
           nil
           (let [~variable (aget ~arr ~i)]

CornuAmmonis

file=""
tweet=""

if [ -n "$1" ]
then
 file="$1" 
else
 echo "Usage: splittwit /path/to/video.mp4 \"My tweet goes here!\""
 exit
fi 

nasser

Rejoyce

Rejoyce is a purely functional, persistent, concatenative language

It maintains an In queue and an Out stackThe In queue represents code yet to be executed, and is initially populated with the program to run

The Out stack represents data to be manipulated, and is initially empty

The two record the complete state of execution at any time

To evaluate a token, Rejoyce returns a completely new In and Out stack

vizanto

//
// Nasty code below:
//
package java.internal;
import java.internal.Runtime;

/**
 * These classes are automatically generated by the compiler. They are only
 * here so there is an option for e.g. defining them as externs if you are compiling
 * in modules (untested)

nasser

(ns sliders)

(defmacro slider [l]
  (let [dashes (vec (repeat l "-"))]
    `(do ~@(map (fn [i]
                  `(defn
                     ~(symbol (clojure.string/join (assoc dashes i "*")))
                     []
                     ~(/ i (- l 1))))
                (range l)))))

nasser

(ns curve)

(defn power [x a]
  (Math/Pow x a))

(defmacro v* [a b] `(Vector2/op_Multiply ~a ~b))
(defmacro v+
  ([a] a)
  ([a b] `(Vector2/op_Addition ~a ~b))
  ([a b & vs] (reduce

nasser

(defmacro chance [& body]
  (let [r (gensym "chance")
        pairs (sort-by first (partition 2 body))
        odds (map first pairs)
        exprs (map last pairs)
        sum (apply + odds)
        fracs (map #(float (/ % sum)) odds)
        frac-pairs (partition 2 (interleave fracs exprs))]
    `(let [~r (rand)]
       (cond

timsgardner

(defn fuzzy-finder-fn [name-fn resource-fn]
  (fn [string-or-regex]
    (let [f (if (instance? System.Text.RegularExpressions.Regex string-or-regex)
              #(re-find string-or-regex (name-fn %))
              (let [^String s string-or-regex]
                #(let [^String n (name-fn %)]
                   (.Contains n s))))]
      (filter f (resource-fn)))))

;; example:

alandipert

;; Copyright (c) Alan Dipert. All rights reserved.
;; The use and distribution terms for this software are covered by the
;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;; By using this software in any fashion, you are agreeing to be bound by
;; the terms of this license.
;; You must not remove this notice, or any other, from this software.

(defn paths
  "Enumerate paths into a nested map."
  ([root]

nasser

#!/usr/bin/ruby
puts open("db/#{ARGV.first}").read