799 lines
29 KiB
C++
799 lines
29 KiB
C++
|
////////////////////////////////////////////////////////////////////////////
|
||
|
|
// 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
|