pub use to_kana_trait::ToKana;
pub use half_width::HalfWidth;
pub use small_kana::SmallKana;
mod to_kana_trait;
mod half_width;
mod small_kana;
pub type Error = String;
pub type Result = std::result::Result<String, Error>;
const KATAKANA_SOFTENED_DIACRITICS: [char;21] = [
'ガ', 'ギ', 'グ', 'ゲ', 'ゴ',
'ザ', 'ジ', 'ズ', 'ゼ', 'ゾ',
'ダ', 'ヂ', 'ヅ', 'デ', 'ド',
'バ', 'ビ', 'ブ', 'ベ', 'ボ',
'ヴ',
];
const KATAKANA_HARDENED_DIACRITICS: [char;5] = [
'パ', 'ピ', 'プ', 'ペ', 'ポ',
];
fn has_softened_diacritic(c: &char) -> bool {
KATAKANA_SOFTENED_DIACRITICS.contains(c)
}
fn has_hardened_diacritic(c: &char) -> bool {
KATAKANA_HARDENED_DIACRITICS.contains(c)
}
fn syllable_divider<'a>(s: &'a str) -> Vec<&'a str> {
const VOWELS: [&str;6] = [
"a",
"e",
"i",
"o",
"u",
"y",
];
let mut vec = Vec::new();
let mut start_index = 0;
for (end_index, c) in s.char_indices() {
match c {
'-' | 'a' | 'e' | 'i' | 'o' | 'u' | ',' | '.' | '!' | '?' => {
vec.push(&s[start_index..=end_index]);
start_index = end_index + 1;
},
'\'' => {
start_index = end_index + 1;
},
'n' => {
match s.get(end_index + 1..=end_index + 1) {
Some(v) if VOWELS.contains(&v) => {},
_ => {
vec.push("n");
start_index = end_index + 1;
},
}
}
_ => {},
}
}
vec
}
pub fn hira(s: &str) -> Result {
let mut hiragana = String::new();
for s in syllable_divider(s) {
let kana: &str = match s {
"," => "、",
"." => "。",
"!" => "!",
"?" => "?",
"-" => "ー",
"a" => "あ",
"i" => "い",
"u" => "う",
"e" => "え",
"o" => "お",
"ka" => "か",
"ki" => "き",
"ku" => "く",
"ke" => "け",
"ko" => "こ",
"kya" => "きゃ",
"kyu" => "きゅ",
"kyo" => "きょ",
"ga" => "が",
"gi" => "ぎ",
"gu" => "ぐ",
"ge" => "げ",
"go" => "ご",
"gya" => "ぎゃ",
"gyu" => "ぎゅ",
"gyo" => "ぎょ",
"sa" => "さ",
"si" | "shi" => "し",
"su" => "す",
"se" => "せ",
"so" => "そ",
"sha" => "しゃ",
"shu" => "しゅ",
"she" => "しぇ",
"sho" => "しょ",
"za" => "ざ",
"zi" | "ji" => "じ",
"zu" => "ず",
"ze" => "ぜ",
"zo" => "ぞ",
"ja" => "じゃ",
"ju" => "じゅ",
"je" => "じぇ",
"jo" => "じょ",
"ta" => "た",
"ti" | "chi" => "ち",
"tu" | "tsu" => "つ",
"te" => "て",
"to" => "と",
"cha" => "ちゃ",
"chu" => "ちゅ",
"che" => "ちぇ",
"cho" => "ちょ",
"thi" => "てぃ",
"thu" => "てゅ",
"da" => "だ",
"di" => "ぢ",
"du" => "づ",
"de" => "で",
"do" => "ど",
"dhi" => "でぃ",
"dhu" => "でゅ",
"na" => "な",
"ni" => "に",
"nu" => "ぬ",
"ne" => "ね",
"no" => "の",
"nya" => "にゃ",
"nyu" => "にゅ",
"nyo" => "にょ",
"ha" => "は",
"hi" => "ひ",
"hu" => "ふ",
"he" => "へ",
"ho" => "ほ",
"hya" => "ひゃ",
"hyu" => "ひゅ",
"hyo" => "ひょ",
"ba" => "ば",
"bi" => "び",
"bu" => "ぶ",
"be" => "べ",
"bo" => "ぼ",
"bya" => "びゃ",
"byu" => "びゅ",
"byo" => "びょ",
"pa" => "ぱ",
"pi" => "ぴ",
"pu" => "ぷ",
"pe" => "ぺ",
"po" => "ぽ",
"pya" => "ぴゃ",
"pyu" => "ぴゅ",
"pyo" => "ぴょ",
"fa" => "ふぁ",
"fi" => "ふぃ",
"fe" => "ふぇ",
"fo" => "ふぉ",
"va" => "ゔぁ",
"vi" => "ゔぃ",
"vu" => "ゔ",
"ve" => "ゔぇ",
"vo" => "ゔぉ",
"ma" => "ま",
"mi" => "み",
"mu" => "む",
"me" => "め",
"mo" => "も",
"mya" => "みゃ",
"myu" => "みゅ",
"myo" => "みょ",
"ya" => "や",
"yu" => "ゆ",
"yo" => "よ",
"ra" => "ら",
"ri" => "り",
"ru" => "る",
"re" => "れ",
"ro" => "ろ",
"rya" => "りゃ",
"ryu" => "りゅ",
"ryo" => "りょ",
"wa" => "わ",
"wo" => "を",
"n" => "ん",
s if s.starts_with('x') && s.len() > 1 => {
hiragana.push_str(&hira(&s[1..]).small()?);
continue;
},
s if s.len() > 2 => {
hiragana.push_str(&add_hira_little_tsu(s)?);
continue;
},
_ => return Err(format!("Pattern not recognized: {:?}", s)),
};
hiragana.push_str(kana);
}
Ok(hiragana)
}
fn add_hira_little_tsu(s: &str) -> Result {
let mut chars = s.chars();
let first_char = chars.next().unwrap();
let next_char = chars.next().unwrap();
if first_char == next_char {
let main_hira = match hira(&s[1..]) {
Ok(s) => s,
Err(e) => return Err(e),
};
let s = format!(
"{}{}",
"っ",
main_hira,
);
return Ok(s);
} else {
return Err(format!("3+ hiragana char pattern not recognized: {}", s));
}
}
pub fn kata(s: &str) -> Result {
let mut katakana = String::new();
for s in syllable_divider(s) {
let kana: &str = match s {
"," => "、",
"." => "。",
"!" => "!",
"?" => "?",
"-" => "ー",
"a" => "ア",
"i" => "イ",
"u" => "ウ",
"e" => "エ",
"o" => "オ",
"ka" => "カ",
"ki" => "キ",
"ku" => "ク",
"ke" => "ケ",
"ko" => "コ",
"kya" => "キャ",
"kyu" => "キュ",
"kyo" => "キョ",
"ga" => "ガ",
"gi" => "ギ",
"gu" => "グ",
"ge" => "ゲ",
"go" => "ゴ",
"gya" => "ギャ",
"gyu" => "ギュ",
"gyo" => "ギョ",
"sa" => "サ",
"si" | "shi" => "シ",
"su" => "ス",
"se" => "セ",
"so" => "ソ",
"sha" => "シャ",
"shu" => "シュ",
"she" => "シェ",
"sho" => "ショ",
"za" => "ザ",
"zi" | "ji" => "ジ",
"zu" => "ズ",
"ze" => "ゼ",
"zo" => "ゾ",
"ja" => "ジャ",
"ju" => "ジュ",
"je" => "ジェ",
"jo" => "ジョ",
"ta" => "タ",
"ti" | "chi" => "チ",
"tu" | "tsu" => "ツ",
"te" => "テ",
"to" => "ト",
"cha" => "チャ",
"chu" => "チュ",
"che" => "チェ",
"cho" => "チョ",
"thi" => "ティ",
"thu" => "テュ",
"da" => "ダ",
"di" => "ヂ",
"du" => "ヅ",
"de" => "デ",
"do" => "ド",
"dhi" => "ディ",
"dhu" => "デュ",
"na" => "ナ",
"ni" => "ニ",
"nu" => "ヌ",
"ne" => "ネ",
"no" => "ノ",
"nya" => "ニャ",
"nyu" => "ニュ",
"nyo" => "ニョ",
"ha" => "ハ",
"hi" => "ヒ",
"hu" | "fu" => "フ",
"he" => "ヘ",
"ho" => "ホ",
"hya" => "ヒャ",
"hyu" => "ヒュ",
"hyo" => "ヒョ",
"ba" => "バ",
"bi" => "ビ",
"bu" => "ブ",
"be" => "ベ",
"bo" => "ボ",
"bya" => "ビャ",
"byu" => "ビュ",
"byo" => "ビョ",
"pa" => "パ",
"pi" => "ピ",
"pu" => "プ",
"pe" => "ペ",
"po" => "ポ",
"pya" => "ピャ",
"pyu" => "ピュ",
"pyo" => "ピョ",
"fa" => "ファ",
"fi" => "フィ",
"fe" => "フェ",
"fo" => "フォ",
"va" => "ヴァ",
"vi" => "ヴィ",
"vu" => "ヴ",
"ve" => "ヴェ",
"vo" => "ヴォ",
"ma" => "マ",
"mi" => "ミ",
"mu" => "ム",
"me" => "メ",
"mo" => "モ",
"mya" => "ミャ",
"myu" => "ミュ",
"myo" => "ミョ",
"ya" => "ヤ",
"yu" => "ユ",
"yo" => "ヨ",
"ra" => "ラ",
"ri" => "リ",
"ru" => "ル",
"re" => "レ",
"ro" => "ロ",
"rya" => "リャ",
"ryu" => "リュ",
"ryo" => "リョ",
"wa" => "ワ",
"wo" => "ヲ",
"n" => "ン",
s if s.starts_with('x') && s.len() > 1 => {
katakana.push_str(&kata(&s[1..]).small()?);
continue;
},
s if s.len() > 2 => {
katakana.push_str(&add_kata_little_tsu(s)?);
continue;
},
_ => return Err(format!("Pattern not recognized: {:?}", s)),
};
katakana.push_str(&kana);
}
Ok(katakana)
}
fn add_kata_little_tsu(s: &str) -> Result {
let mut chars = s.chars();
let first_char = chars.next().unwrap();
let next_char = chars.next().unwrap();
if first_char == next_char {
let main_kata = match kata(&s[1..]) {
Ok(s) => s,
Err(e) => return Err(e),
};
let s = format!(
"{}{}",
"ッ",
main_kata,
);
return Ok(s);
} else {
return Err(format!("3+ katakana char pattern not recognized: {}", s));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn to_hiragana() {
assert_eq!(hira("a"), Ok(String::from("あ")));
assert_eq!(hira("i"), Ok(String::from("い")));
assert_eq!(hira("u"), Ok(String::from("う")));
assert_eq!(hira("e"), Ok(String::from("え")));
assert_eq!(hira("o"), Ok(String::from("お")));
assert_eq!(hira("xa"), Ok(String::from("ぁ")));
assert_eq!(hira("xi"), Ok(String::from("ぃ")));
assert_eq!(hira("xu"), Ok(String::from("ぅ")));
assert_eq!(hira("xe"), Ok(String::from("ぇ")));
assert_eq!(hira("xo"), Ok(String::from("ぉ")));
assert_eq!(hira("ka"), Ok(String::from("か")));
assert_eq!(hira("ki"), Ok(String::from("き")));
assert_eq!(hira("ku"), Ok(String::from("く")));
assert_eq!(hira("ke"), Ok(String::from("け")));
assert_eq!(hira("ko"), Ok(String::from("こ")));
assert_eq!(hira("kya"), Ok(String::from("きゃ")));
assert_eq!(hira("kyu"), Ok(String::from("きゅ")));
assert_eq!(hira("kyo"), Ok(String::from("きょ")));
assert_eq!(hira("ga"), Ok(String::from("が")));
assert_eq!(hira("gi"), Ok(String::from("ぎ")));
assert_eq!(hira("gu"), Ok(String::from("ぐ")));
assert_eq!(hira("ge"), Ok(String::from("げ")));
assert_eq!(hira("go"), Ok(String::from("ご")));
assert_eq!(hira("gya"), Ok(String::from("ぎゃ")));
assert_eq!(hira("gyu"), Ok(String::from("ぎゅ")));
assert_eq!(hira("gyo"), Ok(String::from("ぎょ")));
assert_eq!(hira("sa"), Ok(String::from("さ")));
assert_eq!(hira("si"), Ok(String::from("し")));
assert_eq!(hira("su"), Ok(String::from("す")));
assert_eq!(hira("se"), Ok(String::from("せ")));
assert_eq!(hira("so"), Ok(String::from("そ")));
assert_eq!(hira("sha"), Ok(String::from("しゃ")));
assert_eq!(hira("shu"), Ok(String::from("しゅ")));
assert_eq!(hira("she"), Ok(String::from("しぇ")));
assert_eq!(hira("sho"), Ok(String::from("しょ")));
assert_eq!(hira("za"), Ok(String::from("ざ")));
assert_eq!(hira("zi"), Ok(String::from("じ")));
assert_eq!(hira("zu"), Ok(String::from("ず")));
assert_eq!(hira("ze"), Ok(String::from("ぜ")));
assert_eq!(hira("zo"), Ok(String::from("ぞ")));
assert_eq!(hira("ja"), Ok(String::from("じゃ")));
assert_eq!(hira("ju"), Ok(String::from("じゅ")));
assert_eq!(hira("je"), Ok(String::from("じぇ")));
assert_eq!(hira("jo"), Ok(String::from("じょ")));
assert_eq!(hira("ta"), Ok(String::from("た")));
assert_eq!(hira("ti"), Ok(String::from("ち")));
assert_eq!(hira("tu"), Ok(String::from("つ")));
assert_eq!(hira("xtu"), Ok(String::from("っ")));
assert_eq!(hira("te"), Ok(String::from("て")));
assert_eq!(hira("to"), Ok(String::from("と")));
assert_eq!(hira("cha"), Ok(String::from("ちゃ")));
assert_eq!(hira("chu"), Ok(String::from("ちゅ")));
assert_eq!(hira("che"), Ok(String::from("ちぇ")));
assert_eq!(hira("cho"), Ok(String::from("ちょ")));
assert_eq!(hira("thi"), Ok(String::from("てぃ")));
assert_eq!(hira("thu"), Ok(String::from("てゅ")));
assert_eq!(hira("da"), Ok(String::from("だ")));
assert_eq!(hira("di"), Ok(String::from("ぢ")));
assert_eq!(hira("du"), Ok(String::from("づ")));
assert_eq!(hira("de"), Ok(String::from("で")));
assert_eq!(hira("do"), Ok(String::from("ど")));
assert_eq!(hira("dhi"), Ok(String::from("でぃ")));
assert_eq!(hira("dhu"), Ok(String::from("でゅ")));
assert_eq!(hira("na"), Ok(String::from("な")));
assert_eq!(hira("ni"), Ok(String::from("に")));
assert_eq!(hira("nu"), Ok(String::from("ぬ")));
assert_eq!(hira("ne"), Ok(String::from("ね")));
assert_eq!(hira("no"), Ok(String::from("の")));
assert_eq!(hira("nya"), Ok(String::from("にゃ")));
assert_eq!(hira("nyu"), Ok(String::from("にゅ")));
assert_eq!(hira("nyo"), Ok(String::from("にょ")));
assert_eq!(hira("ha"), Ok(String::from("は")));
assert_eq!(hira("hi"), Ok(String::from("ひ")));
assert_eq!(hira("hu"), Ok(String::from("ふ")));
assert_eq!(hira("he"), Ok(String::from("へ")));
assert_eq!(hira("ho"), Ok(String::from("ほ")));
assert_eq!(hira("hya"), Ok(String::from("ひゃ")));
assert_eq!(hira("hyu"), Ok(String::from("ひゅ")));
assert_eq!(hira("hyo"), Ok(String::from("ひょ")));
assert_eq!(hira("ba"), Ok(String::from("ば")));
assert_eq!(hira("bi"), Ok(String::from("び")));
assert_eq!(hira("bu"), Ok(String::from("ぶ")));
assert_eq!(hira("be"), Ok(String::from("べ")));
assert_eq!(hira("bo"), Ok(String::from("ぼ")));
assert_eq!(hira("bya"), Ok(String::from("びゃ")));
assert_eq!(hira("byu"), Ok(String::from("びゅ")));
assert_eq!(hira("byo"), Ok(String::from("びょ")));
assert_eq!(hira("pa"), Ok(String::from("ぱ")));
assert_eq!(hira("pi"), Ok(String::from("ぴ")));
assert_eq!(hira("pu"), Ok(String::from("ぷ")));
assert_eq!(hira("pe"), Ok(String::from("ぺ")));
assert_eq!(hira("po"), Ok(String::from("ぽ")));
assert_eq!(hira("pya"), Ok(String::from("ぴゃ")));
assert_eq!(hira("pyu"), Ok(String::from("ぴゅ")));
assert_eq!(hira("pyo"), Ok(String::from("ぴょ")));
assert_eq!(hira("fa"), Ok(String::from("ふぁ")));
assert_eq!(hira("fi"), Ok(String::from("ふぃ")));
assert_eq!(hira("fe"), Ok(String::from("ふぇ")));
assert_eq!(hira("fo"), Ok(String::from("ふぉ")));
assert_eq!(hira("va"), Ok(String::from("ゔぁ")));
assert_eq!(hira("vi"), Ok(String::from("ゔぃ")));
assert_eq!(hira("vu"), Ok(String::from("ゔ")));
assert_eq!(hira("ve"), Ok(String::from("ゔぇ")));
assert_eq!(hira("vo"), Ok(String::from("ゔぉ")));
assert_eq!(hira("ma"), Ok(String::from("ま")));
assert_eq!(hira("mi"), Ok(String::from("み")));
assert_eq!(hira("mu"), Ok(String::from("む")));
assert_eq!(hira("me"), Ok(String::from("め")));
assert_eq!(hira("mo"), Ok(String::from("も")));
assert_eq!(hira("mya"), Ok(String::from("みゃ")));
assert_eq!(hira("myu"), Ok(String::from("みゅ")));
assert_eq!(hira("myo"), Ok(String::from("みょ")));
assert_eq!(hira("ya"), Ok(String::from("や")));
assert_eq!(hira("yu"), Ok(String::from("ゆ")));
assert_eq!(hira("yo"), Ok(String::from("よ")));
assert_eq!(hira("xya"), Ok(String::from("ゃ")));
assert_eq!(hira("xyu"), Ok(String::from("ゅ")));
assert_eq!(hira("xyo"), Ok(String::from("ょ")));
assert_eq!(hira("ra"), Ok(String::from("ら")));
assert_eq!(hira("ri"), Ok(String::from("り")));
assert_eq!(hira("ru"), Ok(String::from("る")));
assert_eq!(hira("re"), Ok(String::from("れ")));
assert_eq!(hira("ro"), Ok(String::from("ろ")));
assert_eq!(hira("rya"), Ok(String::from("りゃ")));
assert_eq!(hira("ryu"), Ok(String::from("りゅ")));
assert_eq!(hira("ryo"), Ok(String::from("りょ")));
assert_eq!(hira("wa"), Ok(String::from("わ")));
assert_eq!(hira("wo"), Ok(String::from("を")));
assert_eq!(hira("n"), Ok(String::from("ん")));
}
#[test]
fn hiragana_little_tsu() {
assert_eq!(hira("tte"), Ok(String::from("って")));
assert_eq!(hira("sshi"), Ok(String::from("っし")));
}
#[test]
fn to_katakana() {
assert_eq!(kata("a"), Ok(String::from("ア")));
assert_eq!(kata("i"), Ok(String::from("イ")));
assert_eq!(kata("u"), Ok(String::from("ウ")));
assert_eq!(kata("e"), Ok(String::from("エ")));
assert_eq!(kata("o"), Ok(String::from("オ")));
assert_eq!(kata("xa"), Ok(String::from("ァ")));
assert_eq!(kata("xi"), Ok(String::from("ィ")));
assert_eq!(kata("xu"), Ok(String::from("ゥ")));
assert_eq!(kata("xe"), Ok(String::from("ェ")));
assert_eq!(kata("xo"), Ok(String::from("ォ")));
assert_eq!(kata("ka"), Ok(String::from("カ")));
assert_eq!(kata("ki"), Ok(String::from("キ")));
assert_eq!(kata("ku"), Ok(String::from("ク")));
assert_eq!(kata("ke"), Ok(String::from("ケ")));
assert_eq!(kata("ko"), Ok(String::from("コ")));
assert_eq!(kata("kya"), Ok(String::from("キャ")));
assert_eq!(kata("kyu"), Ok(String::from("キュ")));
assert_eq!(kata("kyo"), Ok(String::from("キョ")));
assert_eq!(kata("ga"), Ok(String::from("ガ")));
assert_eq!(kata("gi"), Ok(String::from("ギ")));
assert_eq!(kata("gu"), Ok(String::from("グ")));
assert_eq!(kata("ge"), Ok(String::from("ゲ")));
assert_eq!(kata("go"), Ok(String::from("ゴ")));
assert_eq!(kata("gya"), Ok(String::from("ギャ")));
assert_eq!(kata("gyu"), Ok(String::from("ギュ")));
assert_eq!(kata("gyo"), Ok(String::from("ギョ")));
assert_eq!(kata("sa"), Ok(String::from("サ")));
assert_eq!(kata("si"), Ok(String::from("シ")));
assert_eq!(kata("su"), Ok(String::from("ス")));
assert_eq!(kata("se"), Ok(String::from("セ")));
assert_eq!(kata("so"), Ok(String::from("ソ")));
assert_eq!(kata("sha"), Ok(String::from("シャ")));
assert_eq!(kata("shu"), Ok(String::from("シュ")));
assert_eq!(kata("she"), Ok(String::from("シェ")));
assert_eq!(kata("sho"), Ok(String::from("ショ")));
assert_eq!(kata("za"), Ok(String::from("ザ")));
assert_eq!(kata("zi"), Ok(String::from("ジ")));
assert_eq!(kata("zu"), Ok(String::from("ズ")));
assert_eq!(kata("ze"), Ok(String::from("ゼ")));
assert_eq!(kata("zo"), Ok(String::from("ゾ")));
assert_eq!(kata("ja"), Ok(String::from("ジャ")));
assert_eq!(kata("ju"), Ok(String::from("ジュ")));
assert_eq!(kata("je"), Ok(String::from("ジェ")));
assert_eq!(kata("jo"), Ok(String::from("ジョ")));
assert_eq!(kata("ta"), Ok(String::from("タ")));
assert_eq!(kata("ti"), Ok(String::from("チ")));
assert_eq!(kata("tu"), Ok(String::from("ツ")));
assert_eq!(kata("xtu"), Ok(String::from("ッ")));
assert_eq!(kata("te"), Ok(String::from("テ")));
assert_eq!(kata("to"), Ok(String::from("ト")));
assert_eq!(kata("cha"), Ok(String::from("チャ")));
assert_eq!(kata("chu"), Ok(String::from("チュ")));
assert_eq!(kata("che"), Ok(String::from("チェ")));
assert_eq!(kata("cho"), Ok(String::from("チョ")));
assert_eq!(kata("thi"), Ok(String::from("ティ")));
assert_eq!(kata("thu"), Ok(String::from("テュ")));
assert_eq!(kata("da"), Ok(String::from("ダ")));
assert_eq!(kata("di"), Ok(String::from("ヂ")));
assert_eq!(kata("du"), Ok(String::from("ヅ")));
assert_eq!(kata("de"), Ok(String::from("デ")));
assert_eq!(kata("do"), Ok(String::from("ド")));
assert_eq!(kata("dhi"), Ok(String::from("ディ")));
assert_eq!(kata("dhu"), Ok(String::from("デュ")));
assert_eq!(kata("na"), Ok(String::from("ナ")));
assert_eq!(kata("ni"), Ok(String::from("ニ")));
assert_eq!(kata("nu"), Ok(String::from("ヌ")));
assert_eq!(kata("ne"), Ok(String::from("ネ")));
assert_eq!(kata("no"), Ok(String::from("ノ")));
assert_eq!(kata("nya"), Ok(String::from("ニャ")));
assert_eq!(kata("nyu"), Ok(String::from("ニュ")));
assert_eq!(kata("nyo"), Ok(String::from("ニョ")));
assert_eq!(kata("ha"), Ok(String::from("ハ")));
assert_eq!(kata("hi"), Ok(String::from("ヒ")));
assert_eq!(kata("hu"), Ok(String::from("フ")));
assert_eq!(kata("he"), Ok(String::from("ヘ")));
assert_eq!(kata("ho"), Ok(String::from("ホ")));
assert_eq!(kata("hya"), Ok(String::from("ヒャ")));
assert_eq!(kata("hyu"), Ok(String::from("ヒュ")));
assert_eq!(kata("hyo"), Ok(String::from("ヒョ")));
assert_eq!(kata("ba"), Ok(String::from("バ")));
assert_eq!(kata("bi"), Ok(String::from("ビ")));
assert_eq!(kata("bu"), Ok(String::from("ブ")));
assert_eq!(kata("be"), Ok(String::from("ベ")));
assert_eq!(kata("bo"), Ok(String::from("ボ")));
assert_eq!(kata("bya"), Ok(String::from("ビャ")));
assert_eq!(kata("byu"), Ok(String::from("ビュ")));
assert_eq!(kata("byo"), Ok(String::from("ビョ")));
assert_eq!(kata("pa"), Ok(String::from("パ")));
assert_eq!(kata("pi"), Ok(String::from("ピ")));
assert_eq!(kata("pu"), Ok(String::from("プ")));
assert_eq!(kata("pe"), Ok(String::from("ペ")));
assert_eq!(kata("po"), Ok(String::from("ポ")));
assert_eq!(kata("pya"), Ok(String::from("ピャ")));
assert_eq!(kata("pyu"), Ok(String::from("ピュ")));
assert_eq!(kata("pyo"), Ok(String::from("ピョ")));
assert_eq!(kata("fa"), Ok(String::from("ファ")));
assert_eq!(kata("fi"), Ok(String::from("フィ")));
assert_eq!(kata("fe"), Ok(String::from("フェ")));
assert_eq!(kata("fo"), Ok(String::from("フォ")));
assert_eq!(kata("va"), Ok(String::from("ヴァ")));
assert_eq!(kata("vi"), Ok(String::from("ヴィ")));
assert_eq!(kata("vu"), Ok(String::from("ヴ")));
assert_eq!(kata("ve"), Ok(String::from("ヴェ")));
assert_eq!(kata("vo"), Ok(String::from("ヴォ")));
assert_eq!(kata("ma"), Ok(String::from("マ")));
assert_eq!(kata("mi"), Ok(String::from("ミ")));
assert_eq!(kata("mu"), Ok(String::from("ム")));
assert_eq!(kata("me"), Ok(String::from("メ")));
assert_eq!(kata("mo"), Ok(String::from("モ")));
assert_eq!(kata("mya"), Ok(String::from("ミャ")));
assert_eq!(kata("myu"), Ok(String::from("ミュ")));
assert_eq!(kata("myo"), Ok(String::from("ミョ")));
assert_eq!(kata("ya"), Ok(String::from("ヤ")));
assert_eq!(kata("yu"), Ok(String::from("ユ")));
assert_eq!(kata("yo"), Ok(String::from("ヨ")));
assert_eq!(kata("xya"), Ok(String::from("ャ")));
assert_eq!(kata("xyu"), Ok(String::from("ュ")));
assert_eq!(kata("xyo"), Ok(String::from("ョ")));
assert_eq!(kata("ra"), Ok(String::from("ラ")));
assert_eq!(kata("ri"), Ok(String::from("リ")));
assert_eq!(kata("ru"), Ok(String::from("ル")));
assert_eq!(kata("re"), Ok(String::from("レ")));
assert_eq!(kata("ro"), Ok(String::from("ロ")));
assert_eq!(kata("rya"), Ok(String::from("リャ")));
assert_eq!(kata("ryu"), Ok(String::from("リュ")));
assert_eq!(kata("ryo"), Ok(String::from("リョ")));
assert_eq!(kata("wa"), Ok(String::from("ワ")));
assert_eq!(kata("wo"), Ok(String::from("ヲ")));
assert_eq!(kata("n"), Ok(String::from("ン")));
}
#[test]
fn katakana_little_tsu() {
assert_eq!(kata("tte"), Ok(String::from("ッテ")));
assert_eq!(kata("sshi"), Ok(String::from("ッシ")));
}
#[test]
fn syllable_division() {
let syllables = syllable_divider("konbanha");
assert_eq!(vec!["ko", "n", "ba", "n", "ha"], syllables);
}
#[test]
fn turn_katakana() {
assert_eq!(Ok(String::from("ターン")), kata("ta-n"));
}
#[test]
fn comma() {
assert_eq!(Ok(String::from("、")), hira(","));
assert_eq!(Ok(String::from("、")), kata(","));
}
#[test]
fn period() {
assert_eq!(Ok(String::from("。")), hira("."));
assert_eq!(Ok(String::from("。")), kata("."));
}
#[test]
fn exclamation_point() {
assert_eq!(Ok(String::from("!")), hira("!"));
assert_eq!(Ok(String::from("!")), kata("!"));
}
#[test]
fn question_mark() {
assert_eq!(Ok(String::from("?")), hira("?"));
assert_eq!(Ok(String::from("?")), kata("?"));
}
}