Kairo: The Language Beyond C++

import std  // import only what you need

// No main() required top-level code runs immediately
// or is callable when imported as a module.
const name  = "Kairo"
var   count = 0

for i in 0..5 {
    std::print(f"Hello, {name}! Count is {count}.")
    count++
}

std::println(f"Ran {count} times.")

 // Call C++ code directly from Kairo with perfect ABI compatibility.
 // my_cpp_lib.hpp contains:
 //
 // int add(int a, int b) { return a + b; }
 // namespace my_cpp_lib {
 //     std::string greet(std::string name) { return "Hello, " + name + "!"; }
 // }
 //
 // C++ namespaces map directly to Kairo module syntax.
 // Functions with no namespace are callable without qualification.

 ffi "c++" import "my_cpp_lib.hpp"  // import a C++ header directly as a module.
                                    // no wrapper generation, no binding step.

 const sum      = add(3, 4)  // direct call, zero overhead.
 var   greeting = my_cpp_lib::greet("Kairo")

 greeting += " Welcome to seamless interop!"  // C++ std::string, manipulated
                                              // directly in Kairo, no conversion.

 std::println(greeting)  // Hello, Kairo! Welcome to seamless interop!

// Call Kairo functions directly from C++ with full ABI compatibility.
// KCC (Kairo C++ Compiler) is the tool that allows you to include Kairo modules directly in C++.
//   `kcc kairo_ffi.cpp` - kcc is a drop-in clang-compatible driver that can include Kairo files.
// Without -cc, use `kairo kairo_ffi.k -c -o kairo_ffi -xc++ -header kairo_ffi.hh` to generate C++ or C headers
// for shipping a Kairo library to C++ consumers.
//
// kairo_ffi.k:
//   import std
//   fn add(a: i32, b: i32) -> i32 { return a + b }
//   fn greet(name: string) -> string { return f"Hello, {name}!" }
//
// Kairo wraps the module under its filename as the exposed C++ namespace.

#include "kairo_ffi.k"  // include the Kairo module directly.
#include <iostream>

int main() {
    int sum = kairo_ffi::add(3, 4);  // direct call, no overhead.
    std::string greeting = kairo_ffi::greet("C++");

    greeting += " Welcome to seamless interop!";

    std::cout << greeting << std::endl;  // Hello, C++! Welcome to seamless interop!
    return 0;
}

 import std

 struct Buffer {
     const size: usize
     var   data: *byte  // safe pointer to a heap allocation

     fn op new (self, size: usize) {
         self.data = std::Memory::alloc(size)
         self.size = size // only the constructor can set size.
     }

     fn op delete (self) {
         std::Memory::free(self.data)
         // compiler hard errors, if we do not free the memory.
         // Even though the compiler proves and has enough information
         // to add the free automatically, it does not, for explicitness
         // and code clarity.
     }

     fn op [](self, i: usize) panic -> *u8 {
         if i >= self.size {
             var x = 0
             return &x // since this is a stack pointer, in debug builds,
                       // Tether changes the decl of x to a unique or shared
                       // pointer, so theres no undefined behavior.
                       // In release builds, hard error with a fix:
                       // var *x = std::Unique<u8>(0)
         }
         return self.data + i
     }
 }

 var buf = Buffer(1024)  // 1KB on the heap.
                         // destructor runs automatically when buf goes out of scope.
 buf[0] = 42
 

import std
import json // imagine this is a complex JSON library

@json::Serializable
struct Config {
    var host:    string;
    var port:    u16;
    var workers: u32 = 4;
}

fn <T impl json::Serializable> json_parse(raw: string) panic -> T;
// imagine this has a complex implementation that can panic with Json::Error::Parse

fn read_file(path: string) panic -> string;
// imagine this has a complex implementation that can panic with Fs::Error::NotFound,
// or Fs::Error::PermissionDenied

fn parse_config(path: string) panic -> Config {
    var raw: string

    raw = read_file(path)
    return json_parse(raw)

    catch _: Fs::Error::NotFound {
        std::println(f"Config file not found: {path}")
        return Config { host: "localhost", port: 8080 }  // recover with a default.
    } catch e: Json::Error::Parse {
        std::println(f"Failed to parse config with error: {e}")
        return Config { host: "localhost", port: 8080 }  // recover with a default.
    } catch e { // We don't care about Fs::Error::PermissionDenied thats the
                // caller's problem, if we don't catch all possible panics,
                // the compiler will error, we can catch it and re-panic.
        panic e // propagate unexpected errors without wrapping or losing context.
    }
}

fn start_server(path: string) -> Config {
    try {
        const config = parse_config(path)
        // parse_config is marked `panic`, so we must catch its errors that
        // can reach this scope (in this case, Fs::Error::PermissionDenied).
        std::println(f"Starting {config.host}:{config.port} {config.workers}workers...")
        return config
    } catch _: Fs::Error::PermissionDenied {
        std::println(f"Permission denied when reading config file: {path}")
        return Config { host: "localhost", port: 8080 }  // recover with a default.
    } // every reachable panic is handled, no panic is needed in this function.
}     // callers of start_server need no error handling at all.