token-string 0.8.4

Short (up to 65,535 bytes) immutable strings to e.g. parse tokens, implemented in Rust. These are sometimes called 'German Strings', because Germans have written the paper mentioning them.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

// SPDX-FileCopyrightText: Copyright (C) 2024 Roland Csaszar
// SPDX-License-Identifier: EUPL-1.2
//
// Project:  token-string
// File:     main.rs
// Date:     16.Nov.2024
// =============================================================================
//! This is just an example on how to use [`token_string`].

#![expect(
	clippy::print_stdout,
	reason = "We are in a CLI program, we need to print something"
)]
#![expect(clippy::use_debug, reason = "We are trying to show debug printing")]

use token_string::{Builder, Collect as _, Concat as _, TokenString};

/// Main entry point of the program.
fn main() {
	let str = "HUGO HUGO HUGO HUGO".to_owned();
	let s1 = TokenString::try_from(str).unwrap();
	println!("S1: {s1}");
	println!("S1 debug: {s1:?}");

	let s1_str: &str = s1.as_str();
	let s1_bytes: &[u8] = s1.as_bytes();
	let s1_string = s1.as_string();
	let s1_chars: Vec<char> = s1.as_chars();

	assert!(&s1 == s1_str, "Should be the same!");
	assert!(&s1 == s1_bytes, "Should be the same!");
	assert!(s1 == s1_string, "Should be the same!");
	assert!(s1.as_chars() == s1_chars, "Should be the same!");

	println!("========================================");

	let s2 = TokenString::try_from("HUGO06").unwrap();
	for i in &s2 {
		println!("S2 iterator: {i}");
	}

	println!("========================================");

	let s3: TokenString = "HUGO HUGO HUGO".try_into().unwrap();
	let s4 = TokenString::default();
	println!("S3 debug: {s3:?}\nS4 debug: {s4:?}");
	println!("S3: '{s3}'\nS4: '{s4}'");
	println!("S2[2..=43]: {}", &s2[2 ..= 3]);

	println!("========================================");

	let s21 = TokenString::try_from("Hello, ").unwrap();
	let s22 = TokenString::try_from("world!").unwrap();

	let mut builder = Builder::<'_, 2>::new(&s21);

	// Create the new `TokenString`. An error may be returned.
	let s21_s22 = builder.concat(&s22).collect().unwrap();

	// Check, if the result is actually "Hello, world!".
	println!("S11 + S22:\n'{s21_s22}'\nshould be:\n'Hello, world!'");

	println!("========================================");
	let mut b = Builder::<'_, 64>::new(&s3);
	println!("Only S3: {b}");
	let c = b.concat(&s3).concat(&s3).unwrap();
	println!("3x S3: {c}");
	let s5 = c.collect_checked().unwrap();
	println!("S5: {s5:?}");

	println!("========================================");
	let s6 = TokenString::try_from("1").unwrap();
	let s7: TokenString = "2".try_into().unwrap();
	let mut d = Builder::<'_, 64>::new(&s2);
	println!("Only S2: {d}");
	let e = d.concat(&s6).concat(&s7).unwrap();
	println!("S2 + S6 + S7: {e}");
	let s8 = e.collect_checked().unwrap();
	println!("S8: {s8:?}");

	println!("========================================");
	let s9 = TokenString::try_from("3").unwrap();
	let s10: TokenString = "4".try_into().unwrap();
	let s11 = Builder::<'_, 64>::new(&s6)
		.concat(&s7)
		.concat(&s9)
		.concat(&s10)
		.collect()
		.unwrap();
	println!("S11: {s11:?}");

	println!("========================================");
	let s12 = token_string::concat!(
		&s6,
		&s7,
		&s9,
		&s10,
		&TokenString::try_from("asd").unwrap()
	)
	.unwrap();
	println!("S12: {s12:?}");
}