La deliciosa lasaña de Lucian

En Rust, asignar un valor a un nombre se denomina vinculación. Las vinculaciones son inmutables a menos que se declaren con la palabra clave mut. Como Rust es un lenguaje de tipado estático, cada vinculación tiene un tipo conocido en tiempo de compilación.

Las vinculaciones se definen normalmente con la palabra clave let. Especificar el tipo de una vinculación es opcional en la mayoría de los casos, ya que la inferencia de tipos de Rust suele poder deducir el tipo a partir de su valor. Una vinculación tiene este aspecto:

// Automatically inferred type
let fingers = 10;

Las funciones son elementos. Mientras que las vinculaciones suelen referirse a un valor concreto, los elementos se refieren a una unidad de organización del código, normalmente una función o un módulo, que está disponible durante toda la vida del programa. Una función devuelve automáticamente el resultado de su última expresión. Una función puede tener 0 o más parámetros, que son vinculaciones cuya vida útil abarca la llamada a la función.

En teoría, la inferencia de tipos sería posible en las funciones, pero está desactivada como una decisión intencionada de diseño del lenguaje. Aunque esto significa que tendrás que dedicar algo más de tiempo al escribir el código para especificar con precisión cuáles son los tipos de entrada y salida de una función, te ahorra tiempo al leer el código, porque todos los tipos de entrada y salida están definidos de forma explícita.

fn add(x: i32, y: i32) -> i32 {
  x + y
}

Para llamar a una función, se escribe su nombre seguido de paréntesis. Si la función requiere parámetros, hay que especificar un argumento para cada uno dentro de los paréntesis.

let five = add(2, 3);

Si no se puede deducir el tipo de una vinculación, el compilador mostrará un error. Para solucionarlo, añade una anotación de tipo explícita a la vinculación.

// Explicit type annotation
let fingers: i32 = 10;

Los elementos de Rust pueden usarse antes o después de definirse, porque tienen una vida estática. Las vinculaciones, en cambio, solo pueden usarse después de haberse definido. Usar una vinculación antes de definirla provoca un error de compilación.

fn main() {
    // `fn add` hasn't yet been defined, but that's perfectly ok
    dbg!(add(3, 4));
}

fn add(x: i32, y: i32) -> i32 {
  x + y
}

// this won't compile; `a` is used before its binding is defined
let b = a;
let a = x + y;

Rust usa llaves ({}) para definir un scope. Una vinculación definida dentro de un scope no puede escapar de él.

let a = 1;
dbg!(a); // 1
{
    // Here, we re-bind `a` to a new value, which is still immutable.
    // This technique is called _shadowing_. The new binding is constrained to
    // this anonymous scope. Outside this scope, the previous binding still
    // applies.
    let a = 2;
    let b = 3;
    dbg!(a, b); // 2, 3
}
// can't use `b` anymore because it is out of scope
// dbg!(b);

// The shadowed `a` in the inner scope above has fallen out of scope,
// leaving us with our original binding.
dbg!(a); // 1

Los elementos de Rust suelen organizarse en módulos. Cada crate es implícitamente un módulo, pero puede definir submódulos internos con la profundidad que se quiera. Un módulo agrupa funcionalidad relacionada y se define con la palabra clave mod.

mod calc_i32 {
    fn add(a: i32, b: i32) -> i32 { a + b }
    fn sub(a: i32, b: i32) -> i32 { a - b }
    fn mul(a: i32, b: i32) -> i32 { a * b }
    fn div(a: i32, b: i32) -> i32 { a / b }
}

Rust admite dos tipos de comentarios. La palabra clave // indica un comentario de una sola línea; todo lo que sigue a la palabra clave hasta el final de la línea se ignora. Las palabras clave /* y */ indican un comentario de varias líneas; todo lo que hay entre esas dos palabras clave se ignora. Es idiomático y una buena práctica preferir los comentarios de una sola línea.

Rust también admite los comentarios de documentación, que aparecen en la documentación generada por cargo doc. Los comentarios de documentación externos se forman con la palabra clave ///, que actúa igual que la palabra clave //. Se aplican al elemento que tienen justo a continuación, como una función:

/// The `add` function produces the sum of its arguments.
fn add(x: i32, y: i32) -> i32 { x + y }

Los comentarios de documentación internos se forman con la palabra clave //!, que actúa igual que la palabra clave //. Se aplican al elemento que los contiene, como un módulo:

mod my_cool_module {
    //! This module is the bee's knees.
}

Los comentarios de documentación pueden tener cualquier longitud y contener markdown, que se renderiza en la documentación generada.