[Boost-commit] svn:boost r61012 - in trunk/libs/spirit/example/scheme: . detail test

Subject: [Boost-commit] svn:boost r61012 - in trunk/libs/spirit/example/scheme: . detail test
From: joel_at_[hidden]
Date: 2010-04-03 03:57:37

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

Log:
scheme operators
Added:
   trunk/libs/spirit/example/scheme/test/scheme.cpp   (contents, props changed)
   trunk/libs/spirit/example/scheme/utree_operators.hpp   (contents, props changed)
Text files modified: 
   trunk/libs/spirit/example/scheme/detail/utree_detail1.hpp |     2                                         
   trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp |   217 +++------------------------------------ 
   trunk/libs/spirit/example/scheme/test/utree_test.cpp      |    13 ++                                      
   trunk/libs/spirit/example/scheme/utree.hpp                |    27 ++--                                    
   4 files changed, 51 insertions(+), 208 deletions(-)

Modified: trunk/libs/spirit/example/scheme/detail/utree_detail1.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/detail/utree_detail1.hpp	(original)
+++ trunk/libs/spirit/example/scheme/detail/utree_detail1.hpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -14,6 +14,8 @@
 # pragma warning(disable: 4244)
 #endif
 
+#include <boost/type_traits/alignment_of.hpp>
+
 namespace scheme { namespace detail
 {
     template <typename UTreeX, typename UTreeY>

Modified: trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp	(original)
+++ trunk/libs/spirit/example/scheme/detail/utree_detail2.hpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -315,167 +315,6 @@
         return bind_impl<F, X>(f, x);
     }
 
-    struct utree_is_equal
-    {
-        typedef bool result_type;
-
-        template <typename A, typename B>
-        bool dispatch(const A&, const B&, boost::mpl::false_) const
-        {
-            return false; // cannot compare different types by default
-        }
-
-        template <typename A, typename B>
-        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
-        {
-            return a == b; // for arithmetic types
-        }
-
-        template <typename A, typename B>
-        bool operator()(const A& a, const B& b) const
-        {
-            return dispatch(a, b,
-                boost::mpl::and_<
-                    boost::is_arithmetic<A>,
-                    boost::is_arithmetic<B> >());
-        }
-
-        template <typename T>
-        bool operator()(const T& a, const T& b) const
-        {
-            // This code works for lists
-            return a == b;
-        }
-
-        template <typename Base, utree_type::info type_>
-        bool operator()(
-            basic_string<Base, type_> const& a,
-            basic_string<Base, type_> const& b) const
-        {
-            return static_cast<Base const&>(a) == static_cast<Base const&>(b);
-        }
-
-        bool operator()(nil, nil) const
-        {
-            return true;
-        }
-    };
-
-    struct utree_is_less_than
-    {
-        typedef bool result_type;
-
-        template <typename A, typename B>
-        bool dispatch(const A&, const B&, boost::mpl::false_) const
-        {
-            return false; // cannot compare different types by default
-        }
-
-        template <typename A, typename B>
-        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
-        {
-            return a < b; // for arithmetic types
-        }
-
-        template <typename A, typename B>
-        bool operator()(const A& a, const B& b) const
-        {
-            return dispatch(a, b,
-                boost::mpl::and_<
-                    boost::is_arithmetic<A>,
-                    boost::is_arithmetic<B> >());
-        }
-
-        template <typename T>
-        bool operator()(const T& a, const T& b) const
-        {
-            // This code works for lists
-            return a < b;
-        }
-
-        template <typename Base, utree_type::info type_>
-        bool operator()(
-            basic_string<Base, type_> const& a,
-            basic_string<Base, type_> const& b) const
-        {
-            return static_cast<Base const&>(a) < static_cast<Base const&>(b);
-        }
-
-        bool operator()(nil, nil) const
-        {
-            BOOST_ASSERT(false);
-            return false; // no less than comparison for nil
-        }
-    };
-
-    struct utree_print
-    {
-        typedef void result_type;
-
-        std::ostream& out;
-        utree_print(std::ostream& out) : out(out) {}
-
-        void operator()(scheme::nil) const
-        {
-            out << "nil";
-        }
-
-        template <typename T>
-        void operator()(T val) const
-        {
-            out << val;
-        }
-
-        void operator()(bool b) const
-        {
-            out << (b ? "true" : "false");
-        }
-
-        void operator()(binary_range const& b) const
-        {
-            out << "b";
-            out.width(2);
-            out.fill('0');
-
-            typedef binary_range::const_iterator iterator;
-            for (iterator i = b.begin(); i != b.end(); ++i)
-                out << std::hex << int((unsigned char)*i);
-            out << std::dec;
-        }
-
-        void operator()(utf8_string_range const& str) const
-        {
-            typedef utf8_string_range::const_iterator iterator;
-            iterator i = str.begin();
-            out << '"';
-            for (; i != str.end(); ++i)
-                out << *i;
-            out << '"';
-        }
-
-        void operator()(utf8_symbol_range const& str) const
-        {
-            typedef utf8_symbol_range::const_iterator iterator;
-            iterator i = str.begin();
-            for (; i != str.end(); ++i)
-                out << *i;
-        }
-
-        template <typename Iterator>
-        void operator()(boost::iterator_range<Iterator> const& range) const
-        {
-            typedef typename boost::iterator_range<Iterator>::const_iterator iterator;
-            (*this)('(');
-            for (iterator i = range.begin(); i != range.end(); ++i)
-            {
-                if (i != range.begin())
-                    (*this)(' ');
-                scheme::utree::visit(*i, *this);
-            }
-            (*this)(')');
-        }
-    };
-
     template <typename UTreeX, typename UTreeY = UTreeX>
     struct visit_impl
     {
@@ -524,6 +363,9 @@
 
                 case type::reference_type:
                     return apply(*x.p, f);
+
+                case type::function_type:
+                    return f(x.f);
             }
         }
 
@@ -577,6 +419,9 @@
 
                 case type::reference_type:
                     return apply(*x.p, y, f);
+
+                case type::function_type:
+                    return visit_impl::apply(y, detail::bind(f, x.f));
             }
         }
     };
@@ -657,6 +502,12 @@
         set_type(type::reference_type);
     }
 
+    inline utree::utree(function_ptr fptr)
+      : f(fptr)
+    {
+        set_type(type::function_type);
+    }
+
     inline utree::utree(utree const& other)
     {
         copy(other);
@@ -742,6 +593,14 @@
         return *this;
     }
 
+    inline utree& utree::operator=(function_ptr fptr)
+    {
+        free();
+        f = fptr;
+        set_type(type::function_type);
+        return *this;
+    }
+
     template <typename F>
     typename F::result_type
     inline utree::visit(utree const& x, F f)
@@ -800,42 +659,6 @@
         return detail::index_impl::apply(l.first, i);
     }
 
-    inline bool operator==(utree const& a, utree const& b)
-    {
-        return utree::visit(a, b, detail::utree_is_equal());
-    }
-
-    inline bool operator<(utree const& a, utree const& b)
-    {
-        return utree::visit(a, b, detail::utree_is_less_than());
-    }
-
-    inline bool operator!=(utree const& a, utree const& b)
-    {
-        return !(a == b);
-    }
-
-    inline bool operator>(utree const& a, utree const& b)
-    {
-        return b < a;
-    }
-
-    inline bool operator<=(utree const& a, utree const& b)
-    {
-        return !(b < a);
-    }
-
-    inline bool operator>=(utree const& a, utree const& b)
-    {
-        return !(a < b);
-    }
-
-    inline std::ostream& operator<<(std::ostream& out, utree const& x)
-    {
-        utree::visit(x, detail::utree_print(out));
-        return out;
-    }
-
     template <typename T>
     inline void utree::push_front(T const& val)
     {

Added: trunk/libs/spirit/example/scheme/test/scheme.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/scheme/test/scheme.cpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,148 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+
+#include "../input/sexpr.hpp"
+#include "../input/parse_sexpr_impl.hpp"
+#include <iostream>
+#include <fstream>
+
+inline std::ostream& println(std::ostream& out, scheme::utree const& val)
+{
+    out << val << std::endl;
+    return out;
+}
+
+#include <boost/unordered_map.hpp>
+
+namespace scheme
+{
+    class environment
+    {
+    public:
+
+        environment(environment* parent = 0)
+          : bindings(), parent(parent) {}
+
+        void define(std::string const& name, utree const& def)
+        {
+            // check for duplicate names
+            BOOST_ASSERT(bindings.find(name) == bindings.end());
+            // $$$ TODO Use exceptions $$$
+            bindings[name] = def;
+        }
+
+        utree* find(std::string const& name)
+        {
+            map::iterator i = bindings.find(name);
+            if (i == bindings.end())
+            {
+                if (parent)
+                    return parent->find(name);
+                return 0;
+            }
+            return &i->second;
+        }
+
+    private:
+
+        typedef boost::unordered_map<std::string, utree> map;
+        map bindings;
+        environment* parent;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Intrinsic functions
+    ///////////////////////////////////////////////////////////////////////////
+    struct arithmetic_function
+    {
+        typedef bool result_type;
+
+        template <typename A, typename B>
+        bool dispatch(const A&, const B&, boost::mpl::false_) const
+        {
+            return false; // cannot compare different types by default
+        }
+
+        template <typename A, typename B>
+        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
+        {
+            return a == b; // for arithmetic types
+        }
+
+        template <typename A, typename B>
+        bool operator()(const A& a, const B& b) const
+        {
+            return dispatch(a, b,
+                boost::mpl::and_<
+                    boost::is_arithmetic<A>,
+                    boost::is_arithmetic<B> >());
+        }
+    };
+
+    utree plus(environment*, utree& args)
+    {
+
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    // Ignore the BOM marking the beginning of a UTF-8 file in Windows
+    char c = in.peek();
+    if (c == '\xef')
+    {
+        char s[3];
+        in >> s[0] >> s[1] >> s[2];
+        s[3] = '\0';
+        if (s != std::string("\xef\xbb\xbf"))
+        {
+            std::cerr << "Error: Unexpected characters from input file: "
+                << filename << std::endl;
+            return 1;
+        }
+    }
+
+    scheme::utree result;
+    if (scheme::input::parse_sexpr(in, result))
+    {
+        std::cout << "success: ";
+        println(std::cout, result);
+        std::cout << std::endl;
+    }
+    else
+    {
+        std::cout << "parse error" << std::endl;
+    }
+
+    return 0;
+}
+
+

Modified: trunk/libs/spirit/example/scheme/test/utree_test.cpp
==============================================================================
--- trunk/libs/spirit/example/scheme/test/utree_test.cpp	(original)
+++ trunk/libs/spirit/example/scheme/test/utree_test.cpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -8,6 +8,7 @@
 #include <boost/config/warning_disable.hpp>
 
 #include "../utree.hpp"
+#include "../utree_operators.hpp"
 #include <iostream>
 
 inline std::ostream& println(std::ostream& out, scheme::utree const& val)
@@ -194,5 +195,17 @@
         println(std::cout, vals[2]);
     }
 
+    { // arithmetic
+        BOOST_ASSERT((utree(456) + utree(123)) == utree(456 + 123));
+        BOOST_ASSERT((utree(456) + utree(123.456)) == utree(456 + 123.456));
+        BOOST_ASSERT((utree(456) - utree(123)) == utree(456 - 123));
+        BOOST_ASSERT((utree(456) - utree(123.456)) == utree(456 - 123.456));
+        BOOST_ASSERT((utree(456) * utree(123)) == utree(456 * 123));
+        BOOST_ASSERT((utree(456) * utree(123.456)) == utree(456 * 123.456));
+        BOOST_ASSERT((utree(456) / utree(123)) == utree(456 / 123));
+        BOOST_ASSERT((utree(456) / utree(123.456)) == utree(456 / 123.456));
+        BOOST_ASSERT((utree(456) % utree(123)) == utree(456 % 123));
+    }
+
     return 0;
 }

Modified: trunk/libs/spirit/example/scheme/utree.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/utree.hpp	(original)
+++ trunk/libs/spirit/example/scheme/utree.hpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -16,8 +16,6 @@
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/range/iterator_range.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/alignment_of.hpp>
 #include <boost/ref.hpp>
 #include "detail/utree_detail1.hpp"
 
@@ -39,7 +37,8 @@
             symbol_type,
             binary_type,
             list_type,
-            reference_type
+            reference_type,
+            function_type
         };
     };
 
@@ -49,6 +48,17 @@
     struct nil {};
 
     ///////////////////////////////////////////////////////////////////////////
+    // The environment (this is forward declared)
+    ///////////////////////////////////////////////////////////////////////////
+    class environment;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Function pointer
+    ///////////////////////////////////////////////////////////////////////////
+    class utree; // forward
+    typedef utree (*function_ptr)(environment* env, utree& args);
+
+    ///////////////////////////////////////////////////////////////////////////
     // A typed string with parametric Base storage. The storage can be any
     // range or (stl container) of chars.
     ///////////////////////////////////////////////////////////////////////////
@@ -164,6 +174,7 @@
         explicit utree(char const* str, std::size_t len);
         explicit utree(std::string const& str);
         explicit utree(boost::reference_wrapper<utree> ref);
+        explicit utree(function_ptr fptr);
 
         template <typename Base, utree_type::info type_>
         explicit utree(basic_string<Base, type_> const& bin);
@@ -179,6 +190,7 @@
         utree& operator=(char const* s);
         utree& operator=(std::string const& s);
         utree& operator=(boost::reference_wrapper<utree> ref);
+        utree& operator=(function_ptr fptr);
 
         template <typename Base, utree_type::info type_>
         utree& operator=(basic_string<Base, type_> const& bin);
@@ -278,16 +290,9 @@
             int i;
             double d;
             utree* p;
+            function_ptr f;
         };
     };
-
-    bool operator==(utree const& a, utree const& b);
-    bool operator<(utree const& a, utree const& b);
-    bool operator!=(utree const& a, utree const& b);
-    bool operator>(utree const& a, utree const& b);
-    bool operator<=(utree const& a, utree const& b);
-    bool operator>=(utree const& a, utree const& b);
-    std::ostream& operator<<(std::ostream& out, utree const& x);
 }
 
 #include "detail/utree_detail2.hpp"

Added: trunk/libs/spirit/example/scheme/utree_operators.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/example/scheme/utree_operators.hpp	2010-04-03 03:57:36 EDT (Sat, 03 Apr 2010)
@@ -0,0 +1,355 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_UTREE_OPERATORS)
+#define BOOST_SPIRIT_UTREE_OPERATORS
+
+#include "utree.hpp"
+#include <boost/preprocessor/cat.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+namespace scheme
+{
+    // Available operators
+    bool operator==(utree const& a, utree const& b);
+    bool operator<(utree const& a, utree const& b);
+    bool operator!=(utree const& a, utree const& b);
+    bool operator>(utree const& a, utree const& b);
+    bool operator<=(utree const& a, utree const& b);
+    bool operator>=(utree const& a, utree const& b);
+    std::ostream& operator<<(std::ostream& out, utree const& x);
+
+    utree operator+(utree const& a, utree const& b);
+    utree operator-(utree const& a, utree const& b);
+    utree operator*(utree const& a, utree const& b);
+    utree operator/(utree const& a, utree const& b);
+    utree operator%(utree const& a, utree const& b);
+
+    // Implementation
+    struct utree_is_equal
+    {
+        typedef bool result_type;
+
+        template <typename A, typename B>
+        bool dispatch(const A&, const B&, boost::mpl::false_) const
+        {
+            return false; // cannot compare different types by default
+        }
+
+        template <typename A, typename B>
+        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
+        {
+            return a == b; // for arithmetic types
+        }
+
+        template <typename A, typename B>
+        bool operator()(const A& a, const B& b) const
+        {
+            return dispatch(a, b,
+                boost::mpl::and_<
+                    boost::is_arithmetic<A>,
+                    boost::is_arithmetic<B> >());
+        }
+
+        template <typename T>
+        bool operator()(const T& a, const T& b) const
+        {
+            // This code works for lists
+            return a == b;
+        }
+
+        template <typename Base, utree_type::info type_>
+        bool operator()(
+            basic_string<Base, type_> const& a,
+            basic_string<Base, type_> const& b) const
+        {
+            return static_cast<Base const&>(a) == static_cast<Base const&>(b);
+        }
+
+        bool operator()(nil, nil) const
+        {
+            return true;
+        }
+    };
+
+    struct utree_is_less_than
+    {
+        typedef bool result_type;
+
+        template <typename A, typename B>
+        bool dispatch(const A&, const B&, boost::mpl::false_) const
+        {
+            return false; // cannot compare different types by default
+        }
+
+        template <typename A, typename B>
+        bool dispatch(const A& a, const B& b, boost::mpl::true_) const
+        {
+            return a < b; // for arithmetic types
+        }
+
+        template <typename A, typename B>
+        bool operator()(const A& a, const B& b) const
+        {
+            return dispatch(a, b,
+                boost::mpl::and_<
+                    boost::is_arithmetic<A>,
+                    boost::is_arithmetic<B> >());
+        }
+
+        template <typename T>
+        bool operator()(const T& a, const T& b) const
+        {
+            // This code works for lists
+            return a < b;
+        }
+
+        template <typename Base, utree_type::info type_>
+        bool operator()(
+            basic_string<Base, type_> const& a,
+            basic_string<Base, type_> const& b) const
+        {
+            return static_cast<Base const&>(a) < static_cast<Base const&>(b);
+        }
+
+        bool operator()(nil, nil) const
+        {
+            BOOST_ASSERT(false);
+            return false; // no less than comparison for nil
+        }
+    };
+
+    struct utree_print
+    {
+        typedef void result_type;
+
+        std::ostream& out;
+        utree_print(std::ostream& out) : out(out) {}
+
+        void operator()(scheme::nil) const
+        {
+            out << "nil";
+        }
+
+        template <typename T>
+        void operator()(T val) const
+        {
+            out << val;
+        }
+
+        void operator()(bool b) const
+        {
+            out << (b ? "true" : "false");
+        }
+
+        void operator()(binary_range const& b) const
+        {
+            out << "b";
+            out.width(2);
+            out.fill('0');
+
+            typedef binary_range::const_iterator iterator;
+            for (iterator i = b.begin(); i != b.end(); ++i)
+                out << std::hex << int((unsigned char)*i);
+            out << std::dec;
+        }
+
+        void operator()(utf8_string_range const& str) const
+        {
+            typedef utf8_string_range::const_iterator iterator;
+            iterator i = str.begin();
+            out << '"';
+            for (; i != str.end(); ++i)
+                out << *i;
+            out << '"';
+        }
+
+        void operator()(utf8_symbol_range const& str) const
+        {
+            typedef utf8_symbol_range::const_iterator iterator;
+            iterator i = str.begin();
+            for (; i != str.end(); ++i)
+                out << *i;
+        }
+
+        template <typename Iterator>
+        void operator()(boost::iterator_range<Iterator> const& range) const
+        {
+            typedef typename boost::iterator_range<Iterator>::const_iterator iterator;
+            (*this)('(');
+            for (iterator i = range.begin(); i != range.end(); ++i)
+            {
+                if (i != range.begin())
+                    (*this)(' ');
+                scheme::utree::visit(*i, *this);
+            }
+            (*this)(')');
+        }
+    };
+
+    template <typename Base>
+    struct arithmetic_function
+    {
+        typedef utree result_type;
+
+        template <typename A, typename B>
+        utree dispatch(A&, B&, boost::mpl::false_) const
+        {
+            // $$$ Throw exception here? $$$
+            return utree(); // cannot apply to different types
+        }
+
+        template <typename A, typename B>
+        utree dispatch(A& a, B& b, boost::mpl::true_) const
+        {
+            return Base::eval(a, b); // for arithmetic types
+        }
+
+        template <typename A, typename B>
+        utree operator()(A& a, B& b) const
+        {
+            return dispatch(a, b,
+                boost::mpl::and_<
+                    boost::is_arithmetic<A>,
+                    boost::is_arithmetic<B> >());
+        }
+    };
+
+    template <typename Base>
+    struct integral_function
+    {
+        typedef utree result_type;
+
+        template <typename A, typename B>
+        utree dispatch(A&, B&, boost::mpl::false_) const
+        {
+            // $$$ Throw exception here? $$$
+            return utree(); // cannot apply to different types
+        }
+
+        template <typename A, typename B>
+        utree dispatch(A& a, B& b, boost::mpl::true_) const
+        {
+            return Base::eval(a, b); // for integral types
+        }
+
+        template <typename A, typename B>
+        utree operator()(A& a, B& b) const
+        {
+            return dispatch(a, b,
+                boost::mpl::and_<
+                    boost::is_integral<A>,
+                    boost::is_integral<B> >());
+        }
+    };
+
+#define SCHEME_CREATE_FUNCTION(name, expr, base)                                \
+    struct BOOST_PP_CAT(function_impl_, name)                                   \
+    {                                                                           \
+        template <typename A, typename B>                                       \
+        static utree eval(A& a, B& b)                                           \
+        {                                                                       \
+            return utree(expr);                                                 \
+        }                                                                       \
+    };                                                                          \
+    base<BOOST_PP_CAT(function_impl_, name)> const                              \
+        BOOST_PP_CAT(base, BOOST_PP_CAT(_, name)) = {};                         \
+    /***/
+
+#define SCHEME_CREATE_ARITHMETIC_FUNCTION(name, expr)                           \
+    SCHEME_CREATE_FUNCTION(name, expr, arithmetic_function)                     \
+    /***/
+
+#define SCHEME_CREATE_INTEGRAL_FUNCTION(name, expr)                             \
+    SCHEME_CREATE_FUNCTION(name, expr, integral_function)                       \
+    /***/
+
+#define SCHEME_CREATE_ARITHMETIC_OPERATOR(name, op)                             \
+    SCHEME_CREATE_FUNCTION(name, a op b, arithmetic_function)                   \
+    inline utree operator op (utree const& a, utree const& b)                   \
+    {                                                                           \
+        return utree::visit(a, b, BOOST_PP_CAT(arithmetic_function, name));     \
+    }                                                                           \
+    /***/
+
+#define SCHEME_CREATE_INTEGRAL_OPERATOR(name, op)                               \
+    SCHEME_CREATE_FUNCTION(name, a op b, integral_function)                     \
+    inline utree operator op (utree const& a, utree const& b)                   \
+    {                                                                           \
+        return utree::visit(a, b, BOOST_PP_CAT(integral_function, name));       \
+    }                                                                           \
+    /***/
+
+    inline bool operator==(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, utree_is_equal());
+    }
+
+    inline bool operator<(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, utree_is_less_than());
+    }
+
+    inline bool operator!=(utree const& a, utree const& b)
+    {
+        return !(a == b);
+    }
+
+    inline bool operator>(utree const& a, utree const& b)
+    {
+        return b < a;
+    }
+
+    inline bool operator<=(utree const& a, utree const& b)
+    {
+        return !(b < a);
+    }
+
+    inline bool operator>=(utree const& a, utree const& b)
+    {
+        return !(a < b);
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, utree const& x)
+    {
+        utree::visit(x, utree_print(out));
+        return out;
+    }
+
+    SCHEME_CREATE_ARITHMETIC_FUNCTION(plus, a+b);
+    SCHEME_CREATE_ARITHMETIC_FUNCTION(minus, a-b);
+    SCHEME_CREATE_ARITHMETIC_FUNCTION(times, a*b);
+    SCHEME_CREATE_ARITHMETIC_FUNCTION(divides, a/b);
+    SCHEME_CREATE_INTEGRAL_FUNCTION(modulus, a%b);
+
+    inline utree operator+(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, arithmetic_function_plus);
+    }
+
+    inline utree operator-(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, arithmetic_function_minus);
+    }
+
+    inline utree operator*(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, arithmetic_function_times);
+    }
+
+    inline utree operator/(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, arithmetic_function_divides);
+    }
+
+    inline utree operator%(utree const& a, utree const& b)
+    {
+        return utree::visit(a, b, integral_function_modulus);
+    }
+}
+
+#endif