Error al usar la función Cow::to_mut en una enumeración en Rust (Error, Cow, Enum)

Publicado por Brisa
hace 4 meses

Hola a todos,

Estoy trabajando en un proyecto de Rust y me he encontrado con un problema al intentar usar la función Cow::to_mut en una enumeración. Estoy utilizando Cow para evitar copias innecesarias de datos en mi aplicación y me gustaría poder mutar el valor interno de la enumeración cuando sea necesario.

Aquí está el código de ejemplo que estoy usando:

use std::borrow::Cow;

enum MyEnum<'a> {
    Immutable(Cow<'a, str>),
    Mutable(Cow<'a, str>),
}

fn main() {
    let mut my_enum = MyEnum::Immutable(Cow::Borrowed("Hello"));

    if let MyEnum::Immutable(ref mut value) = my_enum {
        *value = value.to_mut(); // Error here
    }
}

Al intentar usar value.to_mut(), obtengo el siguiente error:

error[E0502]: cannot borrow `*value` as mutable because `value` is also borrowed as immutable
  --> src/main.rs:13:9
   |
13 |         *value = value.to_mut();
   |         ^^^^^^^^^^^^^^^^^^^^^^^
   |         |
   |         immutable borrow occurs here
   |         immutable borrow later used here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0502`.
error: could not compile `playground` due to previous error

¿Alguien podría explicarme qué estoy haciendo mal y cómo puedo solucionarlo? ¡Aprecio cualquier ayuda que puedan brindarme!

Compartir en

Respuesta de Gordon Shumway
hace 4 meses

¡Hola, Brisa!

El error te está diciendo que tienes un conflicto de préstamos (borrowing). Estás intentando tomar un préstamo mutable (to_mut()) del mismo valor que ya está prestado de forma inmutable en el patrón de coincidencia (if let). En Rust, no puedes tener un préstamo mutable mientras existe un préstamo inmutable, ya que eso violaría las garantías de seguridad en cuanto a la concurrencia y acceso a datos.

Para resolver este problema, necesitas realizar un pequeño ajuste en tu código para trabajar alrededor de las reglas de préstamo de Rust. En lugar de intentar mutar el valor directamente, puedes reemplazar my_enum con una nueva instancia de MyEnum que contenga una versión mutable (clonada en caso de necesidad) del Cow. Aquí te dejo un ejemplo que soluciona el problema:

use std::borrow::Cow;

enum MyEnum<'a> {
    Immutable(Cow<'a, str>),
    Mutable(Cow<'a, str>),
}

fn main() {
    let mut my_enum = MyEnum::Immutable(Cow::Borrowed("Hello"));

    my_enum = match my_enum {
        MyEnum::Immutable(ref value) => {
            MyEnum::Mutable(Cow::Owned(value.to_string()))
        }
        _ => my_enum,
    };

    // Ahora puedes modificar `my_enum` y al mismo tiempo
    // la parte `Mutable(_)` como quieras, por ejemplo:
    if let MyEnum::Mutable(ref mut value) = my_enum {
        *value.to_mut() = "Hello, world!".into(); // Esto es seguro
    }

    println!("{:?}", my_enum);
}

En este código, en lugar de intentar modificar value directamente dentro del préstamo, creamos una nueva instancia de MyEnum reemplazando la variante Immutable con una Mutable que contiene un Cow::Owned. Luego, si necesitas modificar el valor, coincides con la variante Mutable y allí sí puedes llamar a to_mut() sin problemas de préstamos.

Si tienes alguna otra duda, ¡aquí estaré para ayudarte!