Lazy transform in C++
Question: I have the following Python snippet that I would like to reproduce using C++:

    
    
    from itertools import count, imap
    
    source = count(1)
    pipe1 = imap(lambda x: 2 * x, source)
    pipe2 = imap(lambda x: x + 1, pipe1)
    sink = imap(lambda x: 3 * x, pipe2)
    for i in sink:
        print i
    

I've heard of [Boost
Phoenix](http://www.boost.org/doc/libs/1_51_0/libs/phoenix/doc/html/index.html),
but I couldn't find an example of a lazy `transform` behaving in the same way
as Python's `imap`.

Edit: to clarify my question, the idea is not only to apply functions in
sequence using a `for`, but rather to be able to use algorithms like
`std::transform` on infinite generators. The way the functions are composed
(in a more functional language like dialect) is also important, as the next
step is function composition.

Update: thanks bradgonesurfing, David Brown, and Xeo for the amazing answers!
I chose Xeo's because it's the most concise and it gets me right where I
wanted to be, but David's was very important into getting the concepts
through. Also, bradgonesurfing's tipped Boost::Range :).


Answer: Employing [Boost.Range](http://www.boost.org/libs/range/):

    
    
    int main(){
      auto map = boost::adaptors::transformed; // shorten the name
      auto sink = generate(1) | map([](int x){ return 2*x; })
                              | map([](int x){ return x+1; })
                              | map([](int x){ return 3*x; });
      for(auto i : sink)
        std::cout << i << "\n";
    }
    

[Live example including the `generate`
function.](http://liveworkspace.org/code/841508d3b54bed4181d4e9fb6058200f)

