Clojure — partitioning strings into substrings of fixed length

Just a though, perhaps you're looking at this the wrong way. This is a parsing question, and simple parses are often best executed through regular expressions. Clojure has reader macros and special functions to work with Java regexes.

Hey all -- I write up a few versions of the above problem for the guys on my team. I'll post it here in case anyone's interested -- this is for folks who don't know clojure, so apologies for the in-line explanations, if they're not needed. Please see my update to the original question for the code I ended up using, along with docstrings.

(to my team)

Guys, here are a few ways to accomplish the task solved by tileid->xy, shown above. I'm not sure I'm happy with the final version, so I've left these here for us to peruse together. Enjoy!

code:

(fn [tileid]
  (parse-ints
   (map (partial subs tileid) [2 5] [5 8])))

comments:

This first one is... misleading! Here, we're actually calling (subs tileid...) in the first elements of each of the other vectors, not on each vector in turn. I wouldn't go with something like this; it works, but it's confusing.

code:

(fn [tileid]
  (parse-ints
   (map (partial apply subs tileid) [[2 5] [5 8]])))

comments:

This is a little bit better, but not really. Now we have a vector of vectors -- partial takes the stuff after it, and builds a function that takes less arguments than that stuff needs. (in this case, we get: the function (apply subs tileid ...), where the ellipsis can be any group of arguments. Since we're mapping that, we get [2 5] and [5 8] fed in in turn.)

code:

(fn [tileid]
  (parse-ints
   ((juxt #(subs % 2 5) #(subs % 5 8)) tileid)))

comments:

Another way to do the same thing. In this case, juxt gives us a sequence that is the juxtaposition of all of the functions. When we send in an argument, we get the juxtaposition of the results -- in this case, ((subs tileid 2 5) (subs tileid 5 8)), where subs is substring (as above).

code:

(fn [tileid]
  (parse-ints
   (map (partial apply str)
        (partition 3 (s/drop 2 tileid)))))

comments:

This is the same as the next one; it actually compiles to the same byte code, I'm just not using the threading macro here. I don't know if the threading macro makes the code more clear, in this case, but it's a good example of little tweaks for readability, independent of performance.

code:

(fn [tileid]
  (parse-ints
   (map (partial apply str)
        (->> tileid
             (s/drop 2)
             (partition 3)))))

comments:

The referenced one, with the threading macro. As you can see, it takes each thing, evaluates it, and inserts it as the last thing in the next entry. So, here we have tileid inserted, making (s/drop 2 tileid). The whole thing expands to the code above. BE CAREFUL with this! It's a really good solution, but only when it makes things clear -- not when it's used as a way to think iteratively. There's usually some transformation on a list that you can do to get the same effects as the threading macro. (Once we all learn to code the Clojure Way, this stuff will be fine :)

code:

(defn tileid->res
  "Returns a string representation of the resolution referenced by the
supplied MODIS TileID."
  [tileid]
  (res-map (keyword (subs tileid 1 2))))

(fn [tileid]
  (parse-ints
   (map (partial apply str)
        (partition 3 (subs tileid 2)))))

comments:

I ended up going with this bad boy, because it looked closest to my other function, tileid->res. Looking at them together. See how they're of similar? This is nice, as it helps relate the concepts.

You could try the following, using the Java substring method and a vector of offsets:

(defn split-id [tileid]
  (map 
    #(Integer. (.substring tileid % (+ % 3)) ) 
    [2 5]))