In a recent Apprentice Blog of the Week, Alex Hill detailed one way that we can apply common Ruby patterns to our Clojure code. I’ve noticed a similar effect while making the opposite transition, too. Having spent a few months writing mostly Clojure and then transitioning back into writing mostly Ruby, it was interesting to see the way my experience with common patterns in Clojure influenced the way I approached writing Ruby.

Specifically, a couple of patterns I really enjoy using in Clojure are with and when macros. Usually, a macro starting with with- means that something is happening around the code you pass to it, and a macro starting with when- means that your code will be executed if a certain condition is met. For instance, we could write a macro called with-timing that times our code by setting a start time, evaluating the code, then logging the difference between the start and end times before returning our return value.

(defmacro with-timing [body]
		`(let [start# (now)
									ret# ~body]
					(logger/log (- (now) start#))
					ret#))
(defn timed-operation [x]
		(with-timing
				(calculate-some-things x)))

We might also write a macro called when-valid, which takes a record that we created from some user input, and then only evaluates our code if the record is valid, otherwise using the generic handler for invalid records.

(defmacro when-valid [record & body]
		`(if (valid? ~record)
					(render-invalid ~record)
					~@body))
(defn response-for [thing]
		(when-valid thing
														(render-created thing)))

We can implement our timing macro similarly in Ruby, by simply writing a method that takes a block to be called and timed.

def with_timing(&block)
		start_time = Time.now
		return_value = block.call
		log(Time.now - start_time)
		return_value
end

def timed_operation(x)
		with_timing do
				calculate_some_stuff(x)
		end
end

We can also reduce the duplication of a common Rails controller pattern by writing something similar to our when-valid macro in Ruby.

def when_valid(record, &block)
		if record.valid?
				block.call(record)
		else
				flash[:error] = record.errors.messages
				render :new
		end
end

def create
		when_valid(Thing.create(thing_params)) do |thing|
				redirect_to thing
		end
end

Here’s another useful when method for handling HTTP responses in Ruby that Myles Megyesi shared with me.

def when_status(response, responders)
		if responder = responders[response[:status]]
				responder.call(response)
		else
				handle_generically(response)
		end
end

def get_all_the_things
		when_status get("/things"), {
		200 => lambda do |response|
				load_things(response[:body])
		end,
		404 => lambda do
				"Whoops"
		end
		}
end

After transitioning back to writing Ruby after Clojure, I found myself naturally thinking of ways to use blocks and lambdas, among other functional-ish idioms, much more than before writing Clojure—and usually with positive results. It’s interesting to see how learning new languages expands the way you write the languages you already know. Perhaps there are patterns from certain languages you know just waiting to be applied somewhere else.