]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/phoenix/include/boost/phoenix/function/lazy_prelude.hpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bump version to 12.2.2-pve1
[ceph.git] / ceph / src / boost / libs / phoenix / include / boost / phoenix / function / lazy_prelude.hpp
CommitLineData
7c673cae
FG		 1////////////////////////////////////////////////////////////////////////////
2// lazy prelude.hpp
3//
4// Build lazy operations for Phoenix equivalents for FC++
5//
6// These are equivalents of the Boost FC++ functoids in prelude.hpp
7//
8// Usage: All of these are functors which need various numbers of arguments.
9// Those can be supplied as real arguments or as Phoenix arguments.
10// Execution will happen when all the arguments are supplied.
11// e.g.
12// take(2,list)() or take(2,arg1)(list)
13//
14// Implemented so far:
15//
16// id (moved back to operators.hpp)
17//
18// A lot of what comes here uses the list type, so that will be needed first.
19//
20// Now that list<T> is available I can start to build things here.
21//
22//
23// until(pred,f,start) - if pred(start) is true, return start
24// apply value = f(start)
25// apply value = f(value)
26// until pred(value) is true
27// return value
28//
29// The predicate argument pred must be a lazy function taking one argument
30// and returning bool.
31// This can be a lazy function with an argument already.
32// This has to be declared before the call to until.
33// The type can be declated using Predicate as in this example:
34//
35// Predicate<int>::type f(greater(arg1,10));
36// std::cout << until(f, inc, 1)() << std::endl;
37//
38// until2(pred,f,start,value2) - if pred(start,value2) is true, return start
39// apply value1 = f(start)
40// apply value1 = f(value1)
41// until pred(value1,value2) is true
42// return value1
43//
44// NOTE: until2 has been defined because this code does not support
45// FC++ currying, so that a partial function cannot be passed
46// as an argument. This provides a way of passing a second parameter.
47// There is now the option to use Predicate<T> as shown above.
48//
49// odd(n) true if n is odd
50// even(n) true if n is even
51//
52// last(list)
53// all_but_last(list)
54// at(list,n)
55// length(list)
56// filter(pred,list)
57// iterate(function,value)
58// repeat(value)
59// take(n,list)
60// drop(n,list)
61// enum_from(x)
62// enum_from_to(x,y)
63//
64////////////////////////////////////////////////////////////////////////////
65// Interdependence:
66// The old Boost FC++ has a set of headers which interelate and call each
67// other in a complicated way. I am going to document the interdependence
68// of the files here. I will then make sure that they are called correctly
69// starting from this file. John Fletcher. February 2015.
70////////////////////////////////////////////////////////////////////////////
71// BoostFC++ header sequence:
72//
73// prelude.hpp -> list.hpp (optinally monad.hpp at end)
74// list.hpp -> reuse.hpp
75// reuse.hpp -> function.hpp
76// function.hpp -> ref_count.hpp operator.hpp
77// ref_count.hpp -> config.hpp boost headers and RefCountType definition
78// operator.hpp -> lambda.hpp
79// lambda.hpp -> full.hpp (use of lambda internals is optional)
80// full.hpp -> smart.hpp curry.hpp pre_lambda.hpp (optionally full4.hpp)
81// smart.hpp -> signature.hpp
82// curry.hpp -> signature.hpp
83// signature.hpp -> config.hpp
84//
85////////////////////////////////////////////////////////////////////////////
86// Proposed order in lazy_prelude.hpp
87// on the basis that files need what they call.
88//
89// lazy_config.hpp (If needed)* probably not needed.
90// lazy_signature.hpp (If needed)*
91// lazy_smart.hpp (If needed)*
92// lazy_curry.hpp (If needed)*
93// lazy_full.hpp (If needed)*
94// lazy_operator.hpp (absorb definition of RefCountType)
95// lazy_function.hpp (may not now be needed)
96// lazy_reuse.hpp (implemented without use of FC++ functions)
97// lazy_list.hpp
98//
99// * file does not yet exist.
100////////////////////////////////////////////////////////////////////////////
101// This is implemented such that no other lazy_ file calls other lazy_ files.
102// They do call their own external files, which may well be duplicates.
103// That can be sorted out later.
104////////////////////////////////////////////////////////////////////////////
105// Notes: full and curry operations should be covered by Phoenix.
106// The lambda operations are quite different from Phoenix lambda
107// and will be omitted.
108// The implementation monad can be postponed.
109// Some of function and reuse are needed for the list type.
110// I will review later whether they are part of the external interface.
111//
112// John Fletcher February 2015.
113////////////////////////////////////////////////////////////////////////////
114/*=============================================================================
115 Copyright (c) 2000-2003 Brian McNamara and Yannis Smaragdakis
116 Copyright (c) 2001-2007 Joel de Guzman
117 Copyright (c) 2015 John Fletcher
118
119 Distributed under the Boost Software License, Version 1.0. (See accompanying
120 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
121==============================================================================*/
122
123
124#ifndef BOOST_PHOENIX_FUNCTION_LAZY_PRELUDE
125#define BOOST_PHOENIX_FUNCTION_LAZY_PRELUDE
126
127#include <exception>
128#include <vector>
129#include <boost/phoenix/core.hpp>
130#include <boost/phoenix/function.hpp>
131#include <boost/phoenix/scope.hpp>
132#include <boost/phoenix/operator.hpp>
133#include <boost/phoenix/function/lazy_operator.hpp>
134#include <boost/phoenix/function/lazy_reuse.hpp>
135#include <boost/phoenix/function/lazy_list.hpp>
136
137////////////////////////////////////////////////////////////////////////////
138// To come here, the Haskell Prelude things which need list<T>.
139// Things which do not need list<T> are in lazy_operator.hpp.
140////////////////////////////////////////////////////////////////////////////
141
142namespace boost {
143
144 namespace phoenix {
145
146 // These are in fcpp namespace as they introduce an FC++ style.
147 namespace fcpp {
148
149 template <typename T>
150 struct Predicate {
151 typedef typename boost::function1<bool,T> fun1_bool_T;
152 typedef typename boost::phoenix::function<fun1_bool_T> bool_F_T;
153 typedef bool_F_T type;
154 };
155
156 template <typename R>
157 struct Function0 {
158 typedef typename boost::function0<R> fun0_R;
159 typedef typename boost::phoenix::function<fun0_R> R_F;
160 typedef R_F type;
161 };
162
163 template <typename R,typename A0>
164 struct Function1 {
165 typedef typename boost::function1<R,A0> fun1_R_A0;
166 typedef typename boost::phoenix::function<fun1_R_A0> R_F_A0;
167 typedef R_F_A0 type;
168 };
169
170 template <typename R, typename A0, typename A1>
171 struct Function2 {
172 typedef typename boost::function2<R,A0,A1> fun2_R_A0_A1;
173 typedef typename boost::phoenix::function<fun2_R_A0_A1> R_F_A0_A1;
174 typedef R_F_A0_A1 type;
175 };
176
177 }
178
179 namespace impl {
180 using fcpp::INV;
181 using fcpp::VAR;
182 using fcpp::reuser1;
183 using fcpp::reuser2;
184 using fcpp::reuser3;
185 using boost::phoenix::arg_names::arg1;
186
187 struct Pow {
188
189 template <typename Sig>
190 struct result;
191
192 template <typename This, typename N, typename A0>
193 struct result<This(N,A0)>
194 : boost::remove_reference<A0>
195 {};
196
197 template <typename N, typename A0>
198 A0 operator()(N n, const A0 & a0,
199 reuser2<INV,VAR,INV,Pow,N,A0> r = NIL ) const {
200 if ( n <= 0 )
201 return A0(1);
202 else if ( n==1 )
203 return a0;
204 else {
205 A0 a1 = r( Pow(), n-1, a0)();
206 return a0*a1;
207 }
208 }
209
210 };
211
212 struct Apply {
213
214 template <typename Sig>
215 struct result;
216
217 template <typename This, typename N, typename F,typename A0>
218 struct result<This(N,F,A0)>
219 : boost::remove_reference<A0>
220 {};
221
222 template <typename N, typename F, typename A0>
223 A0 operator()(N n, const F &f, const A0 & a0,
224 reuser3<INV,VAR,INV,INV,Apply,N,F,A0> r = NIL ) const {
225 if ( n <= 0 )
226 return a0;
227 else if ( n==1 )
228 return f(arg1)(a0);
229 else {
230 A0 a1 = r( Apply(), n-1, f, a0)();
231 return f(a1)();
232 }
233 }
234
235 };
236
237 struct Odd {
238 template <typename Sig>
239 struct result;
240
241 template <typename This, typename T>
242 struct result<This(T)>
243 {
244 typedef bool type;
245 };
246
247 template <class T>
248 typename result<Odd(T)>::type operator()( const T& x ) const {
249 return x%2==1;
250 }
251 };
252
253 struct Even {
254 template <typename Sig>
255 struct result;
256
257 template <typename This, typename T>
258 struct result<This(T)>
259 {
260 typedef bool type;
261 };
262
263 template <class T>
264 typename result<Even(T)>::type operator()( const T& x ) const {
265 return x%2==0;
266 }
267 };
268
269 }
270 typedef boost::phoenix::function<impl::Pow> Pow;
271 typedef boost::phoenix::function<impl::Apply> Apply;
272 typedef boost::phoenix::function<impl::Odd> Odd;
273 typedef boost::phoenix::function<impl::Even> Even;
274 Pow pow;
275 Apply apply;
276 Odd odd;
277 Even even;
278
279 namespace impl {
280 using fcpp::INV;
281 using fcpp::VAR;
282 using fcpp::reuser1;
283 using fcpp::reuser2;
284 using fcpp::reuser3;
285 using boost::phoenix::arg_names::arg1;
286
287 // I cannot yet do currying to pass e.g. greater(9,arg1)
288 // as a function. This can be done using Predicate<T>::type.
289 struct Until {
290
291 template <typename Sig> struct result;
292
293 template <typename This, typename Pred, typename Unary, typename T>
294 struct result<This(Pred,Unary,T)>
295 : boost::remove_reference<T> {};
296
297 template <class Pred, class Unary, class T>
298 T operator()( const Pred& p,const Unary& op,const T &start) const
299 {
300 T tmp = start;
301 while( !p(tmp)() ) {
302 tmp = apply(1,op,tmp)();
303 }
304 return tmp;
305 }
306
307 };
308
309 struct Until2 {
310
311 template <typename Sig> struct result;
312
313 template <typename This, typename Binary, typename Unary,
314 typename T, typename X>
315 struct result<This(Binary,Unary,T,X)>
316 : boost::remove_reference<T> {};
317
318 template <class Binary, class Unary, class T, class X>
319 typename result<Until2(Binary,Unary,T,X)>::type
320 operator()( const Binary& p, const Unary& op, const T & start,
321 const X & check ) const
322 {
323 T tmp1 = start;
324 T tmp2;
325 while( !p(tmp1,check)() ) {
326 tmp2 = apply(1,op,tmp1)();
327 tmp1 = tmp2;
328
329 }
330 return tmp1;
331 }
332 };
333
334 struct Last {
335 template <typename Sig> struct result;
336
337 template <typename This, typename L>
338 struct result<This(L)>
339 {
340 typedef typename result_of::ListType<L>::value_type type;
341 };
342
343 template <class L>
344 typename result<Last(L)>::type
345 operator()( const L& ll ) const {
346 size_t x = 0;
347 typename result_of::ListType<L>::delay_result_type l = delay(ll);
348 while( !null( tail(l)() )() ) {
349 l = tail(l)();
350 ++x;
351#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
352 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
353 break;
354#endif
355 }
356#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
357 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
358 throw lazy_exception("Your list is too long!!");
359#endif
360 return head(l)();
361 }
362 };
363
364 struct Init {
365
366 template <typename Sig> struct result;
367
368 template <typename This, typename L>
369 struct result<This(L)>
370 {
371 typedef typename result_of::ListType<L>::force_result_type type;
372 };
373
374 template <class L>
375 typename result<Init(L)>::type
376 operator()( const L& l,
377 reuser1<INV,VAR,Init,
378 typename result_of::ListType<L>::delay_result_type>
379 r = NIL ) const {
380 if( null( tail( l )() )() )
381 return NIL;
382 else
383 return cons( head(l)(), r( Init(), tail(l)() )() )();
384 }
385 };
386
387 struct Length {
388 template <typename Sig> struct result;
389
390 template <typename This, typename L>
391 struct result<This(L)>
392 {
393 typedef size_t type;
394 };
395
396 template <class L>
397 size_t operator()( const L& ll ) const {
398 typename L::delay_result_type l = delay(ll);
399 size_t x = 0;
400 while( !null(l)() ) {
401 l = tail(l);
402 ++x;
403 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
404 break;
405 }
406#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
407 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
408 throw lazy_exception("Your list is too long!!");
409#endif
410 return x;
411 }
412 };
413
414 // at is Haskell's operator (!!)
415 // This is zero indexed. at(l,0)() returns the first element.
416 struct At {
417 template <typename Sig> struct result;
418
419 template <typename This, typename L, typename N>
420 struct result<This(L,N)>
421 {
422 typedef typename result_of::ListType<L>::value_type type;
423 };
424
425 template <class L>
426 typename result<At(L,size_t)>::type
427 operator()( L l, size_t n ) const {
428 while( n!=0 ) {
429 l = tail(l);
430 --n;
431 }
432 return head(l)();
433 }
434 };
435
436 template <class P,class L>
437 struct FilterH
438 {
439 P p;
440 L l;
441 FilterH( const P& pp, const L& ll) : p(pp), l(ll) {}
442 template <typename Sig> struct result;
443
444 template <typename This, class PP, class LL>
445 struct result<This(PP,LL)>
446 {
447 typedef typename boost::phoenix::result_of::
448 ListType<LL>::delay_result_type type;
449 };
450 typename result<FilterH(P,L)>::type operator()() const {
451 typedef typename result_of::ListType<L>::
452 delay_result_type result_type;
453 typedef boost::function0<result_type> Fun2_R_P_L;
454 typedef boost::phoenix::function<Fun2_R_P_L> FilterH_R_P_L;
455 if (null(l)() )
456 return NIL;
457 Fun2_R_P_L fun2_R_P_L = FilterH<P,L>(p,tail(l));
458 FilterH_R_P_L filterh_R_P_L(fun2_R_P_L);
459 if( p(head(l))() )
460 return cons( head(l)(), filterh_R_P_L() );
461 else
462 return filterh_R_P_L();
463 }
464 };
465
466 struct Filter {
467 template <typename Sig> struct result;
468
469 template <typename This, typename P, typename L>
470 struct result<This(P,L)>
471 {
472 typedef typename result_of::ListType<L>::delay_result_type
473 type;
474 };
475
476 template <class P, class L>
477 typename result<Filter(P,L)>::type
478 operator()( const P& p, const L& ll) const
479 {
480 typename result_of::ListType<L>::delay_result_type
481 l = delay(ll);
482 typedef typename result_of::ListType<L>::
483 delay_result_type result_type;
484 typedef boost::function0<result_type> Fun2_R_P_L;
485 typedef boost::phoenix::function<Fun2_R_P_L> FilterH_R_P_L;
486 Fun2_R_P_L fun2_R_P_L = FilterH<P,L>(p,l);
487 FilterH_R_P_L filterh_R_P_L(fun2_R_P_L);
488 return filterh_R_P_L();
489 }
490 };
491
492 template <class F,class T>
493 struct IterateH
494 {
495 F f;
496 T t;
497 IterateH( const F& ff, const T& tt) : f(ff), t(tt) {}
498 template <typename Sig> struct result;
499
500 template <typename This,class F2,class T2>
501 struct result<This(F2,T2)>
502 {
503 typedef typename boost::remove_reference<T2>::type TT;
504 typedef typename boost::remove_const<TT>::type TTT;
505 typedef typename UseList::template List<TTT>::type LType;
506 typedef typename result_of::ListType<LType>::
507 delay_result_type type;
508 };
509
510 typename result<IterateH(F,T)>::type operator()() const {
511 typedef typename UseList::template List<T>::type LType;
512 typedef typename result_of::ListType<LType>::
513 delay_result_type result_type;
514 typedef boost::function0<result_type> Fun2_R_F_T;
515 typedef boost::phoenix::function<Fun2_R_F_T> IterateH_R_F_T;
516 Fun2_R_F_T fun2_R_F_T = IterateH<F,T>(f,f(t)());
517 IterateH_R_F_T iterateh_R_F_T(fun2_R_F_T);
518 return cons( t, iterateh_R_F_T() );
519 }
520 };
521
522
523 struct Iterate {
524 // Note: this does always return an odd_list; iterate() takes no ListLike
525 // parameter, and it requires that its result be lazy.
526 template <typename Sig> struct result;
527
528 template <typename This, typename F, typename T>
529 struct result<This(F,T)>
530 {
531 typedef typename boost::remove_reference<T>::type TT;
532 typedef typename boost::remove_const<TT>::type TTT;
533 typedef typename UseList::template List<TTT>::type LType;
534 typedef typename result_of::ListType<LType>::
535 delay_result_type type;
536 };
537
538 template <class F, class T>
539 typename result<Iterate(F,T)>::type operator()
540 (const F& f, const T& t) const {
541 typedef typename UseList::template List<T>::type LType;
542 typedef typename result_of::ListType<LType>::
543 delay_result_type result_type;
544 typedef boost::function0<result_type> Fun2_R_F_T;
545 typedef boost::phoenix::function<Fun2_R_F_T> IterateH_R_F_T;
546 Fun2_R_F_T fun2_R_F_T = IterateH<F,T>(f,f(t)());
547 IterateH_R_F_T iterateh_R_F_T(fun2_R_F_T);
548 return iterateh_R_F_T();
549 }
550 };
551
552 }
553
554 typedef boost::phoenix::function<impl::Until> Until;
555 typedef boost::phoenix::function<impl::Until2> Until2;
556 typedef boost::phoenix::function<impl::Last> Last;
557 typedef boost::phoenix::function<impl::Init> Init;
558 typedef boost::phoenix::function<impl::Length> Length;
559 typedef boost::phoenix::function<impl::At> At;
560 typedef boost::phoenix::function<impl::Filter> Filter;
561 typedef boost::phoenix::function<impl::Iterate> Iterate;
562 Until until;
563 Until2 until2;
564 Last last;
565 Init all_but_last; // renamed from init which is not available.
566 Length length;
567 At at_; //Renamed from at.
568 Filter filter;
569 Iterate iterate;
570
571 namespace impl {
572
573 struct Repeat {
574 // See note for iterate()
575 template <typename Sig> struct result;
576
577 template <typename This, typename T>
578 struct result<This(T)>
579 {
580 typedef typename boost::remove_reference<T>::type TT;
581 typedef typename boost::remove_const<TT>::type TTT;
582 typedef typename UseList::template List<TTT>::type LType;
583 typedef typename result_of::ListType<LType>::
584 delay_result_type type;
585 };
586
587 template <class T>
588 typename result<Repeat(T)>::type operator()( const T& x) const
589 {
590 return iterate(id,x);
591 }
592 };
593
594 struct Take {
595
596 template <typename Sig> struct result;
597
598 template <typename This, typename N, typename L>
599 struct result<This(N,L)>
600 {
601 typedef typename result_of::ListType<L>::force_result_type type;
602 };
603
604 template <class N,class L>
605 typename result<Take(N,L)>::type
606 operator()( N n, const L& l,
607 reuser2<INV,VAR,VAR,Take,N,
608 typename result_of::ListType<L>::force_result_type>
609 r = NIL
610 ) const {
611 if( n <= 0 || null(l)() )
612 return NIL;
613 else {
614 return cons( head(l)(), r( Take(), n-1, tail(l)() )() )();
615 }
616 }
617 };
618
619 struct Drop {
620 template <typename Sig> struct result;
621
622 template <typename This, typename Dummy, typename L>
623 struct result<This(Dummy,L)>
624 {
625 typedef typename result_of::ListType<L>::delay_result_type type;
626 };
627
628 template <class L>
629 typename result<Drop(size_t,L)>::type
630 operator()( size_t n, const L& ll ) const {
631 typename L::delay_result_type l = delay(ll);
632 while( n!=0 && !null(l)() ) {
633 --n;
634 l = tail(l)();
635 }
636 return l;
637 }
638 };
639
640 template <class T>
641 struct EFH
642 {
643 mutable T x;
644 EFH( const T& xx) : x(xx) {}
645 template <typename Sig> struct result;
646
647 template <typename This, class TT>
648 struct result<This(TT)>
649 {
650 typedef typename boost::phoenix::UseList::template
651 List<TT>::type LType;
652 typedef typename boost::phoenix::result_of::
653 ListType<LType>::delay_result_type type;
654 };
655 typename result<EFH(T)>::type operator()() const {
656 typedef typename UseList::template List<T>::type LType;
657 typedef typename result_of::ListType<LType>::
658 delay_result_type result_type;
659 typedef boost::function0<result_type> fun1_R_TTT;
660 //std::cout << "EFH (" << x << ")" << std::endl;
661 ++x;
662 fun1_R_TTT efh_R_TTT = EFH<T>(x);
663 typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
664 EFH_R_T efh_R_T(efh_R_TTT);
665#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
666 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
667 throw lazy_exception("Running away in EFH!!");
668#endif
669 return cons( x-1, efh_R_T() );
670 }
671 };
672
673 struct Enum_from {
674 template <typename Sig> struct result;
675
676 template <typename This, typename T>
677 struct result<This(T)>
678 {
679 typedef typename boost::remove_reference<T>::type TT;
680 typedef typename boost::remove_const<TT>::type TTT;
681 typedef typename UseList::template List<TTT>::type LType;
682 typedef typename result_of::ListType<LType>::
683 delay_result_type type;
684 };
685
686 template <class T>
687 typename result<Enum_from(T)>::type operator()
688 (const T & x) const
689 {
690 typedef typename boost::remove_reference<T>::type TT;
691 typedef typename boost::remove_const<TT>::type TTT;
692 typedef typename UseList::template List<T>::type LType;
693 typedef typename result_of::ListType<LType>::
694 delay_result_type result_type;
695 typedef boost::function0<result_type> fun1_R_TTT;
696 fun1_R_TTT efh_R_TTT = EFH<TTT>(x);
697 typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
698 EFH_R_T efh_R_T(efh_R_TTT);
699 //std::cout << "enum_from (" << x << ")" << std::endl;
700 return efh_R_T();
701 }
702 };
703
704 template <class T>
705 struct EFTH
706 {
707 mutable T x;
708 T y;
709 EFTH( const T& xx, const T& yy) : x(xx), y(yy) {}
710 template <typename Sig> struct result;
711
712 template <typename This, class TT>
713 struct result<This(TT)>
714 {
715 typedef typename boost::phoenix::UseList::template
716 List<TT>::type LType;
717 typedef typename boost::phoenix::result_of::
718 ListType<LType>::delay_result_type type;
719 };
720 typename result<EFTH(T)>::type operator()() const {
721 typedef typename UseList::template List<T>::type LType;
722 typedef typename result_of::ListType<LType>::
723 delay_result_type result_type;
724 typedef boost::function0<result_type> fun1_R_TTT;
725 //std::cout << "EFTH (" << x << ")" << std::endl;
726 if (x > y ) return NIL;
727 ++x;
728 fun1_R_TTT efth_R_TTT = EFTH<T>(x,y);
729 typedef boost::phoenix::function<fun1_R_TTT> EFTH_R_T;
730 EFTH_R_T efth_R_T(efth_R_TTT);
731#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
732 if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
733 throw lazy_exception("Running away in EFTH!!");
734#endif
735 return cons( x-1, efth_R_T() );
736 }
737 };
738
739 struct Enum_from_to {
740 template <typename Sig> struct result;
741
742 template <typename This, typename T>
743 struct result<This(T,T)>
744 {
745 typedef typename boost::remove_reference<T>::type TT;
746 typedef typename boost::remove_const<TT>::type TTT;
747 typedef typename UseList::template List<TTT>::type LType;
748 typedef typename result_of::ListType<LType>::
749 delay_result_type type;
750 };
751
752 template <class T>
753 typename result<Enum_from(T,T)>::type operator()
754 (const T & x, const T & y) const
755 {
756 typedef typename boost::remove_reference<T>::type TT;
757 typedef typename boost::remove_const<TT>::type TTT;
758 typedef typename UseList::template List<T>::type LType;
759 typedef typename result_of::ListType<LType>::
760 delay_result_type result_type;
761 typedef boost::function0<result_type> fun1_R_TTT;
762 fun1_R_TTT efth_R_TTT = EFTH<TTT>(x,y);
763 typedef boost::phoenix::function<fun1_R_TTT> EFTH_R_T;
764 EFTH_R_T efth_R_T(efth_R_TTT);
765 //std::cout << "enum_from (" << x << ")" << std::endl;
766 return efth_R_T();
767 }
768 };
769
770 }
771
772
773 //BOOST_PHOENIX_ADAPT_CALLABLE(apply, impl::apply, 3)
774 // Functors to be used in reuser will have to be defined
775 // using boost::phoenix::function directly
776 // in order to be able to be used as arguments.
777 typedef boost::phoenix::function<impl::Repeat> Repeat;
778 typedef boost::phoenix::function<impl::Take> Take;
779 typedef boost::phoenix::function<impl::Drop> Drop;
780 typedef boost::phoenix::function<impl::Enum_from> Enum_from;
781 typedef boost::phoenix::function<impl::Enum_from_to> Enum_from_to;
782 Repeat repeat;
783 Take take;
784 Drop drop;
785 Enum_from enum_from;
786 Enum_from_to enum_from_to;
787
788 namespace fcpp {
789
790
791 }
792
793 }
794
795}
796
797
798#endif
Ceph