Variáveis e Tipos

Sounio é estaticamente tipado, com inferência de tipos para a maioria dos bindings locais.

Declaração de Variáveis

Variáveis Imutáveis (let)

Por padrão, variáveis são imutáveis:

let x = 42          // Type inferred as i32
let name = "Alice"  // Type inferred as string
let pi = 3.14159    // Type inferred as f64

Variáveis Mutáveis (var)

Use var para variáveis mutáveis:

var counter = 0
counter = counter + 1  // OK

let fixed = 10
fixed = 20  // Error: cannot assign to immutable variable

Anotações de Tipo

Você pode anotar tipos explicitamente:

let x: i32 = 42
let ratio: f64 = 0.5
let flag: bool = true
let message: string = "Hello"

Tipos Primitivos

Tipo	Descrição	Exemplo
`i8`, `i16`, `i32`, `i64`	Inteiros com sinal	`let x: i32 = -42`
`u8`, `u16`, `u32`, `u64`	Inteiros sem sinal	`let y: u32 = 42`
`f32`, `f64`	Ponto flutuante	`let pi: f64 = 3.14`
`bool`	Booleano	`let flag: bool = true`
`char`	Caractere Unicode	`let c: char = 'A'`
`string` / `String`	String de texto	`let s = "hello"`
`str`	Fatia de string emprestada	`let s: &str = "hello"`

Tipos Compostos

Tuplas

let point = (10, 20)
let first = point.0  // 10
let second = point.1 // 20

Arrays

let numbers: [i32; 5] = [1, 2, 3, 4, 5]
let first = numbers[0]  // 1

Vetores (`Vec<T>`)

let items: Vec<i32> = [1, 2, 3, 4]
for x in items {
    // ...
}

Inferência de Tipos

Sounio infere tipos a partir do contexto:

let values = [1, 2, 3]  // Array literal
let vec_values: Vec<i32> = values

Nota da spec: unidades de medida parseiam (por exemplo, unit kg; unit g = 0.001 * kg; unit mg = 0.001 * g;), mas a checagem completa de unidades pode estar habilitada apenas em alguns modos/flags do compilador.

Tipos Epistêmicos (`Knowledge<T>`)

Para valores com incerteza:

let k = Knowledge { value: 42.0 }
let x: f64 = k.unwrap("accepted for demo")

Veja Knowledge Types para mais detalhes.