Tuplas_

PT-BR:
Tuplas são coleções de tamanho fixo com elementos de tipos possivelmente diferentes. São criadas com parênteses e acessadas via .0, .1, .2, etc.

EN-US:
Tuples are fixed-size collections with elements of potentially different types. They are created with parentheses and accessed via .0, .1, .2, etc.

module tuplas

from std.io import println

public func main() {
    // Tupla de int e string / Tuple of int and string
    let par = (42, "resposta")
    let n = par.0
    // 42
    let s = par.1
    // "resposta"

    // Tripla / Triple
    let tripla = (10, 3.14, true)
    let inteiro  = tripla.0
    // 10
    let flutuante = tripla.1
   // 3.14
    let booleano = tripla.2
    // true

    // Tupla com anotação de tipo / Tuple with type annotation
    let coordenada: (int, int) = (100, 200)
    let x = coordenada.0
    // 100
    let y = coordenada.1
    // 200
}

Funções que Retornam Tuplas / Functions Returning Tuples

PT-BR:
Tuplas são úteis para retornar múltiplos valores de uma função.

EN-US:
Tuples are useful for returning multiple values from a function.

func min_max(arr: [int], n: int) returns (int, int) {
    let min = arr[0]
    let max = arr[0]
    for i in 1..n {
        if arr[i] < min {
            min = arr[i]
        }
        if arr[i] > max {
            max = arr[i]
        }
    }
    return (min, max)
}

public func main() {
    let nums = [5, 1, 8, 3, 9, 2]
    let resultado = min_max(nums, 6)
    
    println(f"Min: {resultado.0}, Max: {resultado.1}")
    // Min: 1, Max: 9
}

Desestruturação de Tuplas / Tuple Destructuring

// Acesso direto via campo / Direct access via field
let ponto = (10, 20)
let x = ponto.0
let y = ponto.1

// Desestruturação em let / Destructuring in let
let (a, b) = ponto

// Usando em match / Using in match
match ponto_resultado {
    when (0, 0) then println("Origem"),
    when (x, 0) then println(f"Eixo X em {x}"),
    when (0, y) then println(f"Eixo Y em {y}"),
    when (x, y) then println(f"Ponto ({x}, {y})")
}

Structs também podem ser desestruturadas em let:

record Point {
    public x: int,
    public y: int,
}

let p = Point { x: 10, y: 20 }
let Point { x, y: renamed_y } = p

---