Toy structurally typed compile-to-javascript language
Haskell Scheme
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


A toy compile-to-javascript language with a structural, fully inferred type system.

Some of the current features:

  • Structural typing with row polymorphism (see below).
  • Simple Lua-like syntax without deliminators or whitespace sensitivity.
  • Translates fairly directly to understandable JavaScript.

Immediate problems:

  • Implicit 'this'
  • Primitive types such as String are also objects.

To do (short-term):

  • Sum types
  • Zero overhead 'Maybe' type (using null)
  • Extensive source comments
  • Module system


It's currently a mix of JavaScript and Lua. The JavaScript influence means it's familiar, but it has some nicities of the Lua language, including a lack of semicolons. The syntax is not whitespace significant.


var id = fn (x) { return x }

var sayHello = fn (name) {
  console.log("Hello " ++ name ++ ".")

sayHello("to you")

# Has type {name : String ...} -> ()
var sayHelloPoly = fn (thing) {
  console.log("Hello " ++ ++ ".")

sayHelloPoly({name: "to me", age: 20})
sayHelloPoly({name: "to me", nickname: "meh"})

The main differences from JavaScript here are the shortened 'function' keyword, a lack of semicolons, and the comment character (#).


The type system is fully HM type-inferred.

See: Algorithm W Step-By-Step

Objects are constructed with curly braces and are structurally typed. This means functions can take any object that implements a required interface. The type system is row polymorphic, which takes care of the loss of information problem.

See: Objects and Aspects: Row Polymorphism

Object types are represented as {field1: type1, field2: type2 ...}. The ... means the type is polymorphic, i.e. {name: String ...} will accept the object {name: "Test", age: 20}.