Proposed modifications

Although Melange seems to be fairly useful in its present form, we are currently considering a number of ways in which it may be made more useful. This section contains a brief discussion of several potential changes which may be implemented in the future.

Enumeration clauses

At present, there is no way to modify the default handling of a C enumeration declaration. It is clear that you might wish a mechanism to specify several different explicit options: prefixes for the enumeration constants; re-specification of constant values; and, of course, explicit import: and exclude: options.

Inheritance of “map” and “equate” options

There are some cases in which a set of types imported within one interface definition might be used extensively within another. In the present implementation, the two interface definitions would be handled independently and equivalences between types would not be recognized in the absence of explicit equate: options.

One proposed solution would involve the ability to explicitly “use” one interface definition within another. This would result in all identically named types being implicitly equated and all top-level map: options being inherited. The “use” clause could support roughly the same syntax as the “use” clauses in library and module definitions.In order to make this work, it would be necessary to assign arbitrary names to interface definitions. This would have the added benefit of making them more consistent with other standard Dylan definition forms.

If this change were implemented, a typical interface definition might look something like the following:

define interface date
   #include "date.h";
   use time, import: {"struct time"};
end interface date;

A less ambitious version might remain compatible with the current syntax by replacing the interface name with an “interface-name” option, which would default to the root of the file name. Thus,

define interface
   #include "date.h",
      interface-name: "date";
end interface;

would yield the same effect as the previous example.

Re-merging of the “equate:” and “map:” options

It has been pointed out that the current method of specifying low-level and high-level mappings, while sufficiently expressive, is somewhat verbose and confusing. It would therefore be good to find an alternative notation.

It has been suggested that definitions like:

define interface
   #include "dirent.h",
      equate: {"char *" => <c-string>},
      map: {"char *" => <byte-string>};
end interface;

might be replaced by something like:

define interface
   #include "dirent.h",
      equate-and-map: {"char *" => <c-string> => <byte-string>};
end interface;

or

define interface
   #include "dirent.h";
   transform "char *",
      low-level: <c-string>,
      high-level: <byte-string>;
end interface;