Caracteristicas

Features estables del lenguaje enfocados en claridad, interoperabilidad y desarrollo de sistemas predecible.

Claridad C-Style

Un modelo mental cercano a C, con locales explicitos, loops explicitos y control directo sobre valores y ramas.

fn sumRange(limit: s32) s32 {
    var i: s32 = 0;
    var total: s32 = 0;

    while i < limit {
        total += i;
        i++;
    }

    return total;
}

fn main() s32 @public {
    var total: s32 = sumRange(5);

    if total != 10 {
        return 1;
    }

    return 0;
}

struct Buffer @public {
    data: ptr[u8],
    length: usize,
    capacity: usize
}

fn main() s32 @public {
    var buffer: Buffer = new Buffer {
        data: nullptr,
        length: 8,
        capacity: 64
    };

    buffer->length = buffer->length + 4;
    return buffer->capacity as s32;
}

Generics en Compile-Time

Funciones y estructuras genericas con instanciacion explicita, sin costo dinamico extra.

fn add[T](a: T, b: T) T @public {
    return a + b;
}

struct Pair[T] @public {
    left: T,
    right: T
}

fn main() s32 @public {
    var nums := new Pair[s32] {
        left: 2,
        right: 4
    };

    return nums->left + nums->right;
}

struct Buffer[T] @public {
    data: ptr[T],
    length: usize,
    capacity: usize
}

fn main() s32 @public {
    var buf := new Buffer[u8] {
        data: nullptr,
        length: 0,
        capacity: 64
    };

    return buf->capacity as s32;
}

Interoperabilidad con C

Integracion directa con C mediante @extern y @convention("C").

fn printf(fmt: const array[char]) s32
    @public @arbitraryArgs
    @extern("printf") @convention("C");

fn atoi(text: const array[char]) s32
    @public
    @extern("atoi") @convention("C");

fn puts(text: const array[char]) s32
    @public
    @extern("puts") @convention("C");

fn main() s32 @public {
    if puts("interop ready") < 0 {
        return 1;
    }

    return 0;
}

Condicionales en Compile-Time

Usa @if, @elif y @else para elegir codigo por plataforma al compilar.

@if(isLinux()) const PLATFORM: u32 = 2;
@elif(isWindows()) const PLATFORM: u32 = 1;
@else const PLATFORM: u32 = 3;

fn main() s32 @public {
    var count: s32 = 0;

    @if(false) {
        count += 1;
    } @elif(true) {
        count += 2;
    } @else {
        count += 100;
    }

    return count;
}

Imports Utiles

Combina modulos de std::, aliases e imports selectivos para mantener dependencias explicitas sin ensuciar el archivo.

import std::io;
import std::math;
import std::collections::vector;

fn main() s32 @public {
    var values := vector::newVector[s32]();
    var angle: f64 = math::PI_4;

    vector::pushBack[s32](ref values, 10);
    vector::pushBack[s32](ref values, 20);

    io::print("last=%d cos=%f\n", vector::back[s32](ref values), math::cosine(angle));
    vector::destroyVector[s32](ref values);
    return 0;
}

import "other.thrust" as dep;
import "other.thrust" only { stack, counter };
import module_a::sub::module_b;

fn main() s32 @public {
    var value: module_a::sub::module_b::MyType = 0;

    if counter > 0 {
        return value as s32;
    }

    return 0;
}

Builtins Utiles

Builtins de tipos/layout como sizeOf, alignOf e isSameType.

const U32_SIZE: usize = sizeOf(u32);
const U32_ALIGN: u32 = alignOf(u32);
const U32_BITS: usize = typeWidth(u32);
const PTR_BITS: usize = pointerWidth();
const COMPILER_LEN: usize = stringLength(compilerVersion());

fn verifyTypes() void {
    staticAssert(isSameType(u32, u32), "u32 type check failed");
}

struct Header @public {
    magic: u32,
    count: u16,
    flags: u16
}

const HEADER_SIZE: usize = sizeOf(Header);
const HEADER_ALIGN: u32 = alignOf(Header);

fn validateLayout() void {
    staticAssert(HEADER_SIZE >= 8, "Header layout is too small");
    staticAssert(HEADER_ALIGN >= 2, "Header alignment is too small");
}