Vector

El Vector en Move proporciona una estructura de datos dinámica similar a un array que es flexible y soporta varias operaciones como indexación, agregar y remover elementos. Los vectores en Move son expandibles y soportan indexación basada en 0.

El módulo vector proporciona varias funciones nativas y de Move para gestionar arrays dinámicos:

• empty: Crea un vector vacío.
• length: Retorna la longitud del vector.
• borrow: Retorna una referencia inmutable a un elemento en un índice dado.
• push_back: Agrega un elemento al final del vector.
• borrow_mut: Retorna una referencia mutable a un elemento en un índice dado.
• pop_back: Remueve y retorna el último elemento del vector.
• destroy_empty: Destruye un vector vacío.
• swap: Intercambia elementos en dos índices dados.

Las siguientes constantes definen varios códigos de error usados dentro del módulo:

• EINDEX_OUT_OF_BOUNDS: 0x20000

• empty<Element>(): vector<Element>: Crea un vector vacío.
• singleton<Element>(e: Element): vector<Element>: Crea un vector con un solo elemento.

• push_back<Element>(v: &mut vector<Element>, e: Element): Agrega un elemento al final del vector.
• pop_back<Element>(v: &mut vector<Element>): Element: Remueve y retorna el último elemento del vector.
• remove<Element>(v: &mut vector<Element>, i: u64): Element: Remueve un elemento en un índice específico y desplaza los elementos subsiguientes.
• swap_remove<Element>(v: &mut vector<Element>, i: u64): Element: Intercambia el elemento en el índice dado con el último elemento y lo remueve.

• borrow<Element>(v: &vector<Element>, i: u64): &Element: Retorna una referencia inmutable a un elemento en un índice dado.
• borrow_with_default<Element>(v: &vector<Element>, i: u64, default: &Element): &Element: Retorna una referencia a un elemento o un valor por defecto si el índice está fuera de límites.
• borrow_mut<Element>(v: &mut vector<Element>, i: u64): &mut Element: Retorna una referencia mutable a un elemento en un índice dado.

• length<Element>(v: &vector<Element>): u64: Retorna el número de elementos en el vector.
• is_empty<Element>(v: &vector<Element>): bool: Verifica si el vector está vacío.
• contains<Element>(v: &vector<Element>, e: &Element): bool: Verifica si el vector contiene un elemento dado.
• index_of<Element>(v: &vector<Element>, e: &Element): (bool, u64): Retorna el índice de un elemento dado si se encuentra.
• reverse<Element>(v: &mut vector<Element>): Invierte el orden de los elementos en el vector.
• append<Element>(lhs: &mut vector<Element>, other: vector<Element>): Agrega todos los elementos de un vector a otro.
• for_each<Element>(v: vector<Element>, f: |Element|): Aplica una función a cada elemento en el vector.
• for_each_ref<Element>(v: &vector<Element>, f: |&Element|): Aplica una función a una referencia de cada elemento en el vector.
• for_each_mut<Element>(v: &mut vector<Element>, f: |&mut Element|): Aplica una función a una referencia mutable de cada elemento en el vector.
• fold<Accumulator, Element>(v: vector<Element>, init: Accumulator, f: |Accumulator, Element|Accumulator): Accumulator: Aplica una función para acumular un valor sobre los elementos del vector.
• map<Element, NewElement>(v: vector<Element>, f: |Element|NewElement): vector<NewElement>: Mapea una función sobre los elementos del vector, produciendo un nuevo vector.
• filter<Element: drop>(v: vector<Element>, p: |&Element|bool): vector<Element>: Filtra el vector usando una función predicado.

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

    public entry fun main() {
        let v = vector::empty<u64>();
        vector::push_back(&mut v, 10);
        vector::push_back(&mut v, 20);

        let length = vector::length(&v);
        assert!(length == 2, 0);

        let first_elem = vector::borrow(&v, 0);
        assert!(*first_elem == 10, 0);

        let second_elem = vector::borrow(&v, 1);
        assert!(*second_elem == 20, 0);

        let last_elem = vector::pop_back(&mut v);
        assert!(last_elem == 20, 0);

        vector::destroy_empty(v);
    }
}

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

    public fun append_vectors() {
        let v1 = vector::empty<u64>();
        let v2 = vector::empty<u64>();

        vector::push_back(&mut v1, 1);
        vector::push_back(&mut v1, 2);

        vector::push_back(&mut v2, 3);
        vector::push_back(&mut v2, 4);

        vector::append(&mut v1, v2);

        let length = vector::length(&v1);
        assert!(length == 4, 0);

        let first_elem = vector::borrow(&v1, 0);
        assert!(*first_elem == 1, 0);

        let second_elem = vector::borrow(&v1, 1);
        assert!(*second_elem == 2, 0);

        let third_elem = vector::borrow(&v1, 2);
        assert!(*third_elem == 3, 0);

        let fourth_elem = vector::borrow(&v1, 3);
        assert!(*fourth_elem == 4, 0);
    }
}

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

    public fun remove_elements() {
        let v = vector::empty<u64>();

        vector::push_back(&mut v, 1);
        vector::push_back(&mut v, 2);
        vector::push_back(&mut v, 3);

        let removed_elem = vector::remove(&mut v, 1);
        assert!(removed_elem == 2, 0);

        let length = vector::length(&v);
        assert!(length == 2, 0);

        let first_elem = vector::borrow(&v, 0);
        assert!(*first_elem == 1, 0);

        let second_elem = vector::borrow(&v, 1);
        assert!(*second_elem == 3, 0);
    }
}

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

    public fun swap_elements() {
        let v = vector::empty<u64>();

        vector::push_back(&mut v, 1);
        vector::push_back(&mut v, 2);
        vector::push_back(&mut v, 3);

        vector::swap(&mut v, 0, 2);

        let first_elem = vector::borrow(&v, 0);
        assert!(*first_elem == 3, 0);

        let third_elem = vector::borrow(&v, 2);
        assert!(*third_elem == 1, 0);
    }
}

• vector.move

• Tutorial de Vector de Move Spiders
• Tutorial de Vector de Move Spiders 2