lint: fix clippy::used_underscore_binding

magistau · magistau · commit bc295af7f443 · 2025-07-23T01:52:56.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
@@ -1181,11 +1181,11 @@ pub(crate) fn run_sys_op(op: SysOp, env: &mut Uiua) -> UiuaResult {
         #[cfg_attr(not(feature = "image"), expect(clippy::let_unit_value))]
         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
@@ -152,15 +152,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)
                 }
             }
         }
@@ -170,15 +170,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)
                 }
             }
         }
@@ -643,8 +643,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);
@@ -681,15 +681,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()
@@ -700,12 +700,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();
         }
@@ -754,13 +754,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
@@ -473,99 +473,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
`@@ -152,15 +152,15 @@ enum TslConnection {`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`impl Read for &TlsSocket {`
`155`		`- fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {`
	`155`	`+ fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {`
`156`	`156`	`#[cfg(feature = "tls")]`
`157`	`157`	`{`
`158`	`158`	`match &mut *self.conn.lock() {`
`159`	`159`	`TslConnection::Client(conn) => {`
`160`		`- rustls::Stream::new(conn, &mut &self.stream).read(_buf)`
	`160`	`+ rustls::Stream::new(conn, &mut &self.stream).read(buf)`
`161`	`161`	`}`
`162`	`162`	`TslConnection::Server(conn) => {`
`163`		`- rustls::Stream::new(conn, &mut &self.stream).read(_buf)`
	`163`	`+ rustls::Stream::new(conn, &mut &self.stream).read(buf)`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`}`
`@@ -170,15 +170,15 @@ impl Read for &TlsSocket {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`impl Write for &TlsSocket {`
`173`		`- fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {`
	`173`	`+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {`
`174`	`174`	`#[cfg(feature = "tls")]`
`175`	`175`	`{`
`176`	`176`	`match &mut *self.conn.lock() {`
`177`	`177`	`TslConnection::Client(conn) => {`
`178`		`- rustls::Stream::new(conn, &mut &self.stream).write(_buf)`
	`178`	`+ rustls::Stream::new(conn, &mut &self.stream).write(buf)`
`179`	`179`	`}`
`180`	`180`	`TslConnection::Server(conn) => {`
`181`		`- rustls::Stream::new(conn, &mut &self.stream).write(_buf)`
	`181`	`+ rustls::Stream::new(conn, &mut &self.stream).write(buf)`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`	`}`
`@@ -643,8 +643,8 @@ impl SysBackend for NativeSys {`
`643`	`643`	`}`
`644`	`644`	`#[allow(clippy::print_stdout)]`
`645`	`645`	`#[cfg(all(feature = "terminal_image", feature = "image"))]`
`646`		`- fn show_image(&self, image: image::DynamicImage, _label: Option<&str>) -> Result<(), String> {`
`647`		`- let (_width, _height) = if let Some((w, h)) = terminal_size() {`
	`646`	`+ fn show_image(&self, image: image::DynamicImage, label: Option<&str>) -> Result<(), String> {`
	`647`	`+ let (width, height) = if let Some((w, h)) = terminal_size() {`
`648`	`648`	`let (tw, th) = (w as u32, h.saturating_sub(1) as u32);`
`649`	`649`	`let (iw, ih) = (image.width(), (image.height() / 2).max(1));`
`650`	`650`	`let scaled_to_height = (iw * th / ih.max(1), th);`
`@@ -681,15 +681,15 @@ impl SysBackend for NativeSys {`
`681`	`681`	`return crate::window::Request::Show(crate::media::SmartOutput::Png(`
`682`	`682`	`crate::media::image_to_bytes(&image, image::ImageFormat::Png)`
`683`	`683`	`.map_err(\|e\| e.to_string())?,`
`684`		`- _label.map(Into::into),`
	`684`	`+ label.map(Into::into),`
`685`	`685`	`))`
`686`	`686`	`.send();`
`687`	`687`	`}`
`688`	`688`	`viuer::print(`
`689`	`689`	`&image,`
`690`	`690`	`&viuer::Config {`
`691`		`- width: _width,`
`692`		`- height: _height,`
	`691`	`+ width,`
	`692`	`+ height,`
`693`	`693`	`absolute_offset: false,`
`694`	`694`	`transparent: true,`
`695`	`695`	`..Default::default()`
`@@ -700,12 +700,12 @@ impl SysBackend for NativeSys {`
`700`	`700`	`}`
`701`	`701`	`}`
`702`	`702`	`#[cfg(all(feature = "gif", feature = "invoke"))]`
`703`		`- fn show_gif(&self, gif_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {`
	`703`	`+ fn show_gif(&self, gif_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {`
`704`	`704`	`#[cfg(feature = "window")]`
`705`	`705`	`if crate::window::use_window() {`
`706`	`706`	`return crate::window::Request::Show(crate::media::SmartOutput::Gif(`
`707`	`707`	`gif_bytes,`
`708`		`- _label.map(Into::into),`
	`708`	`+ label.map(Into::into),`
`709`	`709`	`))`
`710`	`710`	`.send();`
`711`	`711`	`}`
`@@ -754,13 +754,13 @@ impl SysBackend for NativeSys {`
`754`	`754`	`.map_err(\|e\| e.to_string())`
`755`	`755`	`}`
`756`	`756`	`#[cfg(feature = "audio")]`
`757`		`- fn play_audio(&self, wav_bytes: Vec<u8>, _label: Option<&str>) -> Result<(), String> {`
	`757`	`+ fn play_audio(&self, wav_bytes: Vec<u8>, label: Option<&str>) -> Result<(), String> {`
`758`	`758`	`use hodaun::*;`
`759`	`759`	`#[cfg(feature = "window")]`
`760`	`760`	`if crate::window::use_window() {`
`761`	`761`	`return crate::window::Request::Show(crate::media::SmartOutput::Wav(`
`762`	`762`	`wav_bytes,`
`763`		`- _label.map(Into::into),`
	`763`	`+ label.map(Into::into),`
`764`	`764`	`))`
`765`	`765`	`.send();`
`766`	`766`	`}`