Simple lazy vector in C++ which enables parallel evaluation.

LazyVector.hpp

#include <functional>
#include <vector>

template<typename T> using VectorIndex = typename std::vector<T>::size_type;

template<typename T>
class LazyVector {
public:
    LazyVector();

    LazyVector(const T &);

    LazyVector(const std::vector<T> &);

    std::vector<T> forceSequential();

private:
    VectorIndex<T> _size;
    std::function<T(VectorIndex<T>)> _f;
};

template<typename T>
LazyVector<T>::LazyVector() : _size(0) { }

template<typename T>
LazyVector<T>::LazyVector(const T &elem) : _size(1), _f([=](VectorIndex<T>) { return elem; }) { }

template<typename T>
LazyVector<T>::LazyVector(const std::vector<T> &elems) : _size(elems.size()),
                                                         _f([=](VectorIndex<T> i) { return elems[i]; }) { }

template<typename T>
std::vector<T> LazyVector<T>::forceSequential() {
    std::vector<T> v;
    v.reserve(_size);
    for (VectorIndex<T> i = 0; i < _size; ++i)
        v.push_back(_f(i));
    return v;
}