Start

// ------ ------
//     Start
// ------ ------

// (This function is invoked by `init` function in `index.html`.)
#[wasm_bindgen(start)]
pub fn start() {
    // Mount the `app` to the element with the `id` "app".
    App::start("app", init, update, view);
}

<script type="module">
    import init from '/pkg/package.js';
    init('/pkg/package_bg.wasm');
</script>

// `App` has generic type parameters `Ms`, `Mdl` and `INodes`.
// `Ms` represents your `Msg`, `Mdl` your `Model` 
// and `INodes` the output value from your `view`. 
impl<Ms, Mdl, INodes> App<Ms, Mdl, INodes>

// We use `where` for better readability. An alternative would be:
// `impl<Ms, Mdl, INodes: IntoNodes<Ms> + 'static> App<Ms, Mdl, INodes>`
where

    // The most of things has to be `'static` because it mitigates 
    // the most of lifetime pains for Seed users but primarily we can't pass 
    // references into JS closures - and we need JS closures a lot,
    // especially in the Seed's core for all listeners and similar stuff.
    //
    // _Note_: I had problems to understand what is `'static` 
    // when I was learning Rust => it DOESN'T mean that the value is in memory 
    // for the entire program/app lifetime. It means it's in memory 
    // as long as necessary and we can pass it as we want
    // and we can store it inside structs without problems - in other words: 
    // it's basically everything, except references. 
    // There are only 2 exceptions:
    // 1. `&'static str` (aka string literals) - they are hardcoded strings
    // in your binary so you don't have to do any runtime memory allocations.
    // 2. `static NUM: i32 = 18;` - static global values. They live 
    // for the entire app lifetime.
    INodes: IntoNodes<Ms> + 'static,
{
    pub fn start(

        // You have to pass something that implements trait `GetElement` as `root_element`.
        // `impl` just hides the concrete type so it often makes the code MUCH more readable
        // and you don't have to introduce generic type parameters. 
        // (More about `GetElement` later.)
        root_element: impl GetElement,

        // There is `impl FnOnce` instead of `fn` so you can pass also a closure as `init`:
        // `App::start("app", |_, _| Model::default(), update, view)`
        //
        // It's `FnOnce + 'static` so the closure can close almost everything:
        // `let something = Everything::new();`
        // `App::start("app", move |_, _| Model { data: something }, update, view)`
        //
        // `OrdersContainer<..>` is a concrete type that implements `Orders`.
        // _Note:_ You shouldn't use `OrdersContainer` directly in your code.
        init: impl FnOnce(Url, &mut OrdersContainer<Ms, Mdl, INodes>) -> Mdl + 'static,

        // `update` is also `FnOnce` although it should be `Fn` because it's called multiple times.
        // There is a little trick: It also implements trait `Clone`, 
        // so it can be "casted" to `Fn` under the hood with the code like:
        // `let i_am_Fn = |argument| i_am_FnOnce.clone()(argument)`
        // That way both the compiler and users are happy - compiler is ok with multiple calls,
        // and `FnOnce + Clone` is the most convenient API for users. 
        // _Note:_ `Clone` is cheap because in the most cases `update` 
        // is `fn` that always implements `Copy` (`Copy` is just a mark for cheap `Clone`). 
        update: impl FnOnce(Ms, &mut Mdl, &mut OrdersContainer<Ms, Mdl, INodes>) + Clone + 'static,
        
        // Rust compiler isn't (yet?) able to compile `impl` in some places 
        // so we have to use generic type parameter `INodes` here.
        view: impl FnOnce(&Mdl) -> INodes + Clone + 'static,

        // `Self` represents `App<...>`.
    ) -> Self { ...

App::start("app", init, update, view);

#[wasm_bindgen(start)]
pub fn start() {
    // You have to enable panic messages forwarding
    // to console log. The same line is also in `App::start`,
    // but it's too late for the `.expect` below.
    //
    // _Note:_ For Seed <= 0.7.0, you have to add `console_error_panic_hook`
    // into dependencies in your `Cargo.toml` or use this commit:
    // `seed = { git = "https://github.com/seed-rs/seed", rev = "0a538f0" }`
    console_error_panic_hook::set_once();

    let root_element = document()
        .get_elements_by_tag_name("section")
        .item(0)
        .expect("`section` as a root element");

    App::start(root_element, init, update, view);
}