lint: fix clippy::used_underscore_binding

magistau · magistau · commit fe8e7e7bff7a · 2025-08-05T22:07:53.000+03:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,8 +18,7 @@ print_stderr = "allow"
 dbg_macro = "warn"
 pedantic = {level = "warn", priority = -1}
 inline_always = "allow"  # TODO: benchmark inlines
-missing_panics_doc = "allow"  # 37
-used_underscore_binding = "allow"  # 39
+missing_panics_doc = "allow"  # TODO
 float_cmp = "allow"  # 40
 map_unwrap_or = "allow"  # 59
 return_self_not_must_use = "allow"  # 61
diff --git a/src/algorithm/encode.rs b/src/algorithm/encode.rs
@@ -71,7 +71,7 @@ impl Value {
         let json_value: serde_json::Value = json5::from_str(json).map_err(|e| env.error(e))?;
         Self::from_json_value(json_value, env)
     }
-    pub(crate) fn from_json_value(json_value: serde_json::Value, _env: &Uiua) -> UiuaResult<Self> {
+    pub(crate) fn from_json_value(json_value: serde_json::Value, env: &Uiua) -> UiuaResult<Self> {
         Ok(match json_value {
             serde_json::Value::Null => f64::NAN.into(),
             serde_json::Value::Bool(b) => b.into(),
@@ -90,7 +90,7 @@ impl Value {
             serde_json::Value::Array(arr) => {
                 let mut rows = Vec::with_capacity(arr.len());
                 for value in arr {
-                    let mut value = Value::from_json_value(value, _env)?;
+                    let mut value = Value::from_json_value(value, env)?;
                     if value.meta.map_keys.is_some() {
                         value = Boxed(value).into();
                     }
@@ -112,7 +112,7 @@ impl Value {
                 let mut values = Vec::with_capacity(map.len());
                 for (k, v) in map {
                     keys.push(Boxed(k.into()));
-                    let mut value = Value::from_json_value(v, _env)?;
+                    let mut value = Value::from_json_value(v, env)?;
                     if value.meta.map_keys.is_some() {
                         value = Boxed(value).into();
                     }
@@ -125,7 +125,7 @@ impl Value {
                 } else {
                     Array::from(values.into_iter().map(Boxed).collect::<EcoVec<_>>()).into()
                 };
-                values.map(keys.into(), _env)?;
+                values.map(keys.into(), env)?;
                 values
             }
         })
@@ -275,15 +275,15 @@ impl Value {
             })
         }
     }
-    pub(crate) fn from_xlsx(_xlsx: &[u8], env: &mut Uiua) -> UiuaResult<Self> {
+    pub(crate) fn from_xlsx(xlsx: &[u8], env: &mut Uiua) -> UiuaResult<Self> {
         #[cfg(not(feature = "calamine"))]
         return Err(env.error("XLSX decoding is not enabled in this environment"));
         #[cfg(feature = "calamine")]
         {
             use calamine::*;
 
             let mut workbook: Xlsx<_> =
-                open_workbook_from_rs(std::io::Cursor::new(_xlsx)).map_err(|e| env.error(e))?;
+                open_workbook_from_rs(std::io::Cursor::new(xlsx)).map_err(|e| env.error(e))?;
             let sheet_names = workbook.sheet_names();
             let fill = env
                 .value_fill()
diff --git a/src/algorithm/reduce.rs b/src/algorithm/reduce.rs
@@ -60,7 +60,7 @@ pub(crate) fn reduce_impl(f: SigNode, depth: usize, env: &mut Uiua) -> UiuaResul
                 return generic_reduce(f, Value::Complex(nums), depth, env);
             }
         }
-        (Some((prim, _flipped)), Value::Byte(bytes)) => {
+        (Some((prim, flipped)), Value::Byte(bytes)) => {
             let fill = env.scalar_fill::<f64>().ok().map(|fv| fv.value);
             if fill.is_none() && env.value_fill().is_some() {
                 return generic_reduce(f, Value::Byte(bytes), depth, env);
@@ -71,7 +71,7 @@ pub(crate) fn reduce_impl(f: SigNode, depth: usize, env: &mut Uiua) -> UiuaResul
                         .into()
                 }
                 #[cfg(feature = "opt")]
-                Primitive::Sub if _flipped => fast_reduce_different(
+                Primitive::Sub if flipped => fast_reduce_different(
                     bytes,
                     0.0,
                     fill,
diff --git a/src/array.rs b/src/array.rs
@@ -401,17 +401,17 @@ where
 
 #[track_caller]
 #[inline(always)]
-pub(crate) fn validate_shape(_shape: &[usize], _len: usize) {
+pub(crate) fn validate_shape(shape: &[usize], len: usize) {
     #[cfg(debug_assertions)]
     {
-        let elems = if _shape.contains(&0) {
+        let elems = if shape.contains(&0) {
             0
         } else {
-            _shape.iter().product()
+            shape.iter().product()
         };
         assert_eq!(
-            elems, _len,
-            "shape {_shape:?} does not match data length {_len}"
+            elems, len,
+            "shape {shape:?} does not match data length {len}"
         )
     }
 }
diff --git a/src/run.rs b/src/run.rs
@@ -1500,7 +1500,7 @@ impl Uiua {
         }
     }
     /// Spawn a thread
-    pub(crate) fn spawn(&mut self, _pool: bool, f: SigNode) -> UiuaResult {
+    pub(crate) fn spawn(&mut self, pool: bool, f: SigNode) -> UiuaResult {
         if !self.rt.backend.allow_thread_spawning() {
             return Err(self.error("Thread spawning is not allowed in this environment"));
         }
@@ -1555,7 +1555,7 @@ impl Uiua {
         #[cfg(not(target_arch = "wasm32"))]
         let recv = {
             let (send, recv) = crossbeam_channel::unbounded();
-            if _pool {
+            if pool {
                 let max_threads = std::thread::available_parallelism()
                     .map(|p| p.get())
                     .unwrap_or(1);
diff --git a/src/sys/mod.rs b/src/sys/mod.rs
@@ -1233,11 +1233,11 @@ pub(crate) fn run_sys_op(op: SysOp, env: &mut Uiua) -> UiuaResult {
         }
         SysOp::WebcamCapture => {
             let index = env.pop(1)?.as_nat(env, "Webcam index must be an integer")?;
-            let _image = (env.rt.backend)
+            let image = (env.rt.backend)
                 .webcam_capture(index)
                 .map_err(|e| env.error(e))?;
             #[cfg(feature = "image")]
-            env.push(crate::media::rgb_image_to_array(_image));
+            env.push(crate::media::rgb_image_to_array(image));
             #[cfg(not(feature = "image"))]
             return Err(env.error("Webcam capture is not supported in this environment"));
         }
diff --git a/src/sys/native.rs b/src/sys/native.rs
@@ -158,15 +158,15 @@ enum TslConnection {
 }
 
 impl Read for &TlsSocket {
-    fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         #[cfg(feature = "tls")]
         {
             match &mut *self.conn.lock() {
                 TslConnection::Client(conn) => {
-                    rustls::Stream::new(conn, &mut &self.stream).read(_buf)
+                    rustls::Stream::new(conn, &mut &self.stream).read(buf)
                 }
                 TslConnection::Server(conn) => {
-                    rustls::Stream::new(conn, &mut &self.stream).read(_buf)
+                    rustls::Stream::new(conn, &mut &self.stream).read(buf)
                 }
             }
         }
@@ -176,15 +176,15 @@ impl Read for &TlsSocket {
 }
 
 impl Write for &TlsSocket {
-    fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         #[cfg(feature = "tls")]
         {
             match &mut *self.conn.lock() {
                 TslConnection::Client(conn) => {
-                    rustls::Stream::new(conn, &mut &self.stream).write(_buf)
+                    rustls::Stream::new(conn, &mut &self.stream).write(buf)
                 }
                 TslConnection::Server(conn) => {
-                    rustls::Stream::new(conn, &mut &self.stream).write(_buf)
+                    rustls::Stream::new(conn, &mut &self.stream).write(buf)
                 }
             }
         }
@@ -663,8 +663,8 @@ impl SysBackend for NativeSys {
     }
     #[allow(clippy::print_stdout)]
     #[cfg(all(feature = "terminal_image", feature = "image"))]
-    fn show_image(&self, image: image::DynamicImage, _label: Option<&str>) -> Result<(), String> {
-        let (_width, _height) = if let Some((w, h)) = terminal_size() {
+    fn show_image(&self, image: image::DynamicImage, label: Option<&str>) -> Result<(), String> {
+        let (width, height) = if let Some((w, h)) = terminal_size() {
             let (tw, th) = (w as u32, h.saturating_sub(1) as u32);
             let (iw, ih) = (image.width(), (image.height() / 2).max(1));
             let scaled_to_height = (iw * th / ih.max(1), th);
@@ -701,15 +701,15 @@ impl SysBackend for NativeSys {
                 return crate::window::Request::Show(crate::media::SmartOutput::Png(
                     crate::media::image_to_bytes(&image, image::ImageFormat::Png)
                         .map_err(|e| e.to_string())?,
-                    _label.map(Into::into),
+                    label.map(Into::into),
                 ))
                 .send();
             }
             viuer::print(
                 &image,
                 &viuer::Config {
-                    width: _width,
-                    height: _height,
+                    width,
+                    height,
                     absolute_offset: false,
                     transparent: true,
                     ..Default::default()
@@ -720,12 +720,12 @@ impl SysBackend for NativeSys {
         }
     }
     #[cfg(all(feature = "gif", feature = "invoke"))]
-    fn show_gif(&self, gif_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {
+    fn show_gif(&self, gif_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {
         #[cfg(feature = "window")]
         if crate::window::use_window() {
             return crate::window::Request::Show(crate::media::SmartOutput::Gif(
                 gif_bytes,
-                _label.map(Into::into),
+                label.map(Into::into),
             ))
             .send();
         }
@@ -774,13 +774,13 @@ impl SysBackend for NativeSys {
         .map_err(|e| e.to_string())
     }
     #[cfg(feature = "audio")]
-    fn play_audio(&self, wav_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {
+    fn play_audio(&self, wav_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {
         use hodaun::*;
         #[cfg(feature = "window")]
         if crate::window::use_window() {
             return crate::window::Request::Show(crate::media::SmartOutput::Wav(
                 wav_bytes,
-                _label.map(Into::into),
+                label.map(Into::into),
             ))
             .send();
         }
diff --git a/src/value.rs b/src/value.rs
@@ -451,99 +451,99 @@ impl Value {
     pub(crate) fn generic_bin_into<T, E>(
         self,
         other: Self,
-        n: impl FnOnce(Array<f64>, Array<f64>) -> Result<T, E>,
-        _b: impl FnOnce(Array<u8>, Array<u8>) -> Result<T, E>,
-        _co: impl FnOnce(Array<Complex>, Array<Complex>) -> Result<T, E>,
-        ch: impl FnOnce(Array<char>, Array<char>) -> Result<T, E>,
-        f: impl FnOnce(Array<Boxed>, Array<Boxed>) -> Result<T, E>,
+        num: impl FnOnce(Array<f64>, Array<f64>) -> Result<T, E>,
+        byte: impl FnOnce(Array<u8>, Array<u8>) -> Result<T, E>,
+        comp: impl FnOnce(Array<Complex>, Array<Complex>) -> Result<T, E>,
+        char: impl FnOnce(Array<char>, Array<char>) -> Result<T, E>,
+        bx: impl FnOnce(Array<Boxed>, Array<Boxed>) -> Result<T, E>,
         err: impl FnOnce(Self, Self) -> E,
     ) -> Result<T, E> {
         match (self, other) {
-            (Self::Num(a), Self::Num(b)) => n(a, b),
-            (Self::Byte(a), Self::Byte(b)) => _b(a, b),
-            (Self::Byte(a), Self::Num(b)) => n(a.convert(), b),
-            (Self::Num(a), Self::Byte(b)) => n(a, b.convert()),
-            (Self::Complex(a), Self::Complex(b)) => _co(a, b),
-            (Self::Complex(a), Self::Num(b)) => _co(a, b.convert()),
-            (Self::Num(a), Self::Complex(b)) => _co(a.convert(), b),
-            (Self::Complex(a), Self::Byte(b)) => _co(a, b.convert()),
-            (Self::Byte(a), Self::Complex(b)) => _co(a.convert(), b),
-            (Self::Char(a), Self::Char(b)) => ch(a, b),
-            (Self::Box(a), Self::Box(b)) => f(a, b),
-            (Self::Box(a), b) => f(a, b.coerce_to_boxes()),
-            (a, Self::Box(b)) => f(a.coerce_to_boxes(), b),
+            (Self::Num(a), Self::Num(b)) => num(a, b),
+            (Self::Byte(a), Self::Byte(b)) => byte(a, b),
+            (Self::Byte(a), Self::Num(b)) => num(a.convert(), b),
+            (Self::Num(a), Self::Byte(b)) => num(a, b.convert()),
+            (Self::Complex(a), Self::Complex(b)) => comp(a, b),
+            (Self::Complex(a), Self::Num(b)) => comp(a, b.convert()),
+            (Self::Num(a), Self::Complex(b)) => comp(a.convert(), b),
+            (Self::Complex(a), Self::Byte(b)) => comp(a, b.convert()),
+            (Self::Byte(a), Self::Complex(b)) => comp(a.convert(), b),
+            (Self::Char(a), Self::Char(b)) => char(a, b),
+            (Self::Box(a), Self::Box(b)) => bx(a, b),
+            (Self::Box(a), b) => bx(a, b.coerce_to_boxes()),
+            (a, Self::Box(b)) => bx(a.coerce_to_boxes(), b),
             (a, b) => Err(err(a, b)),
         }
     }
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn generic_bin_ref<T, E>(
         &self,
         other: &Self,
-        n: impl FnOnce(&Array<f64>, &Array<f64>) -> Result<T, E>,
-        _b: impl FnOnce(&Array<u8>, &Array<u8>) -> Result<T, E>,
-        _co: impl FnOnce(&Array<Complex>, &Array<Complex>) -> Result<T, E>,
-        ch: impl FnOnce(&Array<char>, &Array<char>) -> Result<T, E>,
-        f: impl FnOnce(&Array<Boxed>, &Array<Boxed>) -> Result<T, E>,
+        num: impl FnOnce(&Array<f64>, &Array<f64>) -> Result<T, E>,
+        byte: impl FnOnce(&Array<u8>, &Array<u8>) -> Result<T, E>,
+        comp: impl FnOnce(&Array<Complex>, &Array<Complex>) -> Result<T, E>,
+        char: impl FnOnce(&Array<char>, &Array<char>) -> Result<T, E>,
+        bx: impl FnOnce(&Array<Boxed>, &Array<Boxed>) -> Result<T, E>,
         err: impl FnOnce(&Self, &Self) -> E,
     ) -> Result<T, E> {
         match (self, other) {
-            (Self::Num(a), Self::Num(b)) => n(a, b),
-            (Self::Byte(a), Self::Byte(b)) => _b(a, b),
-            (Self::Byte(a), Self::Num(b)) => n(&a.convert_ref(), b),
-            (Self::Num(a), Self::Byte(b)) => n(a, &b.convert_ref()),
-            (Self::Complex(a), Self::Complex(b)) => _co(a, b),
-            (Self::Complex(a), Self::Num(b)) => _co(a, &b.convert_ref()),
-            (Self::Num(a), Self::Complex(b)) => _co(&a.convert_ref(), b),
-            (Self::Complex(a), Self::Byte(b)) => _co(a, &b.convert_ref()),
-            (Self::Byte(a), Self::Complex(b)) => _co(&a.convert_ref(), b),
-            (Self::Char(a), Self::Char(b)) => ch(a, b),
-            (Self::Box(a), Self::Box(b)) => f(a, b),
-            (Self::Box(a), b) => f(a, &b.coerce_as_boxes()),
-            (a, Self::Box(b)) => f(&a.coerce_as_boxes(), b),
+            (Self::Num(a), Self::Num(b)) => num(a, b),
+            (Self::Byte(a), Self::Byte(b)) => byte(a, b),
+            (Self::Byte(a), Self::Num(b)) => num(&a.convert_ref(), b),
+            (Self::Num(a), Self::Byte(b)) => num(a, &b.convert_ref()),
+            (Self::Complex(a), Self::Complex(b)) => comp(a, b),
+            (Self::Complex(a), Self::Num(b)) => comp(a, &b.convert_ref()),
+            (Self::Num(a), Self::Complex(b)) => comp(&a.convert_ref(), b),
+            (Self::Complex(a), Self::Byte(b)) => comp(a, &b.convert_ref()),
+            (Self::Byte(a), Self::Complex(b)) => comp(&a.convert_ref(), b),
+            (Self::Char(a), Self::Char(b)) => char(a, b),
+            (Self::Box(a), Self::Box(b)) => bx(a, b),
+            (Self::Box(a), b) => bx(a, &b.coerce_as_boxes()),
+            (a, Self::Box(b)) => bx(&a.coerce_as_boxes(), b),
             (a, b) => Err(err(a, b)),
         }
     }
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn generic_bin_mut<T, E>(
         &mut self,
         other: Self,
-        n: impl FnOnce(&mut Array<f64>, Array<f64>) -> Result<T, E>,
-        _b: impl FnOnce(&mut Array<u8>, Array<u8>) -> Result<T, E>,
-        _co: impl FnOnce(&mut Array<Complex>, Array<Complex>) -> Result<T, E>,
-        ch: impl FnOnce(&mut Array<char>, Array<char>) -> Result<T, E>,
-        f: impl FnOnce(&mut Array<Boxed>, Array<Boxed>) -> Result<T, E>,
+        num: impl FnOnce(&mut Array<f64>, Array<f64>) -> Result<T, E>,
+        byte: impl FnOnce(&mut Array<u8>, Array<u8>) -> Result<T, E>,
+        comp: impl FnOnce(&mut Array<Complex>, Array<Complex>) -> Result<T, E>,
+        char: impl FnOnce(&mut Array<char>, Array<char>) -> Result<T, E>,
+        bx: impl FnOnce(&mut Array<Boxed>, Array<Boxed>) -> Result<T, E>,
         err: impl FnOnce(&Self, &Self) -> E,
     ) -> Result<T, E> {
         match (&mut *self, other) {
-            (Self::Num(a), Self::Num(b)) => n(a, b),
-            (Self::Byte(a), Self::Byte(b)) => _b(a, b),
+            (Self::Num(a), Self::Num(b)) => num(a, b),
+            (Self::Byte(a), Self::Byte(b)) => byte(a, b),
             (Self::Byte(a), Self::Num(b)) => {
                 let mut a_num = a.convert_ref();
-                let res = n(&mut a_num, b);
+                let res = num(&mut a_num, b);
                 *self = a_num.into();
                 res
             }
-            (Self::Num(a), Self::Byte(b)) => n(a, b.convert_ref()),
-            (Self::Complex(a), Self::Complex(b)) => _co(a, b),
-            (Self::Complex(a), Self::Num(b)) => _co(a, b.convert_ref()),
+            (Self::Num(a), Self::Byte(b)) => num(a, b.convert_ref()),
+            (Self::Complex(a), Self::Complex(b)) => comp(a, b),
+            (Self::Complex(a), Self::Num(b)) => comp(a, b.convert_ref()),
             (Self::Num(a), Self::Complex(b)) => {
                 let mut a_comp = a.convert_ref();
-                let res = _co(&mut a_comp, b);
+                let res = comp(&mut a_comp, b);
                 *self = a_comp.into();
                 res
             }
-            (Self::Complex(a), Self::Byte(b)) => _co(a, b.convert_ref()),
+            (Self::Complex(a), Self::Byte(b)) => comp(a, b.convert_ref()),
             (Self::Byte(a), Self::Complex(b)) => {
                 let mut a_comp = a.convert_ref();
-                let res = _co(&mut a_comp, b);
+                let res = comp(&mut a_comp, b);
                 *self = a_comp.into();
                 res
             }
-            (Self::Char(a), Self::Char(b)) => ch(a, b),
-            (Self::Box(a), b) => f(a, b.coerce_to_boxes()),
+            (Self::Char(a), Self::Char(b)) => char(a, b),
+            (Self::Box(a), b) => bx(a, b.coerce_to_boxes()),
             (a, Self::Box(b)) => {
                 let mut a_box = take(a).coerce_to_boxes();
-                let res = f(&mut a_box, b);
+                let res = bx(&mut a_box, b);
                 *self = a_box.into();
                 res
             }

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ pub(crate) fn reduce_impl(f: SigNode, depth: usize, env: &mut Uiua) -> UiuaResul`
`60`	`60`	`return generic_reduce(f, Value::Complex(nums), depth, env);`
`61`	`61`	`}`
`62`	`62`	`}`
`63`		`- (Some((prim, _flipped)), Value::Byte(bytes)) => {`
	`63`	`+ (Some((prim, flipped)), Value::Byte(bytes)) => {`
`64`	`64`	`let fill = env.scalar_fill::<f64>().ok().map(\|fv\| fv.value);`
`65`	`65`	`if fill.is_none() && env.value_fill().is_some() {`
`66`	`66`	`return generic_reduce(f, Value::Byte(bytes), depth, env);`
`@@ -71,7 +71,7 @@ pub(crate) fn reduce_impl(f: SigNode, depth: usize, env: &mut Uiua) -> UiuaResul`
`71`	`71`	`.into()`
`72`	`72`	`}`
`73`	`73`	`#[cfg(feature = "opt")]`
`74`		`- Primitive::Sub if _flipped => fast_reduce_different(`
	`74`	`+ Primitive::Sub if flipped => fast_reduce_different(`
`75`	`75`	`bytes,`
`76`	`76`	`0.0,`
`77`	`77`	`fill,`
Original file line number	Diff line number	Diff line change
`@@ -401,17 +401,17 @@ where`
`401`	`401`
`402`	`402`	`#[track_caller]`
`403`	`403`	`#[inline(always)]`
`404`		`-pub(crate) fn validate_shape(_shape: &[usize], _len: usize) {`
	`404`	`+pub(crate) fn validate_shape(shape: &[usize], len: usize) {`
`405`	`405`	`#[cfg(debug_assertions)]`
`406`	`406`	`{`
`407`		`- let elems = if _shape.contains(&0) {`
	`407`	`+ let elems = if shape.contains(&0) {`
`408`	`408`	`0`
`409`	`409`	`} else {`
`410`		`- _shape.iter().product()`
	`410`	`+ shape.iter().product()`
`411`	`411`	`};`
`412`	`412`	`assert_eq!(`
`413`		`- elems, _len,`
`414`		`- "shape {_shape:?} does not match data length {_len}"`
	`413`	`+ elems, len,`
	`414`	`+ "shape {shape:?} does not match data length {len}"`
`415`	`415`	`)`
`416`	`416`	`}`
`417`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1500,7 +1500,7 @@ impl Uiua {`
`1500`	`1500`	`}`
`1501`	`1501`	`}`
`1502`	`1502`	`/// Spawn a thread`
`1503`		`- pub(crate) fn spawn(&mut self, _pool: bool, f: SigNode) -> UiuaResult {`
	`1503`	`+ pub(crate) fn spawn(&mut self, pool: bool, f: SigNode) -> UiuaResult {`
`1504`	`1504`	`if !self.rt.backend.allow_thread_spawning() {`
`1505`	`1505`	`return Err(self.error("Thread spawning is not allowed in this environment"));`
`1506`	`1506`	`}`
`@@ -1555,7 +1555,7 @@ impl Uiua {`
`1555`	`1555`	`#[cfg(not(target_arch = "wasm32"))]`
`1556`	`1556`	`let recv = {`
`1557`	`1557`	`let (send, recv) = crossbeam_channel::unbounded();`
`1558`		`- if _pool {`
	`1558`	`+ if pool {`
`1559`	`1559`	`let max_threads = std::thread::available_parallelism()`
`1560`	`1560`	`.map(\|p\| p.get())`
`1561`	`1561`	`.unwrap_or(1);`
Original file line number	Diff line number	Diff line change
`@@ -1233,11 +1233,11 @@ pub(crate) fn run_sys_op(op: SysOp, env: &mut Uiua) -> UiuaResult {`
`1233`	`1233`	`}`
`1234`	`1234`	`SysOp::WebcamCapture => {`
`1235`	`1235`	`let index = env.pop(1)?.as_nat(env, "Webcam index must be an integer")?;`
`1236`		`- let _image = (env.rt.backend)`
	`1236`	`+ let image = (env.rt.backend)`
`1237`	`1237`	`.webcam_capture(index)`
`1238`	`1238`	`.map_err(\|e\| env.error(e))?;`
`1239`	`1239`	`#[cfg(feature = "image")]`
`1240`		`- env.push(crate::media::rgb_image_to_array(_image));`
	`1240`	`+ env.push(crate::media::rgb_image_to_array(image));`
`1241`	`1241`	`#[cfg(not(feature = "image"))]`
`1242`	`1242`	`return Err(env.error("Webcam capture is not supported in this environment"));`
`1243`	`1243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -158,15 +158,15 @@ enum TslConnection {`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`impl Read for &TlsSocket {`
`161`		`- fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {`
	`161`	`+ fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {`
`162`	`162`	`#[cfg(feature = "tls")]`
`163`	`163`	`{`
`164`	`164`	`match &mut *self.conn.lock() {`
`165`	`165`	`TslConnection::Client(conn) => {`
`166`		`- rustls::Stream::new(conn, &mut &self.stream).read(_buf)`
	`166`	`+ rustls::Stream::new(conn, &mut &self.stream).read(buf)`
`167`	`167`	`}`
`168`	`168`	`TslConnection::Server(conn) => {`
`169`		`- rustls::Stream::new(conn, &mut &self.stream).read(_buf)`
	`169`	`+ rustls::Stream::new(conn, &mut &self.stream).read(buf)`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`	`}`
`@@ -176,15 +176,15 @@ impl Read for &TlsSocket {`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`impl Write for &TlsSocket {`
`179`		`- fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {`
	`179`	`+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {`
`180`	`180`	`#[cfg(feature = "tls")]`
`181`	`181`	`{`
`182`	`182`	`match &mut *self.conn.lock() {`
`183`	`183`	`TslConnection::Client(conn) => {`
`184`		`- rustls::Stream::new(conn, &mut &self.stream).write(_buf)`
	`184`	`+ rustls::Stream::new(conn, &mut &self.stream).write(buf)`
`185`	`185`	`}`
`186`	`186`	`TslConnection::Server(conn) => {`
`187`		`- rustls::Stream::new(conn, &mut &self.stream).write(_buf)`
	`187`	`+ rustls::Stream::new(conn, &mut &self.stream).write(buf)`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`	`}`
`@@ -663,8 +663,8 @@ impl SysBackend for NativeSys {`
`663`	`663`	`}`
`664`	`664`	`#[allow(clippy::print_stdout)]`
`665`	`665`	`#[cfg(all(feature = "terminal_image", feature = "image"))]`
`666`		`- fn show_image(&self, image: image::DynamicImage, _label: Option<&str>) -> Result<(), String> {`
`667`		`- let (_width, _height) = if let Some((w, h)) = terminal_size() {`
	`666`	`+ fn show_image(&self, image: image::DynamicImage, label: Option<&str>) -> Result<(), String> {`
	`667`	`+ let (width, height) = if let Some((w, h)) = terminal_size() {`
`668`	`668`	`let (tw, th) = (w as u32, h.saturating_sub(1) as u32);`
`669`	`669`	`let (iw, ih) = (image.width(), (image.height() / 2).max(1));`
`670`	`670`	`let scaled_to_height = (iw * th / ih.max(1), th);`
`@@ -701,15 +701,15 @@ impl SysBackend for NativeSys {`
`701`	`701`	`return crate::window::Request::Show(crate::media::SmartOutput::Png(`
`702`	`702`	`crate::media::image_to_bytes(&image, image::ImageFormat::Png)`
`703`	`703`	`.map_err(\|e\| e.to_string())?,`
`704`		`- _label.map(Into::into),`
	`704`	`+ label.map(Into::into),`
`705`	`705`	`))`
`706`	`706`	`.send();`
`707`	`707`	`}`
`708`	`708`	`viuer::print(`
`709`	`709`	`&image,`
`710`	`710`	`&viuer::Config {`
`711`		`- width: _width,`
`712`		`- height: _height,`
	`711`	`+ width,`
	`712`	`+ height,`
`713`	`713`	`absolute_offset: false,`
`714`	`714`	`transparent: true,`
`715`	`715`	`..Default::default()`
`@@ -720,12 +720,12 @@ impl SysBackend for NativeSys {`
`720`	`720`	`}`
`721`	`721`	`}`
`722`	`722`	`#[cfg(all(feature = "gif", feature = "invoke"))]`
`723`		`- fn show_gif(&self, gif_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {`
	`723`	`+ fn show_gif(&self, gif_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {`
`724`	`724`	`#[cfg(feature = "window")]`
`725`	`725`	`if crate::window::use_window() {`
`726`	`726`	`return crate::window::Request::Show(crate::media::SmartOutput::Gif(`
`727`	`727`	`gif_bytes,`
`728`		`- _label.map(Into::into),`
	`728`	`+ label.map(Into::into),`
`729`	`729`	`))`
`730`	`730`	`.send();`
`731`	`731`	`}`
`@@ -774,13 +774,13 @@ impl SysBackend for NativeSys {`
`774`	`774`	`.map_err(\|e\| e.to_string())`
`775`	`775`	`}`
`776`	`776`	`#[cfg(feature = "audio")]`
`777`		`- fn play_audio(&self, wav_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {`
	`777`	`+ fn play_audio(&self, wav_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {`
`778`	`778`	`use hodaun::*;`
`779`	`779`	`#[cfg(feature = "window")]`
`780`	`780`	`if crate::window::use_window() {`
`781`	`781`	`return crate::window::Request::Show(crate::media::SmartOutput::Wav(`
`782`	`782`	`wav_bytes,`
`783`		`- _label.map(Into::into),`
	`783`	`+ label.map(Into::into),`
`784`	`784`	`))`
`785`	`785`	`.send();`
`786`	`786`	`}`