Igualdad

Move soporta dos operaciones de igualdad == e != (igual y no igual). Estas operaciones están disponibles solo para ciertos tipos, y ambos operandos deben ser del mismo tipo (no hay coerción implícita).

Fondo

Las operaciones de igualdad retornan un valor bool y son las siguientes:

Sintaxis	Operación	Descripción
==	igual	Retorna true si los dos operandos son iguales
!=	no igual	Retorna true si los dos operandos no son iguales

Tipos Soportados

Ambos operadores de igualdad pueden usarse con todos los tipos primitivos: u8, u16, u32, u64, u128, u256, bool, y address. También están soportados para vector, pero el tipo del vector debe a su vez soportar igualdad.

script {
  fun example() {
    // Tipos primitivos
    assert!(0u8 == 0u8, 0);
    assert!(1u64 != 2u64, 1);
    assert!(true == true, 2);
    assert!(false != true, 3);
    assert!(@0x1 == @0x1, 4);
    assert!(@0x1 != @0x2, 5);

    // Vectores
    assert!(vector<u8>[1, 2, 3] == vector<u8>[1, 2, 3], 6);
    assert!(vector<u8>[1, 2, 3] != vector<u8>[3, 2, 1], 7);
    assert!(vector<bool>[true, false] == vector<bool>[true, false], 8);
  }
}

Tipos No Soportados

Los operadores de igualdad no están soportados para:

• Structs (incluidos recursos)
• Referencias
• Tuplas
• Funciones

script {
  struct S { f: u64 }

  fun example() {
    let s1 = S { f: 0 };
    let s2 = S { f: 0 };

    // Error: igualdad no soportada para structs
    // let are_equal = s1 == s2;

    // Error: igualdad no soportada para referencias
    // let ref1 = &s1;
    // let ref2 = &s2;
    // let refs_equal = ref1 == ref2;
  }
}

Semántica de Igualdad

Comparación por Valor

Para tipos primitivos, la igualdad compara los valores directamente:

script {
  fun value_comparison() {
    let a = 42u64;
    let b = 42u64;
    let c = 43u64;

    assert!(a == b, 0); // Mismo valor
    assert!(a != c, 1); // Valores diferentes

    // Para direcciones
    let addr1 = @0x42;
    let addr2 = @0x42;
    let addr3 = @0x43;

    assert!(addr1 == addr2, 2); // Misma dirección
    assert!(addr1 != addr3, 3); // Direcciones diferentes
  }
}

Comparación de Vectores

Para vectores, la igualdad compara elemento por elemento:

script {
  fun vector_comparison() {
    let vec1 = vector<u64>[1, 2, 3];
    let vec2 = vector<u64>[1, 2, 3];
    let vec3 = vector<u64>[1, 2, 4];
    let vec4 = vector<u64>[1, 2];

    assert!(vec1 == vec2, 0); // Mismos elementos en mismo orden
    assert!(vec1 != vec3, 1); // Diferentes elementos
    assert!(vec1 != vec4, 2); // Diferentes longitudes

    // Vector vacío
    let empty1 = vector<u64>[];
    let empty2 = vector<u64>[];
    assert!(empty1 == empty2, 3); // Vectores vacíos son iguales
  }
}

Comparación de Vectores Anidados

script {
  fun nested_vector_comparison() {
    let nested1 = vector<vector<u8>>[
      vector<u8>[1, 2],
      vector<u8>[3, 4]
    ];

    let nested2 = vector<vector<u8>>[
      vector<u8>[1, 2],
      vector<u8>[3, 4]
    ];

    let nested3 = vector<vector<u8>>[
      vector<u8>[1, 2],
      vector<u8>[3, 5] // Diferente elemento
    ];

    assert!(nested1 == nested2, 0); // Misma estructura
    assert!(nested1 != nested3, 1); // Elementos diferentes
  }
}

Casos de Uso Comunes

Validación de Entrada

module 0x42::validation {
  use std::string::{Self, String};
  use std::vector;

  const E_INVALID_INPUT: u64 = 1;
  const E_EMPTY_STRING: u64 = 2;

  public fun validate_non_zero(value: u64) {
    assert!(value != 0, E_INVALID_INPUT);
  }

  public fun validate_address(addr: address) {
    assert!(addr != @0x0, E_INVALID_INPUT);
  }

  public fun validate_non_empty_string(s: &String) {
    let empty = string::utf8(b"");
    assert!(*s != empty, E_EMPTY_STRING);
  }

  public fun validate_expected_value(actual: u64, expected: u64) {
    assert!(actual == expected, E_INVALID_INPUT);
  }
}

Búsqueda en Vectores

module 0x42::search {
  use std::vector;
  use std::option::{Self, Option};

  public fun find_index<T>(vec: &vector<T>, target: &T): Option<u64> {
    let len = vector::length(vec);
    let mut i = 0;

    while (i < len) {
      if (vector::borrow(vec, i) == target) {
        return option::some(i)
      };
      i = i + 1;
    };

    option::none()
  }

  public fun contains<T>(vec: &vector<T>, target: &T): bool {
    option::is_some(&find_index(vec, target))
  }

  public fun count_occurrences<T>(vec: &vector<T>, target: &T): u64 {
    let len = vector::length(vec);
    let mut count = 0;
    let mut i = 0;

    while (i < len) {
      if (vector::borrow(vec, i) == target) {
        count = count + 1;
      };
      i = i + 1;
    };

    count
  }
}

Filtrado de Datos

module 0x42::filtering {
  use std::vector;

  public fun filter_equal<T: copy>(vec: &vector<T>, target: &T): vector<T> {
    let result = vector::empty<T>();
    let len = vector::length(vec);
    let mut i = 0;

    while (i < len) {
      let element = vector::borrow(vec, i);
      if (element == target) {
        vector::push_back(&mut result, *element);
      };
      i = i + 1;
    };

    result
  }

  public fun filter_not_equal<T: copy>(vec: &vector<T>, target: &T): vector<T> {
    let result = vector::empty<T>();
    let len = vector::length(vec);
    let mut i = 0;

    while (i < len) {
      let element = vector::borrow(vec, i);
      if (element != target) {
        vector::push_back(&mut result, *element);
      };
      i = i + 1;
    };

    result
  }

  public fun remove_duplicates<T: copy>(vec: &vector<T>): vector<T> {
    let result = vector::empty<T>();
    let len = vector::length(vec);
    let mut i = 0;

    while (i < len) {
      let element = vector::borrow(vec, i);
      if (!contains(&result, element)) {
        vector::push_back(&mut result, *element);
      };
      i = i + 1;
    };

    result
  }

  fun contains<T>(vec: &vector<T>, target: &T): bool {
    let len = vector::length(vec);
    let mut i = 0;

    while (i < len) {
      if (vector::borrow(vec, i) == target) {
        return true
      };
      i = i + 1;
    };

    false
  }
}

Comparación de Estados

module 0x42::state_machine {
  const PENDING: u8 = 0;
  const PROCESSING: u8 = 1;
  const COMPLETED: u8 = 2;
  const FAILED: u8 = 3;

  struct Order has key {
    id: u64,
    status: u8,
    owner: address,
  }

  public fun is_pending(order: &Order): bool {
    order.status == PENDING
  }

  public fun is_processing(order: &Order): bool {
    order.status == PROCESSING
  }

  public fun is_completed(order: &Order): bool {
    order.status == COMPLETED
  }

  public fun is_failed(order: &Order): bool {
    order.status == FAILED
  }

  public fun can_process(order: &Order): bool {
    order.status == PENDING
  }

  public fun can_complete(order: &Order): bool {
    order.status == PROCESSING
  }

  public fun is_owned_by(order: &Order, addr: address): bool {
    order.owner == addr
  }
}

Optimizaciones y Rendimiento

Comparación Temprana

Para vectores largos, considera salir temprano si es posible:

module 0x42::optimized_comparison {
  use std::vector;

  public fun vectors_equal_optimized<T>(vec1: &vector<T>, vec2: &vector<T>): bool {
    let len1 = vector::length(vec1);
    let len2 = vector::length(vec2);

    // Salida temprana si las longitudes son diferentes
    if (len1 != len2) {
      return false
    };

    // Si ambos están vacíos, son iguales
    if (len1 == 0) {
      return true
    };

    // Comparar elemento por elemento
    let mut i = 0;
    while (i < len1) {
      if (vector::borrow(vec1, i) != vector::borrow(vec2, i)) {
        return false
      };
      i = i + 1;
    };

    true
  }

  public fun find_first_difference<T>(vec1: &vector<T>, vec2: &vector<T>): Option<u64> {
    let len1 = vector::length(vec1);
    let len2 = vector::length(vec2);
    let min_len = if (len1 < len2) len1 else len2;

    let mut i = 0;
    while (i < min_len) {
      if (vector::borrow(vec1, i) != vector::borrow(vec2, i)) {
        return option::some(i)
      };
      i = i + 1;
    };

    // Si todas las posiciones comparables son iguales pero las longitudes difieren
    if (len1 != len2) {
      option::some(min_len)
    } else {
      option::none()
    }
  }
}

Evitar Comparaciones Innecesarias

module 0x42::efficient_checks {
  use std::vector;

  public fun has_target_at_positions<T>(
    vec: &vector<T>,
    target: &T,
    positions: &vector<u64>
  ): bool {
    let pos_len = vector::length(positions);
    let vec_len = vector::length(vec);
    let mut i = 0;

    while (i < pos_len) {
      let pos = *vector::borrow(positions, i);

      // Verificar límites antes de acceder
      if (pos >= vec_len) {
        return false
      };

      // Verificar igualdad
      if (vector::borrow(vec, pos) != target) {
        return false
      };

      i = i + 1;
    };

    true
  }
}

Patrones de Comparación para Structs

Aunque los structs no soportan igualdad directa, puedes implementar funciones de comparación personalizadas:

module 0x42::custom_equality {
  struct Point {
    x: u64,
    y: u64,
  }

  struct Person {
    name: vector<u8>,
    age: u8,
    address: address,
  }

  public fun points_equal(p1: &Point, p2: &Point): bool {
    p1.x == p2.x && p1.y == p2.y
  }

  public fun persons_equal(p1: &Person, p2: &Person): bool {
    p1.name == p2.name && p1.age == p2.age && p1.address == p2.address
  }

  // Comparación parcial - solo por nombre
  public fun same_name(p1: &Person, p2: &Person): bool {
    p1.name == p2.name
  }

  // Comparación con tolerancia para puntos
  public fun points_near(p1: &Point, p2: &Point, tolerance: u64): bool {
    let x_diff = if (p1.x > p2.x) p1.x - p2.x else p2.x - p1.x;
    let y_diff = if (p1.y > p2.y) p1.y - p2.y else p2.y - p1.y;

    x_diff <= tolerance && y_diff <= tolerance
  }
}

Casos Especiales y Gotchas

Precisión Flotante (No Aplicable a Move)

A diferencia de lenguajes con números de punto flotante, Move solo tiene enteros, por lo que no hay problemas de precisión flotante:

script {
  fun integer_equality() {
    // En Move, esto siempre es seguro
    let a = 1;
    let b = 1;
    assert!(a == b, 0); // Siempre funciona como se espera

    // No hay problemas de precisión flotante como 0.1 + 0.2 != 0.3
  }
}

Vectores Vacíos

script {
  fun empty_vector_equality() {
    let empty1 = vector<u64>[];
    let empty2 = vector<bool>[];

    // Vectores vacíos de diferentes tipos NO son iguales
    // empty1 == empty2; // Error de tipo

    let empty3 = vector<u64>[];
    assert!(empty1 == empty3, 0); // OK - mismo tipo
  }
}

Vectores de Bytes

script {
  fun byte_vector_equality() {
    let bytes1 = b"hello";
    let bytes2 = vector<u8>[104, 101, 108, 108, 111]; // "hello" en ASCII

    assert!(bytes1 == bytes2, 0); // Son iguales

    let bytes3 = b"Hello"; // Diferente capitalización
    assert!(bytes1 != bytes3, 1); // No son iguales
  }
}

Mejores Prácticas

1. Usa Nombres Descriptivos para Comparaciones

// ✅ Bueno - intención clara
public fun is_admin(user_role: u8): bool {
  user_role == ADMIN_ROLE
}

public fun is_zero_address(addr: address): bool {
  addr == @0x0
}

// ❌ Malo - intención poco clara
public fun check(x: u8): bool {
  x == 1
}

2. Combina Comparaciones Lógicamente

// ✅ Bueno - lógica clara
public fun is_valid_user(age: u8, address: address): bool {
  age >= 18 && address != @0x0
}

public fun is_special_case(status: u8, priority: u8): bool {
  status == URGENT_STATUS || priority == HIGH_PRIORITY
}

// ❌ Malo - comparaciones complejas anidadas
public fun complex_check(a: u8, b: u8, c: u8): bool {
  if (a == 1) {
    if (b == 2) {
      c == 3
    } else {
      false
    }
  } else {
    false
  }
}

3. Implementa Funciones de Igualdad para Structs

module 0x42::best_practices {
  struct User {
    id: u64,
    name: vector<u8>,
    active: bool,
  }

  // ✅ Bueno - función de igualdad clara
  public fun users_equal(u1: &User, u2: &User): bool {
    u1.id == u2.id &&
    u1.name == u2.name &&
    u1.active == u2.active
  }

  // ✅ También bueno - comparaciones específicas
  public fun same_user_id(u1: &User, u2: &User): bool {
    u1.id == u2.id
  }

  public fun same_user_name(u1: &User, u2: &User): bool {
    u1.name == u2.name
  }
}

4. Maneja Casos Edge

module 0x42::edge_cases {
  use std::vector;
  use std::option::{Self, Option};

  public fun safe_vector_equal<T>(
    vec1: &Option<vector<T>>,
    vec2: &Option<vector<T>>
  ): bool {
    if (option::is_none(vec1) && option::is_none(vec2)) {
      true
    } else if (option::is_some(vec1) && option::is_some(vec2)) {
      *option::borrow(vec1) == *option::borrow(vec2)
    } else {
      false
    }
  }

  public fun compare_with_default<T: copy>(
    actual: &Option<T>,
    expected: T
  ): bool {
    if (option::is_some(actual)) {
      *option::borrow(actual) == expected
    } else {
      false
    }
  }
}

Errores Comunes

Intentar Comparar Tipos Incompatibles

// ❌ Error - tipos diferentes
script {
  fun type_mismatch() {
    let a = 1u64;
    let b = 1u8;
    // let result = a == b; // Error: tipos incompatibles
  }
}

// ✅ Solución - conversión explícita
script {
  fun correct_comparison() {
    let a = 1u64;
    let b = 1u8;
    let result = a == (b as u64); // OK
  }
}

Intentar Comparar Structs Directamente

// ❌ Error - structs no soportan igualdad
module 0x42::struct_error {
  struct Point { x: u64, y: u64 }

  fun compare_structs() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    // let equal = p1 == p2; // Error
  }
}

// ✅ Solución - función de comparación personalizada
module 0x42::struct_solution {
  struct Point { x: u64, y: u64 }

  public fun points_equal(p1: &Point, p2: &Point): bool {
    p1.x == p2.x && p1.y == p2.y
  }

  fun compare_structs() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    let equal = points_equal(&p1, &p2); // OK
  }
}

Conclusión

La igualdad en Move es un concepto fundamental pero limitado en comparación con otros lenguajes. Entender qué tipos soportan igualdad y cómo implementar comparaciones personalizadas para tipos que no la soportan es crucial para escribir código Move efectivo.

Puntos clave para recordar:

• Solo tipos primitivos y vectores soportan operadores de igualdad
• Los structs requieren funciones de comparación personalizadas
• Las comparaciones de vectores son elemento por elemento
• Siempre considera casos edge como vectores vacíos
• Usa nombres descriptivos para funciones de comparación
• La igualdad en Move es siempre por valor, no por referencia