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.
Permalink
Failed to load latest commit information.
TypeCheck
.gitignore
Javascript.hs
Lex.hs
Main.hs
Parse.hs
Setup.hs
StrictScript.cabal
readme.md
test.ss

readme.md

StrictScript

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

Syntax

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.

Example:

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 " ++ thing.name ++ ".")
}

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 (#).

Types

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}.