Struct

Struct

• Es una forma de agrupar datos relacionados, como si fueran las propiedades de un objeto en una clase
• Un struct en Rust solo define los campos de la estructura
• No contiene métodos directamente (estos se definen en el impl)
• Los métodos definidos en el impl están disponibles para esta instancia, similar a cómo funcionaría en C# o en otros lenguajes

struct BankAccount {
    owner: String,
    balance: f64,
}

struct User {
  active: bool,
  username: String,
  email: String,
  sign_in_count: u32,
}

Structs de tuplas

// Tuplas de structs
struct Color(u8, u8, u8);

let black = Color(0, 0, 0);
let white = Color(255, 255, 255);

Crear instancias

let mut user_1 = User {
  active: true,
  username: String::from("lucas"),
  email: String::from("[email protected]"),
  sign_in_count: 1,
};

// Crear instancias de otras instancias
let user_2: User = User {
  email: String::from("[email protected]"),
  ..user_1 // Copia los valores de user_1
};

Retornar un struct de una función

fn build_user(username: String, email: String) -> User {
  User {
    active: true,
    username,
    email,
    sign_in_count: 1,
  }
}

Impl

• impl se usa para implementar métodos para un struct (o enum)
• En otros lenguajes las variables y los métodos estarían dentro de la misma clase

impl BankAccount { 
  fn new(owner: String, initial_balance: f64) -> Self { 
    BankAccount { 
      owner, 
      balance: initial_balance,
    } 
  }
  
  fn withdraw(&mut self, amount: f64) { 
    if amount <= self.balance { 
      self.balance -= amount; 
    } 
  }
  
  fn deposit(&mut self, amount: f64) { 
	  self.balance += amount;
  }
}

Usando los métodos

let mut lucas_account = BankAccount { 
	owner: "Lucas".to_string(), 
	balance: 100.0 
};

lucas_account.deposit(100);

Self

• Se refiere a la instancia actual del struct dentro de un método
• Similar a los this en otros lenguajes
• Puede ser &self (referencia inmutable), &mut self (referencia mutable), o self (transferencia de propiedad)
• &self: Indica que el método toma una referencia inmutable a la instancia. Esto significa que puedes leer los datos pero no modificarlos.
• &mut self: Indica que el método toma una referencia mutable a la instancia. Esto significa que puedes modificar los datos del struct.

fn withdraw(&mut self, amount: f64) {
    println!("Retirando {} de la cuenta de {}", amount, self.owner);
    self.balance -= amount;
}

Unit-like structs y trait

• Una "unit-like struct" es una estructura sin campos
• Se usan traits ("interface") para definir un conjunto de métodos que un tipo debe implementar
• Se usa impl TraitName for StructName ("implements") para implementar un trait para una estructura.
• Se utiliza principalmente en situaciones donde:     1. Implementar un trait (comportamientos, "interface" o "metodos") para un tipo. En Rust, el concepto de interfaces se llama traits. Un trait define un conjunto de métodos que los tipos deben implementar si desean cumplir con ese trait.     2. No se necesita almacenar datos adicionales.  

// Lo que debe cumplir cualquier metodo de pago
trait MetodoPago {
    fn procesar_pago(&self, monto: f64) -> String;
}

// Metodo de pago 1
struct TarjetaCredito;
impl MetodoPago for TarjetaCredito {
    fn procesar_pago(&self, monto: f64) -> String {
        format!("Procesando pago de ${} con tarjeta de crédito.", monto)
    }
}

// Metodo de pago 2
struct PayPal;
impl MetodoPago for PayPal {
    fn procesar_pago(&self, monto: f64) -> String {
        format!("Procesando pago de ${} con PayPal.", monto)
    }
}