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
/// Alphabet type of text
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Alphabet {
Kana(Kana),
Kanji,
Symbol,
Romaji,
Other,
}
impl Alphabet {
/// Returns `true` if the alphabet is Hiragana.
#[inline]
pub fn is_hiragana(&self) -> bool {
match self {
Alphabet::Kana(k) => k.is_hiragana(),
_ => false,
}
}
/// Returns `true` if the alphabet is Katakana.
#[inline]
pub fn is_katakana(&self) -> bool {
match self {
Alphabet::Kana(k) => k.is_katakana(),
_ => false,
}
}
/// Returns `true` if the alphabet is kana
pub fn is_kana(&self) -> bool {
self.is_hiragana() || self.is_katakana()
}
/// Returns `true` if the alphabet is [`Kanji`].
///
/// [`Kanji`]: Alphabet::Kanji
#[inline]
pub fn is_kanji(&self) -> bool {
matches!(self, Self::Kanji)
}
/// Returns `true` if the alphabet is japanese
pub fn is_japanese(&self) -> bool {
self.is_kana() || self.is_kanji()
}
/// Returns `true` if the alphabet is [`Symbol`].
///
/// [`Symbol`]: Alphabet::Symbol
#[inline]
pub fn is_symbol(&self) -> bool {
matches!(self, Self::Symbol)
}
/// Returns `true` if the alphabet is [`Romaji`].
///
/// [`Romaji`]: Alphabet::Romaji
#[inline]
pub fn is_romaji(&self) -> bool {
matches!(self, Self::Romaji)
}
/// Returns `true` if the alphabet is [`Other`].
///
/// [`Other`]: Alphabet::Other
#[inline]
pub fn is_other(&self) -> bool {
matches!(self, Self::Other)
}
/// Returns alphabet of type hiragana
#[inline]
pub fn hiragana() -> Self {
Self::Kana(Kana::Hiragana)
}
/// Returns alphabet of type katakana
#[inline]
pub fn katakana() -> Self {
Self::Kana(Kana::Katakana)
}
/// Returns alphabet of type kana (both hiragana and katakana)
#[inline]
pub fn kana() -> Self {
Self::Kana(Kana::Both)
}
#[inline]
pub fn eq_both_kana(&self, other: &Self) -> bool {
match self {
Alphabet::Kana(_) => other.is_kana(),
_ => self == other,
}
}
}
/// Type of Kana
#[derive(Clone, Copy, Debug, Eq)]
pub enum Kana {
Hiragana,
Katakana,
Both,
}
impl PartialEq for Kana {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.is_both()
|| other.is_both()
|| core::mem::discriminant(self) == core::mem::discriminant(other)
}
}
impl Kana {
/// Returns `true` if the kana is [`Hiragana`].
///
/// [`Hiragana`]: Kana::Hiragana
#[must_use]
pub fn is_hiragana(&self) -> bool {
matches!(self, Self::Hiragana)
}
/// Returns `true` if the kana is [`Katakana`].
///
/// [`Katakana`]: Kana::Katakana
#[must_use]
pub fn is_katakana(&self) -> bool {
matches!(self, Self::Katakana)
}
/// Returns `true` if the kana is [`Both`].
///
/// [`Both`]: Kana::Both
#[must_use]
pub fn is_both(&self) -> bool {
matches!(self, Self::Both)
}
}