Internal Templates as Special Functions

In a previous post, I had proposed expanding on the concept of multi-line string literals as a way to support DSLs and templates from within Dart. Here is an alternate proposal, using function bodies instead.

Proposal: Represent internal DSL templates as a special type of function. This is similar to Closure Templates, where templates are represented as a function-like structure with a formal parameter list.

Here is what the template definitions would look like:

Sql query2(int minAge) /*-{

        select id,firstName,lastName

        from person

        where age > ${minAge} and groupId=${groupId}

}-*/;

Html personTable(Person p) /*-{

        <table>

          <tr><td>First Name</td><td>${p.firstName}</td></tr>

          <tr><td>Last Name</td><td>${p.lastName}</td></tr>

          </tr>

        </table>

}-*/;

String personTable(Person p) /*-{

        First Name ${p.firstName}

        Last Name ${p.lastName}

}-*/;

I stole the syntax from GWT's JSNI. It seems to work pretty well there.

Then for each supported type DSL there would be two classes:

1. Html: a class representing the generated object, i.e. the result of executing the template
2. HtmlTemplate: defines the dart-templatized grammar for one particular DSL

Examples:

  HtmlTemplate creates Html

  SqlTemplate creates Sql

  StringTemplate creates String

  YamlTemplate creates Yaml

/// defines a dart-templatized DSL grammar

///   there will be one instance per template method

///   each DSL will have different rules regarding 

///   where ${ } expressions can be located

///

///   @type param T is the type of object that this 

///       template creates (i.e. Sql, Html, String)

interface Template<T>

  /// called once - to parse the template

  /// could potentially do nothing and just store the templateText

  /// but fail-fast would be preferred

  TemplateParseResult prepare(String templateText);

        

  /// called every time a template method is called

  T create(TemplateInvocationMirror args)

        

  /// optional. used by tools ???

  /// it would be nice if each ide/editor/tool didn't have to reinvent

  /// everything from scratch

  TemplateGrammar get grammar;

}

/// provides detailed parse error info: line #, column #

interface TemplateParseResult{

}


Making Tool Support Easier
It would nice if tool support for DSL templates is possible. It would be nicer, if tool support for DSL templates actually existed. Perhaps the TemplateGrammar class could provide enough information, so that tools (like IDEs) would not require 400 years in order to start supporting auto-completion, syntax high-lighting, etc.

/// optional. used by tools ???

/// it would be nice if each ide/editor/tool didn't have to reinvent

/// everything from scratch
/// one instance per DSL

interface TemplateGrammar{


}