Various quality of life features

gridbugs · gridbugs · commit e28ca6b140cb · 2025-10-11T21:42:59.000+11:00
diff --git a/caw/src/lib.rs b/caw/src/lib.rs
@@ -74,4 +74,12 @@ pub mod prelude {
 
     #[cfg(feature = "caw_viz_udp_app_lib")]
     pub use super::viz_udp_app_lib::*;
+
+    /// Shorthand for `Default::default`
+    pub fn default<T>() -> T
+    where
+        T: Default,
+    {
+        Default::default()
+    }
 }
diff --git a/core/src/cell.rs b/core/src/cell.rs
@@ -164,7 +164,25 @@ where
     cell(T::default())
 }
 
-impl<T> Stereo<Cell<T>, Cell<T>>
+pub type StereoCell<T> = Stereo<Cell<T>, Cell<T>>;
+pub type StereoCellF32 = StereoCell<f32>;
+
+pub fn stereo_cell_fn<S, F>(mut f: F) -> StereoCell<S::Item>
+where
+    S: SigT + Sync + Send + 'static,
+    F: FnMut() -> S,
+{
+    Stereo::new_fn(|| cell(f()))
+}
+
+pub fn stereo_cell_default<T>() -> StereoCell<T>
+where
+    T: SigT<Item = T> + Clone + Default + Sync + Send + 'static,
+{
+    stereo_cell_fn(T::default)
+}
+
+impl<T> StereoCell<T>
 where
     T: Clone,
 {
@@ -183,9 +201,19 @@ where
     {
         self.as_ref().with_channel(|channel, s| s.set(f(channel)));
     }
+
+    pub fn set_stereo<U, V>(&self, stereo: Stereo<U, V>)
+    where
+        U: SigT<Item = T> + Sync + Send + 'static,
+        V: SigT<Item = T> + Sync + Send + 'static,
+    {
+        let ref_ = self.as_ref();
+        ref_.left.set(stereo.left);
+        ref_.right.set(stereo.right);
+    }
 }
 
-impl Stereo<Cell<f32>, Cell<f32>> {
+impl StereoCellF32 {
     pub fn with_volume<V>(self, volume: V) -> Self
     where
         V: SigT<Item = f32> + Sync + Send + 'static,
diff --git a/core/src/lib.rs b/core/src/lib.rs
@@ -8,6 +8,9 @@ pub use sig::{
     sig_shared, variable,
 };
 pub mod cell;
-pub use cell::{Cell, CellF32, cell, cell_default, cell_f32};
+pub use cell::{
+    Cell, CellF32, StereoCell, StereoCellF32, cell, cell_default, cell_f32,
+    stereo_cell_default, stereo_cell_fn,
+};
 pub mod stereo;
 pub use stereo::{Channel, Stereo, StereoPair};
diff --git a/core/src/sig.rs b/core/src/sig.rs
@@ -744,6 +744,11 @@ where
                 },
             )
     }
+
+    /// A signal with the same values as `self` but every value is wrapped in `Some`.
+    pub fn some(self) -> Sig<impl SigT<Item = Option<S::Item>>> {
+        self.map(Some)
+    }
 }
 
 impl<S, A, B> Sig<S>
@@ -1011,6 +1016,11 @@ where
         self.divide_with_offset(by, 0)
     }
 
+    /// On a gate or trigger signal, this method returns a signal where each "on" value includes a
+    /// count of the number of times the signal has transitioned from off to on. This "counting
+    /// gate" can be used to generate beats with divided clocks where the offset of the divided
+    /// signal remains fixed, even when a divided signal is "restarted" part-way through a cycle,
+    /// such as is the case for live-coding sessions (e.g. in Jupyter).
     pub fn counted(self) -> Sig<impl SigT<Item = Option<u64>>> {
         let mut prev = false;
         let mut count = 0;
@@ -1140,6 +1150,10 @@ where
     {
         self.zip(other).map(|(s, o)| s.or(o))
     }
+
+    pub fn is_some(self) -> Sig<impl SigT<Item = bool>> {
+        self.map(|o| o.is_some())
+    }
 }
 
 impl<T, S> Sig<S>
@@ -1164,6 +1178,16 @@ where
         })
         .unzip()
     }
+
+    pub fn or_last_some(self) -> Sig<impl SigT<Item = T>> {
+        let mut prev = Default::default();
+        self.map_mut(move |o| {
+            if let Some(x) = o {
+                prev = x;
+            }
+            prev.clone()
+        })
+    }
 }
 
 pub struct WithBuf<S, F>
diff --git a/core/src/stereo.rs b/core/src/stereo.rs
@@ -1,4 +1,7 @@
-use std::fmt::Display;
+use std::{
+    fmt::Display,
+    ops::{Add, Mul},
+};
 
 use crate::{Buf, Sig, SigCtx, SigSampleIntoBufT, SigT, sig_ops::sig_add};
 
@@ -220,4 +223,47 @@ impl<S> Stereo<S, S> {
             right: f(&self.right),
         }
     }
+
+    pub fn map_pair_channel<O, F>(self, mut f: F) -> Stereo<O, O>
+    where
+        F: FnMut(S, Channel) -> O,
+    {
+        Stereo {
+            left: f(self.left, Channel::Left),
+            right: f(self.right, Channel::Right),
+        }
+    }
+
+    pub fn map_ref_pair_channel<O, F>(&self, mut f: F) -> Stereo<O, O>
+    where
+        F: FnMut(&S, Channel) -> O,
+    {
+        Stereo {
+            left: f(&self.left, Channel::Left),
+            right: f(&self.right, Channel::Right),
+        }
+    }
+}
+
+impl<LL, LR, RL, RR> Add<Stereo<RL, RR>> for Stereo<LL, LR>
+where
+    LL: Add<RL>,
+    LR: Add<RR>,
+{
+    type Output = Stereo<LL::Output, LR::Output>;
+    fn add(self, rhs: Stereo<RL, RR>) -> Self::Output {
+        Stereo::new(self.left + rhs.left, self.right + rhs.right)
+    }
+}
+
+impl<L, R, RHS> Mul<RHS> for Stereo<L, R>
+where
+    RHS: Clone,
+    L: Mul<RHS>,
+    R: Mul<RHS>,
+{
+    type Output = Stereo<L::Output, R::Output>;
+    fn mul(self, rhs: RHS) -> Self::Output {
+        Stereo::new(self.left * rhs.clone(), self.right * rhs)
+    }
 }
diff --git a/keyboard/src/a440_12tet.rs b/keyboard/src/a440_12tet.rs
@@ -475,6 +475,9 @@ pub mod chord {
             }
         }
 
+        /// Sets the 7th note of the chord to be the appropriate note for a major 7th chord unless
+        /// the chord has a minor 3rd note in which case this method sets the 7th note of the chord
+        /// to be the appropriate note for a minor 7th chord.
         pub const fn infer_7(self) -> Self {
             let seventh = Some(match self.third {
                 Some(Third::Minor) => Seventh::Minor,
@@ -585,13 +588,14 @@ pub mod chord {
 
     #[derive(Clone, Copy, Debug)]
     pub enum Inversion {
+        /// The root note of the chord will be in the specified octave. The notes of the chord will
+        /// be chosen such that `lowest_position` is the lowest note of the chord.
         WithRootOctave {
             root_octave: Octave,
             lowest_position: ChordPosition,
         },
-        InOctave {
-            octave_base: Note,
-        },
+        /// Play all the notes of the chord within this octave.
+        InOctave { octave_base: Note },
     }
 
     impl Default for Inversion {
diff --git a/keyboard/src/event.rs b/keyboard/src/event.rs
@@ -408,21 +408,41 @@ impl ArpState {
         }
     }
 
-    fn insert_note(&mut self, note: Note) {
+    fn insert_note(&mut self, note: Note, shape: &ArpShape) {
         if let Some(index) = self.store.insert(note) {
-            if self.index > index {
-                self.index += 1;
+            match shape {
+                ArpShape::Indices(_) => {
+                    // If the shape is a list of indices then the `index` field refers to and index
+                    // into _that_ list rather than the store, so don't touch it.
+                }
+                _ => {
+                    // If the note referred to by the current index has moved in the store, adjust
+                    // the index to point to that note again.
+                    if self.index > index {
+                        self.index += 1;
+                    }
+                }
             }
         }
     }
-    fn remove_note(&mut self, note: Note) {
+    fn remove_note(&mut self, note: Note, shape: &ArpShape) {
         if let Some(index) = self.store.remove(note) {
-            if self.index > index {
-                self.index -= 1;
+            match shape {
+                ArpShape::Indices(_) => {
+                    // If the shape is a list of indices then the `index` field refers to and index
+                    // into _that_ list rather than the store, so don't touch it.
+                }
+                _ => {
+                    // If the note referred to by the current index has moved in the store, adjust
+                    // the index to point to that note again.
+                    if self.index > index {
+                        self.index -= 1;
+                    }
+                }
             }
         }
     }
-    fn reset(&mut self, shape: ArpShape) {
+    fn reset(&mut self, shape: &ArpShape) {
         self.index = 0;
         use ArpShape::*;
         match shape {
@@ -450,7 +470,7 @@ impl ArpState {
         self.index -= 1;
         self.store.entries[self.index].note
     }
-    fn tick(&mut self, shape: ArpShape) {
+    fn tick(&mut self, shape: &ArpShape) {
         self.current_note = if self.store.entries.is_empty() {
             self.reset(shape);
             None
@@ -649,35 +669,35 @@ where
             let mut events = KeyEvents::empty();
             for event in key_events {
                 if event.pressed {
-                    state.insert_note(event.note);
+                    state.insert_note(event.note, &shape);
                     for i in 0..extend_octaves_high {
                         if let Some(note) =
                             event.note.add_octaves_checked(i as i8 + 1)
                         {
-                            state.insert_note(note);
+                            state.insert_note(note, &shape);
                         }
                     }
                     for i in 0..extend_octaves_low {
                         if let Some(note) =
                             event.note.add_octaves_checked(-(i as i8 + 1))
                         {
-                            state.insert_note(note);
+                            state.insert_note(note, &shape);
                         }
                     }
                 } else {
-                    state.remove_note(event.note);
+                    state.remove_note(event.note, &shape);
                     for i in 0..extend_octaves_high {
                         if let Some(note) =
                             event.note.add_octaves_checked(i as i8 + 1)
                         {
-                            state.remove_note(note);
+                            state.remove_note(note, &shape);
                         }
                     }
                     for i in 0..extend_octaves_low {
                         if let Some(note) =
                             event.note.add_octaves_checked(-(i as i8 + 1))
                         {
-                            state.remove_note(note);
+                            state.remove_note(note, &shape);
                         }
                     }
                 }
@@ -690,7 +710,7 @@ where
                         velocity_01: 0.0,
                     });
                 }
-                state.tick(shape);
+                state.tick(&shape);
                 if let Some(note) = state.current_note {
                     events.push(KeyEvent {
                         note,
diff --git a/utils/src/noise.rs b/utils/src/noise.rs
@@ -6,6 +6,11 @@ pub fn white() -> Sig<impl SigT<Item = f32>> {
     Sig::from_fn(move |_| rng.random::<f32>() * 2. - 1.)
 }
 
+pub fn white_01() -> Sig<impl SigT<Item = f32>> {
+    let mut rng = StdRng::from_os_rng();
+    Sig::from_fn(move |_| rng.random::<f32>())
+}
+
 /// Approximation of brown noise made by integrating white noise with a leaky integrator and
 /// hand-tuning.
 pub fn brown() -> Sig<impl SigT<Item = f32>> {

Original file line number	Diff line number	Diff line change
`@@ -744,6 +744,11 @@ where`
`744`	`744`	`},`
`745`	`745`	`)`
`746`	`746`	`}`
	`747`	`+`
	`748`	+ /// A signal with the same values as `self` but every value is wrapped in `Some`.
	`749`	`+ pub fn some(self) -> Sig<impl SigT<Item = Option<S::Item>>> {`
	`750`	`+ self.map(Some)`
	`751`	`+ }`
`747`	`752`	`}`
`748`	`753`
`749`	`754`	`impl<S, A, B> Sig<S>`
`@@ -1011,6 +1016,11 @@ where`
`1011`	`1016`	`self.divide_with_offset(by, 0)`
`1012`	`1017`	`}`
`1013`	`1018`
	`1019`	`+ /// On a gate or trigger signal, this method returns a signal where each "on" value includes a`
	`1020`	`+ /// count of the number of times the signal has transitioned from off to on. This "counting`
	`1021`	`+ /// gate" can be used to generate beats with divided clocks where the offset of the divided`
	`1022`	`+ /// signal remains fixed, even when a divided signal is "restarted" part-way through a cycle,`
	`1023`	`+ /// such as is the case for live-coding sessions (e.g. in Jupyter).`
`1014`	`1024`	`pub fn counted(self) -> Sig<impl SigT<Item = Option<u64>>> {`
`1015`	`1025`	`let mut prev = false;`
`1016`	`1026`	`let mut count = 0;`
`@@ -1140,6 +1150,10 @@ where`
`1140`	`1150`	`{`
`1141`	`1151`	`self.zip(other).map(\|(s, o)\| s.or(o))`
`1142`	`1152`	`}`
	`1153`	`+`
	`1154`	`+ pub fn is_some(self) -> Sig<impl SigT<Item = bool>> {`
	`1155`	`+ self.map(\|o\| o.is_some())`
	`1156`	`+ }`
`1143`	`1157`	`}`
`1144`	`1158`
`1145`	`1159`	`impl<T, S> Sig<S>`
`@@ -1164,6 +1178,16 @@ where`
`1164`	`1178`	`})`
`1165`	`1179`	`.unzip()`
`1166`	`1180`	`}`
	`1181`	`+`
	`1182`	`+ pub fn or_last_some(self) -> Sig<impl SigT<Item = T>> {`
	`1183`	`+ let mut prev = Default::default();`
	`1184`	`+ self.map_mut(move \|o\| {`
	`1185`	`+ if let Some(x) = o {`
	`1186`	`+ prev = x;`
	`1187`	`+ }`
	`1188`	`+ prev.clone()`
	`1189`	`+ })`
	`1190`	`+ }`
`1167`	`1191`	`}`
`1168`	`1192`
`1169`	`1193`	`pub struct WithBuf<S, F>`
Original file line number	Diff line number	Diff line change
`@@ -408,21 +408,41 @@ impl ArpState {`
`408`	`408`	`}`
`409`	`409`	`}`
`410`	`410`
`411`		`- fn insert_note(&mut self, note: Note) {`
	`411`	`+ fn insert_note(&mut self, note: Note, shape: &ArpShape) {`
`412`	`412`	`if let Some(index) = self.store.insert(note) {`
`413`		`- if self.index > index {`
`414`		`- self.index += 1;`
	`413`	`+ match shape {`
	`414`	`+ ArpShape::Indices(_) => {`
	`415`	+ // If the shape is a list of indices then the `index` field refers to and index
	`416`	`+ // into _that_ list rather than the store, so don't touch it.`
	`417`	`+ }`
	`418`	`+ _ => {`
	`419`	`+ // If the note referred to by the current index has moved in the store, adjust`
	`420`	`+ // the index to point to that note again.`
	`421`	`+ if self.index > index {`
	`422`	`+ self.index += 1;`
	`423`	`+ }`
	`424`	`+ }`
`415`	`425`	`}`
`416`	`426`	`}`
`417`	`427`	`}`
`418`		`- fn remove_note(&mut self, note: Note) {`
	`428`	`+ fn remove_note(&mut self, note: Note, shape: &ArpShape) {`
`419`	`429`	`if let Some(index) = self.store.remove(note) {`
`420`		`- if self.index > index {`
`421`		`- self.index -= 1;`
	`430`	`+ match shape {`
	`431`	`+ ArpShape::Indices(_) => {`
	`432`	+ // If the shape is a list of indices then the `index` field refers to and index
	`433`	`+ // into _that_ list rather than the store, so don't touch it.`
	`434`	`+ }`
	`435`	`+ _ => {`
	`436`	`+ // If the note referred to by the current index has moved in the store, adjust`
	`437`	`+ // the index to point to that note again.`
	`438`	`+ if self.index > index {`
	`439`	`+ self.index -= 1;`
	`440`	`+ }`
	`441`	`+ }`
`422`	`442`	`}`
`423`	`443`	`}`
`424`	`444`	`}`
`425`		`- fn reset(&mut self, shape: ArpShape) {`
	`445`	`+ fn reset(&mut self, shape: &ArpShape) {`
`426`	`446`	`self.index = 0;`
`427`	`447`	`use ArpShape::*;`
`428`	`448`	`match shape {`
`@@ -450,7 +470,7 @@ impl ArpState {`
`450`	`470`	`self.index -= 1;`
`451`	`471`	`self.store.entries[self.index].note`
`452`	`472`	`}`
`453`		`- fn tick(&mut self, shape: ArpShape) {`
	`473`	`+ fn tick(&mut self, shape: &ArpShape) {`
`454`	`474`	`self.current_note = if self.store.entries.is_empty() {`
`455`	`475`	`self.reset(shape);`
`456`	`476`	`None`
`@@ -649,35 +669,35 @@ where`
`649`	`669`	`let mut events = KeyEvents::empty();`
`650`	`670`	`for event in key_events {`
`651`	`671`	`if event.pressed {`
`652`		`- state.insert_note(event.note);`
	`672`	`+ state.insert_note(event.note, &shape);`
`653`	`673`	`for i in 0..extend_octaves_high {`
`654`	`674`	`if let Some(note) =`
`655`	`675`	`event.note.add_octaves_checked(i as i8 + 1)`
`656`	`676`	`{`
`657`		`- state.insert_note(note);`
	`677`	`+ state.insert_note(note, &shape);`
`658`	`678`	`}`
`659`	`679`	`}`
`660`	`680`	`for i in 0..extend_octaves_low {`
`661`	`681`	`if let Some(note) =`
`662`	`682`	`event.note.add_octaves_checked(-(i as i8 + 1))`
`663`	`683`	`{`
`664`		`- state.insert_note(note);`
	`684`	`+ state.insert_note(note, &shape);`
`665`	`685`	`}`
`666`	`686`	`}`
`667`	`687`	`} else {`
`668`		`- state.remove_note(event.note);`
	`688`	`+ state.remove_note(event.note, &shape);`
`669`	`689`	`for i in 0..extend_octaves_high {`
`670`	`690`	`if let Some(note) =`
`671`	`691`	`event.note.add_octaves_checked(i as i8 + 1)`
`672`	`692`	`{`
`673`		`- state.remove_note(note);`
	`693`	`+ state.remove_note(note, &shape);`
`674`	`694`	`}`
`675`	`695`	`}`
`676`	`696`	`for i in 0..extend_octaves_low {`
`677`	`697`	`if let Some(note) =`
`678`	`698`	`event.note.add_octaves_checked(-(i as i8 + 1))`
`679`	`699`	`{`
`680`		`- state.remove_note(note);`
	`700`	`+ state.remove_note(note, &shape);`
`681`	`701`	`}`
`682`	`702`	`}`
`683`	`703`	`}`
`@@ -690,7 +710,7 @@ where`
`690`	`710`	`velocity_01: 0.0,`
`691`	`711`	`});`
`692`	`712`	`}`
`693`		`- state.tick(shape);`
	`713`	`+ state.tick(&shape);`
`694`	`714`	`if let Some(note) = state.current_note {`
`695`	`715`	`events.push(KeyEvent {`
`696`	`716`	`note,`