Cobra

Variables, control flow, loops

let declares, plain = reassigns. Truthiness, operator precedence and and/or returning the deciding operand all follow Python.

let name = "cobra"
let level = 3

if level > 5 and name != "viper"
    print("expert")
elif level > 1
    print("getting there")
else
    print("new")
end

let total = 0
for i in range(1, 11)
    if i % 2 == 0
        continue
    end
    total = total + i
end
print(total)                     # 25 — odd numbers 1..9

while total > 0
    total = total - 10
end

Functions and closures

First-class functions with real closures — inner functions capture and mutate enclosing variables.

def make_counter()
    let count = 0
    def inc()
        count = count + 1
        return count
    end
    return inc
end

let tick = make_counter()
tick()
tick()
print(tick())                    # 3

Lists and dicts

Reference types with deep equality, negative indexing, insertion-ordered dicts, and Python-named methods.

let scores = [70, 95, 80]
scores.sort()
scores.push(60)
print(scores[-1], scores.contains(95))     # 60 true

let ages = {"ada": 36, "alan": 41}
ages["grace"] = 85
print(ages.get("linus", 0))                # 0 — no KeyError surprises
for pair in ages.items()
    print(pair[0], pair[1])
end

Strings

let log = "2026-06-12 ERROR disk full"
print(log.split(" ")[1])                   # ERROR
print(log.upper().startswith("2026"))      # true
print(" | ".join(["a", "b", "c"]))         # a | b | c
print("  padded  ".strip().replace("a", "@"))

Structs — simple classes

init is the constructor, self is implicit, fields are open. Instances print themselves and type() returns the struct name.

struct Point
    def init(x, y)
        self.x = x
        self.y = y
    end
    def length()
        return self.x * self.x + self.y * self.y
    end
    def scale(f)
        self.x = self.x * f
        self.y = self.y * f
    end
end

let p = Point(3, 4)
p.scale(2)
print(p)                         # Point{x: 6, y: 8}
print(p.length(), type(p))       # 100 Point

Errors: try / catch / finally / throw

Throw any value; runtime errors are caught as their message string. Errors unwind through calls to the nearest handler; finally always runs.

def divide(a, b)
    if b == 0
        throw {"code": 400, "reason": "division by zero"}
    end
    return a / b
end

try
    divide(1, 0)
catch err
    print(err["code"], err["reason"])
finally
    print("cleanup always runs")
end

Modules

A module is just a file, run once and cached; its top-level names become members. Native modules (fs, json, …) resolve the same way.

import "geometry.cobra"
import "geometry.cobra" as geo   # cached: same module object

print(geometry.circle_area(2))
print(geo.Rect(3, 4).area())

File I/O and JSON

import "fs"
import "json"

let config = json.parse(fs.read("config.json"))
config["retries"] = 3
fs.write("config.json", json.stringify(config, 2))

for line in fs.read_lines("server.log")
    if line.contains("ERROR")
        print(line)
    end
end

HTTP client and regex

import "http"
import "json"
import "re"

let resp = http.get("https://api.github.com/repos/golang/go")
if resp["status"] == 200
    let repo = json.parse(resp["body"])
    print(repo["stargazers_count"])
end

let emails = re.find_all("\w+@\w+\.\w+", fs.read("contacts.txt"))
print(re.replace("(\w+)-(\w+)", "left-right", "$2-$1"))

An HTTP server in 20 lines

Handlers are plain Cobra functions. A raised error becomes a 500 and the server keeps running.

import "http"
import "json"

let todos = []

def handler(req)
    if req["path"] == "/api/todos" and req["method"] == "POST"
        todos.push(json.parse(req["body"]))
        return {"status": 201, "body": "created"}
    end
    if req["path"] == "/api/todos"
        return {"status": 200,
                "body": json.stringify(todos, 2),
                "headers": {"Content-Type": "application/json"}}
    end
    return {"status": 404, "body": "not found"}
end

http.serve(":8080", handler)

async / await

Calling an async def returns a task immediately. The GIL releases during every blocking call, so these three fetches take as long as the slowest one, not the sum.

import "http"

async def fetch(url)
    return http.get(url)["status"]
end

let tasks = [
    fetch("https://example.com"),
    fetch("https://example.org"),
    fetch("https://example.net")
]
for status in await tasks
    print(status)
end

try
    await fetch("not a url")
catch err
    print("caught:", err)        # task errors surface at the await
end

Processes and sockets

import "proc"
import "net"

let r = proc.shell("git log --oneline | head -3")
print(r["stdout"], r["code"])

let conn = net.connect("example.com:80")
net.send(conn, "HEAD / HTTP/1.0\r\n\r\n")
print(net.recv_line(conn))
net.close(conn)