As you may have noticed I haven't posted anything here for a while - primarily because development of Prefix has been suspended. There's a couple of reasons for this, but the main two are:

1. We've decided to cease operations at the company where I work my day job. Commencing 2012 I'll be officially out of work and looking for something new to do.
2. Given that I can't figure out how to commercialize Prefix, it needs to be put on the back-burner to make room for something that will pay the bills.

I'd like to return to Prefix at some stage but for the moment at least it's shelved. Besides Prefix I also have several other unpublished projects which have also been suspended - the slate needs to be cleared.

Having said all that, this seems to be the perfect opportunity to look for something completely different to work on. So over the coming month(s) I think I'll try my hand at various random things to see what piques my interest. Perhaps something in the mobile space, maybe some game development, perhaps something else. Who knows?

This post is about Prefix - a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

Prefix has had for loops pretty much since day one. I'd deliberately left out foreach loops until now because I wanted to integrate them with some sort of enumerable/generator (eg: IEnumerable<T>) mechanism, but I've decided to put that off for now and just aim for parity with JavaScript functionality.

Enumerating Array Like Objects

First up, the Prefix foreach statement will work with any type that implements a int length variable or property and an indexer that takes an integer parameter - including obviously arrays and strings.

Prefix uses a temporary variable as the counter and just enumerates the collection as you'd expect:

extern dynamic Console;

var x = new string[];
x.push("Hello");
x.push("World");

foreach (var i in x)
{
    Console.WriteLine(i);
}

(function() {

// Start Global Code
var $temp;
var x=[];
x.push("Hello");
x.push("World");
for ($temp=0; $temp<x.length; $temp++)
{
    var i = x[$temp];
    Console.WriteLine(i);
}

})();

The generated code will use an additional temporary variable if the expression begin enumerated might cause side effects. In this example, $temp2 is used to hold the array to avoid multiple calls into fn:

extern dynamic Console;

string[] fn()
{
    var x = new string[];
    x.push("Hello");
    x.push("World");
    return x;
}

foreach (var i in fn())
{
    Console.WriteLine(i);
}

(function() {

function fn()
{
    var x=[];
    x.push("Hello");
    x.push("World");
    return x;
};

// Start Global Code
var $temp, $temp2;
for ($temp=0, $temp2=fn(); $temp<$temp2.length; $temp++)
{
    var i = $temp2[$temp];
    Console.WriteLine(i);
}

})();

(in case you're wondering, Prefix tracks temporary variable allocations and re-uses them, so multiple consecutive loops like this will declare the temporary variables once at the top of the scope (function) and re-use them multiple times over).

Enumerating Dictionaries

I've always thought object enumeration in JavaScript to be a little messy - though I do understand the reasons for it. In JavaScript there's two main reasons for enumerating an object - to get all the values of a associative array, or to enumerate all the methods, properties, fields of an object (say to dump/inspect it). The differences with these two approaches relates to whether to enumerate the prototype chain or not.

The JavaScript for...in statement does enumerate the prototype chain. If you only want the immediate properties of the object (say the keys of a dictionary) you need to use the hasOwnProperty method to detect the items to exclude.

In Prefix, the call to hasOwnProperty is included automatically in generated foreach loops.

(In the following example I'm using backtick escapes to declare literal JavaScript - to better show the object layout).

extern dynamic Console;

// Purposely put something that doesn't belong in the object prototype
// This SHOULD NOT appear in the output
`Object.prototype.somecrap = 23`;

// Create a dictionary
var dict = `{apple:1, pear:2, banana:3}`;

// Dump the contents of the dictionary
foreach (var i in dict)
{
    Console.WriteLine(i);
}

(function() {

// Start Global Code
Object.prototype.somecrap = 23;
var dict={apple:1, pear:2, banana:3};
for (var i in dict)
{
    if (!dict.hasOwnProperty(i))
        continue;
    Console.WriteLine(i);
}

})();

Enumerating Object Members

The above example raises the obvious question of how to enumerate the entire prototype chain? Well, with a new form of the foreach statement: foreach member (var i in whatever).

The following example is the same as the above but I've added the member pseudo-keyword:

extern dynamic Console;

// Purposely put something that doesn't belong in the object prototype
// This SHOULD appear in the output
`Object.prototype.somecrap = 23`;

// Create a dictionary
var dict = `{apple:1, pear:2, banana:3}`;

// Dump all members of the dictionary (including the extra property in the object prototype)
foreach member (var i in dict)
{
    Console.WriteLine(i);
}

(function() {

// Start Global Code
Object.prototype.somecrap = 23;
var dict={apple:1, pear:2, banana:3};
for (var i in dict)
{
    Console.WriteLine(i);
}

})();

The member modifier can also be used on arrays to enumerate the actual members of the array instead of just the items in the array.

Conclusion

That's all for the foreach statement for the moment. I do intend on addition support for something like IEnumerable<T> and yield return but not just yet...

If you've been using the experimental build of Prefix, I haven't updated it with this functionality yet - I'll post something when I do.

This post is about Prefix - a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

A delegate type lets you declare the required prototype of function and pass references to matching functions around. What we need now is an easier way to declare these functions inline - without having to create an actual "function" per se.

Anonymous Functions

An anonymous function is a function declared without a name and with an inferred return type. It's declared using the delegate keyword as part of an expression. Consider the following where an unnamed ("anonymous") function is passed to a another function:

extern dynamic Console;

void DoSomething(Func<int, int> cb)
{
    Console.WriteLine(cb(10));
}

DoSomething(delegate(int x) { return x*88; });

(function() {

function DoSomething(cb)
{
    Console.WriteLine(cb(10));
};

// Start Global Code
DoSomething(function(x) {
    return x*88;
});

})();

Because anonymous functions don't declare a return type, the compiler must be able to infer it from usage. (in the above example it's infered from DoSomething's cb parameter which is declared as Func<int, int>

Lambda Expressions

Lambda expressions are an even more concise way of writing an anonymous function that directly returns the result of a single expression. The syntax for lambda expressions is based around the => operator and prefix supports the same syntax formats as C#. eg:

• ()=>99 - a lambda expression with no parameters
• x=>x*2 - a lambda expression with a single untyped parameter
• (x,y)=>x*y - a lambda expression with multiple untyped parameters
• (int x, int y)=>x*y - a lambda expression with multiple typed parameters

A lambda expression is equivalent to a anonymous function that simply returns a value. So this:

(int x, int y) => x * y

is equivalent to:

delegate(int x, int y) { return x * y; }

Note too that with lambda expressions (unlike anonymous functions) you don't have to specify type arguments for the parameters - they're inferred in the same way the return type is.

Solving the this/that Conundrum

In JavaScript when nesting one function inside another, the inner function doesn't inherit the this reference from the outer function. In order to reference the outer class the developer must manually setup a that reference in the enclosing closure. (see here for a better explanation).

The Prefix compiler however has enough type information to know how to set this up automatically. So if an anonymous function inside a class method refers to a member variable of the outer class, this is automatically stored in a local variable $this and the nested function automatically uses it.

Here's an example showing both a lambda expression and the use of $this:

extern dynamic Console;

class MyClass
{
    public int Value;
    public void DoSomething(int input)
    {
        Func<int, int> fn = x=>Value * x;
        Console.WriteLine(fn(input));
    }
}

var x = new MyClass();
x.Value = 23;
x.DoSomething(10);

(function() {

// class MyClass
var MyClass = function() {};
MyClass.typeName = 'MyClass';
MyClass.prototype.Value = 0;

MyClass.prototype.DoSomething = function(input)
{
    var $this = this;
    var fn=function(x) { return $this.Value*x; };
    Console.WriteLine(fn(input));
};

// Start Global Code
var x=new MyClass();
x.Value = 23;
x.DoSomething(10);

})();

Generic Type Inference

All that's left to do in this area is type inference of generic function arguments from lambda's and anonymous functions - coming soon!

This post is about Prefix - a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

I've always thought JavaScript's runtime type support to be rather lame - not so much in what it can provide, but simply that it's rather inconsistent. For example, using typeof on any custom class/object simply yields "object". Great - not.

In Prefix I wanted to improve this situation a little and provide something a little more reliable. Prefix has two type inspection operators:

typeof

returns the constructor of an object or value

typename

returns a descriptive name for an object type

Both operators can accept either an object instance, or a compile type type name.

For the built in types (boolean, string etc...), typeof returns the boxed object constructor (eg: String.constructor) while typename returns the equivalent of the JavaScript typeof operator (eg: "string", "boolean", "number" etc....)

For Prefix classes, including generic classes typeof returns the class function and typename returns a descriptive name of the class - with generic arguments substituted. eg:

extern dynamic Console;

class Bar
{
}

class MyClass<T>
{
    public void fn()
    {
        Console.WriteLine(typename(T));
    }
}

new MyClass<bool>().fn();
new MyClass<int>().fn();
new MyClass<Bar>().fn();
new MyClass<MyClass<int>>().fn();
Console.WriteLine(typename(MyClass<int>));

boolean
number
Bar
MyClass<>[number]
MyClass<>[number]

Note that although Prefix distinguished between int and double at compile time, there is no such distinction at runtime - hence the appearance number in the resulting typename.

There are a couple of runtime helper functions to support these operators but as always they're tiny, automatically generated by the compiler and only generated when actually needed.

(Don't forget Prefix also supports runtime type querying via the is and as keywords).

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

Burst Fish is a tutorial game written by Seb Lee-Delisle that I found on the excellent creativejs.com site. The original tutorial can be found here http://creativejs.com/tutorials/create-an-ipad-optimised-game/.

I thought this would be an excellent project to port to Prefix as both an example project and as a first experiment to see how Prefix works in the real world. Aside from one missing piece of functionality and a few bugs in the compiler itself, porting it went remarkably well. Here it is:

• View the Game in your Browser (You'll need a webkit based browser - Chrome or Safari)
• Download the Source

(Please note I haven't released Prefix yet so although you can look at the source you can't compile it yourself yet. If you're interested in trying the compiler ping me on Twitter or email me).

To show how the Prefix code looks, here's an extract of the Emitter class used to generate the exploding fish particles:

// Emitted is used to generate the explosion particles
class Emitter
{
    // Constructor
    public Emitter(dynamic domContainer)
    {
        this.domContainer = domContainer;
    }

    // Fields
    private dynamic domContainer;
    private Particle[] _particles = new Particle[];
    private Particle[] _spareParticles = new Particle[];

    // Called by main game loop to update particules
    public void update()
    {
        for (var i=0; i<_particles.length; i++)
        {
            var particle = _particles[i]; 
            if (!particle.update())
            {
                _spareParticles.push(particle);
            }
        }
    }

    // Make an explosion at specified position
    public void makeExplosion(double xpos, double ypos, double zpos)
    {
        // Just create bunch of particles
        for (var i=0; i<30; i++)
        {
            var particle = makeParticle();
            particle.init(xpos, ypos, zpos);
            particle.update(); 
        }
    }

    // Make a particle by initializing a new one, or by grabbing one from 
    // the spare list
    private Particle makeParticle()
    {
        Particle particle;
        if (_spareParticles.length>0)
        {
            particle = _spareParticles.shift();
        }
        else
        {
            particle = new Particle(domContainer); 
            _particles.push(particle); 
        }

        return particle; 
    }

}

// class Emitter
var Emitter = function()
{
    this._particles = [];
    this._spareParticles = [];
};
Emitter.typeName = 'Emitter';
Emitter.prototype.domContainer = null;
Emitter.prototype._particles = null;
Emitter.prototype._spareParticles = null;

Emitter.prototype.ctor$1 = function(domContainer)
{
    Emitter.call(this);
    this.domContainer = domContainer;
    return this;
};

Emitter.prototype.update = function()
{
    for (var i=0; i<this._particles.length; i++)
    {
        var particle=this._particles[i];
        if (!particle.update())
        {
            this._spareParticles.push(particle);
        }
    }
};

Emitter.prototype.makeExplosion = function(xpos, ypos, zpos)
{
    for (var i=0; i<30; i++)
    {
        var particle=this.makeParticle();
        particle.init(xpos, ypos, zpos);
        particle.update();
    }
};

Emitter.prototype.makeParticle = function()
{
    var particle;
    if (this._spareParticles.length>0)
    {
        particle = this._spareParticles.shift();
    }
    else
    {
        particle = (new Particle().ctor$1(this.domContainer));
        this._particles.push(particle);
    }
    return particle;
};

The game works as well as the original and although there are a few bits in the generated code that could be cleaned up, as a first attempt I'm fairly pleased with it.

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

"First-class Functions" are one of those topics that most new programmers struggle with - it's a weird concept passing a function to another function, or storing it in a variable. In JavaScript however this is a fairly common practice and the Prefix equivalent is a delegate.

Simple Delegates

A delegate type declaration gives a name to a function prototype ie: the set of parameters to a function and its return type. Once a delegate type is declared you can create variables or parameters of that type and store or pass function references in them.

eg:

extern dynamic Console;

// This is the delegate type - it specifies that functions
// references by it must have a single integer paramter and
// a void return type
delegate void delDoSomethingWithInt(int a);

// Here's a function that satisfies that requirement
void PrintInt(int x)
{
    Console.WriteLine(x.toString());
}

// Create a variable and store a reference to the function in it
delDoSomethingWithInt fn = PrintInt;

// Call it
fn(5);

(function() {

function PrintInt(x)
{
    Console.WriteLine(x.toString());
};

// Start Global Code
var fn=PrintInt;
fn(5);

})();

Note that in the generated JavaScript all references to the delegate type vanish - however they've served there purpose in letting the compiler check that only matching functions are passed. For example if the PrintInt function accepted a different set of parameters an error would be generated.

Binding Delegates to an Object Reference

In the above example, the function called is a simple global scope function. Delegates however can reference a function on a specific object instance. In this case, Prefix binds the object reference so that it's passed to the function correctly when it's invoked:

extern dynamic Console;

class MyClass
{
    public int Value;
    public void DoSomething()
    {
        Console.WriteLine("MyClass.DoSomething - " + Value.toString());
    }
}

delegate void del();

var inst = new MyClass();
inst.Value=23;

del fn = inst.DoSomething;
fn();

(function() {

// Prefix runtime library
var $dex = {};
$dex.bind=function(a,b){var c=a[b];return function(){c.apply(a,arguments)}} 

// class MyClass
var MyClass = function() {};
MyClass.typeName = 'MyClass';
MyClass.prototype.Value = 0;

MyClass.prototype.DoSomething = function()
{
    Console.WriteLine("MyClass.DoSomething - " + this.Value.toString());
};

// Start Global Code
var inst=new MyClass();
inst.Value = 23;
var fn=$dex.bind(inst, "DoSomething");
fn();

})();

Note that calling the delegate variable fn knows nothing of the MyClass instance, yet calling it still works thanks to the binding done by the helper function $dex.bind.

Generic Delegates

Prefix also supports generic delegates. Consider this example which is identical to the previous example except that the delegate is declared as a generic. The int parameter type isn't resolved until the delegate is used:

extern dynamic Console;

class MyClass
{
    public int Value;
    public void DoSomething(int param)
    {
        Console.WriteLine("MyClass.DoSomething - " + Value.toString() + " - " + param.toString());
    }
}

delegate void del<T>(T a);

var inst = new MyClass();
inst.Value=23;

del<int> fn = inst.DoSomething;
fn(5);

(function() {

// Prefix runtime library
var $dex = {};
$dex.bind=function(a,b){var c=a[b];return function(){c.apply(a,arguments)}} 

// class MyClass
var MyClass = function() {};
MyClass.typeName = 'MyClass';
MyClass.prototype.Value = 0;

MyClass.prototype.DoSomething = function(param)
{
    Console.WriteLine("MyClass.DoSomething - " + this.Value.toString() + " - " + param.toString());
};

// Start Global Code
var inst=new MyClass();
inst.Value = 23;
var fn=$dex.bind(inst, "DoSomething");
fn(5);

})();

Func and Action

Now that Prefix has support for generic delegates, support for Func and Action are simply a matter of declaring them:

delegate TResult Func<TResult>();
delegate TResult Func<T1, TResult>(T1 p1);
delegate TResult Func<T1, T2, TResult>(T1 p1, T2 p2);
// etc...

delegate void Action();
delegate void Action<T1>(T1 p1);
delegate void Action<T1, T2>(T1 p1, T2 p2);
// etc...

Prefix includes built-in declarations for Func and Action with up to 8 parameters:

extern dynamic Console;


int addem(int a, int b)
{
    return a+b;
}

Func<int, int, int> op = addem;

Console.WriteLine(op(10, 20).toString());

(function() {

function addem(a, b)
{
    return a + b;
};

// Start Global Code
var op=addem;
Console.WriteLine(op(10, 20).toString());

})();

Type Inference with Delegates

Prefix supports generic type inference with delegates. The following example declares a generic function with two generic parameters TIn and TOut. Note that when the function is called, it's simply called fn and the type are inferred from the usage. ie: Prefix has inferred that TIn is int and TOut is string.

extern dynamic Console;

TOut fn<TIn, TOut>(Func<TIn,TOut> cb, TIn input)
{
    return cb(input);
}

string convert(int val)
{   
    return val.toString();
}

Console.WriteLine(fn(convert, 23));

(function() {

function fn$2(cb, input)
{
    return cb(input);
};

function convert(val)
{
    return val.toString();
};

// Start Global Code
Console.WriteLine(fn$2(convert, 23));

})();

Conclusion

Delegates are an important concept for Prefix as they bring the language considerably closer to JavaScript's capabilities and also lead into Lambda's and Anonymous Functions which I'm working on now.

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

Arrays

The recent focus with Prefix has been to get to the point where it can support JavaScript arrays. As mentioned in my previous post this involved support for generics, indexers, readonly properties and variadic parameters. What I didn't mention is that although I've added support for compiling all these features from Prefix to JavaScript, for arrays I only needed the ability to declare these constructs - since JavaScript provides the actual array implementation.

Arrays in Prefix are a little different to C# arrays. First, they're implemented as a generic class - Array<T>, as opposed to a type handled in the language itself. Second, since they wrap up the JavaScript array class they can be resized and behave more like a C# List.

So here's the built in declaration of the Array class:

extern class Array<T> : Object
{
    extern readonly int length;
    extern T this[int index] { get; set; }
    extern string join();
    extern string join(string separator);
    extern T pop();
    extern int push(T x);
    extern void reverse();
    extern T shift();
    extern int unshift(T x);
    extern Array<T> slice(int start);
    extern Array<T> slice(int start, int end);  
    extern Array<T> splice(int index, int howmany);
    extern Array<T> splice(int index, int howmany, T insert);
    extern Array<T> concat(Array<T> other_array);
    extern Array<T> concat(params Array<Array<T>> arrays);
    extern int push(params T[] x);
    extern int unshift(params T[] x);
    extern Array<T> splice(int index, int howmany, params T[] insert);
}

It simply declares the standard array manipulation functions. You'll notice there's no declaration for indexOf - since it's not supported in IE's JavaScript engine - I still need to figure out a nice way to normalize those sorts of quirks.

Although the Array type is a generic class the compiler also supports some syntactic sugar to make it look more traditional - any type suffixed with [] gets converted to an array generic. eg: string[] is identical to Array<string>

Using the array class is pretty much as you'd expect and looks very similar to standard JavaScript:

extern dynamic Console;

var x = new string[];
x.push("Hello");
x.push("World");
x.splice(1, 0, "There");

for (int i=0; i<x.length; i++)
    Console.WriteLine(x[i]);

(function() {

// Start Global Code
var x=[];
x.push("Hello");
x.push("World");
x.splice(1, 0, "There");
for (var i=0; i<x.length; i++)
    Console.WriteLine(x[i]);

})();

Note:

• instantiating a new array instance (new string[]) gets re-compiled into just [] (as any self-respecting JavaScript programmer would expect).
• there's no size argument when instantiating an array (as opposed to C#)
• even though the generated code looks almost exactly like the original the real benefit here is all the error checking the compiler is doing for you.
• you can escape the type safety and revert to the wild world of dynamic with dynamic[] - which is essentially an untyped JavaScript array.
• Prefix doesn't yet support the foreach statement, so enumerating an array is currently limited to an integer indexer. Collection enumeration via foreach will be coming soon.

What About .NET's List<T> Class?

It's at this point that I thought I'd be providing a compatible implementation of C#/.NET's List<T> class. After a lot of consideration though I felt this was the wrong approach - re-implementing the .NET runtime is not the point of this project.

There are a few cases where it would be great to compile the same code base under both C# and Prefix. Rather than trying to provide a Prefix implementation of many of the common .NET library functions I'm thinking of doing the opposite - providing a C# implementation of the Prefix runtime.

Of course if you really need List<T> you could always re-implement it yourself in Prefix code.

Next Up

I'm currently working on delegate support and have it mostly working - the current stumbling block is getting generic function type inference working with generic delegate parameters... but more about that later.

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

Infinitely Recursive Generic Types

In my previous post I suggested that I had generics working. Well not quite and I've had to do a major reworking of it. The first problem was that with generics it's possible to have an infinitely recursive type definition. Consider this example:

class MyClass<T>
{
    MyClass<MyClass<T>> SomeFunction();
}

Now imagine you create the closed type MyClass<int>. The return value from the function will be MyClass<MyClass<int>> - but that type has a SomeFunction method that returns MyClass<MyClass<MyClass<int>>>. And so on...

Prefix's original generic implementation tried to fully close generic types as soon as they were used - so the above immediately crashed with a stack overflow exception as it recursively tried to make those closed types.

Of course the fix was simple once I understood it - just delay making those closed types until needed.

You'd think the above is a weird edge case that would never happen. Ironically it cropped up almost the first time I tried to use generics (to declare Prefix's array class).

Nested Generics Might Not Be What You Think

Probably the most difficult part of getting generics working was nested generic classes - that is until I understood what they really are (not what I thought they were). Originally I presumed that on making a closed generic class any inner nested classes would become part of that newly generated closed class.

However that is not the case - at least when you look at how C# does it. In C# a nested generic class is simply a generic class that inherits the same set of generic parameters as the outer class and tacks its own generic parameter on the end.

So this class:

class Outer<T>.Inner<U>

is really implemented as:

class Outer.Inner<T,U>

Discovering this helped solve a whole class of problems with generics but required a fair bit of reworking the code - though pleasingly the generated JavaScript is now simpler and slightly smaller.

Read Only Fields

Now that generics were working properly, I was at the point that I could start looking at what else was required to get arrays working. First up was readonly fields (since the length property of an array should be readonly).

Read only fields work identically to C# readonly fields. They can be initialized via a direct initializer or in the class constructor.

class Foo
{
    public Foo()
    {
        val="Hello World";
    }

    public readonly string val;
}

I haven't included the generated JavaScript code here because the enforcement of readonly-ness is done at compile time - not runtime. You could get around this by casting to a dynamic if you really wanted.

Indexers

Arrays are fairly useless without indexers. Indexers are implemented like properties with parameters. Just like C# they can be overloaded, but Prefix doesn't support variadic (parameter array) indexers. In JavaScript they're implemented as methods $get_at and $set_at.

extern dynamic Console;

class Foo
{
    public string this[int index]
    {
        get
        {
            Console.WriteLine("get[" + index.toString() + "]");
            return index.toString();
        }
        set
        {
            Console.WriteLine("set[" + index.toString() + "] = " + value);
        }
    }
}

var f = new Foo();
Console.WriteLine(f[99]);
f[99]="newval";

(function() {

// class Foo
var Foo = function() {};
Foo.typeName = 'Foo';

Foo.prototype.$get_at = function(index)
{
    Console.WriteLine("get[" + index.toString() + "]");
    return index.toString();
};

Foo.prototype.$set_at = function(index, value)
{
    Console.WriteLine("set[" + index.toString() + "] = " + value);
    return value;
};

// Start Global Code
var f=new Foo();
Console.WriteLine(f.$get_at(99));
f.$set_at(99, "newval");

})();

Variadic Parameters

The JavaScript array class supports passing a variable number of arguments to some of it's methods - commonly called variadic functions.

In C# variadic methods can be called in two ways - normal form and expanded form. For example, this function:

int Sum(params int[] values);

can be called like this:

// Expanded form
Sum(1,2,3,4);

or by passing an array directly:

// Normal form
var values = new int[] { 1, 2, 3, 4 };
Sum(values);

To replicate this in JavaScript, if the passed variable is an array it's assumed to be a normal form call and used directly, otherwise the JavaScript arguments are sliced to create an array.

extern dynamic Console;

int sum(int first, params int[] other)
{
    for (int i=0; i<other.length; i++)
    {
        first += other[i];
    }
    return first;
}

Console.WriteLine(sum(1,2,3,4));

(function() {

function sum(first, other)
{
    if (!(other instanceof Array)) other = Array.prototype.slice.call(arguments, 1);
    for (var i=0; i<other.length; i++)
    {
        first += other[i];
    }
    return first;
};

// Start Global Code
Console.WriteLine(sum(1, 2, 3, 4));

})();

Of course using this technique to detect whether the function is being called in normal or expanded form doesn't work for arrays of arrays (since there isn't enough type information in JavaScript at runtime) to work this out. In this case Prefix disallows the short form calling and generates an error.

Actually, Prefix does a slightly better job than shown above. If the target function is never called in short form, the if statement is omitted and arguments is sliced directly.

Conclusion

I now have everything to get arrays working... which I'll talk about in the next post.

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

What Are Generics?

For this post I'm going to assume you're already familiar with C#'s generic support. If you're not, there are plenty of references and tutorials available online (here's one from Microsoft). In short generics are a way to declare strongly typed classes, interfaces and methods that defer the specification of one or more types until the class or method is used in code

Generics in Prefix

Prefix's supports most of the C# generics capabilities including:

• multiple type parameter
• constraints - base class, required interfaces, new() and class
• generic classes, intefaces and methods
• nested generic types
• parameter type inference for generic functions

To support this functionality there's up to about 1.5kb of automatically embedded and minified runtime code. In many cases however generics can be used with no runtime library requirements - in which case the Prefix compiler will leave it out.

A Simple Generic Class

Here's an example of a simple generic list class: (see further down for notes)

// no warnings
extern dynamic Console;

class MyList<T>
{
    public void Add(T t)
    {
        _data.push(t);
    }

    public T GetAt(int index)
    {
        return (T)(`this._data[index]`);
    }

    public int Count
    {
        get
        {
            return _data.length;
        }
    }

    T[] _data = (T[])(`[]`);
}

var l = new MyList<int>();
Console.WriteLine(l.Count);
l.Add(10);
l.Add(20);
l.Add(30);
Console.WriteLine(l.Count);

for (int i=0; i<l.Count; i++)
{
    Console.WriteLine(l.GetAt(i));
}

(function() {

// class MyList<T>
var MyList$1 = function()
{
    this._data = [];
};
MyList$1.typeName = 'MyList$1';
MyList$1.prototype._data = null;

MyList$1.prototype.Add = function(t)
{
    this._data.push(t);
};

MyList$1.prototype.GetAt = function(index)
{
    return this._data[index];
};

MyList$1.prototype.get_Count = function()
{
    return this._data.length;
};

// Start Global Code
var l=new MyList$1();
Console.WriteLine(l.get_Count());
l.Add(10);
l.Add(20);
l.Add(30);
Console.WriteLine(l.get_Count());
for (var i=0; i<l.get_Count(); i++)
{
    Console.WriteLine(l.GetAt(i));
}

})();

Note the following:

• The JavaScript class name is qualified with the number of type arguments (ie: MyList$1). This is because its possible to have multiple generic classes, each with a different number of generic arguments. MyList<T,U> would be converted to MyList$2 etc...
• Arrays are implemented as a new built-in system generic Array<T>. Unlike C# arrays but like JavaScript arrays, Prefix arrays can be resized after being created.
• Since I don't have complete language level operability with JavaScript arrays yet, I've had to resort to using backtick escapes to get this example to work. (see GetAt and the _data initializer in the Prefix code.)
• There's no runtime overhead with this example - all type checking is done at compile time.

An example with Runtime Dependencies

As in the above example, many generic types - especially collection classes - don't require any runtime type information about the generic type arguments and therefore translate fairly cleanly to JavaScript. When you do need runtime type information things get more complicated, but I've tried to hide away the messy details as much as possible.

Consider this example that can create instances of a type declared through a generic parameter:

extern dynamic Console;

class Foo
{

}

class MyFactory<T> where T:new()
{
    public T CreateInstance()
    {
        return new T();
    }
}

var foo = new MyFactory<Foo>().CreateInstance();
Console.WriteLine(foo is Foo);

(function() {

// Prefix runtime library
var $dex = {};
$dex.makeCachedGeneric=/* removed */ 
$dex.resolveGenericArg=/* removed */
$dex.resolveGenericArgs=/* removed */
$dex.setupGenericClass=/* removed */

// class Foo
var Foo = function() {};
Foo.typeName = 'Foo';

// class MyFactory<T>
var MyFactory$1 = $dex.setupGenericClass(1, null, null, null, function() {});
MyFactory$1.typeName = 'MyFactory$1';

MyFactory$1.prototype.CreateInstance = function()
{
    var T = this.closedClass$1.genericArgs[0];
    
    return new T();
};

// Start Global Code
var foo=(new (MyFactory$1.makeGeneric([Foo]))()).CreateInstance();
Console.WriteLine((foo)!==null);

})();

Note:

• I've removed the runtime library functions because they're messy and distract from the interesting stuff.
• The MyFactory$1 class is initialized using the runtime function setupGeneric which does everything need to turn this into a generic class with runtime information about the generic args.
• MyFactory<Foo> becomes MyFactory$1.makeGeneric([Foo]).
• makeGeneric creates a new class (if not already created) that knows about Foo as the type argument
• Inside CreateInstance you can see T is retrieved via a this.closedClass$1 which is setup by the call to makeGeneric.

As you can see, it's a little messy but quite powerful. I've tried to make the JavaScript code mirror as closely as possible the original Prefix code - mainly it's the makeGeneric call that messes things up - everything else is reasonably out of the way.

This additional runtime code is required when:

• the generic class contains a new T()
• using dynamic casts (as and is) to/from T
• using default(T) and T is not known to be a reference type (ie: no T has no constraints)
• A generic class has static fields (since each set of generic arguments gets its own copy of the variable)

More Examples

Rather than post detailed examples of everything here, feel free to checkout the latest unit test results for more detail. There are examples of generic functions, generic classes with static members, nested generics and more. If you're adventurous, the test cases also include the uncensored JavaScript with the runtime library support functions in all their gory detail.

In conclusion I've tried to make Prefix's generics support powerful but not at the expense of too much interference in the generated JavaScript code. Although I'd like the JavaScript to be cleaner I'm not sure what else could be done to improve it.

Generics is a huge step forward for Prefix and paves the way for a number of other features including arrays and enumerating collections with foreach statements.

This post is about Prefix a modern language that compiles to JavaScript. A language where C# is the inspiration - not the goal. Read more on the Prefix Project Page.

Unit Testing JavaScript

This isn't the first time I've had to run JavaScript code for unit testing. Previously what I've done is hosted the Microsoft Web Control, loaded a page with the appropriate JavaScript code and interoped to it through a Windows Form application. This is how I implemented the unit tests for the JavaScript port of MarkdownDeep - it works, but it's messy and very slow.

For Prefix, I wanted something better so I started looking around for a JavaScript engine that would be easy to host in .NET. I knew about Google's V8 JavaScript engine so that seemed the obvious place to start. I got it building and was about to start on some C++/CLR/IJW interop code for it when I stumbled upon V8Sharp - which does exactly what I needed.

Hosting V8 with V8Sharp is trivial, here's the bit to run some JavaScript code:

var v8 = v8sharp.V8Engine.Create();
v8.Register<TestConsole>("Console", console);
v8.Execute(jsActual);

TestConsole is a simple class that V8Sharp makes available to the script and I use it to route text output to the Console:

public class TestConsole
{
    public TestConsole()
    {
    }
    public void Write(object output)
    {
        Console.Write(output.ToString());
    }
    public void WriteLine(object output)
    {
        Console.WriteLine(output.ToString());
    }
}

So from JavaScript code I can now do this:

Console.WriteLine("Hello World (from JavaScript)");

Building the Rest of the Unit Testing Framework

Next I brought V8 and V8Sharp together with PetaTest. The unit test program has a single test fixture and a single parameterized test case. That one test case loads one of many test scripts from an embedded resource (it could be an external file if necessary). Currently I have about 350+ of these test scripts and I've setup PetaTest so that I can invoke one, all or a subset of tests - depending on what I'm working on.

Format of the Test Scripts

Each unit test script is a text file that looks like this:

extern dynamic Console
Console.WriteLine("Hello World from Prefix");
----
Hello World from Prefix

The test script is divided into two sections separated by a dashed ---- delimiter. The top half is the Prefix code to be compiled and executed. The bottom half is the expected output.

Testing Error Reporting

Of course a compiler needs to generate not just a correctly functioning output program, it should also generate errors when there are problems in the input program. To test these, the expected output can specify an exception that should be generated.

eg:

extern dynamic Console;

public enum MyEnum
{
    a,
    b,
    c,
}

MyEnum.a=12;

-----
// exception: The left hand side of an assignment must be a variable, property or indexer

In compiling this script the unit test will fail if the compiler doesn't generate an exception containing the specified text.

Closer Inspection of the Generated JavaScript

Usually the correctness of the generated script can be confirmed by examining the expected output. There are cases however where I need to ensure that the correct output was generated in a particular way. For this there are a couple of additional directives that can be embedded in the input script to ensure the generated script does or does not contain particular content.

// should generate: Foo.prototype.str = "OK";
// should not generate: this.str = 

extern dynamic Console;

class Foo
{
    public string str = "OK";
} 

Console.WriteLine(new Foo().str);

-----
OK

Note the should generate: and should not generate: directives at the top of the script.

Compiler Options

Finally there are a few other directives that can be used to tweak how the Prefix compiler is invoked.

• // no warnings - by default the test cases are run with warnings as errors (so warnings can be tested). This option disables this.
• // release mode - run the compiler in release mode.

(Note these are directives to the test case framework - not the actual Prefix compiler).

Example output

Here's the current set of unit test results. Right now (late Aug 2011) there are about 350 unit tests, all passing except 1 - which I'm working on.

• Prefix Unit Test Results

If you click on the name of a unit test it will expand to show the input Prefix program, the expected output, the generated JavaScript and the results of the test.

Conclusion

I'm pretty happy with this testing environment. It's fast - 350+ unit tests in under 2 seconds, flexible and I get a nice output report thanks to PetaTest - the linked report above is exactly what PetaTest generates - I haven't modified or re-formatted it in any way.