Language Profile

Resumen rapido del posicionamiento tecnico del lenguaje (paradigma, ejecucion y tipado).

Scope

Documenta el estado de Clot al 2026-03-07. La cobertura corresponde a parser, interpreter, static analyzer, backend LLVM AOT, runtime bridge, i18n y modulos disponibles.

Audience Paths

Style and Conventions

• Todos los ejemplos usan sentencias terminadas con ; cuando aplica.
• Se usa snake_case para variables y nombres de modulo.
• Documenta siempre las precondiciones de funciones que toquen archivos o tipos numericos restringidos.
• Para semantica exacta de errores, usa --lang en si deseas diagnosticos en ingles.

Highlights

Compatibility Notes

• print() sin expresion sigue siendo invalido; usa println() para solo salto de linea.
• long mantiene rango estricto de 64 bits signed.
• double ya no es el default para enteros literales; int (BigInt) es el default.
• for mantiene cabecera estilo Java (for (init; cond; update):) y tambien acepta for item in coleccion: sin parentesis para rangos/iterables simples.
• continue; solo es valido dentro de bucles. Si aparece dentro de un switch anidado en un bucle, continua la iteracion del bucle externo.
• defer solo acepta sentencias simples y se ejecuta en orden LIFO al salir del bloque actual.
• return puede abrirse en una linea y cerrar en otra; el terminador ; sigue siendo obligatorio.
• in verifica elementos en list/tuple/set, claves en map, nombres de propiedad en object y substring en string.
• En LLVM AOT nativo aun no hay lowering dedicado para switch, for-each, do-while, finally, defer ni el operador in; compile mode puede resolverlos via runtime bridge.

Instalacion Rapida

Instala Clot con los binarios de release y ejecuta tu primer archivo en minutos.

curl -fsSL https://raw.githubusercontent.com/jclot/ClotLang/master/scripts/install.sh | bash
clot programa.clot

iwr -useb https://raw.githubusercontent.com/jclot/ClotLang/master/scripts/install.ps1 | iex
clot programa.clot

Personalizacion

# Linux/macOS: fijar version o prefijo
CLOT_VERSION=v0.2.0 CLOT_PREFIX=~/.local curl -fsSL https://raw.githubusercontent.com/jclot/ClotLang/master/scripts/install.sh | bash

# Windows: fijar version o ruta
$env:CLOT_VERSION="v0.2.0"
$env:CLOT_INSTALL_DIR="C:\Ruta\Clot"
iwr -useb https://raw.githubusercontent.com/jclot/ClotLang/master/scripts/install.ps1 | iex

Checksums

# Linux/macOS
shasum -a 256 clot-linux-x86_64.tar.gz

# Windows
Get-FileHash clot-windows-x86_64.zip -Algorithm SHA256

Desinstalar

bash scripts/uninstall.sh

iwr -useb https://raw.githubusercontent.com/jclot/ClotLang/master/scripts/uninstall.ps1 | iex

Quickstart

Desde la raiz del repo, primero compila con CMake y luego ejecuta el binario generado.

Si ya instalaste con los binarios de release, puedes saltar directo a los ejemplos y la guia de Control Flow.

# Opcion recomendada (presets WSL)
cmake --preset wsl-release
cmake --build --preset build-release -j4
# binario: ./build/wsl-release/clot

# Opcion directa (sin presets)
cmake -S . -B build -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DCLOT_ENABLE_LLVM=ON
cmake --build build -j4
# binario: ./build/clot

• cmake --build ...: build normal (sin forzar paralelismo).
• -j4: 4 tareas en paralelo (acelera compilacion).
• -jN: fija N tareas en paralelo (ej. -j8).
• --parallel: paralelismo automatico segun el sistema.
• --parallel N: paralelismo fijo con N tareas.

# Ejecutar en modo interprete
./build/wsl-release/clot hello.clot

# Analisis estatico
./build/wsl-release/clot hello.clot --mode analyze

# Compilar AOT con LLVM (si disponible)
./build/wsl-release/clot hello.clot --mode compile --emit exe -o hello

Si usaste la opcion sin presets, reemplaza ./build/wsl-release/clot por ./build/clot en los comandos.

// hello.clot
name = "Clot";
print("Hola, {name}\\n");
printf("%s %d\\n", "Version", 1);

Control Flow

Clot mantiene su estilo de bloques con : y cierres explicitos, pero ahora cubre el repertorio de control de flujo que normalmente se espera en un lenguaje imperativo moderno: while, for clasico, for-each, do-while, switch, break, continue y pass.

const long limit = 6;
sum = 0;

for (int i = 0; i < limit; i++):
    if(i == 1):
        continue;
    endif
    if(i == 4):
        break;
    endif
    sum += i;
endfor

for (const item in [10, 20, 30]):
    println(item);
endfor

for i in range(3):
    println(i);
endfor

switch(sum):
    case 5:
        println("five");
        break;
    default:
        pass;
endswitch

do:
    sum -= 1;
while(sum > 0);

println("na" in "banana");
println("name" in {name: "Ada"});

• for (init; cond; update): acepta declaraciones, mutaciones o expresiones simples en init y update.
• for (item in coleccion): y for item in coleccion: iteran listas, tuple, set, map, object o string; const en el binding es opcional.
• switch usa fallthrough estilo Java hasta encontrar break; o terminar el bloque.
• pass; es un placeholder valido y no ejecuta ninguna accion.

Ejemplo rapido de for

// for clasico
for (int i = 0; i < 3; i++):
    println("classic {i}");
endfor

// for sobre rango numerico
for i in range(3):
    println("range {i}");
endfor

Strings, Listas y Encadenamiento

// Escapes + interpolacion
user = "Ada";
total = 3;
print("Hola {user}\\n");
println("Tienes {total} notificaciones");
println("precio=" + 300.0);   // conversion implicita a string
println("Plantilla {{user}}"); // imprime: Plantilla {user}

// append en listas
tasks = [];
tasks.append("build");
tasks.append("test");
println(tasks[1]);            // "test"

// acceso encadenado
records = [{meta: {name: "Ana"}}];
println(records[0].meta.name);

// inicializacion por repeticion
slots = [null] * 4;
println(len(slots));          // 4

// encadenamiento general de llamadas
class Counter:
    public int value = 0;
    public func Counter add(delta: int):
        this.value += delta;
        return this;
    endfunc
    public func int value_get():
        return this.value;
    endfunc
endclass

println(Counter().add(2).add(3).value_get()); // 5

Return multilinea

func int pair_sum(a: int, b: int):
    return
        (
            a +
            b
        );
endfunc

println(pair_sum(4, 5)); // 9

Error comun: append (incorrecto vs correcto)

// Incorrecto: tuple no soporta append
tuple pair = tuple("a", "b");
pair.append("c");                 // runtime error

// Correcto: append en list
items = [];
items.append("a");
items.append("b");
println(items);                   // ["a", "b"]

Functions and References

func float free_fall_height(h0: float, v0: float, t: float, g: float = 9.81):
    return h0 + v0 * t - (g * t * t) / 2;
endfunc

println(free_fall_height(100.0, 0.0, 2.0));       // usa g por defecto
println(free_fall_height(100.0, 0.0, 2.0, 10.0)); // override

func inc_and_print(&x):
    x += 1;
    println(x);
endfunc

int n = 10;
inc_and_print(&n);

func ping():
    println("pong");
endfunc

function f = ping();   // referencia a funcion
f();
println(ping());       // imprime "pong" y luego "null"

OOP from Zero

Si nunca has usado OOP en Clot, piensa en class como un molde (template) y en cada objeto como una instancia creada desde ese molde.

1. Define el contrato con interface (que metodos debe exponer la clase).
2. Define la clase con atributos y constructor.
3. Crea objetos llamando el nombre de la clase como funcion.
4. Usa this para referirte al objeto actual.
5. Usa super(...) si heredas con extends.

interface Greeter:
    func string greet();
endinterface

class Person implements Greeter:
    private string _name;

    constructor(name: string):
        this._name = name;
    endconstructor

    public func string greet():
        return "Hola, soy " + this._name;
    endfunc
endclass

p = Person("Ada");
println(p.greet());

Error Handling

Clot soporta throw(value) y cuatro variantes de catch: catch:, catch(err):, catch(Tipo): y catch(Tipo err):. Ademas, finally: es opcional y siempre se ejecuta al cerrar el try. Solo se permite un bloque catch por try. Las formas validas son try/catch, try/finally y try/catch/finally; si aparece, finally siempre va de ultimo. En errores runtime internos, el binding de catch recibe un string localizado; en throw(objeto) recibe el valor lanzado. Si una excepcion no encuentra catch compatible, la ejecucion termina con Excepcion no capturada: Tipo: mensaje (o Unhandled Exception en ingles).

import clot.core.exceptions;

// 1) catch(err): captura cualquier error y expone binding
try:
    throw("boom");
catch(err):
    println(err);
endtry

// 2) catch(Tipo err): captura por tipo + binding
try:
    throw(TypeError("dato invalido"));
catch(TypeError err):
    println(err.message);
endtry

// 3) catch(Tipo): captura por tipo sin binding
try:
    throw(ArgumentError("faltan argumentos"));
catch(ArgumentError):
    println("argument error");
endtry

// 4) catch: captura generica sin binding
try:
    throw(IOError("no se pudo abrir"));
catch:
    println("generic catch");
endtry

// finally y defer en accion
func demo_cleanup():
    defer println("defer: ultimo en declararse, primero en ejecutar");
    defer println("defer: cleanup interno");

    try:
        throw("boom");
    catch(err):
        println(err);
    finally:
        println("finally: cleanup del try");
    endtry
endfunc

demo_cleanup();

// throw sin try/catch (excepcion no capturada) usando funcion
import clot.core.exceptions;

func fail():
    throw(Exception("Something went wrong"));
endfunc

fail();

// Resultado:
// Excepcion no capturada: Exception: Something went wrong

Exception Types (Current)

// Ejemplos runtime inferidos (sin construir objeto manual):
try:
    println(missing_name);
catch(NameError err):
    println(err);
endtry

try:
    obj = {name: "Ada"};
    println(obj.age);
catch(AttributeError err):
    println(err);
endtry

try:
    type();
catch(MissingArgumentError err):
    println(err);
endtry

try:
    input("a", "b");
catch(TooManyArgumentsError err):
    println(err);
endtry

try:
    read_file("missing.txt");
catch(FileNotFoundError err):
    println(err);
endtry

try:
    sleep_ms(-1);
catch(RangeError err):
    println(err);
endtry

try:
    import ghost.module;
catch(ModuleNotFoundError err):
    println(err);
endtry

Analyze and Compile Pipeline

1. Ejecuta --mode analyze para detectar fallas tipicas antes de runtime.
2. Corre en interprete para validar comportamiento dinamico.
3. Compila con LLVM cuando tu subset de programa sea compatible con AOT.
4. Para QA de fases, usa el test diferencial interpret vs compile y el baseline de benchmarks.

./build/wsl-release/clot app.clot --mode analyze --lang en
./build/wsl-release/clot app.clot --lang en
./build/wsl-release/clot app.clot --mode compile --emit exe -o app --runtime-bridge external
scripts/diff_interpret_compile.sh ./build/wsl-release/clot app.clot
benchmarks/baseline.sh ./build/wsl-release/clot

Lexical Structure

Type System (Modifier and Type Summary)

Declaraciones locales tipadas (explicitas)

Puedes declarar variables locales con tipo explicito usando la misma sintaxis de tipos del lenguaje. La validacion ocurre en runtime al asignar y al reasignar.

string nombre = "Ada";
bool activo = true;
null vacio = null;

list bolsa = [1, "dos", true];      // tipado de contenedor
list<int> ids = [1, 2, 3];          // tipado interno fuerte

Field Summary for Composite Types

Operators

Statements

const long n = 5;
sum = 0;

for (int i = 0; i < n; i++):
    sum += i;
endfor

switch(sum):
    case 10:
        println("ten");
        break;
    default:
        pass;
endswitch

try:
    defer println("fin de bloque");
    println("id" in {id: 1});
finally:
    println("cleanup");
endtry

Functions

• Parametros por referencia declarados con & en la firma: func f(&x):.
• En llamada, usa &var para pasar por referencia si la firma lo requiere.
• Type hints opcionales: func float media(a: float, b: float):.
• Tipo de retorno declarado: solo admite 1 tipo por funcion (no union types como int|string).
• Tipos soportados en hints de retorno/parametros: int, double, float, decimal, long, byte, char, tuple, set, map, function, string, bool, list, object, null y tipos de clase de usuario (ej. User, crm.models.Customer).
• Soporte de genericos en hints: list<T>, tuple<T>, set<T>, object<T>, map<K, V>.
• Los tipos de clase son nominales: el valor debe ser una instancia de esa clase (o una subclase). El parser no soporta genericos nominales estilo MiClase<T>.
• Tipado de colecciones en 2 fases: list/object para el contenedor y list<int>/map<string, int> para tipado interno fuerte (incluye anidacion).
• Tambien puedes usar clases como tipo interno en colecciones: list<User>, map<string, User>, object<User>.
• any y dynamic son alias: ambos significan tipo dinamico (internamente equivalente a omitir el tipo).
• Sin tipo de retorno (func nombre(...):) o con func any nombre(...):/func dynamic nombre(...):, el retorno es dinamico y puede variar por llamada.
• Tambien aplica a parametros: x, x: any y x: dynamic son equivalentes y aceptan cualquier tipo de valor.
• Nota: any/dynamic en la doc significa "any o dynamic"; no se escribe con barra en el codigo fuente.
• Valores por defecto soportados en parametros por valor: func f(x: float = 1.0):.
• Las funciones son de primera clase via tipo function.
• Si no hay return, el valor implicito es null.
• return acepta formato multilinea; el parser sigue leyendo hasta encontrar ;.
• Si declaras tipo de retorno, la funcion debe retornar un valor compatible con ese tipo. En func null ..., debes hacer return null; explicito.
• Las llamadas de miembro pueden encadenarse sobre resultados intermedios (por ejemplo: builder.make().with_x(1).build()).
• Reglas de firma: los parametros sin default no pueden ir despues de uno con default; parametros por referencia (&) no aceptan default.

func string greet(name: string):
    return "Hola " + name;
endfunc

func float add(a: float, b: float = 0.0):
    return a + b;
endfunc

func touch(&x):
    x += 1;
endfunc

function ref = add;
println(ref(2, 3));

func any echo_any(x: any):
    return x;
endfunc

func dynamic echo_dynamic(x: dynamic):
    return x;
endfunc

func show_params(a, b: any, c: dynamic):
    println(a);
    println(b);
    println(c);
endfunc

println(echo_any("hola"));
println(echo_dynamic(42));
show_params(10, "texto", [1, 2, 3]);

Return multilinea

func int weighted_sum(a: int, b: int):
    return
        (
            a * 2 +
            b
        );
endfunc

Firmas con tipos de clase personalizados

class User:
    public string name = "anon";
endclass

func User make_user(name: string):
    u = User();
    u.name = name;
    return u;
endfunc

func string greet_user(user: User):
    return "Hola " + user.name;
endfunc

println(greet_user(make_user("Ada")));

Declaraciones locales tipadas

string title = "Reporte";
bool ok = true;
null nothing = null;

// Clases en variables locales tipadas
User owner = make_user("Lin");

Tipado de Colecciones (Detallado)

El modelo actual funciona en dos fases: tipado de contenedor y tipado interno fuerte.

Fase 1: Tipado del contenedor

Valida que el valor sea del tipo de coleccion correcto, pero no restringe los elementos internos.

// Contenedor tipado (interno flexible)
list datos = [1, "dos", true];
object meta = {id: 1, name: "Ana", ok: true};
tuple t = tuple(1, "x");

println(type(datos)); // list
println(type(meta));  // object

Fase 2: Tipado interno fuerte (Genericos)

Ademas del contenedor, valida recursivamente el tipo interno de cada elemento.

list<int> ids = [1, 2, 3];
tuple<float> coords = tuple(1, 2.5, 3);
set<char> letras = set('a', "b", 67);
map<string, int> score = map("ana", 10, "luis", 20);
object<int> counters = {ok: 5, fail: 1};

// Anidacion valida
list<map<string, int>> tabla = [map("a", 1), map("b", 2)];

Casos de error esperados

list<int> bad1 = [1, "2"];                   // Elemento list[1] incompatible con 'int'
map<string, int> bad2 = map("ana", 10, 2, 20); // Clave map[1] incompatible con 'string'
object<int> bad3 = {ok: 1, label: "x"};      // Propiedad object.label incompatible con 'int'

Funciones con colecciones tipadas

func list<int> keep(xs: list<int>):
    return xs;
endfunc

println(keep([1, 2, 3]));
// println(keep([1, "x"])); // error en argumento 'xs'

func map<string, int> mk_scores():
    return map("a", 10, "b", 20);
endfunc

for-each con binding tipado

for (int n in [10, 20, 30]):
    println(n);
endfor

for (list<int> row in [[1, 2], [3, 4]]):
    println(row[0]);
endfor

OOP MVP+ (Guia Completa)

Esta seccion resume exactamente lo implementado en la fase actual para OOP (MVP + extensiones de encapsulacion/abstraccion). Si eres principiante total, empieza por la tabla de construcciones y luego ejecuta el ejemplo completo.

Construcciones OOP y para que sirven

Modificadores OOP

Tipos de clase en firmas (metodos, interfaces y constructores)

En OOP puedes usar tipos de clase en firmas de metodos, parametros de constructor y firmas de interfaces. La verificacion es nominal y respeta herencia.

class User:
    public string name = "anon";
endclass

interface UserReader:
    func User find(id: string);
endinterface

class UserRepo implements UserReader:
    public func User find(id: string):
        u = User();
        u.name = "id=" + id;
        return u;
    endfunc
endclass

class UserService:
    constructor(repo: UserReader):
        this.repo = repo;
    endconstructor

    public func string label(user: User):
        return "User(" + user.name + ")";
    endfunc
endclass

Ejemplo corto: abstract + protected

abstract class Report:
    protected string source;

    constructor(source: string):
        this.source = source;
    endconstructor

    protected func string prefix():
        return "source=" + this.source;
    endfunc

    public abstract func string render():
    endfunc
endclass

class SalesReport extends Report:
    constructor(source: string):
        super(source);
    endconstructor

    public override func string render():
        return this.prefix() + " total=42";
    endfunc
endclass

report = SalesReport("Q1");
println(report.render());     // "source=Q1 total=42"

Error comun: protected (incorrecto vs correcto)

class Counter:
    protected int value;

    constructor(initial: int):
        this.value = initial;
    endconstructor

    public func int read():
        return this.value;
    endfunc
endclass

c = Counter(7);
println(c.read());            // Correcto
println(c.value);             // Incorrecto: acceso externo a protected

Ejemplo OOP completo (todo lo disponible en esta fase)

interface NamedEntity:
    func string display_name();
endinterface

interface Serializable:
    func string serialize();
endinterface

class Entity:
    private string _id;
    public static int created = 0;
    public readonly string created_by;

    constructor(id: string, created_by: string = "system"):
        this._id = id;
        this.created_by = created_by;
        Entity.created += 1;
    endconstructor

    public get id():
        return this._id;
    endget

    public set id(value: string):
        this._id = value;
    endset

    public func string base_info():
        return "Entity#" + this._id;
    endfunc
endclass

class User extends Entity implements NamedEntity, Serializable:
    private string _name;

    constructor(id: string, name: string):
        super(id, "admin");
        this._name = name;
    endconstructor

    public override func string base_info():
        return super.base_info() + " user";
    endfunc

    public func string display_name():
        return this._name;
    endfunc

    public func string serialize():
        return "{id:" + this.id + ",name:" + this._name + "}";
    endfunc

    public get name():
        return this._name;
    endget

    public set name(value: string):
        this._name = value;
    endset
endclass

u = User("U-001", "Ada");
println(u.base_info());
println(u.display_name());
println(u.name);
u.name = "Ada Lovelace";
println(u.serialize());
println(Entity.created);

Validaciones OOP importantes (runtime)

Errores frecuentes (con ejemplo)

// 1) Falta override
class A:
    public func int f():
        return 1;
    endfunc
endclass

class B extends A:
    public func int f():
        return 2;
    endfunc
endclass
// Error: metodo sobrescribe base y requiere override

// 2) super(...) no es primera sentencia
class C extends A:
    constructor():
        x = 1;
        super();
    endconstructor
endclass
// Error: super(...) debe ir primero

Collections

list_values = [10, 20, 30];
println(list_values[1]);

obj = {name: "Ada", score: 10};
println(obj.name);
obj.level = "pro";
println([{user: obj}][0].user.name);

queue = [];
queue.append("first");
queue.append("second");
println(queue[1]);

holes = [null] * 3;
println(len(holes));

tuple pair = tuple("x", 99);
set uniq = set(1, 1, 2, 3);
map dict = map("a", 1, 2, "b");
println(dict[2]);

func int inc(x: int):
    return x + 1;
endfunc
holder = {ops: {inc: inc}};
println(holder.ops["inc"](10)); // llamada encadenada sobre resultado intermedio

println(20 in list_values);      // true
println("a" in dict);            // true (clave)
println("name" in obj);          // true (propiedad)
println("da" in "Ada");          // true (substring)

Colecciones tipadas por fases

// Fase 1: tipado de contenedor (interno flexible)
list bucket = [1, "dos", true];
map registry = map("id", 1, 2, "dos");

// Fase 2: tipado interno fuerte
list<int> numbers = [1, 2, 3];
map<string, int> scores = map("ana", 10, "bob", 20);
object<int> counters = {ok: 1, fail: 0};

Colecciones tipadas con clases

class Item:
    public string name = "n/a";
endclass

i1 = Item();
i1.name = "A";
i2 = Item();
i2.name = "B";

list<Item> items = [i1, i2];
for (Item it in items):
    println(it.name);
endfor

Enum

Los enums se almacenan como objetos con miembros numericos secuenciales iniciando en 0. Puedes recuperar nombre o valor mediante helpers.

enum Estado {
    ACTIVO,
    INACTIVO,
    SUSPENDIDO
};

println(Estado.INACTIVO);                    // 1
println(enum_name(Estado, Estado.INACTIVO)); // "INACTIVO"
println(enum_value(Estado, "ACTIVO"));      // 0

Validations and Limits

Base Builtins - Method Summary

Special field: endl es una constante resoluble en runtime con valor "\n". Uso tipico: print(endl);.

printf - Specifier Summary

Core Module - Method Summary

println(type(10));                  // int
println(type(cast(1.2, "float"))); // float
assert(2 + 2 == 4, "math broken");
try:
    throw("boom");
catch(err):
    println(err);
endtry

Collection Helpers and Enum Helpers

println(range(1, 6, 2));                 // [1, 3, 5]
println(enumerate(["a", "b"], 5));      // [(5, "a"), (6, "b")]
println(zip([1, 2, 3], "ab"));          // [(1, 'a'), (2, 'b')]
println(all([1, true, "x"]));            // true
println(isinstance(10, "number"));       // true
println(hex(-26));                        // -0x1a

System and Async Builtins

id = async_read_file("data.txt");
while !task_ready(id):
    sleep_ms(10);
endwhile
content = await(id);
println(content);

Math Module - Method Summary

Para usar estas funciones debes hacer import math;.

import math;
println(factorial(10));
println(gcd(84, 36));
println(pow(2, 100));
println(log(100, 10));

Math Constants - Field Summary

Module Summary

Base Reference Checklist

• Statements: if, while, for, for-each, do-while, switch, break, continue, pass, func, try/catch/finally, defer, return.
• Tipos: numericos, char, bool, null, listas, objetos, tuple/set/map, function ref.
• Builtins: input, println, printf, type, cast, assert, throw, file/async builtins.
• Jerarquia base de errores disponible con import clot.core.exceptions;.
• Keywords/utilidades base: const, operador in y constante endl.

Package Layout

project/
  app.clot
  clot/
    science/
      utils/
        utils.clot
    core/
      helpers/
        helpers.clot
      exceptions/
        exceptions.clot

import clot.science.utils;
import clot.core.helpers;
import clot.core.exceptions;

// 1) Import de modulo completo
import scripts.math;

// 2) Import de modulo con alias
import scripts.math as math;

// 3) Import directo de simbolo
from scripts.math import add;

// 4) Import directo de simbolo con alias
from scripts.math import Box as Caja;

println(add(2, 3));
println(math.add(4, 5));

a = Caja(7);
b = math.Box(9);
println(a.value + b.value);

Module Resolution Order

Package Contract

1. Define una API publica clara via funciones con firmas estables.
2. Evita side effects al importar, salvo inicializacion minima.
3. Documenta precondiciones y errores esperados.
4. Incluye pruebas smoke para rutas criticas.

Guidelines

Current Status

Deprecation Policy

1. Introducir aviso deprecado en documentacion antes de remover feature.
2. Mantener una ventana minima de compatibilidad de una version mayor.
3. Publicar ruta de migracion con ejemplos antes del retiro definitivo.

Why does int not overflow but long does?

int usa BigInt dinamico (limitado por memoria), mientras long es un entero signed fijo de 64 bits. Si excede su rango, el runtime falla por validacion.

How do I print with and without newline?

• print(expr); no agrega salto.
• println(expr); agrega salto.
• print(endl); emite solo salto de linea.
• printf(...) permite formato tipo C.

What happens if a function does not return?

Devuelve null implicitamente. Ejemplo: println(mi_func()); imprimira null si no hubo return explicito. Excepcion: si la funcion declara un tipo de retorno (por ejemplo func int f(...):), entonces debe retornar un valor compatible o se produce error runtime. Tambien puedes escribir return en varias lineas siempre que cierres con ;.

Cantidad de tipos de retorno por funcion: uno cuando declaras hint (func int ..., func string ..., etc.). Si quieres comportamiento multi-tipo, usa retorno dinamico (func ... sin tipo, o func any .../func dynamic ...). any y dynamic son equivalentes. Tipos declarables: int, double, float, decimal, long, byte, char, tuple, set, map, function, string, bool, list, object y null.

Can I use try, catch and finally together?

Si. Clot acepta tres combinaciones validas: try/catch, try/finally y try/catch/finally.

try:
    risky();
catch(err):
    println(err);
finally:
    println("cleanup");
endtry

• Solo se permite un catch por bloque try.
• Si existe finally, va despues de catch.
• finally siempre intenta ejecutarse al cerrar el try, incluso si hubo error.

Does for-each require const?

No. const es opcional en el binding del for-each.

for (item in values):
    println(item);
endfor

for item in values:
    println(item);
endfor

for (const item in values):
    println(item);
endfor

Usa const cuando quieras impedir reasignar la variable de iteracion dentro del cuerpo. Si no lo necesitas, el binding simple item es valido.

Can I declare a variable first and assign later?

No con una declaracion vacia estilo C/Java. En Clot, toda binding debe nacer con un valor. int x; es invalido.

// invalido
int x;

// valido
x = null;
x = 42;

// valido con tipo local explicito
string name = "Ada";
bool ready = false;

When does defer run?

defer programa una sentencia simple para el final del bloque actual. No corre en el punto donde aparece, sino al salir del bloque. El orden es LIFO.

func sample():
    defer println("third");
    defer println("second");
    println("body");
endfunc

sample();

// salida:
// body
// second
// third

Su uso practico tipico es cleanup por bloque: liberar recursos, restaurar estado, registrar logs finales o ejecutar pasos que deben correr antes de abandonar el bloque.

What does in check?

• valor in [1, 2, 3]: pertenencia por elemento.
• clave in map(...): existencia de clave.
• "prop" in obj: existencia de propiedad en object.
• "na" in "banana": substring.

Is null like Python None? Does none exist?

Conceptualmente, si: null es el valor de ausencia de Clot y es el equivalente mas cercano al None de Python.

La forma oficial del lenguaje es null. none no es keyword, no es alias y no debe usarse como literal nulo en ejemplos o codigo fuente.

Can LLVM AOT compile the new control-flow features natively?

No todas. En el estado actual, switch, for-each, do-while, finally, defer y el operador in no tienen lowering AOT nativo dedicado.

El modo compile puede seguir cubriendo esos casos via runtime bridge, pero no debes asumir que se ejecutaran como IR LLVM puro sin soporte de runtime.

Why must super(...) be first in derived constructors?

Porque la instancia base debe quedar inicializada antes de ejecutar logica propia de la clase derivada. Esto garantiza estado consistente en herencia y evita usar miembros de base antes de tiempo. En Clot OOP MVP, el constructor derivado debe llamar super(...) como primera sentencia y solo una vez.

class Base:
    constructor(x: int):
        this.x = x;
    endconstructor
endclass

class Child extends Base:
    constructor(x: int):
        super(x);      // correcto: primera sentencia
        this.y = x * 2;
    endconstructor
endclass

Can I get enum member name instead of numeric value?

Si. Usa enum_name(EnumObj, EnumObj.MIEMBRO). Para el inverso, usa enum_value(EnumObj, "MIEMBRO").

Module Index Table

A-Z

Core Terms

Full Navigation

1. Manual
   • Scope
   • Audience Paths
   • Style and Conventions
2. What is New
3. Tutorial
4. Language Reference
5. Library Reference
6. Standard Library
7. Base
8. Packages
   • Layout
   • Resolution Order
   • Contract
9. Third-Party Modules
10. Deprecations
11. FAQs
    • int vs long overflow
    • Print and newline
    • Missing return behavior
    • try/catch/finally forms
    • for-each with/without const
    • Declaring empty vars
    • When defer runs
    • What in checks
    • null vs Python None
    • LLVM AOT and control flow
    • Why super(...) first
    • Enum name/value
12. Global Module Index
13. General Index
14. Glossary
15. Reporting Issues
16. Contributing
17. History and License

Issue Template

Title: [Runtime|Parser|LLVM] Short description
Version/Date: 2026-03-07 snapshot
Command: ./build/wsl-release/clot file.clot --mode ... --lang en
Input file:
<paste minimal reproducible clot code>
Expected behavior:
Actual behavior:
Stack/error output:
Environment: OS, compiler, LLVM availability

Severity Guide

Workflow

1. Crear rama por objetivo tecnico.
2. Agregar o ajustar tests antes de merge.
3. Ejecutar build + smoke tests.
4. Actualizar documentacion afectada en esta pagina.

cmake --build --preset build-release -j4
bash tests/smoke.sh ./build/wsl-release/clot
bash tests/llvm_smoke.sh ./build/wsl-release/clot

Documentation Rules

• Todo builtin nuevo debe tener signature, retorno, validaciones y ejemplo.
• Todo tipo nuevo debe actualizar Type Summary y General Index.
• Todo cambio de semantica debe reflejarse en What is New y FAQ relevante.
• Los builtins del interprete deben implementarse en src/interpreter/interpreter_builtins.cpp, no mezclados con ejecucion general.

Recent Timeline

License

El proyecto se distribuye segun LICENSE.txt del repositorio. Verifica terminos antes de redistribuir binarios o integrar codigo en proyectos cerrados.