Derived signals that aren't Copy

[sebastian]

The book describes how one creates dependent signals, for example something like this:

#[component]
pub fn Test(cx: Scope) -> impl IntoView {
    let (count, set_count) = create_signal(cx, 0);
    let amount = 2;
    let more_by_amount = move || count() + amount;

    view! {
        cx,
        <p>{more_by_amount}" > "{count}</p>
        <p>{more_by_amount}" > "{count}</p>
    }
}

All well and good!

But what if one of the values used in the derived signal is not Copy?

Something along what happens in the following (somewhat contrived) example has happened to me on multiple occasions:

#[component]
pub fn Test(cx: Scope, name: String) -> impl IntoView {
    let (count, _set_count) = create_signal(cx, 0);
    let is_error = move || name.len() as i64 > count();
    let not_error = move || !is_error(); 
    // `is_error` is now out of scope as it was moved into `not_error`   

    view! {
        cx,
        <p class:not-error=not_error>"The name "{name}" is too long: "{is_error}</p>
    }
}

The problem here seems to be that name is in fact not Copy and hence my derived signals stop being Copy too. As a result my is_error signal is moved into the not_error one, and no longer available for subsequent use.

Is my approach conceptually wrong somehow?
I have had to do hacks like this, which don't scale well at all:

    // Generate `not_error` but without consuming `name`
    let name_for_len = name.clone();
    let is_error = move || name_for_len.len() as i64 > count();
    let not_error = move || !is_error();

    // Generate a new `is_error`, again without consuming `name`
    let name_for_len = name.clone();
    let is_error = move || name_for_len.len() as i64 > count();

Any ideas and thoughts and feedback would be greatly appreciated!

🙏

[gbj]

Yeah just to be clear your solution is not a hack, it's idiomatic Rust. Another, slightly different or better approach could be:

let name_for_len = name.clone();
let is_error = {
    let name = name.clone();
    move || name.len() as i64 > count()
};

Depends on your preference for style.

Similarly,

let is_error = move || name.len() as i64 > count();
let not_error = {
    let is_error = is_error.clone();
    move || !is_error();
};

view! { cx,
    <p class:not-error=not_error>"The name "{name}" is too long: "{is_error}</p>
}

But we do also provide a Signal wrapper type you can used for derived signals, which it Copy.

#[component]
pub fn Test(cx: Scope, name: String) -> impl IntoView {
    let (count, _set_count) = create_signal(cx, 0);
    let is_error = Signal::derive(cx, move || name.len() as i64 > count());
    let not_error = move || !is_error(); 

    view! {
        cx,
        <p class:not-error=not_error>"The name "{name}" is too long: "{is_error}</p>
    }
}

[sebastian]

Thank you for the reply.

I'll make good use of Signal::derive going forward, or worst come to worst manually clone fields where needed.

My hope is that we can at some point move away from the moveing all over the place. That seems in part to be at the source of my problems.