Structs
Structs são tipos de dados personalizados que permitem nomear e agrupar vários valores relacionados.
Para definir uma struct, use a palavra-chave struct seguida de um nome e de chaves contendo os campos com seus nomes e tipos:
#[derive(Drop)]
struct User {
active: bool,
username: ByteArray,
email: ByteArray,
sign_in_count: u64,
}
Para criar uma instância de uma struct, informe o nome da struct e use chaves com pares chave-valor para os campos.
let user = User {
active: true, username: "someusername123", email: "someone@example.com", sign_in_count: 1
};
Use a notação de ponto para acessar ou modificar os campos de uma instância mutável de struct.
let mut user = User {
active: true, username: "someusername123", email: "someone@example.com", sign_in_count: 1
};
user.email = "anotheremail@example.com";
Propriedade
Os valores em Cairo são imutáveis, e essa imutabilidade garante que, mesmo que muitas variáveis se refiram ao mesmo valor, o valor em si permaneça constante e inalterado.
O proprietário de uma variável é o código que pode ler (e escrever, se for mutável) essa variável.
Regras de propriedade em Cairo:
- Cada variável em Cairo tem um proprietário.
- Só pode haver um proprietário por vez.
- Quando o proprietário sai de escopo, a variável é destruída.
Um escopo é o intervalo dentro de um programa em que uma variável é válida.
fn main() {
// `x` is not valid here, it has not been declared yet
let x: u32 = 3; // `x` is declared, it is valid from this point forward
// do stuff with `x`
} // this scope ended here, `x` goes out of scope and is no longer valid
Quando uma variável sai de escopo, ela é destruída, o que garante que o recurso associado seja liberado corretamente.
Isso é feito implementando ou derivando o trait Drop, que sinaliza ao compilador que o tipo pode ser destruído com segurança quando não for mais útil.
#[derive(Drop)]
struct A {}
fn main() {
A {}; // this value can be destroyed after going out of scope
}
No momento, a implementação de Drop pode ser derivada para todos os tipos, exceto dicionários (Felt252Dict) e tipos que contenham dicionários.
Um valor também pode ser movido, o que acontece quando um valor é passado para outra função, destruindo a variável original que se referia ao valor (tornando essa variável inútil) e criando uma nova variável para guardar o mesmo valor.
fn foo(num: u32) {
// do something with p
}
fn main() {
let num: u32 = 10;
foo(num);
// ownership of `num` was moved into `foo` and is thus no longer valid in this scope
}
Retornar valores equivale a movê-los.
O exemplo abaixo mostra uma função que retorna um valor:
#[derive(Drop)]
struct A {}
fn main() {
// main now owns a1
let a1 = gives_ownership();
// a2 comes into scope
let a2 = A {};
// a2 is moved into takes_and_gives_back, which also moves its return value into a3
let a3 = takes_and_gives_back(a2);
} // Here, a3 and a1 go out of scope and are dropped. a2 was moved, so nothing happens.
// Moves its return value into the function that calls it
fn gives_ownership() -> A {
let some_a = A {};
some_a
}
// This function takes an instance some_a of A and returns it
fn takes_and_gives_back(some_a: A) -> A {
some_a
}
Como uma variável é destruída depois de ser movida, o compilador nos proíbe de reutilizá-la depois.
#[derive(Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(p: Point) {
// do something with p
}
fn main() {
let p = Point { x: 5, y: 10 };
foo(p);
foo(p); // compiler error: Variable was previously moved.
}
Nesse caso, tentamos passar o mesmo valor (a struct Point na variável p) para as duas chamadas de função.
Depois que passamos a variável para a função foo pela primeira vez, a variável não pode mais ser usada.
Uma forma de resolver isso é derivar o trait Copy na nossa struct, o que mudaria o que acontece quando passamos uma variável Copy para uma função: ela não moveria mais o valor, mas criaria uma nova variável que se refere ao mesmo valor.
Essa é uma operação sem custo, porque variáveis são uma abstração do Cairo e os valores são sempre imutáveis.
Para implementar o trait Copy no seu tipo, adicione a anotação #[derive(Copy)] à definição do tipo.
#[derive(Copy, Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(p: Point) {
// do something with p
}
fn main() {
let p = Point { x: 5, y: 10 };
foo(p);
foo(p); // this now works
}
Referências e snapshots
Cairo tem dois recursos para passar um valor sem destruí-lo ou movê-lo, chamados references e snapshots.
Snapshots fornecem uma "visão" imutável de um valor em um determinado momento, permitindo que você mantenha a propriedade de uma variável enquanto acessa seu estado.
Qualquer modificação na variável cria uma nova célula de memória, deixando a visão do snapshot inalterada.
Para criar um snapshot, basta colocar @ antes da instância da variável.
// this function takes in a snapshot using `@` with the data-type
fn get_len(arr: @Array<u128>) -> u32 { //
arr.len()
}
fn foo(arr: Array<u128>) {
arr.pop_front();
}
fn main() {
let mut new_arr: Array<u128> = array![1, 2, 3, 4, 5, 6, 7, 8];
let snapshot = @new_arr; // using `@` to create a snapshot of a variable
let len = get_len(snapshot); // pass the snapshot as argument, retaining ownership
foo(new_arr); // `new_arr` is still valid up until here and no further
}
Para converter um snapshot de volta em uma variável comum, você pode usar o operador desnap *, que é o oposto do operador @.
Só é possível aplicar desnap em tipos que implementam o trait Copy.
fn square(n: @u32) -> u32 {
let n = *n; // we desnap the value
n * n
}
fn main() {
let num: u32 = 10;
let squared = square(@num); // we use `@` to create a snapshot
println!("{} squared = {}", num, squared);
}
Referências permitem que você passe valores mutáveis para funções e que eles sejam retornados implicitamente, mantendo a propriedade no contexto de chamada.
Isso pode ser feito usando o modificador ref, desde que a variável seja declarada como mutável com a palavra-chave mut.
Podemos atualizar o exemplo anterior de Point para usar referências mutáveis em vez de depender do trait Copy, e ele continuaria funcionando.
#[derive(Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(ref p: Point) {
// we can now update the passed values and the changes
// will be visible in the calling context
p.x += 1;
}
fn main() {
let mut p = Point { x: 5, y: 10 };
foo(ref p);
foo(ref p); // this now works even without the Copy trait
println!("p.x = {}", p.x); // p.x = 7
}
Exercício de aprendizagem
