Boost logo

Proto :

Subject: [proto] Recursive functions in a mini language
From: Manjunath Kudlur (keveman_at_[hidden])
Date: 2010-08-06 19:29:54

I had asked boost-users for suggestions on how to define mutually
recursive functions in a DSEL. Here is the original thread.

I am thinking about a solution inspired by Spirit subrules, that looks
as follows :

#include <boost/fusion/container/vector.hpp>
#include <boost/proto/proto.hpp>
#include <vector>
#include <iostream>

using namespace std;

namespace mpl=boost::mpl;
namespace proto=boost::proto;
namespace fusion=boost::fusion;

struct arg{};

proto::terminal<arg<mpl::int_<0> > >::type const _1 = {{}};
proto::terminal<arg<mpl::int_<1> > >::type const _2 = {{}};
proto::terminal<arg<mpl::int_<2> > >::type const _3 = {{}};

struct func {};

#define DECLARE_FUNC(n, x) \
proto::terminal<func<mpl::int_<n> > >::type const x = {{}};

struct _declare_module {};
proto::terminal<_declare_module>::type const declare_module = {{}};

struct _map {};
proto::terminal<_map>::type const map = {{}};

int main()
  int i = 41;

  DECLARE_FUNC(0, det_inverse);
  DECLARE_FUNC(1, negmul);
  DECLARE_FUNC(2, vmul);
  DECLARE_FUNC(3, vadd);
  DECLARE_FUNC(4, precondition);
  DECLARE_FUNC(5, fib);

                            vadd = _1+_2,
                            negmul = -vmul(_1,_2),
                            det_inverse = 1/(_1*_3-_2*_2),
                            vmul = _1*_2,
                            fib = fib(_1-1) + fib(_1-2),
                            precondition = vmul(map(det_inverse, _1,_2,_3), _1)

  std::vector<int> a, b, c;



  return 0;

Basically, the user is forced to declare all the functions using
unique identifiers beforehand. He then declares a module containing
the definitions of the function. He can then call the functions as
module->*func(...). I imagine this can be made to work by parsing the
module and executing the correct function based on the type. I would
like to ask people's opinions on this forum. Do you guys see any
problems? Are there more elegant approaches?


Proto list run by eric at