You are right. Lazyness is not the right word. Functional reactive programming is indeed more accurate.

It's just one header file.

#ifndef MAKELAZY_H
#define MAKELAZY_H

#include <memory>
#include <set>

/**
 * @brief The ValueWatcher class.
 * Abstract type for watchers of values.
 * Watchers are called synchroneously when one of the values that they are
 * watching changes.
 */
class ValueWatcher {
public:
    /**
     * @brief Empty implementation of a virtual destructor.
     */
    virtual ~ValueWatcher() {}
    /**
     * @brief Callback for changes in a value.
     * Function that is called synchroneously by the value that is being watched
     * when that value changes.
     */
    virtual void valueChanged() = 0;
};

/**
 * @brief Class that holds the set of ValueWatchers for a value.
 */
class WatcherRegistry {
private:
    /**
     * @brief The registered instances of ValueWatcher.
     */
    std::set<std::shared_ptr<ValueWatcher>> watchers;
public:
    /**
     * @brief Register a watcher.
     * @param watcher Watcher that shall be signalled when the value changes.
     */
    void registerWatcher(std::shared_ptr<ValueWatcher>& watcher) {
        watchers.insert(watcher);
    }
    /**
     * @brief Unregister a watcher.
     * @param watcher Watcher that shall be signalled when the value changes.
     */
    void unregisterWatcher(std::shared_ptr<ValueWatcher>& watcher) {
        auto p = watchers.find(watcher);
        if (p != watchers.end()) {
            watchers.erase(p);
        }
    }
    /**
     * @brief Call valueChanged() on all the registered ValueWatchers.
     */
    void signalWatchers() {
        auto i = watchers.begin();
        while (i != watchers.end()) {
            (*i)->valueChanged();
            ++i;
        }
    }
};

/**
 * @brief Template class for a value that can be watched.
 * @tparam V Type for the value.
 */
template<typename V>
class WatchedValue {
public:
    using value_type = V;
private:
    value_type m_value;
    WatcherRegistry registry;
public:
    WatchedValue() :m_value(value_type()) {}
    WatchedValue(const value_type& v) :m_value(v) {}
    WatchedValue(value_type&& v) :m_value(std::move(v)) {}
    virtual ~WatchedValue() {}
    void set(const value_type& v) {
        if (v != m_value) {
            m_value = v;
            registry.signalWatchers();
        }
    }
    void set(value_type&& v) {
        if (v != m_value) {
            m_value = std::move(v);
            registry.signalWatchers();
        }
    }
    operator const value_type&() const {
        return m_value;
    }
    void registerWatcher(std::shared_ptr<ValueWatcher>& l) {
        registry.registerWatcher(l);
    }
    void unregisterWatcher(std::shared_ptr<ValueWatcher>& l) {
        registry.unregisterWatcher(l);
    }
};
/**
 * @brief Template class for a value that is input to lazy functions.
 * @tparam V Type for the value.
 */
template<typename V>
class InputValue {
public:
    using value_type = V;
private:
    InputValue() = delete;
    std::shared_ptr<WatchedValue<value_type>> m_value;
public:
    InputValue(const value_type& v) :m_value(new WatchedValue<value_type>(v)) {
    }
    void operator=(const value_type& v) {
        m_value->set(v);
    }
    void operator=(value_type&& v) {
        m_value->set(std::move(v));
    }
    operator const value_type& () { return *m_value; }
    void registerWatcher(std::shared_ptr<ValueWatcher>& l) {
        m_value->registerWatcher(l);
    }
    void unregisterWatcher(std::shared_ptr<ValueWatcher>& l) {
        m_value->unregisterWatcher(l);
    }
};

/**
 * Value that is the result of a function.
 * When the inputs to a function change, the OutputValue changes too.
 * An OutputValue instance can be uses as input to another OutputValue.
 */
template<typename F, typename... Args>
class OutputValue {
public:
    using value_type = typename std::result_of<F(Args...)>::type;
private:
    template<int ...>
    struct seq {
    };
    template<int N, int ...S>
    struct gens : gens<N-1, N-1, S...> {
    };
    template<int ...S>
    struct gens<0, S...>{
        using type = seq<S...>;
    };
    template<std::size_t I = 0>
    typename std::enable_if<I == sizeof...(Args), void>::type
    registerAtInputs() {
    }
    template<std::size_t I = 0>
    typename std::enable_if<I < sizeof...(Args), void>::type
    registerAtInputs() {
        std::get<I>(data()->m_args).registerWatcher(m_data);
        registerAtInputs<I + 1>();
    }
    template<std::size_t I = 0>
    typename std::enable_if<I == sizeof...(Args), void>::type
    unregisterAtInputs() {
    }
    template<std::size_t I = 0>
    typename std::enable_if<I < sizeof...(Args), void>::type
    unregisterAtInputs() {
        std::get<I>(data()->m_args).unregisterWatcher(m_data);
        unregisterAtInputs<I + 1>();
    }

    class Data : public ValueWatcher {
    private:
        template<int ...S>
        value_type callFunc(seq<S...>) {
            return m_function(std::get<S>(m_args) ...);
        }
        value_type calcValue() {
            return callFunc(typename gens<sizeof...(Args)>::type());
        }
        const F m_function;
        WatcherRegistry m_registry;
        value_type m_value;
    public:
        std::tuple<Args...> m_args;
        int m_instanceCount;
        bool m_upToDate;
        Data(F f, Args... args...) :m_function(f), m_args(args...),
            m_instanceCount(1), m_upToDate(false) {
        }
        ~Data() {
        }
        virtual void valueChanged() {
            if (m_upToDate) {
                m_upToDate = false;
                m_registry.signalWatchers();
            }
        }
        /**
         * Get the value.
         * If any of the inputs have changed, the value is recalculated.
         */
        const value_type& value() {
            if (!m_upToDate) {
                m_value = calcValue();
                m_upToDate = true;
            }
            return m_value;
        }
        void registerWatcher(std::shared_ptr<ValueWatcher>& l) {
            m_registry.registerWatcher(l);
        }
        void unregisterWatcher(std::shared_ptr<ValueWatcher>& l) {
            m_registry.unregisterWatcher(l);
        }
    };
    Data* data() {
        return static_cast<Data*>(&*m_data);
    }
    std::shared_ptr<ValueWatcher> m_data;
public:
    OutputValue(F f, Args... args...) :m_data(new Data(f, args...)) {
        registerAtInputs();
    }
    OutputValue(const OutputValue& v) :m_data(v.m_data) {
        data()->m_instanceCount += 1;
    }
    ~OutputValue() {
        data()->m_instanceCount -= 1;
        if (data()->m_instanceCount == 0) {
            unregisterAtInputs();
        }
    }
    value_type apply() {
        return data()->value();
    }
    operator value_type() {
        return data()->value();
    }
    const value_type& operator->() {
        return data()->value();
    }
    void registerWatcher(std::shared_ptr<ValueWatcher>& l) {
        data()->registerWatcher(l);
    }
    void unregisterWatcher(std::shared_ptr<ValueWatcher>& l) {
        data()->unregisterWatcher(l);
    }
};

/**
 * @brief Use an imperative function as a functional expression.
 * The result of the function should rely only on the function parameters.
 * Even if InputValues change, the result of the OutputValue returned by
 * makeLazy() is up to date.
 * @tparam F The signature of the function
 * @tparam Args The arguments into F, these may be constants or instances of
 *              InputValue.
 * @param f The function used in the functional expression.
 * @param args The arguments that go into the functional expression.
 */
template<typename F, typename... Args>
OutputValue<F, Args...>
makeLazy(F f, Args... args) {
    return OutputValue<F, Args...>(f, args...);
}

#endif // MAKELAZY_H