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

Subject: [Boost-commit] svn:boost r61179 - trunk/libs/spirit/example/scheme/test
From: joel_at_[hidden]
Date: 2010-04-10 10:55:03

Author: djowel
Date: 2010-04-10 10:55:03 EDT (Sat, 10 Apr 2010)
New Revision: 61179
URL: http://svn.boost.org/trac/boost/changeset/61179

Log:
cleanup
Text files modified: 
   trunk/libs/spirit/example/scheme/test/scheme.cpp |   140 +++++++++++++++++++-------------------- 
   1 files changed, 67 insertions(+), 73 deletions(-)

Modified: trunk/libs/spirit/example/scheme/test/scheme.cpp
==============================================================================
--- trunk/libs/spirit/example/scheme/test/scheme.cpp	(original)
+++ trunk/libs/spirit/example/scheme/test/scheme.cpp	2010-04-10 10:55:03 EDT (Sat, 10 Apr 2010)
@@ -22,6 +22,7 @@
 #include <map>
 #include <boost/function.hpp>
 #include <boost/foreach.hpp>
+#include <boost/bind.hpp>
 
 namespace scheme
 {
@@ -44,10 +45,10 @@
     ///////////////////////////////////////////////////////////////////////////
     // values
     ///////////////////////////////////////////////////////////////////////////
-    struct value_impl
+    struct value
     {
         utree val;
-        value_impl(utree const& val) : val(val) {}
+        value(utree const& val) : val(val) {}
 
         typedef utree result_type;
         utree operator()(utree const& /*args*/) const
@@ -56,18 +57,24 @@
         }
     };
 
-    inline function val(utree const& val)
+    struct value_composer
     {
-        return function(value_impl(val));
-    }
+        typedef function result_type;
+        function operator()(utree const& val) const
+        {
+            return function(value(val));
+        }
+    };
+
+    value_composer const val = {};
 
     ///////////////////////////////////////////////////////////////////////////
     // arguments
     ///////////////////////////////////////////////////////////////////////////
-    struct argument_impl
+    struct argument
     {
         int n;
-        argument_impl(int n) : n(n) {}
+        argument(int n) : n(n) {}
 
         typedef utree result_type;
         utree operator()(utree const& args) const
@@ -76,101 +83,72 @@
         }
     };
 
-    inline function arg(int n)
-    {
-        return function(argument_impl(n));
-    }
-
-    struct make_arg
+    struct argument_composer
     {
-        int n;
-        make_arg(int n) : n(n) {}
-
         typedef function result_type;
-        function operator()(function_list& operands)
+        function operator()(int n) const
         {
-            // check arity here!
-            return function(argument_impl(n));
+            return function(argument(n));
         }
     };
 
+    argument_composer const arg = {};
+
     ///////////////////////////////////////////////////////////////////////////
-    // reference
+    // composite
     ///////////////////////////////////////////////////////////////////////////
-    struct reference_impl
+    struct composite
     {
-        function& f;
-        reference_impl(function& f) : f(f) {}
-
-        typedef utree result_type;
-        utree operator()(utree const& args) const
-        {
-            return f(args);
-        }
+        function_list elements;
+        composite(function_list const& elements)
+          : elements(elements) {}
     };
 
-    inline function ref(function& f)
-    {
-        return function(reference_impl(f));
-    }
-
     ///////////////////////////////////////////////////////////////////////////
     // plus
     ///////////////////////////////////////////////////////////////////////////
-    struct plus_impl
+    struct plus_function : composite
     {
-        function_list operands;
-
-        plus_impl(function_list& operands_)
-        {
-            // we take ownership of the operands
-            operands_.swap(operands);
-        }
+        plus_function(function_list& elements)
+          : composite(elements) {}
 
         typedef utree result_type;
         utree operator()(utree const& args) const
         {
             utree result(0);
-            BOOST_FOREACH(function const& operand, operands)
+            BOOST_FOREACH(function const& element, elements)
             {
-                result = result + operand(args);
+                result = result + element(args);
             }
             return result;
         }
     };
 
-    struct make_plus
+    struct plus_composer
     {
         typedef function result_type;
-        function operator()(function_list& operands)
+        function operator()(function_list& elements)
         {
-            // check arity here!
-            return function(plus_impl(operands));
+            return function(plus_function(elements));
         }
     };
 
-    make_plus const plus = {};
+    plus_composer const plus = {};
 
     ///////////////////////////////////////////////////////////////////////////
-    // fcall
+    // call
     ///////////////////////////////////////////////////////////////////////////
-    struct fcall_impl
+    struct call_function : composite
     {
         function f;
-        function_list operands;
-
-        fcall_impl(function const& f, function_list& operands_)
-          : f(f)
-        {
-            // we take ownership of the operands
-            operands_.swap(operands);
-        }
+        call_function(function const& f, function_list& elements)
+          : composite(elements), f(f) {}
 
         typedef utree result_type;
         utree operator()(utree const& args) const
         {
             utree fargs;
-            BOOST_FOREACH(function const& operand, operands)
+            BOOST_FOREACH(function const& operand, elements)
             {
                 fargs.push_back(operand(args));
             }
@@ -178,25 +156,43 @@
         }
     };
 
-    struct make_fcall
+    struct call_composer
     {
         function f;
         int arity;
-        make_fcall(function const& f, int arity)
+        call_composer(function const& f, int arity)
           : f(f), arity(arity) {}
 
         typedef function result_type;
-        function operator()(function_list& operands)
+        function operator()(function_list& elements)
         {
             // $$$ use throw $$$
-            BOOST_ASSERT(operands.size() == arity);
-            return function(fcall_impl(f, operands));
+            BOOST_ASSERT(elements.size() == arity);
+            return function(call_function(f, elements));
         }
     };
 
+    inline call_composer const call(function const& f, int arity)
+    {
+        return call_composer(f, arity);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////
 //  The compiler
 ///////////////////////////////////////////////////////////////////////////////
+    //~ struct make_arg
+    //~ {
+        //~ int n;
+        //~ make_arg(int n) : n(n) {}
+
+        //~ typedef function result_type;
+        //~ function operator()(function_list& elements)
+        //~ {
+            //~ // check arity here!
+            //~ return function(argument(n));
+        //~ }
+    //~ };
+
     typedef boost::function<function(function_list&)> make_function;
 
     struct compiler_environment
@@ -269,17 +265,17 @@
         {
             compiler_environment local_env(env);
             for (std::size_t i = 0; i < args.size(); ++i)
-                local_env.define(args[i], make_arg(i));
-            make_fcall mf(compile(body, local_env), args.size());
-            env.define(name, make_function(mf));
+                local_env.define(args[i], boost::bind(arg, i));
+            env.define(name,
+                make_function(call(compile(body, local_env), args.size())));
         }
 
         void define_nullary_function(
             std::string const& name,
             utree const& body) const
         {
-            make_fcall mf(compile(body, env), 0);
-            env.define(name, make_function(mf));
+            env.define(name,
+                make_function(call(compile(body, env), 0)));
         }
 
         template <typename Iterator>
@@ -294,8 +290,6 @@
                 {
                     // a function
                     utree const& decl = *i++;
-
-
                     Iterator di = decl.begin();
                     std::string fname(get_symbol(*di++));
                     std::vector<std::string> args;
@@ -344,7 +338,7 @@
 
     void build_basic_environment(compiler_environment& env)
     {
-        env.define("+", make_plus());
+        env.define("+", plus_composer());
     }
 }