CSquared

• PipelineReader → Lexer → Parser → Evaluator
• Functionsfirst-class · closures · recursion
• Typesint · real · string · bool · object · array · lambda
• Concurrencyasync · parallel · lock
• HostC# · .NET 4.5
• WrittenBy hand · 2015

1. 01
   read

   Walk the source

   The Reader streams the program file one character at a time, keeping a running line and position so any error can point straight at the place that caused it.

2. 02
   scan

   Group into tokens

   The Lexer turns that stream of characters into lexemes: keywords, identifiers, numbers, strings, operators. A pushback stack lets it hand a token back, so the parser can peek ahead and change its mind.

3. 03
   parse

   Fold into a tree

   The Parser is recursive descent with one token of lookahead. It reads the flat run of tokens and folds them into a tree of statements and expressions: the shape of the program, made explicit.

4. 04
   evaluate

   Make it mean something

   The Evaluator walks that tree and asks each node to evaluate itself. A literal returns a value, an if chooses a branch, a lambda call binds arguments and runs a body. Behavior falls out of the walk.

5. 05
   resolve

   Remember the scopes

   Every evaluation happens against an Environment: a chain of scopes linked to their parents. Lookups walk outward until they find a name, and a closure simply holds onto the scope it was born in.

1. 01

   One node, two files

   Every construct in the language is a single C# class split in half. The parser side, under Parser/Types, holds only its shape: the fields it parsed. The evaluator side, under Evaluator/Evaluables, holds only its behavior: a single Evaluate method. The compiler fuses the two halves into one type.

   in contextThis is the old tension between adding new node types and adding new operations, quietly resolved with a language feature instead of a visitor or a giant switch. To add a feature you add two small files and nothing else changes. The parser never imports the runtime, and the runtime never re-describes the syntax.

2. 02

   Functions are values, and they remember

   Lambdas are first-class. You can store them in variables, pass them as arguments, return them from other functions, and recurse through them. A declared lambda captures the environment it was written in, so an object's method can still see the object's fields long after the object was built.

   in contextFirst-class functions with real closures, hand-rolled in 2015. An object in CSquared is little more than an environment with a face, which is exactly why a method closes over its siblings. The same model JavaScript and Python lean on, reached by building it rather than reading about it.

3. 03

   Objects you can push and pop

   An object doubles as a stack. The arrow operators add and remove anonymous members: list <- value pushes onto the end, and value <- list pops from the front. Their mirror image, ->, works from the other side. A handful of characters turn a plain object into a queue or a stack.

   in contextIt is a small, opinionated primitive, and it pays for itself immediately. The reverse-Polish calculator below is a dozen lines precisely because the operand stack is just an object with two arrows pointed at it.

4. 04

   Real concurrency, not a toy

   async runs an expression on a background task and hands you a future; touch the value later and it blocks only if the work is still going. parallel foreach runs every iteration at once. lock guards a variable so two threads cannot tangle over it.

   in contextMost languages built for fun stop at sequential execution. CSquared shipped futures, data-parallel loops, and mutual exclusion. Under the hood each maps onto something the host already did well: async becomes a task, parallel foreach becomes a parallel query, and lock guards the variable's box directly.

Three small programs, each leaning on a different corner of the language. The output is what the interpreter actually prints.

// objects hold fields and methods that close over them
var person = {
    var name = "chris caruso";
    var age = 21;
    var greet = () => name + " · " + age;
};

println(person.greet());

chris caruso · 21

// reverse-Polish calculator — an object is the stack
var stack = { };

stack <- 3;          // push
stack <- 4;          // push

var b; var a;
stack -> b;          // pop  4
stack -> a;          // pop  3

stack <- a + b;      // push the sum

var result;
stack -> result;
println(result);

7

// four jobs, one counter, no tangles
var counter = 0;

var work = () => {
    var i = 0;
    while (i < 250000) {
        lock (counter) { counter = counter + 1; }
        i = i + 1;
    }
};

var jobs = { };
jobs <- work; jobs <- work;
jobs <- work; jobs <- work;

parallel foreach (job in jobs) { job(); }

println(counter);

1000000

The whole interpreter, reader to evaluator, ported to run in your browser. Pick an example or write your own, then press Run. Nothing leaves this page.

// First-class lambdas that remember where they were born.
var fib = (n) => {
    if (n < 2) { return n; }
    return fib(n - 1) + fib(n - 2);
};

var i = 0;
while (i <= 10) {
    print("fib(" + i);
    println(") = " + fib(i));
    i = i + 1;
}

Press Run to execute the program.