Groovy Style "builders" in Suneido

One of the neat features in Groovy is its "builders". For example, using an XML markup builder:

builder.invoices
  {
  invoice(number: 1234)
      {
      item(type: 'part')
          { product(name: 'widget', cost: 100) }
      }
  }

which produces:

<invoices>
  <invoice number="1234">
      <item type="part">
          <product name="widget" cost="100" />
      </item>
  </invoice>
</invoices>

The builder doesn't actually have methods for "invoice", "part", etc. Instead, dynamic language "tricks" are used to catch "unknown" method calls.

It made me wonder how close I could come to this with Suneido. Here's what I came up with:

builder.invoices()
  {
  .invoice(number: 1234)
      {
      .item(type: 'part')
          { .product(name: 'widget', cost: 100) }
      }
  }

The main difference is that Suneido requires '.' on method calls. Otherwise it's pretty much identical. One thing the Groovy XML builder doesn't handle is tag contents containing a mixture of text and tags. I handled this in Suneido with a special '_' method. For example:

builder.p()
  {
  ._('start ')
  .b() { 'middle' }
  ._(' end')
  }

which produces:

<p>start <b>middle</b> end</p>

Here is the entire implementation of a Suneido XmlBuilder:

class
  {
  New()
      { .s = '' }
  Default(@args)
      {
      .s $= '<' $ args[0]
      for m in args.Members(named:)
          if m isnt #block
              .s $= ' ' $ m $ '="' $ args[m] $ '"'
      if args.Member?(#block)
          {
          .s $= '>'
          result = .Eval2(args.block)
          if result.Size() is 1
              .s $= result[0]
          .s $= '</' $ args[0] $ '>'
          }
      else
          .s $= ' />'
      return
      }
  _(s)
      { .s $= s; return }
  ToString()
      { return .s }
  }

One minor problem with the Suneido version is that certain methods are "built in" (e.g. Size) and therefore can't be used in the builder. [This is a result of trying to make class instances behave the same as generic containers. I'm starting to think this was a mistake, but I'm not sure how to go about changing something so fundamental.]

I had to make to make a slight fix to Suneido to make this work. The approach I used was to use instance.Eval(function) to evaluate the blocks in the "context" of the builder. But I found that Eval didn't work with blocks (only functions). Luckily it was easy to fix. (Actually, I'm using Eval2 which returns the result inside an object so you can determine if there was a return value or not.)

Groovy First Impressions

I recently picked up a copy of Groovy in Action. Groovy is a dynamic language based on Java infrastructure - it compiles to Java byte codes, runs on Java virtual machines, and has full access to Java libraries. You can call Java from Groovy and vice versa.

I just started reading the book, but the Groovy language looks interesting. There are some close similarities with Suneido, and of course differences. For example, this could be either Suneido or Groovy:

list = [1, 2, 3]
map = [name: "Fred", age: 24]

although Suneido would also allow this but Groovy wouldn't:

listmap = [1, 2, 3, name: "Fred", age: 24]

This is because Suneido uses a combined list/map data type whereas Groovy has separate list and map types.

BTW I like this map notation better than Ruby's, which uses a lot more punctuation:

map = { :name => "fred", :age => 24 }

Groovy's closures are also quite similar to Suneido's blocks:

Groovy: { arg -> ... }
Suneido: { |arg| ... }

I borrowed Suneido's block syntax from Smalltalk. The extra '|' before the parameters makes it easier to parse.

One feature I like is that you can write:

list.each { key, value -> ... }

whereas in Suneido you'd need parenthesis after the "each" function call:

list.each() { |key, value| ... }

This might not be too hard to add to Suneido since it's currently a syntax error (not ambiguous). In both Groovy and Suneido this is equivalent to list.each({...})

In addition to =~ for regular expression matching (the same as Suneido) Groovy also has ==~ which must match the entire string i.e. the same as "^(...)$". I'm tempted to add this to Suneido because it's a common mistake to omit the '^' and '$' and/or the parenthesis.

That's about as far as I've gotten. I'm not sure if I'll ever use Groovy but it's always interesting to look at other languages. And since the Java platform is quite ubiquitous, that makes Groovy more widely applicable. Groovy also has a web framework called Grails that is similar to Ruby on Rails.