Learning to use foldl and map

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(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,[], Output) ->  
lines(Cube,[First|Rest], Output) ->  

line(Cube,Points) ->  
line(Cube,[First|Rest],Output) ->  

line(_Cube,[],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.