Hypothetical strongly-typed functional language

better_loop.txt

// See, now it's starting to look presentable.

def main (
  set x2 (
    for n in range(1, 100) (
      mul(n, 2)
    )
  )
  
  set sum (
    reduce x2 (fn(a:int, b:int) {
      add(a, b)
    })
  )
  
  print(sum)
)

better_switch.txt

// An actual switch expression. Bam.

def classify [n:int] -> string (
  switch (
    lt(0, n): "Negative",
    eq(mod(2, n), 0): "Even Positive",
    default: "Odd Positive"
  )
)

def main [args: string*] (
  for arg in args (
    print(
      classify(parse_int(arg))
    )
  )
)

dom.txt

import <dom> as $dom

def handle_click [e: $dom.Event] (
  $dom.alert("Hello, world!")
)

def main (
  $dom.listen (
    $dom.el("#button"),
    "click",
    handle_click
  )
)

fib.txt

def fib [n: int] -> int (
  lte(1, n)
    ? n
    : add(
      fib(sub(n, 1)),
      fib(sub(n, 2))
    )
)

def main (
  print(fib(13))
)

fizz_buzz.txt

def fizz_buzz [max: int] (
  loop(max, fn (i:int) {
    print(run(add(i, 1), fn(n:int) {
      branch([
        [
          and(eq(mod(3, n), 0), eq(mod(5, n), 0)),
          "FizzBuzz"
        ],
        [
          eq(mod(3, n), 0),
          "Fizz"
        ],
        [
          eq(mod(5, n), 0),
          "Buzz"
        ]
      ])
    }))
  })
)

hello.txt

def main (
  print("Hello, world!")
)

struct.txt

// Structs can be used for easy JSON serialization...

struct Todo (
  text: string,
  
)

// Structs can be local, and defined within a function.
def main (
  struct Foo (
    status: bool,
    children: Foo* = []
  )
  
  set foo (
    new Foo (
      status = false,

      children = [
        new Foo(status = true)
      ]
    )
  )
  
  // JSON encode
  set json_string print(json_encode(foo))
  
  // Parse JSON
  print(Foo(json_string))
)

union_type.txt

// You can define a union type
type Primitive = int | double | string | bool;

// Rejects anything that is not a primitive.
def print_prim [p: Primitive] (
  print(p)
)

def main (
  print_prim(add(1, 3))
)

This has migrated to https://github.com/thosakwe/tobe_lisp

Using Shared, it's possible to share state across multiple sandboxes, using a simple mutex.

def main (
  set sum share(0)

  for i in range(1, 4) (
    fork(threadProc, [sum])
  )

  print sum.get()
)

def threadProc [sum:Shared<int>] (
  sum.set(sum.get() + 1)
)