source: liblaziness/lazy.h

#ifndef __LAZY_H__
#define __LAZY_H__
#include "r.h"
#include "assert.h"
#include "delegate.h"
#include <functional>
#include <utility>
#include "lambda_trait.h"

// TODO: is case of simple function use typedef instead
template <typename T>
class LazyBase
{
//      _assert_subclass<TInit, DelegateBase<T>>
public:
        virtual ~LazyBase() { }
        bool isEvaluated() const
        {
                return !val.isNull();
        }
        void evaluate()
        {
                if (val.isNull())
                {
                        val = fun();
                        fun.free();
                }
        }
        R<T> get()
        {
                evaluate();
                return val;
        }
        explicit LazyBase(Delegate<T> fun) : fun(fun), val() { }
        friend R< LazyBase<T> > Ref::mk< LazyBase<T> >();
        friend R< LazyBase<Int> > suspend(Int val);
        friend R< LazyBase<UInt> > suspend(UInt val);
        template <typename U> friend R< LazyBase<U> > suspend(R<U> val);
        template <typename U, typename V> friend R< LazyBase<U> > suspendP(R<V> val);
private:
        explicit LazyBase() : fun(), val() { }

        Delegate<T> fun;
        R<T> val;
};

// specialize R definition for LazyBase to make lazy objects more useable
template <typename T>
class R< LazyBase<T>, true > : public R< LazyBase<T>, false >
{
        protected:
                // passing protected constructors
                inline R(int i) : R< LazyBase<T>, false >(i) { }
        public:
                // passing public constructors
                inline R() : R< LazyBase<T>, false>() { }
                template<typename U, bool od> inline R(R< LazyBase<U>, od >& o) : R< LazyBase<T>, false>(o, 0) { _assert_subclass<U, T> ERROR; }
                template<typename U, bool od> inline R(R< LazyBase<U>, od >&& o) : R< LazyBase<T>, false>(o, 0) { _assert_subclass<U, T> ERROR; }
                // passing operator=
                template<typename U, bool od> inline R< LazyBase<T>, true >& operator=(R< LazyBase<U>, od >&& o) { R< LazyBase<T>, false >::operator=(o); return *this; }
                template<typename U, bool od> inline R< LazyBase<T>, true >& operator=(R< LazyBase<U>, od >& o) { R< LazyBase<T>, false >::operator=(o); return *this; }
                // additional functionality
                inline T* operator->() { return &this->deref().get().deref(); }
                inline T& operator*() { return this->deref().get().deref(); }
                inline R<T> getR() { return this->deref().get(); }
                // keep reference makeable with Ref::mk
                friend class Ref;
};

template<typename T>
using Lazy = R< LazyBase<T> >;

template<typename T>
Lazy<T> mkLazy(Delegate<T> init)
{
        return Ref::mk< LazyBase<T> >(init);
}

/*template <typename T, typename TReal>
Lazy<T, TReal, FunBase<T, TReal> > mkLazy(typename FunBase<T, TReal>::FunType fun)
{
        return mkLazy(mkFun(fun));
}*/

template <typename T>
Lazy<T> mkLazy(R<T> (*fun)())
{
        return mkLazy<T>(mkFun(fun));
}

template <typename T>
R<T> lazyVal(Lazy<T> lval)
{
        return lval.deref().get();
}

template <typename T>
bool isEvaluated(R< LazyBase<T> > lval)
{
        return lval.deref().isEvaluated();
}

template <typename T>
Lazy<T> suspend(R<T> val)
{
        Lazy<T> l = Ref::mk< LazyBase<T> >();
        l.deref().val = val;
        return l;
}

Lazy<Int> suspend(Int i)
{
        auto l = Ref::mk< LazyBase<Int> >();
        l.deref().val = Ref::mk<Int, Int>(i);
        return l;
}

Lazy<UInt> suspend(UInt i)
{
        auto l = Ref::mk< LazyBase<UInt> >();
        l.deref().val = Ref::mk<UInt, UInt>(i);
        return l;
}

template <typename U, typename V>
Lazy<U> suspendP(R<V> val)
{
        Lazy<U> l = Ref::mk< LazyBase<U> >();
        l.deref().val = val;
        return l;
}

template <typename T>
T& operator*(LazyBase<T>& lval)
{
        return *(lval.get());
}

#include <iostream>


// moved to lazy_op.h
/*template <typename T>
class LazyOp
{
        private:
                static R<T> inc_inner(Lazy<T> i)
                {
                        return Ref::mk<T, T>(lazyVal(i).deref() + 1);
                }
                static R<T> add_inner(Lazy<T> a, Lazy<T> b)
                {
                        //std::cout << "adding : " << lazyVal(a).deref() << " + " << lazyVal(b).deref() << std::endl;
                        return Ref::mk<T, T>(lazyVal(a).deref() + lazyVal(b).deref());
                }
                static R<T> sqr_inner(Lazy<T> x)
                {
                        T val = lazyVal(x).deref();
                        return Ref::mk<T, T>(val * val);
                }
        public:
                static Lazy<T> inc(Lazy<T> i)
                {
                        auto fun = mkFun(&inc_inner, i);
                        return mkLazy<T>(fun);
                }
                static Lazy<T> add(Lazy<T> a, Lazy<T> b)
                {
                        auto fun = mkFun(&add_inner, a, b);
                        return mkLazy<T>(fun);
                }
                static Lazy<T> sqr(Lazy<T> x)
                {
                        return mkLazy<T>(mkFun(&sqr_inner, x));
                }
};*/

/*template <typename T>
class LazyOpR
{
        public:
                typedef LazyBase<Int> LazyInt
                lazyOpR()
                {
                        rAdd = Ref::mk< Funx2Base<LazyInt, LazyInt, LazyInt>, Funx2Base<LazyInt, LazyInt, LazyInt>::FunType, R<LazyInt>, R<LazyInt> >(LazyOp::, arg1, arg2);
                }
                ~lazyOpR() { }

                Funx2<LazyBase<Int>, LazyBase<Int>, LazyBase<Int>> rAdd;
};*/

/**** function lazification ****/
/*template<typename T>
Delegate<T> lazify(R<T> (*fun)())
{
        return mkFun([] (decltype(fun) fun) {
                return mkLazy(mkFun([] (decltype(fun) fun) {
                        return fun();
                }, fun));
        }, fun);
}*/

/*template<typename T, typename T1>
Delegate<T> lazify(R<T> (*fun) (R<T1>))
{
        return mkFun1([] (decltype(fun) fun, Lazy<T1> arg1) {
                return mkLazy(mkFun([] (decltype(fun) fun, Lazy<T1> arg1) {
                        return fun(arg1.getR());
                }, fun));
        }, fun);
}*/

template<typename TFun, int arg_count>
struct lazify_data;

template<typename TFun>
struct lazify_data<TFun, 0>
{
        typedef typename lambdatype<TFun>::return_type return_type;
        typedef Delegate<typename return_type::etype> delegate_type;
        typedef Delegate<LazyBase<typename return_type::etype>> ldelegate_type;
};

template<typename TFun>
struct lazify_data<TFun, 1>
{
        typedef typename lambdatype<TFun>::return_type return_type;
        typedef typename lambdatype<TFun>::arg1_type arg1_type;
        typedef Delegate1<typename return_type::etype, typename arg1_type::etype> delegate_type;
        typedef Delegate1<LazyBase<typename return_type::etype>, LazyBase<typename arg1_type::etype>> ldelegate_type;
};

template<typename TFun, int arg_count, typename TFunData>
class Lazify;

template<typename TFun, typename TFunData>
class Lazify<TFun, 0, TFunData>
{
        public:
                static auto doLazify(TFun fun) -> typename TFunData::ldelegate_type
                {
                        return mkLFun([] (typename TFunData::delegate_type fun) {
                                return mkLazy(mkLFun([] (typename TFunData::delegate_type fun) {
                                        return fun();
                                }, fun));
                        }, mkLFun(fun));
                }
};

template<typename TFun, typename TFunData>
class Lazify<TFun, 1, TFunData>
{
        public:
                static auto doLazify(TFun fun) -> typename TFunData::ldelegate_type
                {
                        return mkLFun1([] (typename TFunData::delegate_type fun, Lazy<typename TFunData::arg1_type::etype> arg1) {
                                return mkLazy(mkLFun([] (typename TFunData::delegate_type fun, Lazy<typename TFunData::arg1_type::etype> arg1) {
                                        return fun(arg1.getR());
                                }, fun, arg1));
                        }, mkLFun1(fun));
                }
};

template<typename TFun, int arg_count = lambdatype<TFun>::arg_count, typename TFunData = lazify_data<TFun, arg_count>>
auto lazify(TFun fun) -> typename TFunData::ldelegate_type
{
        return Lazify<TFun, arg_count, TFunData>::doLazify(fun);
}

#endif