Controlar el flujo

Condiciones y bucles

fn classify(value: i64, values: [3]i64) -> i64 {
    let label = if value > 0 { 1 } else if value < 0 { -1 } else { 0 }

    let mut index: usize = 0
    let mut total = label
    while index < len(values) {
        total += values[index]
        index = index + 1
    }

    for item in values {
        total += item
    }

    total
}

if es una expresión. while y for apoyo break y continue. Un bucle encabezado por name: puede ser apuntado desde bucles anidados con break :name / continue :name; llanura break/continue sigue significando el bucle más interno y se permite la reutilización secuencial de una etiqueta. Al salir se ejecuta una limpieza específica de borde para cada ámbito intermedio y nunca se cruza un spawn límite. Etiquetado break/continue no tomar ningún valor. for sobre rangos, matrices, cortes y text/buffer valores (str, string, bytes, shared_bytes) se reduce a una asignación directa libre index/length bucle. Rendimiento de texto y buffers u8 elementos (unidades de bytes, indexación coincidente); Los elementos de solo movimiento requieren una indexación y un manejo de propiedad explícitos. enumerate sigue los mismos tipos con un usize índice.

Partido y ADT

enum Response {
    Ok(i64)
    Err(str)
}

fn status(value: Response) -> i64 {
    match value {
        Ok(code) => code
        Err(message) => -1
    }
}

Los brazos coincidentes no necesitan comas a menos que el límite sea ambiguo: un brazo cuyo cuerpo termina en una expresión seguida por un patrón (/[ requiere la coma (B044). La coincidencia debe ser exhaustiva a menos que el flujo restante sea inalcanzable. Los patrones admiten literales, tuplas, estructuras, variantes, enlaces, descartes y guardias. Las cargas útiles de solo movimiento se transfieren solo cuando se selecciona un brazo; un patrón o guardia fallido preserva al propietario para armas posteriores.

`if let` y `while let`

fn label(found: ?string) -> i64 {
    if let Some(text) = found { len(text) as i64 } else { 0 }
}

fn count_down(from: ?i64) -> i64 {
    let mut total: i64 = 0
    let mut current = from
    while let Some(value) = current {
        total += value
        if value > 0 { current = Some(value - 1) } else { current = None }
    }
    total
}

Ambas son formas superficiales sobre match y desugar en un partido de dos brazos cuyo segundo brazo es el complemento, por lo que el comportamiento vinculante, la exhaustividad y la limpieza de move/borrow son exactamente las reglas del partido. if let Some(...) nombra a su complemento None; otro patrón variante mantiene un brazo comodín, que H032 rechaza cuando el escrutado lleva una carga útil de solo movimiento (escriba los brazos match explícitos allí), y un patrón irrefutable (while let name = value) se rechaza como H029.

Opciones, resultados y `?`

fn find(enabled: bool) -> ?i64 {
    if enabled { Some(42) } else { None }
}

fn forward(enabled: bool) -> ?i64 {
    let value = find(enabled)?
    Some(value)
}

? produce el present/success carga útil o devuelve el error correspondiente. La propagación de resultados puede cambiar el tipo de éxito pero conserva el tipo de error. No se produce ninguna asignación o clonación implícita. ? no puede cruzar un spawn límite.

Limpieza en bordes de flujo

caída, return, break, y continue ejecutar el plan de limpieza verificado para propietarios vivos. Panic/trap/abort Los bordes nunca se desenrollan y no se limpian.