scm2cpp-learn 0.18.0__py3-none-win_amd64.whl

scm2cpp_learn/_generated/scm2cpp.hpp

@@ -0,0 +1,1627 @@
+#ifndef SCM2CPP
+#define SCM2CPP
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include <list>
+#include <map>
+#include <algorithm>
+#include <limits>
+#include <array>
+#include <cmath>
+#include <cstdarg>
+
+// Marks a function compilable for both host and device.  Under nvcc it
+// expands to the CUDA qualifiers; everywhere else to nothing, so the
+// same generated text serves both toolchains.  The translator applies
+// it only to functions whose bodies stay inside the device-safe subset.
+#if defined(__CUDACC__)
+#define SCM2CPP_FN __host__ __device__
+#else
+#define SCM2CPP_FN
+#endif
+
+//#include <type_traits>
+#include <functional>
+
+#ifndef SCM2CPP_MINIMAL // the full-feature runtime: everything a numeric kernel never touches
+
+
+#include <boost/function.hpp>
+#include <boost/functional.hpp>
+
+//#include <boost/thread.hpp>
+
+#include <boost/typeof/typeof.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/function_type.hpp>
+
+#include <boost/preprocessor.hpp>
+
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/logical.hpp>
+
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/comparison.hpp>
+#include <boost/mpl/filter_view.hpp>
+#include <boost/mpl/sizeof.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/sort.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/unique.hpp>
+
+//#include <boost/fusion/iterator.hpp>
+//#include <boost/fusion/include/iterator.hpp>
+
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/algorithm.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/include/list.hpp>
+#include <boost/fusion/include/vector.hpp>
+
+#include <boost/fusion/container/list/cons.hpp>
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/make_cons.hpp>
+#include <boost/fusion/container/generation/make_cons.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/include/make_list.hpp>
+
+
+#include <boost/fusion/iterator/iterator_facade.hpp>
+#include <boost/fusion/include/iterator_facade.hpp>
+
+#include <boost/fusion/algorithm/auxiliary/copy.hpp>
+#include <boost/fusion/include/copy.hpp>
+
+#include <boost/fusion/algorithm/transformation/push_front.hpp>
+#include <boost/fusion/include/push_front.hpp>
+
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/include/push_back.hpp>
+
+
+#include <boost/variant.hpp>
+
+
+#define null_P scm2cpp::is_null
+#define eq_P scm2cpp::is_eq
+#define eqv_P scm2cpp::is_eqv
+#define equal_P scm2cpp::is_equal
+
+
+
+
+#define CONSED_AS_STD_PAIR 1
+#if CONSED_AS_STD_PAIR
+#define consd std::pair
+#endif
+
+// #include <boost/intrusive/slist.hpp>
+// #include <boost/intrusive/list.hpp>
+// #include <boost/intrusive/list_hook.hpp>
+
+namespace scm2cpp
+{
+
+
+
+
+
+  typedef boost::fusion::nil nil_type;
+  typedef boost::fusion::nil nil;
+  typedef boost::fusion::nil null_type;
+ 
+  //nil_type null;
+  nil_type null();
+  //nil_type nil();
+  //nil_type & nil = null;
+
+  typedef std::string string_type;
+  
+  struct symbol_type : public string_type
+  { symbol_type(string_type & st) : string_type(st)    {}
+    symbol_type(char *c) : string_type(c) {}  };
+
+  inline symbol_type string_to_symbol(string_type &st){return symbol_type(st);}
+  inline string_type symbol_to_string(symbol_type &st){return st;}
+
+
+  typedef boost::mpl::vector<char,int,short,long,float,double,bool> c_number_types;
+  // Exact rationals, replacing rational: the four
+  // operations, normalization with the sign on the numerator, and
+  // ordering by cross-multiplication -- what the number-type order
+  // and eqv need, and nothing else.
+  struct rational {
+    int num, den;
+    static int gcd_(int a, int b)
+    { while (b) { int t = a % b; a = b; b = t; } return a < 0 ? -a : a; }
+    rational(int n = 0, int d = 1) : num(n), den(d) {
+      if (den < 0) { num = -num; den = -den; }
+      int g = gcd_(num, den); if (g > 1) { num /= g; den /= g; }
+    }
+    rational operator+(const rational& o) const
+    { return rational(num*o.den + o.num*den, den*o.den); }
+    rational operator-(const rational& o) const
+    { return rational(num*o.den - o.num*den, den*o.den); }
+    rational operator*(const rational& o) const
+    { return rational(num*o.num, den*o.den); }
+    rational operator/(const rational& o) const
+    { return rational(num*o.den, den*o.num); }
+    bool operator==(const rational& o) const
+    { return num == o.num && den == o.den; }
+    bool operator<(const rational& o) const
+    { return (long long)num*o.den < (long long)o.num*den; }
+    explicit operator double() const { return (double)num / den; }
+  };
+  inline std::ostream& operator<<(std::ostream& os, const rational& r)
+  { return os << r.num << "/" << r.den; }
+
+  typedef boost::mpl::vector<rational,std::complex<double> > not_c_number_types;
+  typedef boost::mpl::insert_range<c_number_types,boost::mpl::end<c_number_types>::type,not_c_number_types>::type number_types;
+
+  typedef boost::mpl::push_back<number_types,string_type>::type number_string_types;
+  typedef boost::mpl::push_back<number_types,symbol_type>::type number_symbol_types;  
+  typedef boost::mpl::push_back<number_string_types,symbol_type>::type number_string_symbol_types;
+  typedef boost::mpl::push_back<not_c_number_types,string_type>::type not_c_number_string_types;
+  typedef boost::mpl::push_back<not_c_number_string_types,symbol_type>::type not_c_number_string_symbol_types;
+
+
+  template<typename Base
+	   , class Enable = void	   
+	   >	   
+  struct quoted 
+  : Base
+  { Base & value;     quoted(Base & base):Base(base),value(base)     {} };
+
+
+  template<typename Base
+	   //, class Enable = void
+	   //,typename boost::disable_if<boost::is_arithmetic<Base> >::type
+	   >	   
+  //struct quoted 
+  struct quoted<Base
+		,typename boost::disable_if<boost::is_arithmetic<Base> >::type>
+  : Base
+  { Base & value;     quoted(Base & base):Base(base),value(base)     {} };
+  
+  template<typename Base>
+  struct quoted<Base
+		,typename boost::enable_if<boost::is_arithmetic<Base> >::type>
+#if 0
+    :
+    less_than_comparable < quoted<Base>,
+    equality_comparable < quoted<Base>,
+    less_than_comparable2 < quoted<Base>, Base,
+    equality_comparable2 < quoted<Base>, Base,
+    addable < quoted<Base>,
+    subtractable < quoted<Base>,
+    multipliable < quoted<Base>,
+    dividable < quoted<Base>,
+    addable2 < quoted<Base>, Base,
+    subtractable2 < quoted<Base>, Base,
+    subtractable2_left < quoted<Base>, Base,
+    multipliable2 < quoted<Base>, Base,
+    dividable2 < quoted<Base>, Base,
+    dividable2_left < quoted<Base>, Base,
+    incrementable < quoted<Base>,
+    decrementable < quoted<Base>
+    > > > > > > > > > > > > > > > >
+#endif
+  : boost::operators<quoted<Base> >
+  {    
+    Base value;
+    quoted(Base base):value(base)     {} 
+    bool operator<(const quoted<Base>& x) const { return value < x.value; }
+    bool operator==(const quoted<Base>& x) const { return value == x.value; }
+    quoted<Base>& operator+=(const quoted<Base>& x) { value+=x.value; return *this; }
+    quoted<Base>& operator-=(const quoted<Base>& x) { value-=x.value; return *this; }
+    quoted<Base>& operator*=(const quoted<Base>& x) { value*=x.value; return *this; }
+    quoted<Base>& operator/=(const quoted<Base>& x) { value/=x.value; return *this; }
+    quoted<Base>& operator%=(const quoted<Base>& x) { value%=x.value; return *this; }
+    quoted<Base>& operator|=(const quoted<Base>& x) { value|=x.value; return *this; }
+    quoted<Base>& operator&=(const quoted<Base>& x) { value&=x.value; return *this; }
+    quoted<Base>& operator^=(const quoted<Base>& x) { value^=x.value; return *this; }
+    quoted<Base>& operator++()                 { ++value;       return *this; }
+    quoted<Base>& operator--()                 { --value;       return *this; }
+
+  };
+
+
+  
+  template<typename Base> quoted<Base> quote(Base &base){return quoted<Base>(base); }
+
+  template<typename Base> quoted<Base> 
+  quote(Base base,typename boost::enable_if<boost::is_arithmetic<Base>, Base>::type* = 0)
+  {return quoted<Base>(base);}
+
+
+  
+  template<typename Base>
+  struct unquoted
+  {    Base & value;    
+    unquoted(Base &base):value(base)
+    {}  };
+  
+  template<typename Base>  unquoted<Base> unquote(Base &base){return unquoted<Base>(base); }
+
+  template<typename Base>
+  struct quasiquoted 
+  {    Base & value;    
+    quasiquoted(Base &base):value(base)
+    {}  };
+
+  template<typename Base>  quasiquoted <Base> quasiquote(Base &base){return quasiquoted<Base>(base); }
+
+
+#if 1
+  typedef boost::mpl::transform< number_string_types,quoted<boost::mpl::_1> >::type quoted_number_string_types ;  
+  typedef boost::mpl::insert_range<quoted_number_string_types,
+			   boost::mpl::end<quoted_number_string_types>::type,
+			   number_string_symbol_types>::type value_types;
+
+ 
+  typedef boost::mpl::transform< number_types,quoted<boost::mpl::_1> >::type quoted_number_types ;  
+  typedef boost::mpl::insert_range<quoted_number_types,
+			   boost::mpl::end<quoted_number_types>::type,
+			   number_symbol_types>::type scalar_types;
+
+  typedef boost::mpl::vector<char,int,short,long> int_types;
+  typedef boost::mpl::transform<int_types, quoted<boost::mpl::_1> >::type quoted_int_types ;  
+  typedef boost::mpl::insert_range<quoted_int_types,
+			   boost::mpl::end<quoted_int_types>::type,
+			   int_types>::type int_quote_types;
+#endif
+
+
+  
+  /////////////////////////list begin///////////////////////////////////
+
+#if CONSED_AS_STD_PAIR 
+#else
+  template<typename C ,typename D>  struct 
+  consed : std::pair<C,D> {};
+#endif
+#if 0
+  template<typename Seqs ,typename Last>  struct 
+  appended : std::pair<Seqs,Last> {};
+#else
+  template<typename Seqs>  struct 
+  appended 
+  {
+    Seqs &value;
+    appended(const Seqs & seqs):value(seqs){}
+  };
+
+#endif
+
+  //s8vector 	signed exact integer in the range -(2^7) to (2^7)-1
+  // u8vector 	unsigned exact integer in the range 0 to (2^8)-1
+  // s16vector	signed exact integer in the range -(2^15) to (2^15)-1
+  // u16vector	unsigned exact integer in the range 0 to (2^16)-1
+  // s32vector	signed exact integer in the range -(2^31) to (2^31)-1
+  // u32vector	unsigned exact integer in the range 0 to (2^32)-1
+  // s64vector	signed exact integer in the range -(2^63) to (2^63)-1
+  // u64vector	unsigned exact integer in the range 0 to (2^64)-1 
+
+
+
+
+
+  template<typename T> struct is_uniform_sequence :public boost::mpl::false_ {}; 
+  template<> struct is_uniform_sequence<std::string > :public boost::mpl::true_ {};
+  template<typename T> struct is_uniform_sequence<std::vector<T> > :public boost::mpl::true_ {};
+  template<typename T> struct is_uniform_sequence<std::list<T> > :public boost::mpl::true_ {};  
+  template<typename T,std::size_t N> struct is_uniform_sequence<std::array<T,N> >  :public boost::mpl::true_ {};
+
+
+  template<typename T,typename E> struct is_uniform_sequence_of :public boost::mpl::false_ {}; 
+  template<> struct is_uniform_sequence_of<std::string,char> :public boost::mpl::true_ {};
+  template<typename T> struct is_uniform_sequence_of<std::vector<T>,T> :public boost::mpl::true_ {};
+  template<typename T> struct is_uniform_sequence_of<std::list<T>,T> :public boost::mpl::true_ {};  
+  template<typename T,std::size_t N> struct is_uniform_sequence_of<std::array<T,N>,T>  :public boost::mpl::true_ {};
+  
+  // cons and cdr on a uniform sequence used to answer with a
+  // boost::ptr_container view sharing the caller's storage; without
+  // boost they answer with a std::list copy, which is the persistent
+  // semantics Scheme meant anyway.
+  template<typename T> struct uniform_sequence_to_boost_ptr_sequence_view {typedef T type;};
+  template<typename T> struct uniform_sequence_to_boost_ptr_sequence_view<std::vector<T> >
+  {typedef std::list<T> type; };
+  template<typename T,std::size_t N> struct uniform_sequence_to_boost_ptr_sequence_view<std::array<T,N> >
+  {typedef std::list<T> type; };
+
+  template<typename T> struct 
+  uniform_sequence_value_type 
+  {typedef typename T::value_type type;};
+  template<typename C,typename D> struct 
+  uniform_sequence_value_type<std::pair<C,D> > 
+  {typedef C type;};
+
+
+  template<typename T> struct 
+  is_sequence : boost::mpl::or_<
+    boost::fusion::traits::is_sequence<T>
+    ,is_uniform_sequence<T>
+    >{};
+
+  template<typename T> struct is_std_pair : boost::mpl::false_ {};
+  template<typename C,typename D> struct is_std_pair<std::pair<C,D> > : boost::mpl::true_ {};
+
+
+  template<typename T> struct 
+  is_pair_type : boost::mpl::or_<
+    is_sequence<T>
+    ,is_std_pair<T>
+    >{};
+  template<> struct 
+  is_pair_type<nil_type> : boost::mpl::false_ {};
+  template<typename T> bool is_pair(const T& dummy){return is_pair_type<T>::value; }
+
+  
+  template<typename T> struct 
+  is_list_type : is_sequence<T> {};
+  template<typename C,typename D> struct 
+  is_list_type<std::pair<C,D> > : is_list_type<D> {};
+  template<typename T> bool is_list(const T& dummy){return is_list_type<T>::value;}  
+  
+
+
+
+  template<typename T> struct 
+  is_subst_ref_object  :public 
+  boost::mpl::or_<   
+    boost::is_array<T>
+    ,boost::fusion::traits::is_sequence<T> 
+    ,is_uniform_sequence<T>
+    >{};
+  template<typename C,typename D> struct 
+  is_subst_ref_object<std::pair<C,D> > :public boost::mpl::true_ {};
+  template<typename C,typename D> struct 
+  is_subst_ref_object<std::map<C,D> > :public boost::mpl::true_ {};
+
+  template<typename T>  struct 
+  is_subst_copy_object :public boost::mpl::not_<is_subst_ref_object<T> > {};
+
+  template<typename T> struct to_subst_type : boost::mpl::if_< 
+    is_subst_copy_object<T>
+    ,boost::mpl::identity<T>
+    ,boost::add_reference<T>
+    >::type {};
+  
+
+  inline bool is_null(const nil_type  & dummy){return true;}
+  template<typename T> bool is_null(const std::list<T> & l){return (l.size()==0);}
+  template<typename T> bool is_null(const std::vector<T> & l){return (l.size()==0);}
+  template<typename T> bool is_null(const T & dummy){return false;}
+
+
+
+  template<typename C, typename D> std::pair<
+    typename to_subst_type<C>::type    
+    ,typename to_subst_type<D>::type>
+  cons(const C & c,const D & d
+       ,typename boost::disable_if<boost::mpl::or_<
+	 boost::fusion::traits::is_sequence<D>
+	 ,is_uniform_sequence_of<D,C>
+	 > > ::type* =0 
+    ){return std::pair<
+      typename to_subst_type<C>::type    
+      ,typename to_subst_type<D>::type
+      > (const_cast<C &>(c),const_cast<D &>(d)); }
+#if 1
+  template <typename T,typename Sequence>  
+  boost::fusion::cons<typename to_subst_type<T>::type,Sequence > 
+  cons(const T & e,
+       const Sequence & seq
+       ,typename boost::enable_if<
+	 boost::fusion::traits::is_sequence<Sequence> 
+	 > ::type*  = 0
+       ){ return boost::fusion::cons<typename to_subst_type<T>::type,Sequence >(e,seq);}
+#else
+  template <typename T,typename Sequence>    
+  typename boost::fusion::result_of::as_list<
+    typename boost::fusion::result_of::push_front<
+    Sequence, 
+    typename to_subst_type<T>::type
+      >::type
+    >::type
+  cons(T & e,
+       Sequence &seq
+       ,typename boost::enable_if<
+	 boost::fusion::traits::is_sequence<Sequence> 
+	 > ::type*  = 0
+       ){ return boost::fusion::push_front<
+      Sequence, 
+      typename to_subst_type<T>::type
+      >(seq, e);}
+#endif
+
+  template <typename T>
+  std::list<T>
+  cons(const T & e,const nil_type & seq){
+    std::list<T> l;
+    l.push_front(e);
+    return l;}
+
+  template<typename C, typename D> 
+  typename uniform_sequence_to_boost_ptr_sequence_view<D>::type   
+  cons(C e
+       ,const D & d
+       ,typename boost::enable_if<boost::mpl::and_<
+	 is_subst_copy_object<C>
+	 ,is_uniform_sequence_of<D,C>	 
+	 > >::type*  = 0            
+       ){typename uniform_sequence_to_boost_ptr_sequence_view<D>::type
+      l(d.begin(),d.end()); l.push_front(e); return l;}
+
+  template<typename C, typename D> 
+  typename uniform_sequence_to_boost_ptr_sequence_view<D>::type   
+  cons(C & e
+       ,const D & d
+       ,typename boost::enable_if<boost::mpl::and_<
+	 is_subst_ref_object<C>
+	 ,is_uniform_sequence_of<D,C>	 
+	 > >::type* = 0            
+       ){typename uniform_sequence_to_boost_ptr_sequence_view<D>::type
+      l(d.begin(),d.end()); l.push_front(e); return l;}
+
+
+  template<typename T>  std::list<T>
+  make_uniform_list(const int n,const T & x)
+  {return std::list<T>(n,x);}
+
+  template<typename T>  std::vector<T>
+  make_uniform_vector(const int n,const T & x)
+  {return std::vector<T>(n,x)  ;}
+
+
+  template<typename T> const T* cdr(const T l[]){return l+1;}
+
+  template<typename C, typename D> D
+  cdr(const std::pair<C,D> & seq){return seq.second;}
+
+  template<typename Seq> 
+  typename uniform_sequence_to_boost_ptr_sequence_view<Seq>::type   
+  cdr(const Seq & seq
+       ,typename boost::enable_if<is_uniform_sequence<Seq> >::type*  = 0 ){ 
+    typename Seq::const_iterator i=seq.begin();i++;
+    return 
+    typename uniform_sequence_to_boost_ptr_sequence_view<Seq>::type(i,seq.end());
+  }
+
+
+  template <typename Sequence>  
+  typename Sequence::cdr_type
+  //boost::fusion::cons<Sequence>::cdr_type
+  cdr( Sequence & seq
+       ,typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type* = 0
+       ){return seq.cdr; }
+
+#if 0
+  ///////dummy for list_ref
+  template <typename Sequence>  Sequence 
+  cdr(const Sequence & seq
+       ,typename boost::disable_if<boost::mpl::or_<	 
+	 boost::fusion::traits::is_sequence<Sequence> 
+	 ,is_uniform_sequence<Sequence> > 
+	 >::type* = 0
+       ){ return seq;}
+#endif
+
+
+  template<typename L, typename T> void
+  set_cdr(const L & l, const T & t){&cdr(l)=t;}  
+
+
+  template<typename T> const T* car_pointer(const T l[]){return l;}
+  template<typename C, typename D> const C* car_pointer(const std::pair<C,D> & seq){return &seq.first;}  
+  template <typename Sequence>   typename Sequence::const_iterator
+  //typename boost::enable_if< is_uniform_sequence<Sequence>,  typename Sequence::iterator>::type 
+  car_pointer(const Sequence & seq
+	      ,typename boost::enable_if<is_uniform_sequence<Sequence> >::type* = 0 
+	      ){return seq.begin();}
+  template <typename Sequence>  typename boost::fusion::result_of::begin<Sequence const>::type
+  car_pointer(const Sequence & seq
+ 	      ,typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*  = 0            
+       ){return boost::fusion::begin(seq);}
+
+  template<typename T> T car(const T l[]){return l[0];}
+  template<typename C, typename D> const C car(const std::pair<C,D> & seq){return seq.first;}  
+  template <typename Sequence> typename Sequence::iterator::value_type
+  car(Sequence & seq
+      ,typename boost::enable_if<is_uniform_sequence<Sequence> >::type*  = 0 
+      ){return *seq.begin();}
+  // A const-reference overload so that temporaries can be passed. ptr_list
+  // has value_type T*, so use iterator::value_type as the non-const one does.
+  template <typename Sequence> typename Sequence::iterator::value_type
+  car(const Sequence & seq
+      ,typename boost::enable_if<is_uniform_sequence<Sequence> >::type*  = 0
+      ){return *seq.begin();}
+  template <typename Sequence>  
+  //typename Sequence::car_type
+  typename boost::fusion::result_of::value_of<typename boost::fusion::result_of::begin<Sequence const>::type>::type
+  car(const Sequence & seq
+      ,typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*  = 0            
+       ){ 
+    //return seq.car;
+    return boost::fusion::deref(boost::fusion::begin(seq));
+  }
+
+#if 0
+  ///////dummy for list_ref
+  template <typename Sequence>  Sequence 
+  car(const Sequence & seq
+       ,typename boost::disable_if<boost::mpl::or_<	 
+	 boost::fusion::traits::is_sequence<Sequence> 
+	 ,is_uniform_sequence<Sequence> > 
+	 >::type* = 0
+       ){ return seq;}
+#endif
+
+
+  template<typename L, typename T> void
+  set_car(const L & l, const T & t){*car_pointer(l)=t;}  
+
+  template<typename T> const T* list_ref_pointer(const T l[] ,int n ){return l+n;}
+  template<typename T> T list_ref(const T l[] ,int n ){return l[n];}
+  template<typename T> T list_ref(const std::vector<T> & l ,const int &n ){ return l[n];}
+#if 0
+  template <typename Sequence> typename Sequence::iterator
+  list_ref_pointer(Sequence & seq,std::size_t n
+		   ,typename boost::enable_if<is_uniform_sequence<Sequence> >::type*  = 0){
+    typename Sequence ::iterator it  = seq.begin();
+    std::advance(it, n);
+    return it;}
+  template <typename Sequence> typename Sequence::iterator::value_type
+  list_ref(Sequence & seq,std::size_t n
+	   ,typename boost::enable_if<is_uniform_sequence<Sequence> >::type*  = 0)
+  {return *list_ref_pointer(seq,n);}
+#else
+  template<typename T> 
+  typename std::list<T>::const_iterator
+  list_ref_pointer(const std::list<T> & l ,const int & n ){
+    typename std::list<T>::const_iterator it  = l.begin();
+    std::advance(it, n);return it;}
+  template<typename T> T
+  list_ref(const std::list<T> & l ,const int &n ){
+    return *list_ref_pointer(l ,n );}
+
+
+  template<typename T> 
+  typename std::vector<T>::const_iterator
+  list_ref_pointer(const std::vector<T> & l ,const int & n ){
+    typename std::vector<T>::const_iterator it  = l.begin();
+    std::advance(it, n);
+    return it;}
+#endif
+
+
+
+#if 0
+#if 0
+  template <typename Ret,typename Sequence>  Ret
+  car_ret_type_chk(const Sequence & seq
+		   ,typename boost::enable_if<boost::is_same<Ret, BOOST_TYPEOF_TML(car(seq)) > >::type* = 0
+		   ){return car(seq);}
+  template <typename Ret,typename Sequence>  Ret
+  car_ret_type_chk(const Sequence & seq
+		   ,typename boost::disable_if<boost::is_same<Ret, BOOST_TYPEOF_TML(car(seq)) > >::type* = 0
+		   ){return Ret();}
+#endif
+
+  template <typename Ret,typename Sequence>  Ret
+  list_ref(const Sequence & seq, int n
+	   //,typename boost::disable_if<boost::fusion::traits::is_sequence<Sequence> >::type*  = 0      
+	   ,typename boost::disable_if<boost::mpl::or_<	 
+	     boost::fusion::traits::is_sequence<Sequence> 
+	     ,is_uniform_sequence<Sequence> > 
+				       >::type* = 0
+	   ){
+    if(n<=0){ return 
+	car(seq)
+	//car_ret_type_chk<Ret>(seq)
+	;}
+    else{ return list_ref<Ret>(cdr(seq), n-1);}}
+#endif
+
+  template<typename V>
+  struct fusion_at_n_functor
+  {
+    mutable int i;
+    int n;
+    mutable V value;
+    fusion_at_n_functor(int _n):i(0),n(_n){}
+    void operator()(const V & t) const
+    { if(i==n){value=t;} i++;}  
+    template<typename T>
+    void operator()(const T & t) const
+    { i++;}
+  };
+
+  template <typename First,typename Last,typename AtN > void
+  list_ref_fusion_impl(First i,Last last,AtN &atn,boost::mpl::true_ ){}
+  template <typename First,typename Last,typename AtN > void
+  list_ref_fusion_impl(First i,Last last,AtN &atn,boost::mpl::false_ ){
+    //std::cout << atn.i << "," <<atn.n << ":" ;    
+    if(atn.i == atn.n ){atn(boost::fusion::deref(i));}
+    else{
+      atn(boost::fusion::deref(i));
+      list_ref_fusion_impl(boost::fusion::next(i),last,atn,
+			   boost::fusion::result_of::equal_to<
+			     typename boost::fusion::result_of::next<First>::type,Last>());}}
+
+  template <typename Ret,typename Sequence>  Ret
+  list_ref(Sequence & seq, int n
+	   ,typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*  = 0            
+	   ){ 
+    fusion_at_n_functor<Ret> atn(n);
+#if 0
+    //dbug
+    boost::fusion::for_each(seq, atn);
+#else
+    list_ref_fusion_impl(boost::fusion::begin(seq),boost::fusion::end(seq) ,atn,
+			 boost::fusion::result_of::equal_to<
+			   typename boost::fusion::result_of::begin<Sequence>::type,
+			   typename boost::fusion::result_of::end<Sequence>::type>());    
+#endif
+    return atn.value;}
+
+
+#if 1
+  //////////////////////////////////
+  template <typename Ret,typename C,typename D> Ret
+  list_ref(std::pair<C,D> & seq,int n
+	   //,typename boost::enable_if<typename boost::mpl::contains <value_types,D>::type >::type* =0
+	   ,typename boost::disable_if<boost::mpl::or_<	 
+	     is_sequence<D> 
+	     ,is_std_pair<D>
+	     > >::type* =0		     
+	   ){
+    if(n<=0){ return 
+	car(seq);
+    }else{
+      return seq.second;
+    }}
+  //////////////////////////////////
+
+  template <typename Ret,typename C,typename D> Ret
+  list_ref(const std::pair<C,D> & seq, int n)
+  {
+    if(n<=0){ return 
+	car(seq)
+	;}    
+    else{ return list_ref<Ret>(cdr(seq), n-1);}}
+#else
+
+  template <typename Ret,typename AtN> void
+  list_ref_pair_impl(std::pair<double,double> & seq,AtN &atn
+		     ){
+    if(atn.i == atn.n ){
+      atn(seq.first);
+    }
+    else{
+      atn(seq.second);
+    }}
+
+
+  template <typename Ret,typename C,typename D,typename AtN> void
+  list_ref_pair_impl(std::pair<C,D> & seq,AtN &atn
+		     //,typename boost::enable_if<typename boost::mpl::contains <value_types,D>::type >::type* =0		     
+		     ){
+    if(atn.i == atn.n ){
+      atn(seq.first);
+    }
+    else{
+      atn(seq.second);
+    }}
+
+  template <typename Ret,typename C,typename D,typename AtN> void
+  list_ref_pair_impl(std::pair<C,D> & seq,AtN &atn
+		     ,typename boost::enable_if<is_sequence<D> >::type* = 0
+		     ){
+    if(atn.i == atn.n ){
+      atn(seq.first);
+    }
+    else{
+      atn(seq.first);
+      atn.value=list_ref<Ret>(seq.second,atn.n - atn.i );    
+    }}
+
+  template <typename Ret,typename C,typename D,typename AtN> void
+  list_ref_pair_impl(std::pair<C,D> & seq,AtN &atn
+		     ,typename boost::enable_if<is_std_pair<D> >::type* = 0
+		     ){
+    if(atn.i == atn.n ){
+      atn(seq.first);
+    }
+    else{
+      atn(seq.first);
+      list_ref_pair_impl<Ret>(seq.second,atn);
+    }}
+
+  template <typename Ret,typename C,typename D> Ret
+  list_ref(const std::pair<C,D> & seq, int n)
+  {
+    fusion_at_n_functor<Ret> atn(n);
+    list_ref_pair_impl<Ret>(seq,atn);
+    return atn.value;
+  }
+
+#endif
+
+#if 0
+  template<typename C, typename D>
+  std::map<C,D>
+  append(const std::pair<C,D> &l1,const std::pair<C,D> &l2)
+  {
+    std::map<C,D> ll;
+    ll.insert(l1);
+    ll.insert(l2);
+    return ll;
+  }
+#endif
+
+#if 1
+  template<typename Seq> 
+  typename uniform_sequence_to_boost_ptr_sequence_view<Seq>::type
+  append(const Seq & l1, const Seq & l2
+	 ,typename boost::enable_if<is_uniform_sequence<Seq> >::type*  = 0 ){ 
+    typedef typename Seq::iterator::value_type value_type;  
+    typename Seq::const_reverse_iterator ir=l1.rbegin(); 
+    typename uniform_sequence_to_boost_ptr_sequence_view<Seq>::type ll(l2.begin(),l2.end());
+    for(std::size_t i=0;i<l1.size();i++){ll.push_front(new value_type(*ir++));}
+    return ll;
+  }
+#else
+  template<typename Seq> 
+  typename uniform_sequence_to_boost_ptr_sequence_view<Seq>::type
+  append(const Seq & l1, const Seq & l2
+	 ,typename boost::enable_if<is_uniform_sequence<Seq> >::type*  = 0 ){ 
+    Seq ll(l1);
+    ll.insert(l1.end(), l2.begin(),l2.end() );
+    return ll;
+  }
+#endif
+
+
+#if 1
+  template<typename Seq1,typename Seq2> 
+  boost::fusion::joint_view<Seq1,Seq2>
+  append(Seq1 & l1, Seq2 & l2
+	 ,typename boost::enable_if<boost::mpl::and_<
+	   boost::fusion::traits::is_sequence<Seq1>
+	   ,boost::fusion::traits::is_sequence<Seq2> >
+	   >::type*  = 0 
+	 ){
+    Seq1 l1b;
+    boost::fusion::copy(l1b,l1);
+    boost::fusion::joint_view<Seq1,Seq2> ll(l1b,l2);
+    return ll;
+  }
+#endif
+
+
+#if 0
+  template<typename Seq1,typename Seq2> 
+  typename boost::fusion::result_of::as_list<
+    typename boost::fusion::result_of::push_back<
+      //seq1a_type
+      typename boost::fusion::result_of::as_list<  
+	typename boost::fusion::result_of::erase<
+	  Seq1,
+	  typename boost::fusion::result_of::advance<
+	    typename boost::fusion::result_of::begin<Seq1>::type,
+	    boost::mpl::plus<
+	      boost::fusion::result_of::size<Seq1>
+	      ,boost::mpl::int_<-1> > >::type
+	>::type
+	>::type
+      ,
+      //result_back_type & 
+      //Seq2
+      BOOST_TYPEOF(cons(boost::fusion::back(Seq1()),Seq2())) &
+      //BOOST_TYPEOF(cons(Seq1(),Seq2()))
+      >::type
+    >::type
+  append(Seq1 & seq1, Seq2 & seq2
+	 ,typename boost::enable_if<
+	   boost::mpl::and_<
+	     boost::fusion::traits::is_sequence<Seq1>
+	     ,boost::mpl::not_< 
+	       boost::fusion::traits::is_sequence<Seq2> > > >::type*  = 0 
+	 ){
+    //Seq1 ll;boost::fusion::copy(ll,seq1);//Seq1 ll(seq1);
+    typedef 
+#if 0
+      boost::fusion::result_of::as_list<     
+      boost::fusion::result_of::erase<
+	Seq1,
+	boost::fusion::result_of::advance<
+	  boost::fusion::result_of::begin<Seq1>::type,
+	  boost::mpl::plus< 
+	    boost::fusion::result_of::size<Seq1>
+	    ,boost::mpl::int_<-1> > >::type
+	>::type>::type 
+#else
+      typename boost::fusion::result_of::as_list<  
+	typename boost::fusion::result_of::erase<
+	  Seq1,
+	  typename boost::fusion::result_of::advance<
+	    typename boost::fusion::result_of::begin<Seq1>::type,
+	    boost::mpl::plus<
+	      boost::fusion::result_of::size<Seq1>
+	      ,boost::mpl::int_<-1> > >::type >::type>::type
+#endif
+	seq1a_type;
+    seq1a_type ll(seq1);
+    //typedef boost::fusion::result_of::back<Seq1> seq1_back_type;
+    //typedef boost::result_of<cons(seq1_back_type,Seq2)>::type result_back_type;
+    //BOOST_TYPEOF(cons(boost::fusion::back(seq1),seq2));
+    //BOOST_TYPEOF(cons(seq1_back_type(),Seq2()));    
+    //boost::type_of
+    //boost::fusion::erase(ll, back(vec));
+    //boost::fusion::back(ll)=cons(boost::fusion::back(seq1),seq2 );
+    return 
+      boost::fusion::push_back(ll,cons(boost::fusion::back(seq1),seq2  )  );
+  //return ll;
+  }
+#endif
+
+
+#if 0
+  template<typename Seq1,typename Seq2> 
+  appended<Seq1,Seq2>
+  append(Seq1 & l1, Seq2 & l2
+	 //,typename boost::enable_if<boost::mpl::and_<
+	 //boost::fusion::traits::is_sequence<Seq1>
+	   //,is_uniform_sequence<Seq2> >
+	   //>::type*  = 0 
+	 ){
+	   return appended<Seq1,Seq2>(l1,l2);
+  }
+#endif
+
+#if 0
+  template<typename Seq>  
+  typename uniform_sequence_to_boost_ptr_sequence_view<
+    typename Seq::iterator::value_type
+    >::type
+  //typename Seq::iterator::value_type
+  append(Seq & ll
+	 ,typename boost::enable_if<
+	   boost::mpl::and_<
+	     is_uniform_sequence<Seq> 
+	     ,is_uniform_sequence<
+	       typename Seq::iterator::value_type
+	       > >
+	   >::type*  = 0
+	 )
+  {
+    //typedef typename Seq::iterator::value_type value_type;  
+    typename Seq::const_reverse_iterator ir=ll.rbegin(); 
+    typename uniform_sequence_to_boost_ptr_sequence_view<
+      typename Seq::iterator::value_type
+      >::type
+      l((*ir).begin(),(*ir).end());
+    ir++;
+    for(std::size_t i=1;i<ll.size();i++){
+      l=append(*ir++,l);
+    }
+    return l;
+  }
+#endif
+
+
+#if 0
+  template<typename T>  
+  boost::ptr_list<T, boost::view_clone_allocator>
+  append(std::list<T> &l1,std::list<T> &l2)
+  {
+    boost::ptr_list<T, boost::view_clone_allocator> ll(l2.begin(),l2.end());
+    //std::list<T>::const_iterator i
+    typename std::list<T>::reverse_iterator ir=l1.rbegin();
+    for(int i=0;i<l1.size();i++){
+      ll.push_front(
+		    //&(*ir++)
+		    //*ir++
+		    //std::auto_ptr<T>(&(*ir++))
+		    new T(*ir++)
+		    //ptr_r2lvalue(*ir++)
+		    );
+    }
+    return ll;
+  }
+#endif
+
+
+  template<typename Seq> 
+  boost::fusion::reverse_view<Seq>
+  reverse(Seq & seq
+	 ,typename boost::enable_if<boost::fusion::traits::is_sequence<Seq> >::type*  = 0){
+    return boost::fusion::reverse(seq) ;
+  }
+
+
+	      
+  
+
+  /////////////////////////list end ///////////////////////////////////  
+
+
+
+
+
+
+  //template<typename Base>  quoted<Base> quote(Base &base){return quoted<Base>(base); }
+
+
+  
+
+
+  typedef std::basic_ofstream<char> stream_type;
+
+  typedef boost::mpl::vector<std::basic_ofstream<char>
+			     ,std::streambuf
+			     ,std::ostream,std::istream
+			     ,std::ifstream,std::ofstream
+			     ,std::stringstream
+			     ,std::istream,std::ostream
+			     ,std::string
+			     > stream_types;
+   
+#if 0   
+  typedef boost::mpl::transform< number_string_types,quoted<boost::mpl::_1> >::type quoted_number_string_types ;  
+  typedef boost::mpl::insert_range<quoted_number_string_types,
+			   boost::mpl::end<quoted_number_string_types>::type,
+			   number_string_symbol_types>::type value_types;
+
+ 
+  typedef boost::mpl::transform< number_types,quoted<boost::mpl::_1> >::type quoted_number_types ;  
+  typedef boost::mpl::insert_range<quoted_number_types,
+			   boost::mpl::end<quoted_number_types>::type,
+			   number_symbol_types>::type scalar_types;
+
+  typedef boost::mpl::vector<char,int,short,long> int_types;
+  typedef boost::mpl::transform<int_types, quoted<boost::mpl::_1> >::type quoted_int_types ;  
+  typedef boost::mpl::insert_range<quoted_int_types,
+			   boost::mpl::end<quoted_int_types>::type,
+			   int_types>::type int_quote_types;
+#endif
+  
+  inline bool is_eq(symbol_type & x, symbol_type & y)  {return x==y;}
+  //bool is_eq(string_type & x, string_type & y)  {return (& x)==(& y);}  
+  template<typename T>  bool is_eq(T x, T y,typename boost::enable_if<boost::is_integral<T>, T>::type* = 0)  {return x==y;}
+  template<typename T>  bool is_eq(quoted<T> &x, quoted<T> &y,typename boost::enable_if<boost::is_integral<T>, T>::type* = 0)      {return x.value==y.value;}
+  template<typename T>  bool is_eq(quoted<T> &x, T y,typename boost::enable_if<boost::is_integral<T>, T>::type* = 0)  {return x.value==y;}
+  template<typename T>  bool is_eq(T x, quoted<T> &y,typename boost::enable_if<boost::is_integral<T>, T>::type* = 0)  {return x==y.value;}  
+  template<typename T>  bool is_eq(T & x, T & y,typename boost::disable_if<typename boost::mpl::contains <int_quote_types,T>::type >::type* =0)  {return (&x)==(&y);}
+  template<typename T1,typename T2>  bool is_eq(T1 x, T2 y){return false;}
+
+
+  //bool is_eqv(string_type & x, string_type & y)  {return x==y;}  
+  inline bool is_eqv(symbol_type & x, symbol_type & y)  {return x==y;}
+  inline bool is_eqv(rational & x, rational & y)  {return x==y;}
+  inline bool is_eqv(quoted<rational > & x, rational & y)  {return x.value==y;}
+  inline bool is_eqv(rational  & x, quoted<rational > & y)  {return x==y.value;}
+  inline bool is_eqv(quoted<rational > & x, quoted<rational > & y)  {return x.value==y.value;}  
+  template<typename T> bool is_eqv(T x, T y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0)  {return x==y;}
+  template<typename T> bool is_eqv(quoted<T> &x, quoted<T> &y ,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0)  {return x.value==y.value;}
+  template<typename T> bool is_eqv(quoted<T> &x, T y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0)  {return x.value==y;}
+  template<typename T> bool is_eqv(T x, quoted<T> &y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0)  {return x==y.value;}
+  template<typename T> bool is_eqv(T & x, T & y,typename boost::disable_if<typename boost::mpl::contains <scalar_types,T>::type >::type* =0)  {return (&x)==(&y);}
+  template<typename T1,typename T2> bool is_eqv(T1 x, T2 y){return false;}
+
+
+  template<typename T1,typename T2> bool is_equal(const T1 & x, const T2 & y){return false;}
+  template<typename T> bool is_equal(const T & x,const T & y){return ( ( x ) == ( y ) );}
+  template<typename T> bool is_equal(const quoted<T> &x, const quoted<T> &y) {return is_equal(x.value,y.value);} ////////////
+  //template<> bool is_equal(string_type & x, string_type & y)   {return x==y;}
+  //template<> bool is_equal(symbol_type & x, symbol_type & y)   {return x==y;}  
+  
+  // //bool is_equal(quoted<symbol_type> & x, quoted<symbol_type> & y)   {return x.value==y.value;}  
+  // template<typename T> bool is_equal(T  x, T  y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0) {return x==y;}
+
+  // //template<typename T> bool is_equal(T &x, T &y,typename boost::disable_if<boost::is_arithmetic<T>, T>::type* = 0) {return x==y;}
+  //template<typename T> bool is_equal(quoted<T> &x, T y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0) {return x.value==y;}
+  //template<typename T> bool is_equal(T x, quoted<T> &y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0) {return x==y.value;}
+  // //template<typename T> bool is_equal(quoted<T> &x, quoted<T> &y,typename boost::enable_if<boost::is_arithmetic<T>, T>::type* = 0) {return x.value==y.value;}
+  template<typename T> bool is_equal(const quoted<T> &x,const T & y
+   				     ,typename boost::enable_if<typename boost::mpl::contains <
+				       //not_c_number_string_types
+				       number_string_types
+				       ,T>::type >::type* =0)   {return x.value==y;}
+  template<typename T> bool is_equal(const T & x,const quoted<T> &y
+   				     ,typename boost::enable_if<typename boost::mpl::contains <
+				       //not_c_number_string_types
+				       number_string_types
+				       ,T>::type >::type* =0)  {return x==y.value;}
+  // // template<typename T> bool is_equal(quoted<T> & x, quoted<T> &y
+  // // 				     ,typename boost::enable_if<typename boost::mpl::contains <not_c_number_string_types,T>::type >::type* =0)  {return x.value==y.value;}
+
+
+  // // template<typename T> bool is_equal(quoted<T> &x, quoted<T> &y
+  // // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T>::type >::type* =0)
+  // // {return is_equal(x.value,y.value);} 
+  // // template<typename T> bool is_equal(T &x, quoted<T> &y
+  // // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T>::type >::type* =0)
+  // // {return is_equal(x,y.value);} 
+
+  // // template<typename T> bool is_equal(quoted<T> &x, T &y
+  // // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T>::type >::type* =0)
+  // // {return is_equal(x.value,y);} 
+  // // template<typename T1,typename T2> bool is_equal(quoted<T1> &x, quoted<T2> &y
+  // // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T1>::type >::type* =0
+  // // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T2>::type >::type* =0
+  // // 						  )
+  // // {return is_equal(x.value,y.value);}
+  // template<typename T> bool is_equal(T & x, T & y
+  // 				     ,typename boost::disable_if<typename boost::mpl::contains <value_types,T>::type >::type* =0)  
+  // {return x==y;}
+  // 				       //number_string_symbol_types
+
+
+
+
+  ///////variant shrink  begin
+
+  //typedef boost::mpl::vector<int,rational,float,double,long double,std::complex<double> >::type scheme_ordered_number_types;
+  //typedef scheme_ordered_number_types ordered_number_types;
+  typedef boost::mpl::vector<int,rational,float,double,std::complex<double>  >::type default_type_order;
+
+
+
+////////////mpl general util begin
+
+template<typename TypeVec>
+struct is_mpl_sequence_single : 
+  boost::is_same<
+  typename boost::mpl::size<TypeVec>::type
+  ,typename boost::mpl::long_<1> >
+ {};
+
+template<typename TypeVec>
+struct mpl_sequence_if_single_then_element_else_variant : public
+  boost::mpl::if_<
+  typename is_mpl_sequence_single<TypeVec>::type
+  ,
+  typename 
+  boost::mpl::front<TypeVec>//::type
+  //,typename TypeVec::type
+  //,TypeVec
+  ,typename boost::make_variant_over<TypeVec>
+  >::type
+{};
+
+  template<typename TypeVec,typename IsLess>
+  struct max_in_mpl_sequence_given_is_less_lambda : public 
+  boost::mpl::fold<
+    TypeVec
+    ,typename boost::mpl::front<TypeVec>::type
+    ,boost::mpl::if_<
+       boost::mpl::bind2<IsLess,boost::mpl::_1 , boost::mpl::_2 >
+       //typename boost::mpl::apply<IsLess,boost::mpl::_1 , boost::mpl::_2 >//::type
+       //typename IsLess::apply< boost::mpl::_1 , boost::mpl::_2 >
+       //boost::mpl::true_
+       ,boost::mpl::_2 , boost::mpl::_1 >
+    >
+  {};
+
+
+  template<typename TypeVec,typename TypeOrder>
+  struct mpl_vector_contains_filter : boost::mpl::filter_view<
+    TypeVec
+    ,boost::mpl::contains<TypeOrder,boost::mpl::_1>
+    >
+  {};
+
+  template<typename TypeVec,typename TypeOrder>
+  struct mpl_vector_not_contains_filter : boost::mpl::filter_view<
+    TypeVec
+    ,boost::mpl::not_<boost::mpl::contains<TypeOrder,boost::mpl::_1> >
+    >
+  {};
+
+
+
+////////////mpl general util end
+
+
+
+   template<typename T1,typename T2,typename TypeOrder>
+   struct is_less_in_orderd_mpl_sequence :
+     boost::is_same <
+     typename boost::mpl::find<      
+      typename  boost::mpl::iterator_range<
+	typename boost::mpl::find<TypeOrder,T2>::type , 
+	typename boost::mpl::end<TypeOrder>::type
+	>::type , 
+      T1 >::type, 
+    typename boost::mpl::end<TypeOrder>::type >
+  {};
+
+  typedef boost::mpl::lambda<is_less_in_orderd_mpl_sequence<boost::mpl::_1 , boost::mpl::_2 , default_type_order> >::type is_less_over_default_type_order_mpl_lambda;
+
+
+  template<typename T1,typename TBase,typename TypeOrder>
+   struct is_generalizable_to_using_generaize_order_sequence :
+     boost::mpl::if_<
+     typename 
+     boost::mpl::contains<TypeOrder,T1>::type
+     ,
+     typename
+     boost::mpl::if_<
+	typename 
+	boost::mpl::contains<TypeOrder,TBase>::type
+	,
+	//typename 
+	is_less_in_orderd_mpl_sequence<T1,TBase,TypeOrder> //::type
+	,
+	//typename 
+	boost::mpl::false_ //::type 
+	>::type
+     ,
+     //typename 
+     boost::mpl::false_ //::type 
+     > ::type
+  {};
+
+template<typename TypeOrder>
+struct generate_mpl_lambda_is_generalizable_to_from_type_order_sequence
+{ typedef typename boost::mpl::lambda<is_generalizable_to_using_generaize_order_sequence<boost::mpl::_1 , boost::mpl::_2 , TypeOrder> >::type type;
+};
+
+//typedef boost::mpl::lambda<is_generalizable_to_using_generaize_order_sequence<boost::mpl::_1 , boost::mpl::_2 , default_type_order> >::type is_generalizable_using_default_type_order_mpl_lambda;
+
+typedef generate_mpl_lambda_is_generalizable_to_from_type_order_sequence<default_type_order>::type is_generalizable_using_default_type_order_mpl_lambda;
+
+
+//template<typename TypeVec,typename Greater>
+template<typename TypeVec,typename TypeBase,typename IsGeneralizable>
+  struct generalize_type_sequence_to_base : 
+  boost::mpl::transform<
+    TypeVec
+    ,boost::mpl::if_<
+       boost::mpl::bind2<IsGeneralizable,boost::mpl::_1 , TypeBase >
+       ,TypeBase
+       ,boost::mpl::_1>
+   >
+  {};
+
+
+template<typename TypeVec,typename IsGeneralizable>
+struct generaize_type_sequence_using_is_generalizable_to : 
+  boost::mpl::fold<
+  TypeVec
+  ,TypeVec
+  ,
+  //typename 
+  generalize_type_sequence_to_base<boost::mpl::_1,boost::mpl::_2,IsGeneralizable > //::type
+  >::type
+{};
+
+  
+template<typename TypeVec,typename IsGeneralizable=is_generalizable_using_default_type_order_mpl_lambda >
+struct make_variant_shrink_over : public
+//mpl_sequence_if_single_to_element
+mpl_sequence_if_single_then_element_else_variant<
+  typename 
+  boost::mpl::unique<
+    typename 
+    generaize_type_sequence_using_is_generalizable_to<TypeVec,IsGeneralizable>::type
+    ,boost::is_same<boost::mpl::_1,boost::mpl::_2>
+    >::type
+  >//::type
+  {};
+
+
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+typename max_in_mpl_sequence_given_is_less_lambda<
+  typename 
+  boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >::types
+  ,is_generalizable_using_default_type_order_mpl_lambda>::type 
+get_number(boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& x)
+{
+  return boost::get<
+    typename max_in_mpl_sequence_given_is_less_lambda<
+      typename 
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >::types
+      ,is_generalizable_using_default_type_order_mpl_lambda>::type
+    >(x);  
+}
+
+
+
+template<typename T>
+T & get_number(boost::optional<T &> x) {  return *x;}
+
+template<typename T>
+T & get_number(boost::optional<const T &> x) {  return *x;}
+
+
+template<typename T>
+T  get_number(boost::optional<T > x) {  return *x;}
+
+template<typename T>
+T get_number(T x)
+{ 
+  return x;
+}
+
+
+
+template<typename T> boost::optional<T &> 
+optional_attach(T &x) { boost::optional<T &> y(x); return y; }
+
+template<typename T> boost::optional<T &>  
+optional_attach(const T &x) 
+{ boost::optional<T &> y(const_cast<T &>(x)); return y; }
+
+
+
+
+
+  // template<typename Seq,typename X>
+  // struct mpl_adjoin_copy_vector : public 
+  // boost::mpl::fold<
+  //   //typename TypeVec::type ,
+  //   Seq ,
+  //   //typename Seq::type ,
+  //   boost::mpl::vector1<X> ,
+  //   //boost::mpl::insert<boost::mpl::_1,boost::mpl::_2>
+  //   boost::mpl::push_back<boost::mpl::_1,boost::mpl::_2> //::type
+  //   //boost::mpl::push_front<boost::mpl::_1 , boost::mpl::_2 >
+  //   >
+  // {};
+
+
+  ///////variant shrink end
+
+
+
+
+
+
+
+
+#if CONSED_AS_STD_PAIR
+#undef consd
+#endif
+
+  
+  
+}
+
+
+//template<class T>void Func(T arg1, typename ::boost::enable_if_c< ::boost::is_same<T, int>::value >::type* =0) { ... }
+
+//template<class T>void Func(T arg1, typename ::boost::enable_if_c< ::boost::is_same<T, string>::value >::type* =0) { ... }
+
+template<typename F,typename ResultType>
+  struct promise
+  {
+    //need partial specialization or enable_if    
+    //typedef typename boost::function_types::result_type<F>::type result_type;
+    //typedef typename F::result_type result_type;    
+    typedef ResultType result_type;
+    result_type result;
+    bool is_evaled;    
+    F f;
+    promise(F & _f):f(_f),is_evaled(false){}
+    inline result_type operator()(){ 
+      if(is_evaled)
+	return result;
+      else{	
+	result=f();
+	is_evaled=true;	
+	return result;
+      }}
+};
+
+
+
+
+#ifdef BOOST_NO_DECLTYPE
+
+template<typename F> promise<F,typename boost::function_types::result_type<F>::type> make_promise(F &f){  return promise<F,typename boost::function_types::result_type<F>::type>(f);}
+template<typename ResultType,typename F> promise<F,ResultType> make_promise(F f){  return promise<F,ResultType>(f);}
+#else
+
+template<typename F> auto make_promise(F f) -> promise<F,decltype(f())>{return promise<F,decltype(f())>(f);}
+
+#endif
+
+template<typename F> promise<boost::function<F>,typename boost::function<F>::result_type> make_promise(boost::function<F> &f){  return promise<boost::function<F>,typename boost::function<F>::result_type>(f);}
+
+
+#ifdef BOOST_NO_DECLTYPE
+#else
+// By reference: a promise memoises into itself, so forcing a copy computes
+// the value again and leaves the original still unevaluated. Taking it by
+// value made (force p) twice run the body twice, which is exactly what a
+// promise is for not doing. The const overload serves promises reached
+// through a const reference; those cannot memoise, but they still yield
+// the right value.
+template<typename PromiseType>
+auto force(PromiseType & promise) -> decltype(promise())
+{
+  return promise();
+}
+template<typename PromiseType>
+auto force(const PromiseType & promise) -> decltype(PromiseType(promise)())
+{
+  PromiseType copy(promise);
+  return copy();
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Delayed streams as a nominal type whose recursion is erased through
+// std::function. Expanding the type structurally yields an infinite type and
+// the occurs check rejects it; naming it lets unification compare element
+// types in a single step, so inference terminates.
+namespace scm2cpp {
+
+  template<typename T> struct stream_cell {
+    typedef T value_type;
+    T head;
+    std::function<stream_cell<T>()> tail;
+    stream_cell(){}
+    stream_cell(const T& h, const std::function<stream_cell<T>()>& t)
+      : head(h), tail(t) {}
+  };
+
+  // Corresponds to (cons a (delay b)); wraps b without evaluating it.
+  template<typename T, typename F>
+  stream_cell<T> make_stream(const T& h, F f) {
+    return stream_cell<T>(h, std::function<stream_cell<T>()>(f));
+  }
+
+  template<typename T> T car(const stream_cell<T>& s) { return s.head; }
+  template<typename T> std::function<stream_cell<T>()> cdr(const stream_cell<T>& s) { return s.tail; }
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+#endif // SCM2CPP_MINIMAL
+
+// An n-dimensional summed-area table.  Built once over a flat row-major
+// array, it answers the sum over any axis-aligned box in O(2^n) additions
+// by inclusion-exclusion, instead of O(volume) by looping.  The table is a
+// representation an inferencer may choose for an array whose only reads
+// are box sums; the choice is valid only if every write precedes the
+// first query, which build() makes explicit.
+namespace scm2cpp {
+
+  // A (vector e ...) literal: the arity is the array's extent, so the
+  // whole thing is one fixed-size value. Elements are cast to the first
+  // element's type, mirroring the inference rule that types the literal
+  // from its first element.
+  template<typename T>
+  inline std::array<T, 1> make_array(T e0)
+  { std::array<T, 1> a = {{ e0 }}; return a; }
+  template<typename T, typename... Es>
+  inline std::array<T, 1 + sizeof...(Es)> make_array(T e0, Es... es)
+  { std::array<T, 1 + sizeof...(Es)> a = {{ e0, static_cast<T>(es)... }}; return a; }
+
+  // (make-vector N v) with a literal extent: one fixed-size value with
+  // every element v.  What boost::assign::list_of used to spell.
+  template<typename T, std::size_t N>
+  inline std::array<T, N> filled_array(T v)
+  { std::array<T, N> a; a.fill(v); return a; }
+
+  // Dynamic-extent array parameters as views.  A span is one pointer:
+  // host code converts to it implicitly from std::vector or std::array,
+  // device code from a raw device pointer, and the callee indexes it
+  // the same either way.  Writes go to the caller's memory -- what the
+  // reference parameter meant, without the container crossing into
+  // device code.  The generated subset never resizes or measures a
+  // parameter, so a pointer is the whole interface.
+  // n is the length when the span was made from a container (or given
+  // one), 0 when only a pointer was; the --cuda back end needs it to copy
+  // the elements, nothing else reads it.
+  template<typename T> struct span {
+    T* p;
+    std::size_t n;
+    SCM2CPP_FN span(T* p) : p(p), n(0) {}
+    SCM2CPP_FN span(T* p, std::size_t n) : p(p), n(n) {}
+    span(std::vector<T>& v) : p(v.data()), n(v.size()) {}
+    template<std::size_t N> span(std::array<T, N>& a) : p(a.data()), n(N) {}
+    SCM2CPP_FN T& operator[](std::size_t i) const { return p[i]; }
+    T* data() const { return p; }
+    std::size_t size() const { return n; }
+  };
+  template<typename T> struct cspan {
+    const T* p;
+    std::size_t n;
+    SCM2CPP_FN cspan(const T* p) : p(p), n(0) {}
+    SCM2CPP_FN cspan(const T* p, std::size_t n) : p(p), n(n) {}
+    cspan(span<T> s) : p(s.p), n(s.n) {}
+    cspan(const std::vector<T>& v) : p(v.data()), n(v.size()) {}
+    template<std::size_t N> cspan(const std::array<T, N>& a) : p(a.data()), n(N) {}
+    SCM2CPP_FN const T& operator[](std::size_t i) const { return p[i]; }
+    const T* data() const { return p; }
+    std::size_t size() const { return n; }
+  };
+
+  // A memo for a pure call: (memo-call M E KEY ...) is
+  //   memo_get(M, memo_key().add(KEY)...str(), [&]() { return E; })
+  // M a hash table from the key's bytes to E's value (the translator's
+  // (make-hash), an std::unordered_map<std::string, V>), so E runs once
+  // per distinct key.  A key is scalars by value and, through
+  // add_range, the first N elements of an array -- the index set a
+  // gather read, say.  The bytes are the values' object representation,
+  // so 0.0 and -0.0 are different keys (a miss, never a wrong hit).
+  struct memo_key {
+    std::string b;
+    template<typename T> memo_key& add(const T& v) {
+      b.append(reinterpret_cast<const char*>(&v), sizeof(T));
+      return *this;
+    }
+    template<typename V> memo_key& add_range(const V& v, long n) {
+      add(n);
+      for (long i = 0; i < n; ++i) add(v[i]);
+      return *this;
+    }
+    const std::string& str() const { return b; }
+  };
+  template<typename M, typename F>
+  inline typename M::mapped_type memo_get(M& m, const std::string& k, F f) {
+    auto it = m.find(k);
+    if (it != m.end()) return it->second;
+    typename M::mapped_type v = f();
+    m.emplace(k, v);
+    return v;
+  }
+
+  template<typename T, int N> struct integral_image {
+    std::vector<T> table;      // padded with a zero border: dim[k]+1 per axis
+    int dim[N];                // extents of the source array
+    int stride[N];             // strides of the padded table, innermost last
+
+    integral_image() { for (int k = 0; k < N; ++k) { dim[k] = 0; stride[k] = 0; } }
+
+    // src is the flat row-major source; dims its extents, slowest axis first.
+    template<typename Src>
+    void build(const Src& src, const int (&dims)[N]) {
+      std::size_t total = 1;
+      for (int k = N; k-- > 0; ) {
+        dim[k] = dims[k];
+        stride[k] = int(total);
+        total *= std::size_t(dims[k] + 1);
+      }
+      table.assign(total, T(0));
+      // Fill: table[i0+1,..] = src[i0,..], then prefix-sum along each axis.
+      std::size_t count = 1;
+      for (int k = 0; k < N; ++k) count *= std::size_t(dim[k]);
+      for (std::size_t s = 0; s < count; ++s) {
+        std::size_t rem = s, t = 0;
+        for (int k = N; k-- > 0; ) {
+          int i = int(rem % std::size_t(dim[k])); rem /= std::size_t(dim[k]);
+          t += std::size_t(i + 1) * std::size_t(stride[k]);
+        }
+        table[t] = src[s];
+      }
+      for (int k = 0; k < N; ++k)
+        for (std::size_t t = 0; t < total; ++t)
+          if (int(t / std::size_t(stride[k])) % (dim[k] + 1) != 0)
+            table[t] += table[t - std::size_t(stride[k])];
+    }
+
+    // Sum of the source over the closed box [lo[k], hi[k]] on every axis.
+    T query(const int (&lo)[N], const int (&hi)[N]) const {
+      T acc = T(0);
+      for (unsigned corner = 0; corner < (1u << N); ++corner) {
+        std::size_t t = 0; int sign = 1;
+        for (int k = 0; k < N; ++k) {
+          int edge = (corner >> k) & 1 ? lo[k] : hi[k] + 1;   // 0..dim[k]
+          if ((corner >> k) & 1) sign = -sign;
+          t += std::size_t(edge) * std::size_t(stride[k]);
+        }
+        acc += sign > 0 ? table[t] : T(0) - table[t];
+      }
+      return acc;
+    }
+
+    // The two-dimensional case, spelled out for the generated code.
+    T query2(int i0, int i1, int j0, int j1) const {
+      const int lo[2] = { i0, j0 }, hi[2] = { i1, j1 };
+      return query(lo, hi);
+    }
+  };
+
+
+  // Operator tags for monoid_table: the fold's operation as a type, so
+  // the loop bodies inline with no function-pointer indirection.
+  template<typename T> struct mt_add { static T op(T a, T b) { return a + b; } };
+  template<typename T> struct mt_mul { static T op(T a, T b) { return a * b; } };
+  template<typename T> struct mt_min { static T op(T a, T b) { return a < b ? a : b; } };
+  template<typename T> struct mt_max { static T op(T a, T b) { return a < b ? b : a; } };
+
+  // The integral image generalised to a commutative monoid: the same
+  // padded table, the borders holding the identity instead of zero, the
+  // axis scans folding with OP. What is answerable shrinks with the
+  // structure: prefix() reads an origin-anchored box straight out of the
+  // table and needs nothing but associativity and an identity, which is
+  // why -I can take any catalogued operator through here; the
+  // inclusion-exclusion query of integral_image needs subtraction and
+  // stays with the additive group.
+  template<typename T, int N, typename OP> struct monoid_table {
+    std::vector<T> table;
+    int dim[N];
+    int stride[N];
+
+    monoid_table() { for (int k = 0; k < N; ++k) { dim[k] = 0; stride[k] = 0; } }
+
+    template<typename Src>
+    void build(const Src& src, const int (&dims)[N], T id) {
+      std::size_t total = 1;
+      for (int k = N; k-- > 0; ) {
+        dim[k] = dims[k];
+        stride[k] = int(total);
+        total *= std::size_t(dims[k] + 1);
+      }
+      table.assign(total, id);
+      std::size_t count = 1;
+      for (int k = 0; k < N; ++k) count *= std::size_t(dim[k]);
+      for (std::size_t s = 0; s < count; ++s) {
+        std::size_t rem = s, t = 0;
+        for (int k = N; k-- > 0; ) {
+          int i = int(rem % std::size_t(dim[k])); rem /= std::size_t(dim[k]);
+          t += std::size_t(i + 1) * std::size_t(stride[k]);
+        }
+        table[t] = src[s];
+      }
+      for (int k = 0; k < N; ++k)
+        for (std::size_t t = 0; t < total; ++t)
+          if (int(t / std::size_t(stride[k])) % (dim[k] + 1) != 0)
+            table[t] = OP::op(table[t - std::size_t(stride[k])], table[t]);
+    }
+
+    // The fold of the source over the origin-anchored box [0, hi[k]] on
+    // every axis: one table read, no inverse anywhere.
+    T prefix(const int (&hi)[N]) const {
+      std::size_t t = 0;
+      for (int k = 0; k < N; ++k)
+        t += std::size_t(hi[k] + 1) * std::size_t(stride[k]);
+      return table[t];
+    }
+  };
+
+  // (integral-image v n m) in the generated code: build a rank-2 table.
+  template<typename T, typename Src>
+  integral_image<T,2> make_integral_image2(const Src& src, int n, int m) {
+    integral_image<T,2> ii;
+    const int dims[2] = { n, m };
+    ii.build(src, dims);
+    return ii;
+  }
+
+}
+
+#endif
+
+//Copyright (C) 2011-2026  Hirotaka Niitsuma
+//
+//This header is part of Scm2Cpp and is distributed under the MIT License.
+//See the LICENSE file in the project root for the full text.
+//
+//Note: this header is included into the C++ that Scm2Cpp generates, and so
+//becomes part of the user's program. The MIT terms were chosen so that this
+//imposes no obligation on that program beyond preserving this notice.