Module silkenweb::value

Abstract over the signal/value-ness of types.

This allows you to write a single function that works for both signals and values.

Example

struct Exec;

impl Executor for Exec {
    fn spawn(&mut self, future: impl Future<Output = ()> + 'static) {
        // This is a stub `Executor` for brevity. In real code, it should
        // run the future.
    }
}

fn increment_and_print(x: impl SignalOrValue<Item = i32>) {
    x.map(|x| x + 1).select_spawn(
        |_exec, x| println!("{x}"),
        |exec, x| {
            x.for_each(|x| {
                println!("{x}");
                async {}
            })
        },
        &mut Exec,
    );
}

let x_signal = Mutable::new(0);
let x_value = 0;

increment_and_print(x_value);
increment_and_print(Sig(x_signal.signal()));

Structs

• Sig
  Newtype wrapper to mark this type as a signal.
• Val
  Newtype wrapper to mark this type as a static value.

Traits

• Executor
  A type that can spawn futures.
• RefSignalOrValue
  Abstract over a type that can be a value or a signal of an underlying type.
• RefValue
  Marker trait for values that can be used with RefSignalOrValue.
• SignalOrValue
  Like RefSignalOrValue, when you know the type is 'static.
• Value
  Marker trait for values that can be used with SignalOrValue.