how to use vector::destroy()

[huisq]

As per title, is it possible to give an example?
Also, if an unused vector is not destroyed does it take up storage and affect gas cost?

[0xmaayan]

You only have to use it if the value inside the vector is not drop. Usually we put a value in a vector that it is drop so it’ll get released automatically.

[gregnazario]

tl;dr you won't have to destroy the vector manually, unless the compiler tells you that that the vector was not droppable.

Situations you would need to use destroy

Destroy is only used if the struct does not have drop. The purpose here is to prevent losing data without specifically destroying the item.

If the item that you're storing is not drop then you'll have to use destroy. If it's drop it'll get destroyed automatically when you remove it from a resource on chain.

If the resource is not drop, and you don't destroy it, compilation will fail.

Example

module deployer::destroy_example {

    use std::signer;
    use std::vector;

    /// Resource to hold the item for this example
    struct StorageResource has key {
        vec: vector<NotDroppable>
    }

    /// This struct does not have `drop` so it cannot be dropped automatically
    struct NotDroppable has store {
        num: u8
    }

    /// Creates an example
    entry fun create(caller: &signer) {
        let vec = vector[
            NotDroppable { num: 0 },
            NotDroppable { num: 255 }
        ];

        move_to(caller, StorageResource {
            vec
        });
    }

    /// Destroys the vector with a lambda function
    entry fun destroy_with_lambda(caller: &signer) acquires StorageResource {
        let caller_address = signer::address_of(caller);
        let StorageResource {
            vec
        } = move_from<StorageResource>(caller_address);

        // Iterate through all items in the vector, destroying each
        vector::destroy(vec, |item| {
            NotDroppable {
                num: _ // Drop the number
            } = item;
        })
    }

    /// Destroys each item, then destroys the vector
    entry fun destroy_with_loop(caller: &signer) acquires StorageResource {
        let caller_address = signer::address_of(caller);
        let StorageResource {
            vec
        } = move_from<StorageResource>(caller_address);

        // Iterate through all items in the vector, destroying each
        let length = vector::length(&vec);
        for (i in 0..length) {
            let item = vector::pop_back(&mut vec);
            destroy_not_droppable(item)
        };

        // Once the vector is empty, you can destroy the vector
        vector::destroy_empty(vec)
    }

    /// Destroys a non-droppable item by dropping what's inside it
    fun destroy_not_droppable(item: NotDroppable) {
        NotDroppable {
            num: _ // Drop the number
        } = item;
    }
}