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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
#[doc = "Utilities for manipulating the char type"];
/*
Lu Uppercase_Letter an uppercase letter
Ll Lowercase_Letter a lowercase letter
Lt Titlecase_Letter a digraphic character, with first part uppercase
Lm Modifier_Letter a modifier letter
Lo Other_Letter other letters, including syllables and ideographs
Mn Nonspacing_Mark a nonspacing combining mark (zero advance width)
Mc Spacing_Mark a spacing combining mark (positive advance width)
Me Enclosing_Mark an enclosing combining mark
Nd Decimal_Number a decimal digit
Nl Letter_Number a letterlike numeric character
No Other_Number a numeric character of other type
Pc Connector_Punctuation a connecting punctuation mark, like a tie
Pd Dash_Punctuation a dash or hyphen punctuation mark
Ps Open_Punctuation an opening punctuation mark (of a pair)
Pe Close_Punctuation a closing punctuation mark (of a pair)
Pi Initial_Punctuation an initial quotation mark
Pf Final_Punctuation a final quotation mark
Po Other_Punctuation a punctuation mark of other type
Sm Math_Symbol a symbol of primarily mathematical use
Sc Currency_Symbol a currency sign
Sk Modifier_Symbol a non-letterlike modifier symbol
So Other_Symbol a symbol of other type
Zs Space_Separator a space character (of various non-zero widths)
Zl Line_Separator U+2028 LINE SEPARATOR only
Zp Paragraph_Separator U+2029 PARAGRAPH SEPARATOR only
Cc Control a C0 or C1 control code
Cf Format a format control character
Cs Surrogate a surrogate code point
Co Private_Use a private-use character
Cn Unassigned a reserved unassigned code point or a noncharacter
*/
export is_alphabetic,
is_XID_start, is_XID_continue,
is_lowercase, is_uppercase,
is_whitespace, is_alphanumeric,
to_digit, to_lower, to_upper, maybe_digit, cmp;
import is_alphabetic = unicode::derived_property::Alphabetic;
import is_XID_start = unicode::derived_property::XID_Start;
import is_XID_continue = unicode::derived_property::XID_Continue;
#[doc(
brief = "Indicates whether a character is in lower case, defined \
in terms of the Unicode General Category 'Ll'."
)]
pure fn is_lowercase(c: char) -> bool {
ret unicode::general_category::Ll(c);
}
#[doc(
brief = "Indicates whether a character is in upper case, defined \
in terms of the Unicode General Category 'Lu'."
)]
pure fn is_uppercase(c: char) -> bool {
ret unicode::general_category::Lu(c);
}
#[doc(
brief = "Indicates whether a character is whitespace, defined in \
terms of the Unicode General Categories 'Zs', 'Zl', 'Zp' \
additional 'Cc'-category control codes in the range [0x09, 0x0d]"
)]
pure fn is_whitespace(c: char) -> bool {
ret ('\x09' <= c && c <= '\x0d')
|| unicode::general_category::Zs(c)
|| unicode::general_category::Zl(c)
|| unicode::general_category::Zp(c);
}
#[doc(
brief = "Indicates whether a character is alphanumeric, defined \
in terms of the Unicode General Categories 'Nd', \
'Nl', 'No' and the Derived Core Property 'Alphabetic'."
)]
pure fn is_alphanumeric(c: char) -> bool {
ret unicode::derived_property::Alphabetic(c) ||
unicode::general_category::Nd(c) ||
unicode::general_category::Nl(c) ||
unicode::general_category::No(c);
}
#[doc(
brief = "Convert a char to the corresponding digit. \
Safety note: This function fails if `c` is not a valid char",
return = "If `c` is between '0' and '9', the corresponding value \
between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is \
'b' or 'B', 11, etc."
)]
pure fn to_digit(c: char) -> u8 unsafe {
alt maybe_digit(c) {
option::some(x) { x }
option::none { fail; }
}
}
#[doc(
brief = "Convert a char to the corresponding digit. Returns none when \
character is not a valid hexadecimal digit."
)]
pure fn maybe_digit(c: char) -> option::t<u8> {
alt c {
'0' to '9' { option::some(c as u8 - ('0' as u8)) }
'a' to 'z' { option::some(c as u8 + 10u8 - ('a' as u8)) }
'A' to 'Z' { option::some(c as u8 + 10u8 - ('A' as u8)) }
_ { option::none }
}
}
/*
FIXME: works only on ASCII
*/
#[doc(
brief = "Convert a char to the corresponding lower case."
)]
pure fn to_lower(c: char) -> char {
alt c {
'A' to 'Z' { ((c as u8) + 32u8) as char }
_ { c }
}
}
/*
FIXME: works only on ASCII
*/
#[doc(
brief = "Convert a char to the corresponding upper case."
)]
pure fn to_upper(c: char) -> char {
alt c {
'a' to 'z' { ((c as u8) - 32u8) as char }
_ { c }
}
}
#[doc(
brief = "Compare two chars.",
return = "-1 if a<b, 0 if a==b, +1 if a>b"
)]
pure fn cmp(a: char, b: char) -> int {
ret if b > a { -1 }
else if b < a { 1 }
else { 0 }
}
#[test]
fn test_is_lowercase() {
assert is_lowercase('a');
assert is_lowercase('ö');
assert is_lowercase('ß');
assert !is_lowercase('Ü');
assert !is_lowercase('P');
}
#[test]
fn test_is_uppercase() {
assert !is_uppercase('h');
assert !is_uppercase('ä');
assert !is_uppercase('ß');
assert is_uppercase('Ö');
assert is_uppercase('T');
}
#[test]
fn test_is_whitespace() {
assert is_whitespace(' ');
assert is_whitespace('\u2007');
assert is_whitespace('\t');
assert is_whitespace('\n');
assert !is_whitespace('a');
assert !is_whitespace('_');
assert !is_whitespace('\u0000');
}
#[test]
fn test_to_digit() {
assert (to_digit('0') == 0u8);
assert (to_digit('1') == 1u8);
assert (to_digit('2') == 2u8);
assert (to_digit('9') == 9u8);
assert (to_digit('a') == 10u8);
assert (to_digit('A') == 10u8);
assert (to_digit('b') == 11u8);
assert (to_digit('B') == 11u8);
assert (to_digit('z') == 35u8);
assert (to_digit('Z') == 35u8);
}
#[test]
#[should_fail]
#[ignore(cfg(target_os = "win32"))]
fn test_to_digit_fail_1() {
to_digit(' ');
}
#[test]
#[should_fail]
#[ignore(cfg(target_os = "win32"))]
fn test_to_digit_fail_2() {
to_digit('$');
}
#[test]
fn test_to_lower() {
assert (to_lower('H') == 'h');
assert (to_lower('e') == 'e');
//assert (to_lower('Ö') == 'ö');
assert (to_lower('ß') == 'ß');
}
#[test]
fn test_to_upper() {
assert (to_upper('l') == 'L');
assert (to_upper('Q') == 'Q');
//assert (to_upper('ü') == 'Ü');
assert (to_upper('ß') == 'ß');
}
|
