Miķelis Vindavs axelarge

ClojureScript macros: kinda, sorta, not really.

ClojureScript does not have a standalone macro system. To write ClojureScript macros, one must write them in Clojure and then refer to them in ClojureScript code. This situation is workable, but at a minimum it forces one to keep ClojureScript code and the macros it invokes in separate files. I miss the locality of regular Clojure macros, so I wrote something called maptemplate that gives me back some of what I miss. The technique may be useful in other scenarios.

Problem

Suppose you're wrapping functionality in another namespace or package so that you can have your own namespace of identically named but otherwise decorated functions:

ClojureScript:

	$stack, $draws = [], {}

	def method_missing *args
	return if args[0][/^to_/]
	$stack << args.map { \|a\| a or $stack.pop }
	$draws[$stack.pop(2)[0][0]] = args[1] if args[0] == :<
	end

	class Array
	def +@

	-- show running queries (pre 9.2)
	SELECT procpid, age(clock_timestamp(), query_start), usename, current_query
	FROM pg_stat_activity
	WHERE current_query != '<IDLE>' AND current_query NOT ILIKE '%pg_stat_activity%'
	ORDER BY query_start desc;

	-- show running queries (9.2)
	SELECT pid, age(clock_timestamp(), query_start), usename, query
	FROM pg_stat_activity
	WHERE query != '<IDLE>' AND query NOT ILIKE '%pg_stat_activity%'

	Hello scala, my old friend
	I've come to take you home again
	Because a feature slowly creeping
	left me plagued with doubts and weeping
	and the version that was tagged in the repo
	just has to go
	it lacks the signs of soundness

	On sleepless nights I hacked alone
	applying ant and other tools of stone

	/©2013 Viktor Klang/
	package akka.util
	import java.util.concurrent.atomic.AtomicReference
	import scala.concurrent.{ Future, ExecutionContext }
	import scala.annotation.tailrec
	class Cache[K, V](__ec: ExecutionContext, throughput: Int) extends AtomicReference[Map[K, V]] {
	implicit val executor = SerializedSuspendableExecutionContext(throughput)(__ec)
	@tailrec final def update(f: Map[K, V] ⇒ Map[K, V]): Map[K, V] = {
	val v = get
	val nv = f(v)

	/**
	* Several macros simplifying use of weak references to self inside blocks
	* which goal is to reduce risk of retain cycles.
	*
	* Example:
	* @code

	@interface Example : NSObject{
	int _i;
	}

	Dear [First Name],

	We're really sorry but our systems were compromised and the attackers managed to take a copy
	of your passwords.

	The passwords were stored as:

	[ ] Bcrypt hashes with a cost factor of X
	[ ] PBKDF2 hashes with an iteration count of X
	[ ] scrypt because I am Colin Percival

	Apples-MacBook-Pro:~ debasishg$ scala
	Welcome to Scala version 2.10.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_45).
	Type in expressions to have them evaluated.
	Type :help for more information.

	scala> :paste
	// Entering paste mode (ctrl-D to finish)

	implicit class RContext(sc: StringContext) {
	def r =

	case class Inject[-E, +A](inject: E => A) {

	// covariant functor and monad
	def map[B](f: A => B): Inject[E, B] =
	Inject { e => f(inject(e)) }
	def flatMap[ε <: E, B](f: A => Inject[ε, B]): Inject[ε, B] =
	Inject { e => f(inject(e)).inject(e) }

	// to satisfy for-comprehension desugaring in scala < 2.10
	def filter(f: A => Boolean): Inject[E, A] =

	*.class
	*.swp