The Basics

Braid has a tiny, imperative core language. You can assign to variables with var, do basic arithmetic, define functions with def, and write comments with #:

# Gravitational potential energy!
var g = 9.8;
def gpe(mass:Float, height:Float)
  mass * height * g;
gpe(2.0, 3.0)

This program evaluates to around 58.8. (Copy and paste any of these examples into the interactive dingus to see it working.)

Functions

You can define functions like this:

def name(arg1:Type, arg2:Type, ...)
    body

The body is just an expression. In Braid's syntax, ; sequences expressions and binds loosely; if you want a long function body, you'll want to surround it with parentheses:

def name(arg1:Type, arg2:Type, ...) (
    body;
    more body
)

You can also write lambdas (a.k.a. anonymous functions) using fun:

(fun x:Int -> x * 2)(21)

Types

Braid has the basic types Float, Int, Bool, and String built in. There's also a Void type for functions that don't return anything and an Any type for unsound interactions with the outside world.

Function types are written ArgType1 ArgType2 -> RetType. Here's a higher-order function, for example:

def twice(f:Int->Int, n:Int)
  f(f(n));
twice(fun n:Int -> n + 3, 36)

You can also create type aliases. The syntax is type NewType = OldType. Here's an example:

type Num = Float;
def add(n:Num, m:Float)
  n + m;
add(12.0, 30.0)

There are also tuples (product types), which use Rust-like constructor and destructor syntax:

def first(t: Int * String)
  (t).0;
var questions = 42, "the question";
first(questions)

Interoperation via extern

The language can also interoperate with JavaScript. Use extern to declare something from JavaScript land:

extern Math.PI: Float;
def circumference(radius:Float)
  2.0 * Math.PI * radius;
circumference(5.0)

Braid treats the entire name Math.PI as one token; the . is not significant from its perspective.

Parentheses-Free Function Syntax

There's also an ML-esque syntax for defining and invoking functions, which can occasionally be more appropriate:

var g = 9.8;
var gpe = fun mass:Float height:Float -> mass * height * g;
gpe 2.0 3.0

I realize it's somewhat silly to have both C-like call(arg, arg) syntax and ML-like call arg arg syntax, but the flexibility is occasionally convenient for some examples.