I have been working on a small line drawing project, and part of that project is indexing nested lists based on sets of indices.

Firstly I wrote a function to return the recursive nth item. So for this data [[[1,2],[3,4]],[[5,6],[7,8]]] and the input [1,2,1] the value 3 is returned. Here’s my original function:

point(Cube,[First|Rest]) -> point(lists:nth(First,Cube),Rest); point(Cube,[]) -> Cube.

I then had a couple of functions to return point lists for each list of points look-ups. The first *line* was for connected points, and the second *lines* to draw separate lines. So using the same data above, and the input [[1,2,1],[2,2,2],[1,1,1]] to *line* would generate [3,8,1], and lists of that input to *lines* creates lists of results. Brilliant I know, here’s my code:

lines(Cube,Lines) -> lines(Cube,lists:reverse(Lines),[]). lines(_Cube,[], Output) -> Output; lines(Cube,[First|Rest], Output) -> lines(Cube,Rest,[line(Cube,First)|Output]). line(Cube,Points) -> line(Cube,lists:reverse(Points),[]). line(Cube,[First|Rest],Output) -> line(Cube,Rest,[point(Cube,First)|Output]); line(_Cube,[],Output) -> Output.

I used a wrapper function to reverse the input, to solve the list construction order. I was quite proud of my groking tail recursion. But couldn’t help notice *line* and *lines* are the same, but not the same. While reading how to do the output formatting, I came across some good examples on using foldl and map. Surprise, the examples where like my functions, so I rewrote them like this (renaming *point* to *nth_nth*):

lines(Cube,Lines) -> lists:map(fun(Line) -> line(Cube, Line) end, Lines). line(Cube,Points) -> lists:map(fun(Point) -> nth_nth(Cube, Point) end, Points). nth_nth(Vals,Nths) -> lists:foldl(fun(Nth,List) -> lists:nth(Nth,List) end, Vals, Nths).

Much better, but I started to have a nagging feeling about using anonymous functions to just call a single function. I then found the way to refer to other functions by name, but this does not work for the *map* as I am binding an extra variable, but for *foldl* it does work as it’s arity is 2, thus *nth_nth* can be written as:

nth_nth(Vals,Nths) -> lists:foldl({list,nth}, Vals, Nths).

I thought the use of the fold function to return nested look-up results was clever. The new functions have less total lines, but each line is much denser, so may appear harder to read, but I am using standard functions so the cost to comprehend should be lower.