← Back
Editing: lazy_prelude.hpp
//////////////////////////////////////////////////////////////////////////// // lazy prelude.hpp // // Build lazy operations for Phoenix equivalents for FC++ // // These are equivalents of the Boost FC++ functoids in prelude.hpp // // Usage: All of these are functors which need various numbers of arguments. // Those can be supplied as real arguments or as Phoenix arguments. // Execution will happen when all the arguments are supplied. // e.g. // take(2,list)() or take(2,arg1)(list) // // Implemented so far: // // id (moved back to operators.hpp) // // A lot of what comes here uses the list type, so that will be needed first. // // Now that list<T> is available I can start to build things here. // // // until(pred,f,start) - if pred(start) is true, return start // apply value = f(start) // apply value = f(value) // until pred(value) is true // return value // // The predicate argument pred must be a lazy function taking one argument // and returning bool. // This can be a lazy function with an argument already. // This has to be declared before the call to until. // The type can be declated using Predicate as in this example: // // Predicate<int>::type f(greater(arg1,10)); // std::cout << until(f, inc, 1)() << std::endl; // // until2(pred,f,start,value2) - if pred(start,value2) is true, return start // apply value1 = f(start) // apply value1 = f(value1) // until pred(value1,value2) is true // return value1 // // NOTE: until2 has been defined because this code does not support // FC++ currying, so that a partial function cannot be passed // as an argument. This provides a way of passing a second parameter. // There is now the option to use Predicate<T> as shown above. // // odd(n) true if n is odd // even(n) true if n is even // // last(list) // all_but_last(list) // at(list,n) // length(list) // filter(pred,list) // iterate(function,value) // repeat(value) // take(n,list) // drop(n,list) // enum_from(x) // enum_from_to(x,y) // //////////////////////////////////////////////////////////////////////////// // Interdependence: // The old Boost FC++ has a set of headers which interelate and call each // other in a complicated way. I am going to document the interdependence // of the files here. I will then make sure that they are called correctly // starting from this file. John Fletcher. February 2015. //////////////////////////////////////////////////////////////////////////// // BoostFC++ header sequence: // // prelude.hpp -> list.hpp (optinally monad.hpp at end) // list.hpp -> reuse.hpp // reuse.hpp -> function.hpp // function.hpp -> ref_count.hpp operator.hpp // ref_count.hpp -> config.hpp boost headers and RefCountType definition // operator.hpp -> lambda.hpp // lambda.hpp -> full.hpp (use of lambda internals is optional) // full.hpp -> smart.hpp curry.hpp pre_lambda.hpp (optionally full4.hpp) // smart.hpp -> signature.hpp // curry.hpp -> signature.hpp // signature.hpp -> config.hpp // //////////////////////////////////////////////////////////////////////////// // Proposed order in lazy_prelude.hpp // on the basis that files need what they call. // // lazy_config.hpp (If needed)* probably not needed. // lazy_signature.hpp (If needed)* // lazy_smart.hpp (If needed)* // lazy_curry.hpp (If needed)* // lazy_full.hpp (If needed)* // lazy_operator.hpp (absorb definition of RefCountType) // lazy_function.hpp (may not now be needed) // lazy_reuse.hpp (implemented without use of FC++ functions) // lazy_list.hpp // // * file does not yet exist. //////////////////////////////////////////////////////////////////////////// // This is implemented such that no other lazy_ file calls other lazy_ files. // They do call their own external files, which may well be duplicates. // That can be sorted out later. //////////////////////////////////////////////////////////////////////////// // Notes: full and curry operations should be covered by Phoenix. // The lambda operations are quite different from Phoenix lambda // and will be omitted. // The implementation monad can be postponed. // Some of function and reuse are needed for the list type. // I will review later whether they are part of the external interface. // // John Fletcher February 2015. //////////////////////////////////////////////////////////////////////////// /*============================================================================= Copyright (c) 2000-2003 Brian McNamara and Yannis Smaragdakis Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2015 John Fletcher Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ==============================================================================*/ #ifndef BOOST_PHOENIX_FUNCTION_LAZY_PRELUDE #define BOOST_PHOENIX_FUNCTION_LAZY_PRELUDE #include <exception> #include <vector> #include <boost/phoenix/core.hpp> #include <boost/phoenix/function.hpp> #include <boost/phoenix/scope.hpp> #include <boost/phoenix/operator.hpp> #include <boost/phoenix/function/lazy_operator.hpp> #include <boost/phoenix/function/lazy_reuse.hpp> #include <boost/phoenix/function/lazy_list.hpp> //////////////////////////////////////////////////////////////////////////// // To come here, the Haskell Prelude things which need list<T>. // Things which do not need list<T> are in lazy_operator.hpp. //////////////////////////////////////////////////////////////////////////// namespace boost { namespace phoenix { // These are in fcpp namespace as they introduce an FC++ style. namespace fcpp { template <typename T> struct Predicate { typedef typename boost::function1<bool,T> fun1_bool_T; typedef typename boost::phoenix::function<fun1_bool_T> bool_F_T; typedef bool_F_T type; }; template <typename R> struct Function0 { typedef typename boost::function0<R> fun0_R; typedef typename boost::phoenix::function<fun0_R> R_F; typedef R_F type; }; template <typename R,typename A0> struct Function1 { typedef typename boost::function1<R,A0> fun1_R_A0; typedef typename boost::phoenix::function<fun1_R_A0> R_F_A0; typedef R_F_A0 type; }; template <typename R, typename A0, typename A1> struct Function2 { typedef typename boost::function2<R,A0,A1> fun2_R_A0_A1; typedef typename boost::phoenix::function<fun2_R_A0_A1> R_F_A0_A1; typedef R_F_A0_A1 type; }; } namespace impl { using fcpp::INV; using fcpp::VAR; using fcpp::reuser1; using fcpp::reuser2; using fcpp::reuser3; using boost::phoenix::arg_names::arg1; struct Pow { template <typename Sig> struct result; template <typename This, typename N, typename A0> struct result<This(N,A0)> : boost::remove_reference<A0> {}; template <typename N, typename A0> A0 operator()(N n, const A0 & a0, reuser2<INV,VAR,INV,Pow,N,A0> r = NIL ) const { if ( n <= 0 ) return A0(1); else if ( n==1 ) return a0; else { A0 a1 = r( Pow(), n-1, a0)(); return a0*a1; } } }; struct Apply { template <typename Sig> struct result; template <typename This, typename N, typename F,typename A0> struct result<This(N,F,A0)> : boost::remove_reference<A0> {}; template <typename N, typename F, typename A0> A0 operator()(N n, const F &f, const A0 & a0, reuser3<INV,VAR,INV,INV,Apply,N,F,A0> r = NIL ) const { if ( n <= 0 ) return a0; else if ( n==1 ) return f(arg1)(a0); else { A0 a1 = r( Apply(), n-1, f, a0)(); return f(a1)(); } } }; struct Odd { template <typename Sig> struct result; template <typename This, typename T> struct result<This(T)> { typedef bool type; }; template <class T> typename result<Odd(T)>::type operator()( const T& x ) const { return x%2==1; } }; struct Even { template <typename Sig> struct result; template <typename This, typename T> struct result<This(T)> { typedef bool type; }; template <class T> typename result<Even(T)>::type operator()( const T& x ) const { return x%2==0; } }; } typedef boost::phoenix::function<impl::Pow> Pow; typedef boost::phoenix::function<impl::Apply> Apply; typedef boost::phoenix::function<impl::Odd> Odd; typedef boost::phoenix::function<impl::Even> Even; Pow pow; Apply apply; Odd odd; Even even; namespace impl { using fcpp::INV; using fcpp::VAR; using fcpp::reuser1; using fcpp::reuser2; using fcpp::reuser3; using boost::phoenix::arg_names::arg1; // I cannot yet do currying to pass e.g. greater(9,arg1) // as a function. This can be done using Predicate<T>::type. struct Until { template <typename Sig> struct result; template <typename This, typename Pred, typename Unary, typename T> struct result<This(Pred,Unary,T)> : boost::remove_reference<T> {}; template <class Pred, class Unary, class T> T operator()( const Pred& p,const Unary& op,const T &start) const { T tmp = start; while( !p(tmp)() ) { tmp = apply(1,op,tmp)(); } return tmp; } }; struct Until2 { template <typename Sig> struct result; template <typename This, typename Binary, typename Unary, typename T, typename X> struct result<This(Binary,Unary,T,X)> : boost::remove_reference<T> {}; template <class Binary, class Unary, class T, class X> typename result<Until2(Binary,Unary,T,X)>::type operator()( const Binary& p, const Unary& op, const T & start, const X & check ) const { T tmp1 = start; T tmp2; while( !p(tmp1,check)() ) { tmp2 = apply(1,op,tmp1)(); tmp1 = tmp2; } return tmp1; } }; struct Last { template <typename Sig> struct result; template <typename This, typename L> struct result<This(L)> { typedef typename result_of::ListType<L>::value_type type; }; template <class L> typename result<Last(L)>::type operator()( const L& ll ) const { size_t x = 0; typename result_of::ListType<L>::delay_result_type l = delay(ll); while( !null( tail(l)() )() ) { l = tail(l)(); ++x; #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) break; #endif } #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) throw lazy_exception("Your list is too long!!"); #endif return head(l)(); } }; struct Init { template <typename Sig> struct result; template <typename This, typename L> struct result<This(L)> { typedef typename result_of::ListType<L>::force_result_type type; }; template <class L> typename result<Init(L)>::type operator()( const L& l, reuser1<INV,VAR,Init, typename result_of::ListType<L>::delay_result_type> r = NIL ) const { if( null( tail( l )() )() ) return NIL; else return cons( head(l)(), r( Init(), tail(l)() )() )(); } }; struct Length { template <typename Sig> struct result; template <typename This, typename L> struct result<This(L)> { typedef size_t type; }; template <class L> size_t operator()( const L& ll ) const { typename L::delay_result_type l = delay(ll); size_t x = 0; while( !null(l)() ) { l = tail(l); ++x; if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) break; } #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) throw lazy_exception("Your list is too long!!"); #endif return x; } }; // at is Haskell's operator (!!) // This is zero indexed. at(l,0)() returns the first element. struct At { template <typename Sig> struct result; template <typename This, typename L, typename N> struct result<This(L,N)> { typedef typename result_of::ListType<L>::value_type type; }; template <class L> typename result<At(L,size_t)>::type operator()( L l, size_t n ) const { while( n!=0 ) { l = tail(l); --n; } return head(l)(); } }; template <class P,class L> struct FilterH { P p; L l; FilterH( const P& pp, const L& ll) : p(pp), l(ll) {} template <typename Sig> struct result; template <typename This, class PP, class LL> struct result<This(PP,LL)> { typedef typename boost::phoenix::result_of:: ListType<LL>::delay_result_type type; }; typename result<FilterH(P,L)>::type operator()() const { typedef typename result_of::ListType<L>:: delay_result_type result_type; typedef boost::function0<result_type> Fun2_R_P_L; typedef boost::phoenix::function<Fun2_R_P_L> FilterH_R_P_L; if (null(l)() ) return NIL; Fun2_R_P_L fun2_R_P_L = FilterH<P,L>(p,tail(l)); FilterH_R_P_L filterh_R_P_L(fun2_R_P_L); if( p(head(l))() ) return cons( head(l)(), filterh_R_P_L() ); else return filterh_R_P_L(); } }; struct Filter { template <typename Sig> struct result; template <typename This, typename P, typename L> struct result<This(P,L)> { typedef typename result_of::ListType<L>::delay_result_type type; }; template <class P, class L> typename result<Filter(P,L)>::type operator()( const P& p, const L& ll) const { typename result_of::ListType<L>::delay_result_type l = delay(ll); typedef typename result_of::ListType<L>:: delay_result_type result_type; typedef boost::function0<result_type> Fun2_R_P_L; typedef boost::phoenix::function<Fun2_R_P_L> FilterH_R_P_L; Fun2_R_P_L fun2_R_P_L = FilterH<P,L>(p,l); FilterH_R_P_L filterh_R_P_L(fun2_R_P_L); return filterh_R_P_L(); } }; template <class F,class T> struct IterateH { F f; T t; IterateH( const F& ff, const T& tt) : f(ff), t(tt) {} template <typename Sig> struct result; template <typename This,class F2,class T2> struct result<This(F2,T2)> { typedef typename boost::remove_reference<T2>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<TTT>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type type; }; typename result<IterateH(F,T)>::type operator()() const { typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> Fun2_R_F_T; typedef boost::phoenix::function<Fun2_R_F_T> IterateH_R_F_T; Fun2_R_F_T fun2_R_F_T = IterateH<F,T>(f,f(t)()); IterateH_R_F_T iterateh_R_F_T(fun2_R_F_T); return cons( t, iterateh_R_F_T() ); } }; struct Iterate { // Note: this does always return an odd_list; iterate() takes no ListLike // parameter, and it requires that its result be lazy. template <typename Sig> struct result; template <typename This, typename F, typename T> struct result<This(F,T)> { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<TTT>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type type; }; template <class F, class T> typename result<Iterate(F,T)>::type operator() (const F& f, const T& t) const { typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> Fun2_R_F_T; typedef boost::phoenix::function<Fun2_R_F_T> IterateH_R_F_T; Fun2_R_F_T fun2_R_F_T = IterateH<F,T>(f,f(t)()); IterateH_R_F_T iterateh_R_F_T(fun2_R_F_T); return iterateh_R_F_T(); } }; } typedef boost::phoenix::function<impl::Until> Until; typedef boost::phoenix::function<impl::Until2> Until2; typedef boost::phoenix::function<impl::Last> Last; typedef boost::phoenix::function<impl::Init> Init; typedef boost::phoenix::function<impl::Length> Length; typedef boost::phoenix::function<impl::At> At; typedef boost::phoenix::function<impl::Filter> Filter; typedef boost::phoenix::function<impl::Iterate> Iterate; Until until; Until2 until2; Last last; Init all_but_last; // renamed from init which is not available. Length length; At at_; //Renamed from at. Filter filter; Iterate iterate; namespace impl { struct Repeat { // See note for iterate() template <typename Sig> struct result; template <typename This, typename T> struct result<This(T)> { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<TTT>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type type; }; template <class T> typename result<Repeat(T)>::type operator()( const T& x) const { return iterate(id,x); } }; struct Take { template <typename Sig> struct result; template <typename This, typename N, typename L> struct result<This(N,L)> { typedef typename result_of::ListType<L>::force_result_type type; }; template <class N,class L> typename result<Take(N,L)>::type operator()( N n, const L& l, reuser2<INV,VAR,VAR,Take,N, typename result_of::ListType<L>::force_result_type> r = NIL ) const { if( n <= 0 || null(l)() ) return NIL; else { return cons( head(l)(), r( Take(), n-1, tail(l)() )() )(); } } }; struct Drop { template <typename Sig> struct result; template <typename This, typename Dummy, typename L> struct result<This(Dummy,L)> { typedef typename result_of::ListType<L>::delay_result_type type; }; template <class L> typename result<Drop(size_t,L)>::type operator()( size_t n, const L& ll ) const { typename L::delay_result_type l = delay(ll); while( n!=0 && !null(l)() ) { --n; l = tail(l)(); } return l; } }; template <class T> struct EFH { mutable T x; EFH( const T& xx) : x(xx) {} template <typename Sig> struct result; template <typename This, class TT> struct result<This(TT)> { typedef typename boost::phoenix::UseList::template List<TT>::type LType; typedef typename boost::phoenix::result_of:: ListType<LType>::delay_result_type type; }; typename result<EFH(T)>::type operator()() const { typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> fun1_R_TTT; //std::cout << "EFH (" << x << ")" << std::endl; ++x; fun1_R_TTT efh_R_TTT = EFH<T>(x); typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T; EFH_R_T efh_R_T(efh_R_TTT); #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) throw lazy_exception("Running away in EFH!!"); #endif return cons( x-1, efh_R_T() ); } }; struct Enum_from { template <typename Sig> struct result; template <typename This, typename T> struct result<This(T)> { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<TTT>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type type; }; template <class T> typename result<Enum_from(T)>::type operator() (const T & x) const { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> fun1_R_TTT; fun1_R_TTT efh_R_TTT = EFH<TTT>(x); typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T; EFH_R_T efh_R_T(efh_R_TTT); //std::cout << "enum_from (" << x << ")" << std::endl; return efh_R_T(); } }; template <class T> struct EFTH { mutable T x; T y; EFTH( const T& xx, const T& yy) : x(xx), y(yy) {} template <typename Sig> struct result; template <typename This, class TT> struct result<This(TT)> { typedef typename boost::phoenix::UseList::template List<TT>::type LType; typedef typename boost::phoenix::result_of:: ListType<LType>::delay_result_type type; }; typename result<EFTH(T)>::type operator()() const { typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> fun1_R_TTT; //std::cout << "EFTH (" << x << ")" << std::endl; if (x > y ) return NIL; ++x; fun1_R_TTT efth_R_TTT = EFTH<T>(x,y); typedef boost::phoenix::function<fun1_R_TTT> EFTH_R_T; EFTH_R_T efth_R_T(efth_R_TTT); #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH) throw lazy_exception("Running away in EFTH!!"); #endif return cons( x-1, efth_R_T() ); } }; struct Enum_from_to { template <typename Sig> struct result; template <typename This, typename T> struct result<This(T,T)> { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<TTT>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type type; }; template <class T> typename result<Enum_from(T,T)>::type operator() (const T & x, const T & y) const { typedef typename boost::remove_reference<T>::type TT; typedef typename boost::remove_const<TT>::type TTT; typedef typename UseList::template List<T>::type LType; typedef typename result_of::ListType<LType>:: delay_result_type result_type; typedef boost::function0<result_type> fun1_R_TTT; fun1_R_TTT efth_R_TTT = EFTH<TTT>(x,y); typedef boost::phoenix::function<fun1_R_TTT> EFTH_R_T; EFTH_R_T efth_R_T(efth_R_TTT); //std::cout << "enum_from (" << x << ")" << std::endl; return efth_R_T(); } }; } //BOOST_PHOENIX_ADAPT_CALLABLE(apply, impl::apply, 3) // Functors to be used in reuser will have to be defined // using boost::phoenix::function directly // in order to be able to be used as arguments. typedef boost::phoenix::function<impl::Repeat> Repeat; typedef boost::phoenix::function<impl::Take> Take; typedef boost::phoenix::function<impl::Drop> Drop; typedef boost::phoenix::function<impl::Enum_from> Enum_from; typedef boost::phoenix::function<impl::Enum_from_to> Enum_from_to; Repeat repeat; Take take; Drop drop; Enum_from enum_from; Enum_from_to enum_from_to; namespace fcpp { } } } #endif
Save File
Cancel