Master
Cocotte.

Introduction

Cocotte is a compiled, dynamically-typed language built with Rust. It bridges the gap between the rapid prototyping of scripting languages and the performance profile of native software.

Installation

Automated (Recommended)

curl -fsSL https://cocotte-lang.pages.dev/install.sh | bash

Manual Installation

Download the binary for your platform from the GitHub releases page, rename it to cocotte, make it executable, and move it to a directory in your $PATH.

chmod +x cocotte
mv cocotte /usr/local/bin/

Environment Variables

Cocotte respects the following environment variables:

CLI Reference

Project Layout

Cocotte follows a "convention over configuration" approach. A standard project structure ensures compatibility with all CLI tools.

Syntax: Core

Data Types

Variables & Scoping

Cocotte uses block-level scoping. Use var for declarations. Re-declaration in the same scope is a compile-time error.

var x = 10
{
    var x = 20 # New scope, valid shadowing
    print x    # Prints 20
}
print x        # Prints 10

Truthiness

Only false and nil are falsy. Everything else, including 0 and "", is truthy.

if 0
    print "Zero is truthy!"
end

if ""
    print "Empty string is truthy!"
end

Syntax: Classes & OOP

Cocotte implements a prototype-based class system. The init method serves as the constructor.

class Animal
    func init(name)
        self.name = name
    end

    func eat()
        print self.name + " is eating"
    end
end

class Cat < Animal # Inheritance
    func speak()
        print "Meow"
    end
end

var kitty = Cat("Luna")
kitty.eat()
kitty.speak()

Error Handling

Cocotte uses a try/catch mechanism for runtime exceptions. You can manually trigger errors using the error keyword.

try
    var f = open("missing.txt", "r")
catch e
    print "Failed to open file: " + e
end

func validate(n)
    if n < 0
        error "Number must be positive"
    end
end

String Methods

Global Functions

List Methods

Map Methods

File I/O

Cocotte provides high-level primitives for interacting with the file system. These operations are synchronous and optimized for developer productivity.

# Reading a file
var content = read_file("config.json")

# Writing a file
write_file("logs.txt", "Execution started
")

# Path manipulation
var exists = file_exists("data.db")
if exists
    delete_file("data.db")
end

SQLite Integration

Embedded database support for persistent data storage. Uses the standard SQLite engine.

module add "sqlite"

var db = sqlite.open("data.db")

db.execute("CREATE TABLE users (id INT, name TEXT)")
db.execute("INSERT INTO users VALUES (1, 'Alice')")

var rows = db.query("SELECT * FROM users")
for row in rows
    print row.get("name")
end

db.close()

JSON Handling

Bidirectional conversion between Cocotte data structures and JSON strings.

module add "json"

var raw = '{"name": "Cocotte", "version": 1.0}'
var data = json.parse(raw)
print data.get("name")

var encoded = json.stringify({"id": 42})
print encoded

Mathematics

HTTP Client & Server

module add "http"

# GET Request
var data = http.get("https://api.github.com/zen")
print data

# POST with JSON
var user = {"name": "Cocotte"}
var resp = http.post_json("https://httpbin.org/post", user)

module add "http"

http.serve(3000, func(req)
    var method = req.get("method")
    var path = req.get("path")
    
    print "Log: " + method + " " + path
    
    return {
        "status": 200,
        "body": "Hello from Cocotte Server!",
        "headers": {"Content-Type": "text/plain"}
    }
end)

GUI: Charlotte

Charlotte is an immediate-mode GUI toolkit powered by egui. It renders hardware-accelerated interfaces with minimal overhead.

module add "charlotte"

var state = {"clicks": 0}

charlotte.window("App", 400, 300, func(ui)
    ui.heading("Click Counter")
    ui.label("Current count: " + state.get("clicks"))
    
    if ui.button("Add +1")
        state.set("clicks", state.get("clicks") + 1)
    end
end)

Testing & Debugging

Built-in Assertions

Use the global assertion suite for robust unit testing.

# my_test.cot
func add(a, b) return a + b end

assert_eq(add(1, 1), 2)
assert_ne(add(1, 1), 3)
assert(true) # General boolean check

Debugging Hooks

The debug_inspect(val) function provides a deep print of any data structure, including class instances.

var complex = {"a": [1, 2], "b": {"c": true}}
debug_inspect(complex)

Automation: Charlotfile

The Charlotfile allows you to define project-specific tasks and automation scripts using Cocotte syntax. Run tasks with cocotte exec <task>.

# Charlotfile
task "build"
    exec "cocotte build --release"
end

task "clean"
    delete_file("bin/main")
end

Config: Millet.toml

The project manifest file defines metadata, dependencies, and compilation targets. It's the central configuration for your Cocotte project.

[project]
name = "MyProject"
version = "0.1.0"
authors = ["You"]

[dependencies]
http = "latest"
json = "local:./lib/json"

[build]
entry = "src/main.cot"
target = "native"

Cross-Compilation

Cocotte leverages LLVM to enable seamless cross-compilation from a single host machine to various targets, making it easy to distribute your application.

# Compile for Windows from Linux
cocotte build --target x86_64-pc-windows-msvc

# Compile for ARM64 Linux
cocotte build --target aarch64-unknown-linux-gnu

Deployment Guide

Since Cocotte compiles to a static, standalone binary with zero dependencies, deployment is as simple as copying the file to your server or packaging it in a minimal Docker container.

FROM scratch
COPY bin/app /app
ENTRYPOINT ["/app"]

Performance & Profiling