Pass Hrp by reference

The `Hrp` type is a struct containing an 83 byte arary, as such it
should be passed by reference (borrowed) not copied.

Author: tcharding

src/lib.rs

@@ -37,7 +37,7 @@
 //!
 //! // Encode arbitrary data using "abc" as the human-readable part and append a bech32m checksum.
 //! let hrp = Hrp::parse("abc").expect("valid hrp");
-//! let address = bech32::encode::<Bech32m>(hrp, &DATA).expect("failed to encode address");
+//! let address = bech32::encode::<Bech32m>(&hrp, &DATA).expect("failed to encode address");
 //! assert_eq!(address, ADDR);
 //!
 //! // Encode arbitrary data as a Bitcoin taproot address.
@@ -46,7 +46,7 @@
 //!
 //! // No-alloc: Encode without allocating (ignoring that String::new() allocates :).
 //! let mut buf = String::new();
-//! bech32::encode_to_fmt::<Bech32m, String>(&mut buf, hrp, &DATA).expect("failed to encode to buffer");
+//! bech32::encode_to_fmt::<Bech32m, String>(&mut buf, &hrp, &DATA).expect("failed to encode to buffer");
 //! assert_eq!(buf, ADDR);
 //! # }
 //! ```
@@ -215,7 +215,7 @@ pub fn decode(s: &str) -> Result<(Hrp, Vec<u8>), DecodeError> {
 /// `Ck` algorithm (`NoChecksum` to exclude checksum all together).
 #[cfg(feature = "alloc")]
 #[inline]
-pub fn encode<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::Error> {
+pub fn encode<Ck: Checksum>(hrp: &Hrp, data: &[u8]) -> Result<String, fmt::Error> {
     encode_lower::<Ck>(hrp, data)
 }
 
@@ -225,7 +225,7 @@ pub fn encode<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::Error>
 /// `Ck` algorithm (`NoChecksum` to exclude checksum all together).
 #[cfg(feature = "alloc")]
 #[inline]
-pub fn encode_lower<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::Error> {
+pub fn encode_lower<Ck: Checksum>(hrp: &Hrp, data: &[u8]) -> Result<String, fmt::Error> {
     let mut buf = String::new();
     encode_lower_to_fmt::<Ck, String>(&mut buf, hrp, data)?;
     Ok(buf)
@@ -237,7 +237,7 @@ pub fn encode_lower<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::
 /// `Ck` algorithm (`NoChecksum` to exclude checksum all together).
 #[cfg(feature = "alloc")]
 #[inline]
-pub fn encode_upper<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::Error> {
+pub fn encode_upper<Ck: Checksum>(hrp: &Hrp, data: &[u8]) -> Result<String, fmt::Error> {
     let mut buf = String::new();
     encode_upper_to_fmt::<Ck, String>(&mut buf, hrp, data)?;
     Ok(buf)
@@ -250,7 +250,7 @@ pub fn encode_upper<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> Result<String, fmt::
 #[inline]
 pub fn encode_to_fmt<Ck: Checksum, W: fmt::Write>(
     fmt: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), fmt::Error> {
     encode_lower_to_fmt::<Ck, W>(fmt, hrp, data)
@@ -263,11 +263,11 @@ pub fn encode_to_fmt<Ck: Checksum, W: fmt::Write>(
 #[inline]
 pub fn encode_lower_to_fmt<Ck: Checksum, W: fmt::Write>(
     fmt: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), fmt::Error> {
     let iter = data.iter().copied().bytes_to_fes();
-    let chars = iter.with_checksum::<Ck>(&hrp).chars();
+    let chars = iter.with_checksum::<Ck>(hrp).chars();
     for c in chars {
         fmt.write_char(c)?;
     }
@@ -281,11 +281,11 @@ pub fn encode_lower_to_fmt<Ck: Checksum, W: fmt::Write>(
 #[inline]
 pub fn encode_upper_to_fmt<Ck: Checksum, W: fmt::Write>(
     fmt: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), fmt::Error> {
     let iter = data.iter().copied().bytes_to_fes();
-    let chars = iter.with_checksum::<Ck>(&hrp).chars();
+    let chars = iter.with_checksum::<Ck>(hrp).chars();
     for c in chars {
         fmt.write_char(c.to_ascii_uppercase())?;
     }
@@ -300,7 +300,7 @@ pub fn encode_upper_to_fmt<Ck: Checksum, W: fmt::Write>(
 #[inline]
 pub fn encode_to_writer<Ck: Checksum, W: std::io::Write>(
     w: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), std::io::Error> {
     encode_lower_to_writer::<Ck, W>(w, hrp, data)
@@ -314,11 +314,11 @@ pub fn encode_to_writer<Ck: Checksum, W: std::io::Write>(
 #[inline]
 pub fn encode_lower_to_writer<Ck: Checksum, W: std::io::Write>(
     w: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), std::io::Error> {
     let iter = data.iter().copied().bytes_to_fes();
-    let chars = iter.with_checksum::<Ck>(&hrp).chars();
+    let chars = iter.with_checksum::<Ck>(hrp).chars();
     for c in chars {
         w.write_all(&[c as u8])?;
     }
@@ -333,11 +333,11 @@ pub fn encode_lower_to_writer<Ck: Checksum, W: std::io::Write>(
 #[inline]
 pub fn encode_upper_to_writer<Ck: Checksum, W: std::io::Write>(
     w: &mut W,
-    hrp: Hrp,
+    hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), std::io::Error> {
     let iter = data.iter().copied().bytes_to_fes();
-    let chars = iter.with_checksum::<Ck>(&hrp).chars();
+    let chars = iter.with_checksum::<Ck>(hrp).chars();
     for c in chars {
         w.write_all(&[c.to_ascii_uppercase() as u8])?;
     }
@@ -403,15 +403,15 @@ mod tests {
     #[test]
     fn encode_bech32m() {
         let hrp = Hrp::parse_unchecked("test");
-        let got = encode::<Bech32m>(hrp, &DATA).expect("failed to encode");
+        let got = encode::<Bech32m>(&hrp, &DATA).expect("failed to encode");
         let want = "test1lu08d6qejxtdg4y5r3zarvary0c5xw7kmz4lky";
         assert_eq!(got, want);
     }
 
     #[test]
     fn encode_bech32_lower() {
         let hrp = Hrp::parse_unchecked("test");
-        let got = encode_lower::<Bech32>(hrp, &DATA).expect("failed to encode");
+        let got = encode_lower::<Bech32>(&hrp, &DATA).expect("failed to encode");
         let want = "test1lu08d6qejxtdg4y5r3zarvary0c5xw7kw79nnx";
         assert_eq!(got, want);
     }
@@ -421,7 +421,7 @@ mod tests {
     fn encode_bech32_lower_to_writer() {
         let hrp = Hrp::parse_unchecked("test");
         let mut buf = Vec::new();
-        encode_lower_to_writer::<Bech32, _>(&mut buf, hrp, &DATA).expect("failed to encode");
+        encode_lower_to_writer::<Bech32, _>(&mut buf, &hrp, &DATA).expect("failed to encode");
 
         let got = std::str::from_utf8(&buf).expect("ascii is valid utf8");
         let want = "test1lu08d6qejxtdg4y5r3zarvary0c5xw7kw79nnx";
@@ -431,7 +431,7 @@ mod tests {
     #[test]
     fn encode_bech32_upper() {
         let hrp = Hrp::parse_unchecked("test");
-        let got = encode_upper::<Bech32>(hrp, &DATA).expect("failed to encode");
+        let got = encode_upper::<Bech32>(&hrp, &DATA).expect("failed to encode");
         let want = "TEST1LU08D6QEJXTDG4Y5R3ZARVARY0C5XW7KW79NNX";
         assert_eq!(got, want);
     }
@@ -441,7 +441,7 @@ mod tests {
     fn encode_bech32_upper_to_writer() {
         let hrp = Hrp::parse_unchecked("test");
         let mut buf = Vec::new();
-        encode_upper_to_writer::<Bech32, _>(&mut buf, hrp, &DATA).expect("failed to encode");
+        encode_upper_to_writer::<Bech32, _>(&mut buf, &hrp, &DATA).expect("failed to encode");
 
         let got = std::str::from_utf8(&buf).expect("ascii is valid utf8");
         let want = "TEST1LU08D6QEJXTDG4Y5R3ZARVARY0C5XW7KW79NNX";

src/primitives/decode.rs

@@ -942,7 +942,7 @@ mod tests {
             "an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio";
 
         let hrp = Hrp::parse_unchecked(hrps);
-        let s = crate::encode::<Bech32>(hrp, &[]).expect("failed to encode empty buffer");
+        let s = crate::encode::<Bech32>(&hrp, &[]).expect("failed to encode empty buffer");
 
         let unchecked = UncheckedHrpstring::new(&s).expect("failed to parse address");
         assert_eq!(unchecked.hrp(), hrp);