Using Piglet to create a DSL – Setting the stage for turtles

Piglet has quite a few uses, and a case where it shines in particular is in the area of domain specific languages. So, in order to compliment the admittedly scarce tutorials on how to actually use Piglet, I intend to write a short little series on how to make a domain specific language using Piglet. Let’s get straight to it.

Enter the Turtle

I’m going to go for a classic educational DSL here, Turtle graphics. Because everyone like turtles, right? Basically, it’s a way of drawing graphics that could be imagined as if you had a (very obedient) turtle with a paintbrush attached to the back of it’s shell. Masterfully trained, it responds to three commands:

• Put the brush up or down
• Move forward or backward a certain number of steps
• Rotate a certain number of degrees

I have made a little WPF application that implements this behaviour. Eschewing all the WPF junk, here’s the turtle itself:

```    public class Turtle
{
private double angle;
private double x;
private double y;

public Turtle(Canvas canvas)
{
this.canvas = canvas;
x = canvas.ActualWidth/2;
y = canvas.ActualHeight/2;
}

public bool PenDown { get; set; }

public void Move(double distance)
{
var oldX = x;
var oldY = y;

if (PenDown)
{
canvas.Children.Add(new Line { X1 = oldX, Y1 = oldY, X2 = x, Y2 = y, Stroke = new SolidColorBrush(Color.FromRgb(0, 0, 0))});
}
}

public void Rotate(float a)
{
angle += a;
}
}
```

Nothing fancy, unless you’ve forgotten all about basic trigonometry. It takes a canvas and when moving it leaves trails if the pen is set to down. Using the turtle is straightforward. This program draws a twenty-sided polygon:

```var turtle = new Turtle(canvas);
turtle.Rotate(90);

turtle.PenDown = true;

for (int i = 0; i < 20; ++i)
{
turtle.Rotate(360/20);
turtle.Move(20);
}
```

It’s fun drawing with the turtle, but cumbersome since you’d have to recompile every time you want to change the shape. What we would really want is to describe it in a structured way using text. Sort of like a mini-programming language. LOGO would be the classic for turtle programming, but I feel it would be more fun to make our own little language for this.

Turtleese

When making a DSL or full blown language, in any tool, it’s usually easiest to start small and work your way up. To get the ball rolling, or turtle walking, let’s make a language that contains only the basic commands understood by the turtle. A sample piece of this rudimentary turtleese looks like this:

```pendown
move 50
rotate 90
move 50
rotate 90
move 50
rotate 90
move 50
penup
move -10
rotate 90
move 10
pendown
move 30
rotate 90
move 30
rotate 90
move 30
rotate 90
move 30
```

This program should make the turtle draw two concentric squares, 10 units apart. It’s really verbose, but it’s a start that we can improve on. If we look at the structure of the program, we can see that this is made up of list of statements. This is the key to formulate a grammar for parsing the language. Piglet gives us two options for configuring a parser, a fluent and a more technical interface. I’ll use the fluent interface for this series, maybe in the end provide an equivalent grammar in the technical interface. In the end, it’ll serve to deepen the knowledge of how grammars actually work, though you should have a pretty good idea when we actually get there.

Here’s the entire thing:

```var turtle = new Turtle(canvas1);

var configurator = ParserFactory.Fluent();
var statementList = configurator.Rule();
var statement = configurator.Rule();

{
turtle.PenDown = true;
return null;
})
.Or.By("penup").WhenFound(f =>
{
turtle.PenDown = false;
return null;
})
.Or.By("move").Followed.By<int>().As("Distance").WhenFound(f =>
{
turtle.Move(f.Distance);
return null;
})
.Or.By("rotate").Followed.By<int>().As("Angle").WhenFound(f =>
{
turtle.Rotate(f.Angle);
return null;
});
var parser = configurator.CreateParser();
parser.Parse(code.Text);
```

Going through it line by line. First we make a `configurator` object. This is the object that we’ll use to make the parser. Then we make two rules, `statementList` and `statement`. A thing of huge importance here. The order of declaring these is vitally important. You see, if you’d make this in the wrong order it would just try to find a single statement. A parser constructed by Piglet must be able to parse everything you give it down to a single rule. For now, the single rule is the statement list. Usually it’s something like “program” for a programming language or translation unit or something to that effect.

Moving on, we declare that a statementList unsurprisingly is made up by a list of statement. This is a reference to another rule.

A statement is declared as one of the four commands that the turtle understands. Following each possibility there is a lambda that gets executed when the parser has recognized that a rule is to be applied. For now we make the turtle do the same thing as the command says. There is a need to return something from the parse function, we ignore that for now and return null. Later on we’ll revisit this and find out why you want to return things from rules.

The `move` and `rotate` are interesting, since they have a parameter which is an integer value. We’ll need to find out the value of this parameter. In Piglet, this requires you to give the parameter a name. This name then becomes accessible on the `dynamic` object that is the input to the `WhenFound` function. Integers are simple types, so Piglet has a built-in function for recognizing them.

Calling parser.Parse with the code causes to the turtle to do what you wanted it to. The program also gives some helpful hints for when you’ve confused our poor reptilian friend, you get this functionality for free when using Piglet.

The full source code for this tutorial is found on GitHub: TurtlePig. Feel free to fork and mess about with it. The same repo will be updated once this tutorial continues, so you might find a slightly different version. I’ll figure a way to keep all versions accessible.

Next time, we’ll take a look at making this language a lot more capable – step by step.

Tagged , , ,

2 thoughts on “Using Piglet to create a DSL – Setting the stage for turtles”

1. […] In the last part we created a very basic DSL for use with turtle graphics. Today we’re going to extend the language with more capabilites and learn more about how to use Piglet and also incidentally a bit of compiler construction (nothing scary, I promise). […]

2. muyiwa says:

Hi I tried copying the simple Latin name example in F# and ran into the problem Genus not defined:
wondering if you have some pointers on correcting this:

open System.Linq
open System.Text
open System.Text.RegularExpressions
open Microsoft.FSharp.Reflection

type Plant()=
member val Genus=”” with get, set
member val Species=”” with get,set
member val SubSpecies=”” with get,set
member val IsHybrid=false with get,set
new(gen:string, sp:string, sub:string) as this = Plant() then do
this.Genus <- gen
this.Species <- sp
this.SubSpecies (f:>obj) ))
.Followed.By(name1).As(“Species”)
.WhenFound((fun (f) -> ((new Plant(f.Genus, f.Species, “”)) :>obj)) )

let parser = config.CreateParser()
let result = parser.Parse(name):?> Plant
result

[]
let main argv =
let parser = New ParseLatinPlantName
let result = parser.Parse(“Salvia sylvatica “)
printfn “Genus:%s” (result.Genus.ToString() )
printfn “Species: %s” (result.Species.ToString())
printfn “Subspecies:%s” (result.SubSpecies.ToString())