#string

bin+lib fixedstr

strings of constant maximum size that can be copied and stack allocated using const generics

19 releases

new 0.3.3 May 28, 2023
0.2.12 Apr 30, 2023
0.2.9 Jan 14, 2023
0.2.8 Apr 2, 2022
0.1.1 Nov 21, 2021

#416 in Rust patterns

Download history 236/week @ 2023-02-05 256/week @ 2023-02-12 314/week @ 2023-02-19 379/week @ 2023-02-26 374/week @ 2023-03-05 322/week @ 2023-03-12 412/week @ 2023-03-19 602/week @ 2023-03-26 1259/week @ 2023-04-02 974/week @ 2023-04-09 1211/week @ 2023-04-16 1770/week @ 2023-04-23 1593/week @ 2023-04-30 2175/week @ 2023-05-07 1997/week @ 2023-05-14 2119/week @ 2023-05-21

7,990 downloads per month
Used in lambdascript

MIT license

390KB
1.5K SLoC

Library for strings of fixed maximum lengths that can be copied and stack-allocated using const generics. Certain provided types such as zstr<8> and str8 are smaller in size than a &str.

Examples

  let a:str8 = str8::from("abcdef"); //a str8 can hold up to 7 bytes
  let a2 = a;  // copied, not moved
  let ab = a.substr(1,5);  // copies substring to new string
  assert_eq!(ab, "bcde");  // can compare for equality with &str
  assert_eq!(ab.len(),4);
  println!("str8: {}", &a);   // impls Display
  assert_eq!(&a[..3], "abc"); // impls Index for Range types
  assert!(a<ab); // and Ord, Hash, Debug, Eq, other common traits
  let astr:&str = a.to_str(); // convert to &str (zero copy)
  let aowned:String = a.to_string(); // convert to owned string
  let afstr:fstr<8> = fstr::from(a); // fstr is another fixedstr crate type
  let azstr:zstr<16> = zstr::from(a); // so is zstr
  let a32:str32 = a.resize(); // same kind of string but with 31-byte capacity  
  let mut u = str8::from("aλb"); //unicode support
  assert_eq!(u.nth(1), Some('λ'));  // get nth character
  assert_eq!(u.nth_ascii(3), 'b');  // get nth byte as ascii character
  assert!(u.set(1,'μ'));  // changes a character of the same character class
  assert!(!u.set(1,'c')); // .set returns false on failure
  assert!(u.set(2,'c'));
  assert_eq!(u, "aμc");
  assert_eq!(u.len(),4);  // length in bytes
  assert_eq!(u.charlen(),3);  // length in chars
  let mut ac:str16 = a.reallocate().unwrap(); //copies to larger capacity type
  let remainder = ac.push("ghijklmnopq"); //append up to capacity, returns remainder
  assert_eq!(ac.len(),15);
  assert_eq!(remainder, "pq");
  ac.truncate(9);  // keep first 9 chars
  assert_eq!(&ac,"abcdefghi");
  let (upper,lower) = (str8::make("ABC"), str8::make("abc"));
  assert_eq!(upper, lower.to_ascii_upper()); // no owned String needed

  let c1 = str8::from("abcd"); // string concatenation with + for strN types  
  let c2 = str8::from("xyz");
  let c3 = c1 + c2;           
  assert_eq!(c3,"abcdxyz");
  assert_eq!(c3.capacity(),15);  // type of c3 is str16

  let c4 = str_format!(str16,"abc {}{}{}",1,2,3); // impls std::fmt::Write
  assert_eq!(c4,"abc 123");  //str_format! truncates if capacity exceeded
  let c5 = try_format!(str8,"abcdef{}","ghijklmn");
  assert!(c5.is_none());  // try_format! returns None if capacity exceeded

  let mut s = <zstr<8>>::from("abcd");
  s[0] = b'A';   // impls IndexMut for zstr (not for fstr nor strN types)
  assert_eq!('A', ac.nth_ascii(0));

Consult the documentation for details.


Recent Addition: module flexible_string

Dependencies