Exercism: "Extract-Transform-Load in Clojure"

This is my solution to the Extract-Transform-Load problem in Clojure.

I wrote several working versions in the REPL but this is the one that I finally submitted to Exercism as my first iteration:

	(ns etl)
	(defn transform [data-set]
	(reduce
	(fn [data [letters num]]
	(reduce
	(fn [data letter]
	(assoc
	data
	(clojure.string/lower-case letter)
	num))
	data
	letters))
	{}
	(zipmap (vals data-set) (keys data-set))))

view raw etl0.clj hosted with ❤ by GitHub

I used destructuring to extract the letters and score from the key-value pair which reduce was passing to the anonymous helper.

It works but it's not very readable.

In the second iteration I introduced a helper function, assoc-pairs, to improve its readability but the naming was still bad:

	(ns etl (:require [clojure.string :as str]))
	(defn transform [data-set]
	(let
	[assoc-pairs
	(fn [data [letters num]]
	(reduce
	#(assoc %1 (str/lower-case %2) num)
	data
	letters))]
	(reduce
	assoc-pairs
	{}
	(zipmap (vals data-set) (keys data-set)))))

view raw etl1.clj hosted with ❤ by GitHub

So I renamed some parameters and helper functions for the third iteration:

	(ns etl (:require [clojure.string :as str]))
	(defn transform [letters-per-score]
	(let
	[associate-score-to-letters
	(fn [scores-per-letter [letters score]]
	(let
	[associate-score-to-letter
	(fn [scores-per-letter letter]
	(assoc
	scores-per-letter
	(str/lower-case letter)
	score))]
	(reduce
	associate-score-to-letter
	scores-per-letter
	letters)))]
	(reduce
	associate-score-to-letters
	{}
	(zipmap
	(vals letters-per-score)
	(keys letters-per-score)))))

view raw etl2.clj hosted with ❤ by GitHub

I find that, even though, using the let form to create the local bindings that gave names to the internal helper functions, associate-score-to-letters and associate-score-to-letter helps to reveal the intention of each helper function, it also creates a "parentheses vortex" that can obscure the code at the same time.

I wish Clojure would let me define these local functions just nesting the function definitions inside the enclosing function, like the functions sqrt_iter, good_enough? and improve defined inside custom_sqrt in this Scheme example (I coded it using DrRacket):

	(define (average x y)
	(/ (+ x y) 2))
	(define (custom_sqrt x)
	(define (sqrt_iter previous_guess guess)
	(if (good_enough? previous_guess guess)
	guess
	(sqrt_iter guess
	(improve guess))))
	(define (good_enough? previous_guess guess)
	(< (abs (- previous_guess guess))
	0.001))
	(define (improve guess)
	(average guess (/ x guess)))
	(sqrt_iter 0.0 1.0))

view raw SICP_example_1_1_7_block.scm hosted with ❤ by GitHub

I think that a feature like that would help to make my Clojure solution easier to read.

You can nitpick my solution here or see all the exercises I've done so far in this repository.