Struct Map 

pub struct Map<R, F> { /* private fields */ }

A mapping type that transforms a resolvable value using a function.

Map wraps an existing Resolvable and applies a transformation function to its resolved output. This enables fluent APIs like color.lighten(0.2) or font.with_weight(Bold) without losing reactivity.

Example

use waterui_core::resolve::Map;

// Create a lighter version of the accent color
let lighter_accent = Map::new(
    theme::color::Accent,
    |color| color.with_lightness(color.lightness() + 0.2)
);

The transformation is applied lazily when the signal emits, so if the underlying Accent color changes (e.g., dark mode toggle), the lighter version updates too.

Implementations

impl<R, F> Map<R, F>

pub const fn new<T, U>(resolvable: R, func: F) -> Self

where R: Resolvable<Resolved = T>, F: Fn(T) -> U + Clone + 'static, T: 'static, U: 'static,

Creates a new mapping that transforms the resolved value using the given function.

Trait Implementations

impl<R: Clone, F: Clone> Clone for Map<R, F>

fn clone(&self) -> Map<R, F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug, F> Debug for Map<R, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, F, T, U> Resolvable for Map<R, F>

where R: Resolvable<Resolved = T>, F: Fn(T) -> U + Clone + 'static, T: 'static, U: 'static,

type Resolved = U

The concrete type produced after resolution.

fn resolve(&self, env: &Environment) -> impl Signal<Output = Self::Resolved>

Resolves this value in the given environment, returning a reactive signal.