Candor

Candor is a language inspired by javascript, but with less features and, therefore, less complexity. So no semicolons, no exceptions and simplified anonymous function syntax (dart-like).

Main goal of Candor is to provide a powerful and developer-friendly language that can be easily optimized by compiler.

Language basics

Candor is essentially inspired by the ECMA-script, but has much less features and complexity (for compiler).

Functions are declared in dart-like style, variables are implicitly scoped (i.e. if variable has no use in outer scopes, it'll be allocated in one where you declared it).

// Keywords: nil, true, false, typeof
// sizeof, keysof, if, else, while,
// for, break, continue, return, new

// Primitives
nil
true
false
NaN
1
'abc'
"abc"
[1, 2, 3]
{ a: 1, 'b': 2, "c": 3 }

// Variables and objects
a = 1
a.b = "abc"
a.b.c = a
a[b()][c] = x

delete a[b] // removes key and value from object

// While object literals are restricted to
// declaring strings as keys, any value
// can be used as a key. This allows for all
// kinds of interesting data structures like
// efficient sets and unique unguessable keys.
a = { "5": "five" }
a[5] = 5
a["5"]         // -> "five"
a[5]           // -> 5
a[{ hello: "World" }] = "key is object, value is string!"

// Functions
a() {
return 1
}
a()
// Functions are also objects and can have properties
a.b = "foo"

// Arrays are also objects, except they
// internally keep track of the largest
// integer index so that sizeof works with them.
a = [1,2,3]
a.foo = true
sizeof a       // -> 3
a.foo          // -> true

// typeof.  Sometimes it's useful to know what type a variable is

typeof nil     // -> "nil"
typeof true    // -> "boolean"
typeof false   // -> "boolean"
typeof 42      // -> "number"
typeof "Hello" // -> "string"
typeof [1,2,3] // -> "array"
typeof {a: 5}  // -> "object"
typeof (){}    // -> "function"

// sizeof gives the size of an array (max integer key + 1)
// or string (number of bytes)
// gives nil for other types

sizeof "Hello" // -> 5
sizeof [1,2,3] // -> 3
sizeof {}      // -> 0

// keysof returns an array of all the keys in an object
keys = keysof { name: "Tim", age: 29 }
keys           // -> ["name", "age"]

// Control flow

// The variables in the condition head are scoped with the condition,
// not the optional body block.

// Conditionals
person = { age: 29, name: "Tim" }

// With block
if (person.age > 18) {
  person.name  // -> "Tim"
}

// Without block
if (person.age > 18) person.name

// using else
if (person.age > 18) {
  // do something with `person`
} else {
  // do something else
}

if (person.age > 18) action(person)
else otherAction()

// While loops
i = 0
sum = 0
while (i < 10) {
  sum = sum + i
  i++
}

// break and continue. `while` loop can have
// `break` and `continue`
// break exits a loop immediately, continue,
// skips to the next iteration

// Object Oriented Programming

// There are no dynamic prototypes in candor,
// but there is a fast-clone
// operation and special method calling syntax
// to make OOP style programming
// possible if you prefer that style.

// Create a prototype object
Rectangle = {
  getArea: (self) {
    return self.w * self.h
  },
  initialize: (self, w, h) {
    self.w = w
    self.h = h
  }
}

// First create a fast shallow clone of
// the Rectangle prototype
rect = clone Rectangle

// Then initialize it using a one of the functions
rect.initialize(rect, 3, 5)

// Now we can use this object
rect.getArea(rect) // -> 15

// To make calling methods easier, there is
// special syntax sugar using `:`
// instead of `.` for function calls
// It means to call the function with
// whatever is left of the `:` as the first argument.

// The previous two calls can be written as:
rect:initialize(3, 5)
rect:getArea() // -> 15