Hi all, The discussion a little bit ago regarding using path's grammar in a custom virtual filesystem reminded me of my experience when I made a simple unpacking program using boost::filesystem::path. One thing that wasn't as trivial as I might have liked was descending recursively down the internal hierarchy. It would have been nice to have head() and tail() decomposition functions ( though with possibly better names ) analogous to the branch_path() and leaf() functions, but for the front of the path. That way I could have simply looked for the head() element at the current level and recursed with tail(). ( Though I ended up doing it by having my get_file function delegate to one that worked with an iterator range, which is more efficient, but... ) The implementation is, of course, fairly trivial, something along the lines of the following: std::string path::head() { if ( empty() ) return std::string(); return *begin(); } path path::tail() { if ( empty() ) return path(); return std::accumulate( next(begin()), end(), std::divides<path>() ); } And the obvious has_head() and has_tail(). The usage would be something similar to: file &directory::get_file(boost::filesystem::path p) { if ( !p.has_tail() ) return files[ p.head() ]; return subdirectories[ p.head() ].get_file( p.tail() ); } Assuming appropriate ( not part of boost ) directory and file classes. Opinions? Interest? - Scott McMurray P.S. I'm particularly fond of the accumulate/divides hack :P