Tawla is a small language that
compiles to real machine code.

$ pip install tawla

$ tawlac run app.twl     # compile and run a file
$ tawlac new myapp       # scaffold a new project
$ tawlac version         # print the version
$ tawlac help            # or: tawlac help run

class Main {
    void main() {
        print("Hello, Tawla!");
    }
}

$ tawlac run hello.twl
Hello, Tawla!

int count = 67;
float pi = 3.14159;       // float and double are the same 64-bit type
bool ready = true;
string name = "Ahmed";
var inferred = 42;        // an int

int x;                    // declared without a value -> 0
bool flag;                // -> false

print(count);             // 67
print(name + "!");        // Ahmed!
print(7 / 2);             // 3   (integer division)
print(7.0 / 2);           // 3.5 (a float makes it floating point)

bool ok = age >= 18 && verified;   // && and  || or  ! not
bool any = retry || fallback;
if (!found) { print("missing"); }

// short-circuit: the right side is skipped when the left decides it,
// so this never calls a method on a null reference:
if (user != null && user.active()) { print("hi"); }

// ternary: cond ? a : b  (only the taken branch runs)
int max = a > b ? a : b;
string label = n == 0 ? "zero" : n < 10 ? "small" : "big";

int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum = sum + i;
}
print(sum);               // 55

int n = 8;
while (n > 1) {
    if (n == 2 * (n / 2)) { n = n / 2; } else { n = 3 * n + 1; }
}

int factorial(int n) {
    if (n <= 1) { return 1; }
    return n * factorial(n - 1);
}

void greet(string who) {
    print("Hello, " + who);
}

print(factorial(5));      // 120
greet("world");

class Point {
    private int x;
    private int y;

    public Point(int px, int py) {
        this.x = px;
        this.y = py;
    }

    public int sum() { return this.x + this.y; }
}

class Main {
    void main() {
        Point p = new Point(3, 4);
        print(p.sum());       // 7
    }
}

class Counter {
    private int count;                          // hidden

    public Counter() { this.count = 0; }
    public void bump() { this.count = this.count + 1; }
    public int value() { return this.count; }
}

class Main {
    void main() {
        Counter c = new Counter();
        c.bump(); c.bump();
        print(c.value());     // 2
        // c.count here would be a compile error: count is private
    }
}

class Animal {
    protected int legs;
    public Animal(int n) { this.legs = n; }
    public int legCount() { return this.legs; }
    public string speak() { return "..."; }
}

class Dog : Animal {
    public Dog() { super(4); }
    public string speak() { return "woof"; }   // override
}

class Main {
    void main() {
        Animal a = new Dog();      // static type Animal, runtime Dog
        print(a.speak());          // woof  (dynamic dispatch)
        print(a.legCount());       // 4
    }
}

interface Shape {
    int area();
}

class Square : Shape {
    private int side;
    public Square(int s) { this.side = s; }
    public int area() { return this.side * this.side; }
}

int areaOf(Shape s) { return s.area(); }   // works for any Shape

class Main {
    void main() {
        print(areaOf(new Square(5)));      // 25
    }
}

abstract class Animal {
    public abstract int speak();          // no body
    public int legs() { return 4; }       // concrete, inherited
}

class Cat : Animal {
    public int speak() { return 2; }      // must implement
}

class Box<T> {
    private T value;
    public Box(T v) { this.value = v; }
    public T get() { return this.value; }
}

class Main {
    void main() {
        Box<int> n = new Box<int>(42);
        print(n.get());                        // 42

        var s = new Box<string>("boxed");      // var also works
        print(s.get());                        // boxed
    }
}

User u;                    // a declaration with no value -> null
if (u == null) {
    print("no user yet");
}

string name = u != null ? u.name() : "guest";   // safe with short-circuit/ternary

int[] a = new int[5];
int i = 0;
while (i < a.length) {
    a[i] = i * i;
    i = i + 1;
}
print(a[4]);              // 16
// a[9] would abort with "array index out of bounds"

string s = "hello";
print(s.length);              // 5
print(charAt(s, 0));          // 104  (the character code of 'h')
print(substring(s, 1, 4));    // ell

int n = toInt("40") + 2;
print(toString(n));           // 42
print(toFloat("3.5") * 2.0);  // 7

import "IO.twl";

class Main {
    void main() {
        write("What's your name? ");
        string name = readLine();
        write("How old are you? ");
        int age = readInt();
        print("Hi " + name);
        print(age + 1);          // your age next year
    }
}

import "Collections.twl";

class Main {
    void main() {
        List<int> xs = new List<int>();
        xs.add(10); xs.add(20); xs.add(30);
        print(xs.size());          // 3
        print(xs.get(1));          // 20
        xs.set(1, 99);

        Map<string, int> ages = new Map<string, int>();
        ages.put("Ahmed", 36);
        print(ages.has("Ahmed"));  // true
        print(ages.get("Ahmed"));  // 36
    }
}

import "Json.twl";

Json d = parseJson("{\"name\": \"Ahmed\", \"tags\": [\"twl\", \"py\"]}");
print(d.get("name").asString());        // Ahmed
print(d.get("tags").size());            // 2
print(d.get("tags").at(0).asString());  // twl
if (d.get("admin").isNull()) { print("no admin field"); }

import "Json.twl";

Json out = jsonObject();
out.setString("status", "ok");
out.setInt("count", 3);
print(out.toString());                  // {"status":"ok","count":3}

import "Http.twl";

class Health : Handler {
    public void handle(Request req) { req.respond(200, "ok"); }
}
class Echo : Handler {
    public void handle(Request req) { req.respond(200, req.body()); }
}

class Main {
    void main() {
        Router router = new Router();
        router.get("/health", new Health());
        router.post("/echo", new Echo());

        print("listening on http://localhost:8080");
        new Server(8080).serve(router);
    }
}

class GetUser : Handler {
    public void handle(Request req) {
        req.respond(200, "user " + req.param("id"));
    }
}
// ...
router.get("/users/:id", new GetUser());

import "Http.twl";
import "Json.twl";

class Main {
    void main() {
        Response r = fetch("http://localhost:8080/health");
        if (r.status() == 200) {
            print(r.body());
        }

        Json payload = jsonObject();
        payload.setString("name", "Ahmed");
        Response created = httpRequest("POST", "http://localhost:8080/users", payload.toString());
        print(created.status());
    }
}

Db db = new Db("app.db");
db.exec("CREATE TABLE users(id INTEGER PRIMARY KEY, name TEXT, age INT)");

Stmt ins = db.prepare("INSERT INTO users(name, age) VALUES (?, ?)");
ins.bindString(0, "Ada"); ins.bindInt(1, 36); ins.exec();

Stmt q = db.prepare("SELECT name FROM users WHERE age > ?");
q.bindInt(0, 18);
Rows r = q.query();
while (r.next()) { print(r.getString("name")); }

string id = uuid();
string sig = hmacSha256("secret-key", id);
writeFile("audit.log", id + " " + sig + "\n");
string mode = getenv("APP_MODE");
if (mode == null) { mode = "dev"; }

print("hi ${user.name}, ${n + 1} items");

// every class can serialize itself
req.respondJson(200, user.toJson());   // {"id":7,"name":"Ada",...}

fuck_around {
    throw "something broke";
} find_out (e) {
    print(e);                 // something broke
}

fuck_around {
    int[] a = new int[2];
    print(a[9]);              // out of bounds is catchable
} find_out (e) {
    print("recovered");
}

$ tawlac new myapp     # create ./myapp with a starter project
$ cd myapp
$ tawlac run           # runs the manifest's entry point

$ mkdir hello && cd hello
$ tawlac init          # scaffold a project in the current directory
$ tawlac run