guise/reactive/
binding.rs

1//! `Binding` — a two-way connection to a value (SwiftUI's `Binding`).
2//!
3//! A [`Signal`] is the store; a `Binding` is the connection: a getter and a
4//! setter over `App`. Components accept one through `.bind(...)` (controlled
5//! builders) or `X::bind(entity, &signal, cx)` (stateful entities), so a value
6//! flows both ways without hand-written change handlers.
7//!
8//! ```ignore
9//! // Whole signal as a binding:
10//! let dark = use_state(cx, false);
11//! Switch::new("dark-mode").bind(dark.binding());
12//!
13//! // One field of a struct signal (a lens):
14//! let settings = use_state(cx, Settings::default());
15//! Slider::bind(&volume_slider, &settings, cx); // entities bind to signals
16//! Checkbox::new("mute").bind(settings.lens(|s| s.muted, |s, v| s.muted = v));
17//! ```
18
19use std::rc::Rc;
20
21use gpui::App;
22
23use super::signal::Signal;
24
25type Getter<T> = Rc<dyn Fn(&App) -> T>;
26type Setter<T> = Rc<dyn Fn(&mut App, T)>;
27
28/// A two-way connection to a value: a getter and a setter over `App`.
29///
30/// Cheap to clone (both accessors are `Rc`-shared) and `'static`, so it can be
31/// captured by element closures. Build one from a [`Signal`] with
32/// [`Signal::binding`] or [`Signal::lens`], or from raw accessors with
33/// [`Binding::new`].
34pub struct Binding<T> {
35  get: Getter<T>,
36  set: Setter<T>,
37}
38
39impl<T> Clone for Binding<T> {
40  fn clone(&self) -> Self {
41    Binding {
42      get: self.get.clone(),
43      set: self.set.clone(),
44    }
45  }
46}
47
48impl<T: 'static> Binding<T> {
49  /// Create a binding from a getter and a setter.
50  pub fn new(get: impl Fn(&App) -> T + 'static, set: impl Fn(&mut App, T) + 'static) -> Self {
51    Binding {
52      get: Rc::new(get),
53      set: Rc::new(set),
54    }
55  }
56
57  /// Read the current value.
58  pub fn get(&self, cx: &App) -> T {
59    (self.get)(cx)
60  }
61
62  /// Write a new value.
63  pub fn set(&self, cx: &mut App, value: T) {
64    (self.set)(cx, value)
65  }
66
67  /// Bidirectional transform (e.g. `Binding<f64>` <-> `Binding<String>`):
68  /// `from` converts on read, `into` converts back on write.
69  pub fn map<U: 'static>(
70    &self,
71    from: impl Fn(T) -> U + 'static,
72    into: impl Fn(U) -> T + 'static,
73  ) -> Binding<U> {
74    let get = self.get.clone();
75    let set = self.set.clone();
76    Binding {
77      get: Rc::new(move |cx| from(get(cx))),
78      set: Rc::new(move |cx, value| set(cx, into(value))),
79    }
80  }
81
82  /// Read-only binding over a fixed value; writes are a no-op. Useful for
83  /// disabled or demo states.
84  pub fn constant(value: T) -> Self
85  where
86    T: Clone,
87  {
88    Binding {
89      get: Rc::new(move |_cx| value.clone()),
90      set: Rc::new(|_cx, _value| {}),
91    }
92  }
93}
94
95impl<T: Clone + PartialEq + 'static> Signal<T> {
96  /// The whole signal as a binding. Writes go through
97  /// [`Signal::set_if_changed`], so equal values skip the notify.
98  pub fn binding(&self) -> Binding<T> {
99    let read = self.clone();
100    let write = self.clone();
101    Binding::new(
102      move |cx| read.get(cx),
103      move |cx, value| write.set_if_changed(cx, value),
104    )
105  }
106}
107
108impl<T: 'static> Signal<T> {
109  /// Project a field: signal of a struct -> binding of one field (a lens).
110  /// Writes that leave the field unchanged skip the notify.
111  pub fn lens<U: Clone + PartialEq + 'static>(
112    &self,
113    get: impl Fn(&T) -> U + 'static,
114    set: impl Fn(&mut T, U) + 'static,
115  ) -> Binding<U> {
116    let get = Rc::new(get);
117    let project = get.clone();
118    let read = self.clone();
119    let write = self.clone();
120    Binding::new(
121      move |cx| project(read.read(cx)),
122      move |cx, value| {
123        if get(write.read(cx)) == value {
124          return;
125        }
126        write.update(cx, |slot| set(slot, value));
127      },
128    )
129  }
130}
131
132#[cfg(test)]
133mod tests {
134  use super::*;
135
136  #[test]
137  fn clone_shares_the_accessors() {
138    let binding = Binding::new(|_cx| 1i32, |_cx, _value| {});
139    let clone = binding.clone();
140    assert_eq!(Rc::strong_count(&binding.get), 2);
141    assert_eq!(Rc::strong_count(&clone.set), 2);
142  }
143
144  #[test]
145  fn map_shares_the_source_accessors() {
146    let binding = Binding::new(|_cx| 1.5f64, |_cx, _value| {});
147    let _mapped: Binding<String> = binding.map(|v| v.to_string(), |s| s.parse().unwrap_or(0.0));
148    // `map` captures the source's accessors rather than copying values.
149    assert_eq!(Rc::strong_count(&binding.get), 2);
150    assert_eq!(Rc::strong_count(&binding.set), 2);
151  }
152}
guise/reactive/binding.rs

guise/reactive/
binding.rs
