containers

Traversable is in a sense the class of containers whose structure has a “path” (that can correspond to a list), the elements on which can be modified without dissolving the structure. Hence zipTrav :: Traversable t => t a -> [b] -> Maybe (t (a,b)) zipTrav = evalStateT . traverse zp where zp a = do bs <- get case bs of [] -> lift Nothing (b:bs') -> put bs' >> return (a,b) However, that list-state traversal seems a bit hackish and likely not the most efficient way to do it. I'd suppose there would be a standard function that accomplished the above or a more general task, but I can't figure out

The 3-argument form of list::splice() moves a single element from one list to the other. SGI's documentation explicitly states that all iterators, including the one pointing to the element being moved remain valid. Roguewave's documentation does not say anything about iterator invalidation properties of splice() methods, whereas the C++ standard explicitly states that it invalidates all iterators and references to the element being spliced. splicing() in practice works as defined by SGI, but I get assertion failure (dereferencing invalid iterator) in debug / secure SCL versions of microsoft's

Mounting a Docker volume while being under a Windows host, has been a huge pain for me, and I could not get it to work. Currently I got the following simple Dockerfile: FROM php:5-apache RUN apt-get update When I build an image from it, and start a container docker build -t phisch:dev . docker run phisch:dev the container starts properly. But when I am trying to mount a volume, docker run -v /c/Users/phisch/dev/htdocs:/var/www phisch:dev the following message will be displayed: C:\Users\phisch\dev>docker run -v /c/Users/phisch/dev/htdocs:/var/www phisch:dev no such file or directory docker:

This may seem frivolous to some of you, but which of the following 2 methods of iteration over a STL container is better? Why ? class Elem; typedef vector<Elem> ElemVec; ElemVec elemVec; // Method 0 for (ElemVec::iterator i = elemVec.begin(); i != elemVec.end(); ++i) { Elem& e = *i; // Do something } // Method 1 for (int i = 0; i < elemVec.size(); ++i) { Elem& e = elemVec.at(i); // Do something } Method 0 seems like cleaner STL, but Method 1 achieves the same with lesser code. Simple iteration over a container is what appears all over the place in any source code. So, I'm inclined to pick

I'd like to create a std::map that contains a std::vector of iterators into itself, to implement a simple adjacency list-based graph structure. However, the type declaration has me stumped: it would seem you need the entire map type definition to get the iterator type of said map, like so: map< int, Something >::iterator MyMap_it; // what should Something be? map< int, vector<MyMap_it> > MyMap_t; Is there some sort of partial map iterator type I can get with just the key type, so I can declare the full map? You could use forward declaration of a new type. class MapItContainers; typedef map<int