Conceptos básicos

Texto fuente y nombres

.sd los archivos son UTF-8. Strings/comments puede contener Unicode; Los identificadores siguen siendo ASCII. Los nombres de los valores (funciones, variables, campos, módulos) utilizan minúsculas; los tipos nominales (estructuras, enumeraciones, uniones, rasgos, parámetros genéricos) y variantes usan UpperCamelCase; Las constantes son mayúsculas y minúsculas.

const MAX_ITEMS: usize = 64

fn main() -> i64 {
    // ação and 日本語 are valid comment text
    let greeting = "olá"
    (MAX_ITEMS + len(greeting)) as i64
}

El literal tiene un tipo prestado estático str. El UTF-8 válido de propiedad utiliza el string. len devuelve la longitud del byte; Las operaciones Unicode scalar/grapheme pertenecen a bibliotecas.

Fijaciones

fn release(ticket: i64) {}

fn main() -> i64 {
    let answer = 42
    let mut count: usize = 0
    count += 1
    let linear ticket = 7
    release(ticket)
    answer + count as i64
}

Los enlaces son inmutables de forma predeterminada. La mutación a través de un enlace requiere mut. linear crea una obligación de consumo exactamente una vez.

Tipos de núcleos

números enteros: i8…i64, u8…u64, isize, usize; byte alias u8
flotadores: f32, f64
controlar: bool, void, never
text/buffers: str, string, bytes, shared_bytes
compuesto: matrices [n]t, cortes []t/mut []t, tuplas, estructuras, ADT, uniones, opciones, resultados, valores de funciones, punteros, genéricos, linear t

Agregados

struct Point { x: i64, y: i64 }

enum Color { Red Green Blue }

fn main() -> i64 {
    let origin = Point { x: 0, y: 0 }
    let selected = Color.Green
    match selected {
        Color.Green => origin.x
        Color.Red => origin.y
        Color.Blue => 0
    }
}

enum define ADT que incluyen enumeraciones sin carga útil. Las uniones sin procesar requieren unsafe construction/access.

Un literal repetido llena una matriz fija a partir de un literal:

fn layout() -> i64 {
    let slots: [4]usize = [0; 4]
    let bytes: [3]u8 = [255; 3]
    let grid: [2][3]i64 = [[0; 3]; 2]
    (slots[3] + bytes[2] as usize + grid[1][2] as usize) as i64
}

El tipo de elemento proviene de la anotación o del tipo esperado de la matriz, por lo que no es necesaria ninguna conversión. El valor debe ser un literal (o una conversión de uno, o una matriz de ellos): se rechaza un valor de lugar o de llamada (B048) en lugar de evaluarse silenciosamente una vez por elemento, y el recuento debe ser un literal entero positivo (B049) de como máximo 65536 (B050), porque los elementos se materializan individualmente; los rellenos más grandes pertenecen a un búfer de montón o a un bucle explícito.

Expresiones

bloques, if, y match valores de rendimiento. Utilice la expresión final para un resultado implícito y return para un regreso anticipado. La aritmética de enteros sigue las reglas deterministas en SEMANTIC_RULES.md; la indexación segura permanece marcada en las versiones de lanzamiento.

El compilador limpio implementa tipos phase-1/2 f"..." interpolación para texto, bool, enteros, flotantes, especificaciones de formato y estático display/debug rasgos. uso {{/}} para llaves literales y .to_string()? sólo cuando se requiere una cadena contigua propia. La impresión sigue siendo una operación explícita de la biblioteca.