indutny/candor

// Defining a recursive function
factorial(x) {
  if (x == 1) return 1
  return x * factorial(x - 1)
}

factorial(10)

// Implementing a forEach function
forEach(array, callback) {
  if (typeof array != "array") return
  length = sizeof array
  i = 0
  while (i < length) {
    callback(i, array[i])
    i++
  }
}

// Implementing switch with chained if..else
type = typeof value
if      (type == "nil")     handleNil(value)
else if (type == "boolean") handleBoolean(value)
else if (type == "number")  handleNumber(value)
else if (type == "string")  handleString(value)
else handleObject(value)

// Implementing switch using objects
handlers = {
  "nil":     handleNil,
  "boolean": handleBoolean,
  "number":  handleNumber,
  "string":  handleString
}
handler = handlers[typeof value]
if (handler) handler(value)
else handleObject(value)

// 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