Should I worry about using forget method with Closure?

[blueowlgreenfish]

I have an html form that checks password validation on submit by using wasm-bindgen's Closure, web-sys's HtmlInputElement, etc.
It documents that, in Closure's example, forget method leaks memory in Rust and it should be handled carefully, but I don't really know how to handle it carefully.

I experimented if the onsubmit function works without forget method, but it didn't work.

Is there a documentation of how exactly I can be careful with this forget method?
If I don't fully understand this, should I not use this in production?
If so, is there an alternative to this?

[blueowlgreenfish]

I asked the same question on stackoverflow here just in case someone is curious.

[Liamolucko]

Using forget is fine as long as you only call it once or a fixed number of times. So in your case, it's fine as long as you only set onsubmit once upon startup.

Here's an example of a case where forget shouldn't be used:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    fn requestAnimationFrame(callback: &Closure<dyn FnMut()>);
}

#[wasm_bindgen(start)]
pub fn start() {
    // Start the rAF loop.
    frame_handler();
}

fn frame_handler() {
    let closure = Closure::new(frame_handler);
    requestAnimationFrame(&closure);

    // Don't do this - this will leak memory every frame.
    closure.forget();
}

Since this example uses the same closure every time, we can instead create the closure once and give it a reference to itself to call requestAnimationFrame with:

use std::mem;
use std::rc::{Rc, Weak};

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    fn requestAnimationFrame(callback: &Closure<dyn FnMut()>);
}

#[wasm_bindgen(start)]
pub fn start() {
    // Give the closure a reference to itself using `Rc::new_cyclic`, which
    // initializes the `Rc` with a closure taking a `Weak` reference as an
    // argument.
    let closure = Rc::new_cyclic(|this: &Weak<_>| {
        // &Weak -> Weak
        let this = this.clone();
        Closure::new(move || {
            // Upgrade the `Weak` to an `Rc`.
            // We can't do this outside the closure because the `Weak` only
            // becomes `upgrade`able after `Rc::new_cyclic` returns.
            let this = this.upgrade().unwrap();
            requestAnimationFrame(&this);
        })
    });

    // Leak the `Rc` so that the closure will live forever.
    // Since this only happens once, it's fine.
    mem::forget(closure);
}