[Boost-commit] svn:boost r61238 - trunk/libs/spirit/example/scheme

Subject: [Boost-commit] svn:boost r61238 - trunk/libs/spirit/example/scheme
From: joel_at_[hidden]
Date: 2010-04-13 01:50:15

Author: djowel
Date: 2010-04-13 01:50:15 EDT (Tue, 13 Apr 2010)
New Revision: 61238
URL: http://svn.boost.org/trac/boost/changeset/61238

Log:
good to go!
Text files modified: 
   trunk/libs/spirit/example/scheme/scheme_interpreter.hpp |   159 ++++++++++++++++++++++++++++++++++----- 
   trunk/libs/spirit/example/scheme/scheme_intinsics.hpp   |    99 ++++--------------------                
   2 files changed, 153 insertions(+), 105 deletions(-)

Modified: trunk/libs/spirit/example/scheme/scheme_interpreter.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/scheme_interpreter.hpp	(original)
+++ trunk/libs/spirit/example/scheme/scheme_interpreter.hpp	2010-04-13 01:50:15 EDT (Tue, 13 Apr 2010)
@@ -89,10 +89,10 @@
     ///////////////////////////////////////////////////////////////////////////
     // values
     ///////////////////////////////////////////////////////////////////////////
-    struct value
+    struct value_function
     {
         utree val;
-        value(utree const& val) : val(val) {}
+        value_function(utree const& val) : val(val) {}
 
         typedef utree result_type;
         utree operator()(args_type /*args*/) const
@@ -101,24 +101,24 @@
         }
     };
 
-    struct value_composer
+    struct value
     {
         typedef actor result_type;
         actor operator()(utree const& val) const
         {
-            return actor(value(val));
+            return actor(value_function(val));
         }
     };
 
-    value_composer const val = {};
+    value const val = {};
 
     ///////////////////////////////////////////////////////////////////////////
     // arguments
     ///////////////////////////////////////////////////////////////////////////
-    struct argument
+    struct argument_function
     {
-        int n;
-        argument(int n) : n(n) {}
+        std::size_t n;
+        argument_function(std::size_t n) : n(n) {}
 
         typedef utree result_type;
         utree operator()(args_type args) const
@@ -127,16 +127,16 @@
         }
     };
 
-    struct argument_composer
+    struct argument
     {
         typedef actor result_type;
-        actor operator()(int n) const
+        actor operator()(std::size_t n) const
         {
-            return actor(argument(n));
+            return actor(argument_function(n));
         }
     };
 
-    argument_composer const arg = {};
+    argument const arg = {};
     actor const _1 = arg(0);
     actor const _2 = arg(1);
     actor const _3 = arg(2);
@@ -151,17 +151,6 @@
     ///////////////////////////////////////////////////////////////////////////
     // composite
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    inline actor as_function(T const& val)
-    {
-        return scheme::val(utree(val));
-    }
-
-    inline actor const& as_function(actor const& f)
-    {
-        return f;
-    }
-
     template <typename Derived>
     struct composite
     {
@@ -197,6 +186,130 @@
         {
             return *static_cast<Derived const*>(this);
         }
+
+        template <typename T>
+        static actor as_function(T const& val)
+        {
+            return scheme::val(utree(val));
+        }
+
+        static actor const& as_function(actor const& f)
+        {
+            return f;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // unary_function
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Derived>
+    struct unary_function
+    {
+        actor a;
+        typedef unary_function<Derived> base_type;
+
+        unary_function(actor const& a)
+          : a(a) {}
+
+        typedef utree result_type;
+        utree operator()(args_type args) const
+        {
+            return derived().eval(a(args));
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    template <typename Function>
+    struct unary_composite : composite<unary_composite<Function> >
+    {
+        using base_type::operator();
+        actor operator()(actor_list const& elements) const
+        {
+            return actor(Function(elements.front()));
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // binary_function
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Derived>
+    struct binary_function
+    {
+        actor a;
+        actor b;
+        typedef binary_function<Derived> base_type;
+
+        binary_function(actor const& a, actor const& b)
+          : a(a), b(b) {}
+
+        typedef utree result_type;
+        utree operator()(args_type args) const
+        {
+            return derived().eval(a(args), b(args));
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    template <typename Function>
+    struct binary_composite : composite<binary_composite<Function> >
+    {
+        using base_type::operator();
+        actor operator()(actor_list const& elements) const
+        {
+            actor_list::const_iterator i = elements.begin();
+            actor a = *i++;
+            actor b = *i;
+            return actor(Function(a, b));
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // vararg_function
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Derived>
+    struct vararg_function : composite<Derived>
+    {
+        typedef vararg_function<Derived> base_type;
+        actor_list elements;
+        vararg_function(actor_list const& elements)
+          : elements(elements) {}
+
+        using composite<Derived>::operator();
+        utree operator()(args_type args) const
+        {
+            actor_list::const_iterator i = elements.begin();
+            utree result = (*i++)(args);
+            boost::iterator_range<actor_list::const_iterator>
+                rest(i++, elements.end());
+            BOOST_FOREACH(actor const& element, rest)
+            {
+                derived().eval(result, element(args));
+            }
+            return result;
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    template <typename Function>
+    struct vararg_composite : composite<vararg_composite<Function> >
+    {
+        using base_type::operator();
+        actor operator()(actor_list const& elements) const
+        {
+            return actor(Function(elements));
+        }
     };
 
     ///////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/spirit/example/scheme/scheme_intinsics.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/scheme_intinsics.hpp	(original)
+++ trunk/libs/spirit/example/scheme/scheme_intinsics.hpp	2010-04-13 01:50:15 EDT (Tue, 13 Apr 2010)
@@ -30,7 +30,7 @@
         }
     };
 
-    struct if_composer : composite<if_composer>
+    struct if_composite : composite<if_composite>
     {
         using base_type::operator();
         actor operator()(actor_list const& elements) const
@@ -43,71 +43,30 @@
         }
     };
 
-    if_composer const if_ = if_composer();
+    if_composite const if_ = if_composite();
 
     ///////////////////////////////////////////////////////////////////////////
     // less_than_equal
     ///////////////////////////////////////////////////////////////////////////
     struct less_than_equal_function
+      : binary_function<less_than_equal_function>
     {
-        actor a;
-        actor b;
         less_than_equal_function(actor const& a, actor const& b)
-          : a(a), b(b) {}
+          : base_type(a, b) {}
 
         typedef utree result_type;
-        utree operator()(args_type args) const
+        utree eval(utree const& a, utree const& b) const
         {
-            return a(args) <= b(args);
+            return a <= b;
         }
     };
 
-    struct less_than_equal_composer : composite<less_than_equal_composer>
-    {
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            actor_list::const_iterator i = elements.begin();
-            actor a = *i++;
-            actor b = *i;
-            return actor(less_than_equal_function(a, b));
-        }
-    };
-
-    less_than_equal_composer const less_than_equal
-        = less_than_equal_composer();
-    less_than_equal_composer const lte = less_than_equal; // synonym
-
-    ///////////////////////////////////////////////////////////////////////////
-    // vararg_function
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename Derived>
-    struct vararg_function : composite<Derived>
-    {
-        typedef vararg_function<Derived> base_type;
-        actor_list elements;
-        vararg_function(actor_list const& elements)
-          : elements(elements) {}
-
-        using composite<Derived>::operator();
-        utree operator()(args_type args) const
-        {
-            actor_list::const_iterator i = elements.begin();
-            utree result = (*i++)(args);
-            boost::iterator_range<actor_list::const_iterator>
-                rest(i++, elements.end());
-            BOOST_FOREACH(actor const& element, rest)
-            {
-                derived().eval(result, element(args));
-            }
-            return result;
-        }
+    struct less_than_equal_composite
+      : binary_composite<less_than_equal_function> {};
 
-        Derived const& derived() const
-        {
-            return *static_cast<Derived const*>(this);
-        }
-    };
+    less_than_equal_composite const less_than_equal
+        = less_than_equal_composite();
+    less_than_equal_composite const lte = less_than_equal; // synonym
 
     ///////////////////////////////////////////////////////////////////////////
     // plus
@@ -123,16 +82,8 @@
         }
     };
 
-    struct plus_composer : composite<plus_composer>
-    {
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            return actor(plus_function(elements));
-        }
-    };
-
-    plus_composer const plus = plus_composer();
+    struct plus_composite : vararg_composite<plus_function> {};
+    plus_composite const plus = plus_composite();
 
     ///////////////////////////////////////////////////////////////////////////
     // minus
@@ -148,16 +99,8 @@
         }
     };
 
-    struct minus_composer : composite<minus_composer>
-    {
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            return actor(minus_function(elements));
-        }
-    };
-
-    minus_composer const minus = minus_composer();
+    struct minus_composite : vararg_composite<minus_function> {};
+    minus_composite const minus = minus_composite();
 
     ///////////////////////////////////////////////////////////////////////////
     // times
@@ -173,16 +116,8 @@
         }
     };
 
-    struct times_composer : composite<times_composer>
-    {
-        using base_type::operator();
-        actor operator()(actor_list const& elements) const
-        {
-            return actor(times_function(elements));
-        }
-    };
-
-    times_composer const times = times_composer();
+    struct times_composite : vararg_composite<times_function> {};
+    times_composite const times = times_composite();
 }
 
 #endif