-- |
-- Module      :  Melodics.Ukrainian
-- Copyright   :  (c) OleksandrZhabenko 2019-2020
-- License     :  MIT
-- Maintainer  :  olexandr543@yahoo.com
--
-- Functions provide functionality of a musical instrument synthesizer or for Ukrainian speech synthesis
-- especially for poets, translators and writers.
--

module Melodics.Ukrainian (
  appendS16LEFile
  , convertToProperUkrainian
  , takeData
  , isUkrainian
) where

import Data.Char
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector as VB
import qualified Data.ByteString.Char8 as B
import System.IO
import CaseBi.Unboxed (getBFst')
import qualified CaseBi as X (getBFst')
import Data.List.InnToOut.Basic (mapI, mapI2)
import Paths_mmsyn6ukr

{-
-- Inspired by: https://mail.haskell.org/pipermail/beginners/2011-October/008649.html
-}

data Triple = Z | O | T
  deriving (Triple -> Triple -> Bool
(Triple -> Triple -> Bool)
-> (Triple -> Triple -> Bool) -> Eq Triple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Triple -> Triple -> Bool
$c/= :: Triple -> Triple -> Bool
== :: Triple -> Triple -> Bool
$c== :: Triple -> Triple -> Bool
Eq,Eq Triple
Eq Triple
-> (Triple -> Triple -> Ordering)
-> (Triple -> Triple -> Bool)
-> (Triple -> Triple -> Bool)
-> (Triple -> Triple -> Bool)
-> (Triple -> Triple -> Bool)
-> (Triple -> Triple -> Triple)
-> (Triple -> Triple -> Triple)
-> Ord Triple
Triple -> Triple -> Bool
Triple -> Triple -> Ordering
Triple -> Triple -> Triple
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Triple -> Triple -> Triple
$cmin :: Triple -> Triple -> Triple
max :: Triple -> Triple -> Triple
$cmax :: Triple -> Triple -> Triple
>= :: Triple -> Triple -> Bool
$c>= :: Triple -> Triple -> Bool
> :: Triple -> Triple -> Bool
$c> :: Triple -> Triple -> Bool
<= :: Triple -> Triple -> Bool
$c<= :: Triple -> Triple -> Bool
< :: Triple -> Triple -> Bool
$c< :: Triple -> Triple -> Bool
compare :: Triple -> Triple -> Ordering
$ccompare :: Triple -> Triple -> Ordering
$cp1Ord :: Eq Triple
Ord,Int -> Triple -> ShowS
[Triple] -> ShowS
Triple -> String
(Int -> Triple -> ShowS)
-> (Triple -> String) -> ([Triple] -> ShowS) -> Show Triple
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Triple] -> ShowS
$cshowList :: [Triple] -> ShowS
show :: Triple -> String
$cshow :: Triple -> String
showsPrec :: Int -> Triple -> ShowS
$cshowsPrec :: Int -> Triple -> ShowS
Show)

-- | Function to take raw sound data from the \".wav\" file given.
takeData :: FilePath -> IO B.ByteString
takeData :: String -> IO ByteString
takeData String
file = do
  ByteString
data1 <- String -> IO ByteString
B.readFile String
file
  let dataN :: ByteString
dataN = Int -> ByteString -> ByteString
B.drop Int
44 ByteString
data1 in ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
dataN

-- | The function that actually produces a .raw file. The mapping table is given in the @Map.txt@ file.
appendS16LEFile ::  VB.Vector String -> Handle -> IO ()
appendS16LEFile :: Vector String -> Handle -> IO ()
appendS16LEFile Vector String
xs Handle
hdl | Bool -> Bool
not (Vector String -> Bool
forall a. Vector a -> Bool
VB.null Vector String
xs) =
  do
    [String]
dataFileList <- (String -> IO String) -> [String] -> IO [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> IO String
getDataFileName
      [String
"-.wav", String
"0.wav", String
"1.wav", String
"A.wav", String
"B.wav", String
"C.wav", String
"D.wav", String
"E.wav", String
"F.wav", String
"G.wav", String
"H.wav",
        String
"I.wav", String
"J.wav", String
"K.wav", String
"L.wav", String
"M.wav", String
"N.wav", String
"O.wav", String
"P.wav", String
"Q.wav", String
"R.wav",
          String
"S.wav", String
"T.wav", String
"U.wav", String
"V.wav", String
"W.wav", String
"X.wav", String
"Y.wav", String
"Z.wav", String
"a.wav", String
"b.wav", String
"c.wav",
            String
"d.wav", String
"e.wav", String
"f.wav"]
    Vector ByteString
dataList <- (String -> IO ByteString)
-> Vector String -> IO (Vector ByteString)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Vector a -> m (Vector b)
VB.mapM String -> IO ByteString
takeData (Vector String -> IO (Vector ByteString))
-> ([String] -> Vector String)
-> [String]
-> IO (Vector ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Vector String
forall a. [a] -> Vector a
VB.fromList ([String] -> IO (Vector ByteString))
-> [String] -> IO (Vector ByteString)
forall a b. (a -> b) -> a -> b
$! [String]
dataFileList
    (String -> IO ()) -> Vector String -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
VB.mapM_ (\String
u ->
      if (ByteString -> Bool) -> Vector ByteString -> Bool
forall a. (a -> Bool) -> Vector a -> Bool
VB.all (\ByteString
z -> ByteString -> Int
B.length ByteString
z Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) Vector ByteString
dataList
        then let rs :: String
rs =  ShowS
forall a. [a] -> [a]
tail ShowS -> (Handle -> String) -> Handle -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
' ') ShowS -> (Handle -> String) -> Handle -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'}') ShowS -> (Handle -> String) -> Handle -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> String
forall a. Show a => a -> String
show (Handle -> String) -> Handle -> String
forall a b. (a -> b) -> a -> b
$ Handle
hdl in do
          Handle -> IO ()
hClose Handle
hdl
          Bool
closedHdl <- Handle -> IO Bool
hIsClosed Handle
hdl
          if Bool
closedHdl
            then do
                   String -> ByteString -> IO ()
B.appendFile String
rs (ByteString -> IO ()) -> ByteString -> IO ()
forall a b. (a -> b) -> a -> b
$ Vector ByteString
dataList Vector ByteString -> Int -> ByteString
forall a. Vector a -> Int -> a
VB.! ((Int, Vector (String, Int)) -> String -> Int
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (Int
0, [(String, Int)] -> Vector (String, Int)
forall a. [a] -> Vector a
VB.fromList [(String
"-", Int
0), (String
"0", Int
1), (String
"1", Int
2), (String
"а", Int
3), (String
"б", Int
4),
                     (String
"в", Int
5), (String
"г", Int
6), (String
"д", Int
7), (String
"дж", Int
8), (String
"дз", Int
9), (String
"е", Int
10), (String
"ж", Int
11), (String
"з", Int
12), (String
"и", Int
13),
                        (String
"й", Int
14), (String
"к", Int
15), (String
"л", Int
16), (String
"м", Int
17), (String
"н", Int
18), (String
"о", Int
19), (String
"п", Int
20), (String
"р", Int
21),
                          (String
"с", Int
22), (String
"сь", Int
23), (String
"т", Int
24), (String
"у", Int
25), (String
"ф", Int
26), (String
"х", Int
27), (String
"ц", Int
28), (String
"ць", Int
29), (String
"ч", Int
30),
                            (String
"ш", Int
31), (String
"ь", Int
32), (String
"і", Int
33), (String
"ґ", Int
34)]) String
u)
            else String -> IO ()
forall a. HasCallStack => String -> a
error String
"File is not closed!"
        else String -> IO ()
forall a. HasCallStack => String -> a
error String
"Data sound file is not read!") Vector String
xs
    Handle -> IO ()
hClose Handle
hdl
                       | Bool
otherwise = () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | The function that converts a written Ukrainian text into the sounding in the program phonetical respesentation.
-- It is not exact phonetically but you can make for yourself a general impression of the Ukrainian sounding.
convertToProperUkrainian :: String -> VB.Vector String
convertToProperUkrainian :: String -> Vector String
convertToProperUkrainian String
ys = [(String, Triple)] -> Vector String
toVector ([(String, Triple)] -> Vector String)
-> (String -> [(String, Triple)]) -> String -> Vector String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(String, Triple)] -> [(String, Triple)]
correctA ([(String, Triple)] -> [(String, Triple)])
-> (String -> [(String, Triple)]) -> String -> [(String, Triple)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(String, Triple)] -> [(String, Triple)]
applyChanges ([(String, Triple)] -> [(String, Triple)])
-> (String -> [(String, Triple)]) -> String -> [(String, Triple)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [(String, Triple)]
createTuplesByAnalysis (String -> [(String, Triple)])
-> ShowS -> String -> [(String, Triple)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
changeJotted ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
secondConv ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
wasFstConverted ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
filterUkr (String -> Vector String) -> String -> Vector String
forall a b. (a -> b) -> a -> b
$ String
ys

correctB :: [String] -> [String]
correctB :: [String] -> [String]
correctB ys :: [String]
ys@(String
xs:[String]
xss) | Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([String] -> Int) -> ([String] -> [String]) -> [String] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"1") ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> [String]
takeFromFT2 Int
6 ([String] -> Int) -> [String] -> Int
forall a b. (a -> b) -> a -> b
$ [String]
ys) Int
1 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT =
  ShowS -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (\String
t -> if String
t String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"1" Bool -> Bool -> Bool
|| Char -> Bool
isPunctuation (String -> Char
forall a. [a] -> a
head String
t) then String
"-" else String
t) (Int -> [String] -> [String]
takeFromFT2 Int
6 [String]
ys) [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String] -> [String]
correctB (Int -> [String] -> [String]
dropFromFT2 Int
6 [String]
ys)
                     | Bool
otherwise = (if Char -> Bool
isPunctuation (Char -> Bool) -> (String -> Char) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Char
forall a. [a] -> a
head (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xs then String
"-" else String
xs)String -> [String] -> [String]
forall a. a -> [a] -> [a]
:[String] -> [String]
correctB [String]
xss
correctB [] = []

filterUkr :: String -> String
filterUkr :: ShowS
filterUkr String
xs = (Char -> String) -> ShowS
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Char
x -> if Char -> Bool
isUkrainian Char
x then [Char -> Char
toLower Char
x] else if Char -> Bool
isSpace Char
x Bool -> Bool -> Bool
|| Char -> Bool
isControl Char
x Bool -> Bool -> Bool
|| Char -> Bool
isPunctuation Char
x then [Char
x] else []) String
xs

secondConv :: String -> String
secondConv :: ShowS
secondConv (Char
y:String
ys) | if Char -> Bool
isSpace Char
y then Bool
True else Char -> Bool
isControl Char
y = Char
'1'Char -> ShowS
forall a. a -> [a] -> [a]
:ShowS
secondConv String
ys
                  | Bool
otherwise = Char
yChar -> ShowS
forall a. a -> [a] -> [a]
:ShowS
secondConv String
ys
secondConv String
_ = []

createTuplesByAnalysis :: String -> [(String, Triple)]
createTuplesByAnalysis :: String -> [(String, Triple)]
createTuplesByAnalysis x :: String
x@(Char
y:String
ys) | (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1075\1076\1078\1079\1082\1085\1087\1089\1090\1092\1093\1094\1095\1096" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
y = String -> [(String, Triple)]
initialA String
x
                                | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ys) Bool -> Bool -> Bool
&& String -> Char
forall a. [a] -> a
head String
ys Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\1081' Bool -> Bool -> Bool
&& Char -> Bool
isConsNotJ Char
y = case Char
y of
  Char
'\1089' -> (String
"\1089\1100", Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
createTuplesByAnalysis (ShowS
forall a. [a] -> [a]
tail String
ys)
  Char
'\1094' -> (String
"\1094\1100", Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
createTuplesByAnalysis (ShowS
forall a. [a] -> [a]
tail String
ys)
  Char
_       -> ([Char
y], Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String
"\1100", Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
createTuplesByAnalysis (ShowS
forall a. [a] -> [a]
tail String
ys)
                                | Bool
otherwise = ([Char
y], Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
createTuplesByAnalysis String
ys
createTuplesByAnalysis String
_ = []

canChange :: Char -> Triple
canChange :: Char -> Triple
canChange Char
x | Char -> Bool
isSpace Char
x Bool -> Bool -> Bool
|| Char -> Bool
isControl Char
x Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-' = Triple
O
            | (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1075\1076\1078\1079\1082\1085\1087\1089\1090\1092\1093\1094\1095\1096" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
x = Triple
T
            | Bool
otherwise = Triple
Z

isVoicedObstruent :: String -> Bool
isVoicedObstruent :: String -> Bool
isVoicedObstruent String
xs | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
xs) = (Bool, Vector (String, Bool)) -> String -> Bool
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (Bool
False, [(String, Bool)] -> Vector (String, Bool)
forall a. [a] -> Vector a
VB.fromList ([(String, Bool)] -> Vector (String, Bool))
-> [(String, Bool)] -> Vector (String, Bool)
forall a b. (a -> b) -> a -> b
$ [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String
"\1073",String
"\1075",String
"\1076",String
"\1076\1078",String
"\1076\1079",String
"\1078",String
"\1079",String
"\1169"] (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) String
xs
                     | Bool
otherwise = Bool
False

initialA :: String -> [(String, Triple)]
initialA :: String -> [(String, Triple)]
initialA t1 :: String
t1@(Char
t:String
ts) | Char -> Triple
canChange Char
t Triple -> Triple -> Bool
forall a. Eq a => a -> a -> Bool
== Triple
O = (String
"1", Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
initialA String
ts
                   | Char -> Triple
canChange Char
t Triple -> Triple -> Bool
forall a. Eq a => a -> a -> Bool
== Triple
T =
 if (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1076\1085\1089\1090\1093\1094" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
t
   then let (String
us,String
vs) = Int -> String -> (String, String)
forall a. Int -> [a] -> ([a], [a])
splitAt Int
2 String
t1 in
    if (Bool, Vector (String, Bool)) -> String -> Bool
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (Bool
False, [(String, Bool)] -> Vector (String, Bool)
forall a. [a] -> Vector a
VB.fromList ([(String, Bool)] -> Vector (String, Bool))
-> [(String, Bool)] -> Vector (String, Bool)
forall a b. (a -> b) -> a -> b
$ [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String
"\1076\1078",String
"\1076\1079",String
"\1085\1090",String
"\1089\1090",String
"\1089\1100",String
"\1090\1089",String
"\1090\1100",String
"\1093\1075",String
"\1094\1100"] (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) String
us
      then (String
us, Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
initialA (String
vs)
      else ([Char
t], Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
initialA String
ts
   else case ((Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1075\1078\1079\1082\1087\1092\1095\1096" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
t) of
          ~Bool
True -> ([Char
t], Triple
T)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
initialA String
ts
                   | Bool
otherwise = ([Char
t], Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:String -> [(String, Triple)]
initialA String
ts
initialA String
_ = []

wasFstConverted :: String -> String
wasFstConverted :: ShowS
wasFstConverted = (Char -> Bool) -> (Char -> String) -> ShowS
forall a. (a -> Bool) -> (a -> [a]) -> [a] -> [a]
mapI Char -> Bool
mustBeConverted Char -> String
convertionFst

mustBeConverted :: Char -> Bool
mustBeConverted :: Char -> Bool
mustBeConverted Char
c = (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"'-\700\1097\1102\1103\1108\1111\8217" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
c

convertionFst :: Char -> String
convertionFst :: Char -> String
convertionFst Char
u = (String, Vector (Char, String)) -> Char -> String
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' ([Char
u], [(Char, String)] -> Vector (Char, String)
forall a. [a] -> Vector a
VB.fromList ([(Char, String)] -> Vector (Char, String))
-> [(Char, String)] -> Vector (Char, String)
forall a b. (a -> b) -> a -> b
$ String -> [String] -> [(Char, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"'-\700\1097\1102\1103\1108\1111\8217" [String
"0",String
"0",String
"0",String
"\1096\1095",String
"\1081\1091",String
"\1081\1072",String
"\1081\1077",String
"\1081\1110",String
"0"]) Char
u

isConsNotJ :: Char -> Bool
isConsNotJ :: Char -> Bool
isConsNotJ = (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1073\1074\1075\1076\1078\1079\1082\1083\1084\1085\1087\1088\1089\1090\1092\1093\1094\1095\1096\1097\1169" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True))

changeJotted :: String -> String
changeJotted :: ShowS
changeJotted (Char
x:Char
y:Char
z:String
zs) | ((Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> [(Char, Bool)] -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String -> [Bool] -> [(Char, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip String
"\1072\1077\1080\1091\1110" (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) Char
z) Bool -> Bool -> Bool
&& (Char
y Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\1081') Bool -> Bool -> Bool
&& (Char -> Bool
isConsNotJ Char
x) = Char
xChar -> ShowS
forall a. a -> [a] -> [a]
:Char
'\1100'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
zChar -> ShowS
forall a. a -> [a] -> [a]
:ShowS
changeJotted String
zs
                        | Char -> Bool
isConsNotJ Char
x Bool -> Bool -> Bool
&& Char
y Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\1110' = Char
xChar -> ShowS
forall a. a -> [a] -> [a]
:Char
'\1100'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
yChar -> ShowS
forall a. a -> [a] -> [a]
:ShowS
changeJotted (Char
zChar -> ShowS
forall a. a -> [a] -> [a]
:String
zs)
                        | Bool
otherwise = Char
xChar -> ShowS
forall a. a -> [a] -> [a]
:ShowS
changeJotted (Char
yChar -> ShowS
forall a. a -> [a] -> [a]
:Char
zChar -> ShowS
forall a. a -> [a] -> [a]
:String
zs)
changeJotted String
xs = String
xs

applyChanges :: [(String, Triple)] -> [(String, Triple)]
applyChanges :: [(String, Triple)] -> [(String, Triple)]
applyChanges ((String, Triple)
z:(String, Triple)
t:[(String, Triple)]
zs) | (String, Triple) -> Triple
forall a b. (a, b) -> b
snd (String, Triple)
z Triple -> Triple -> Bool
forall a. Eq a => a -> a -> Bool
== Triple
T =
  ((String, Triple), Vector (String, (String, Triple)))
-> String -> (String, Triple)
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (((String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
z, Triple
Z), [(String, (String, Triple))] -> Vector (String, (String, Triple))
forall a. [a] -> Vector a
VB.fromList ([(String, (String, Triple))] -> Vector (String, (String, Triple)))
-> ([(String, Triple)] -> [(String, (String, Triple))])
-> [(String, Triple)]
-> Vector (String, (String, Triple))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [(String, Triple)] -> [(String, (String, Triple))]
forall a b. [a] -> [b] -> [(a, b)]
zip [String
"\1075",String
"\1076",String
"\1076\1079",String
"\1078",String
"\1079",String
"\1082",String
"\1085\1090",
    String
"\1087",String
"\1089",String
"\1089\1090",String
"\1089\1100",String
"\1090",String
"\1090\1089",String
"\1090\1100",String
"\1092",String
"\1093",String
"\1093\1075",String
"\1094",String
"\1094\1100",String
"\1095",String
"\1096"]
      ([(String, Triple)] -> Vector (String, (String, Triple)))
-> [(String, Triple)] -> Vector (String, (String, Triple))
forall a b. (a -> b) -> a -> b
$ [[(String, Triple)] -> (String, Triple)
гT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
дT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
дзT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
жT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
зT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
кT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs),
        [(String, Triple)] -> (String, Triple)
нтT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
пT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
сT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
стT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
сьT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
тT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
тсT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
тьT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs),
          [(String, Triple)] -> (String, Triple)
фT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
хT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
хгT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
цT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
цьT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
чT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs), [(String, Triple)] -> (String, Triple)
шT ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs)]) ((String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
applyChanges ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs)
                      | Bool
otherwise = (String, Triple)
z(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
applyChanges ((String, Triple)
t(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
zs)
applyChanges [(String
xs, Triple
_)] = [(String
xs, Triple
Z)]
applyChanges [(String, Triple)]
_ = []

-- in the further ??T functions the last (, T) means that it must be afterwards be separated with the soft sign into two tuples (1 additional function in the composition)
-- need further processing means that there should be additional checks and may be transformations. May be they can be omitted

isSoftDOrL :: [(String, Triple)] -> Bool
isSoftDOrL :: [(String, Triple)] -> Bool
isSoftDOrL [(String, Triple)]
xs = (Bool, Vector (String, Bool)) -> String -> Bool
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (Bool
False, [(String, Bool)] -> Vector (String, Bool)
forall a. [a] -> Vector a
VB.fromList ([(String, Bool)] -> Vector (String, Bool))
-> ([Bool] -> [(String, Bool)]) -> [Bool] -> Vector (String, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String
"\1073\1100",String
"\1074\1100",String
"\1076\1100",String
"\1079\1100",String
"\1083\1100",
  String
"\1084\1100",String
"\1085\1100",String
"\1087\1100",String
"\1089\1100",String
"\1090\1100",String
"\1092\1100",String
"\1094\1100"] ([Bool] -> Vector (String, Bool))
-> [Bool] -> Vector (String, Bool)
forall a b. (a -> b) -> a -> b
$ (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
xs)

isSoftDen :: [(String, Triple)] -> Bool
isSoftDen :: [(String, Triple)] -> Bool
isSoftDen [(String, Triple)]
xs = (Bool, Vector (String, Bool)) -> String -> Bool
forall a b. Ord a => (b, Vector (a, b)) -> a -> b
X.getBFst' (Bool
False, [(String, Bool)] -> Vector (String, Bool)
forall a. [a] -> Vector a
VB.fromList ([(String, Bool)] -> Vector (String, Bool))
-> ([Bool] -> [(String, Bool)]) -> [Bool] -> Vector (String, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String
"\1076\1100",String
"\1079\1100",String
"\1083\1100",String
"\1085\1100",String
"\1089\1100",
  String
"\1090\1100",String
"\1094\1100"] ([Bool] -> Vector (String, Bool))
-> [Bool] -> Vector (String, Bool)
forall a b. (a -> b) -> a -> b
$ (Bool -> [Bool]
forall a. a -> [a]
repeat Bool
True)) (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
xs) Bool -> Bool -> Bool
|| Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1076\1079\1100"

гT :: [(String, Triple)] -> (String, Triple)
гT :: [(String, Triple)] -> (String, Triple)
гT ((String, Triple)
t:[(String, Triple)]
_) | String -> Char
forall a. [a] -> a
head ((String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
t) Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\1082' Bool -> Bool -> Bool
|| String -> Char
forall a. [a] -> a
head ((String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
t) Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\1090' = (String
"\1093", Triple
Z)
         | Bool
otherwise = (String
"\1075", Triple
Z)
гT [(String, Triple)]
_ = (String
"г", Triple
Z)

дT :: [(String, Triple)] -> (String, Triple)
дT :: [(String, Triple)] -> (String, Triple)
дT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1078",String
"\1095",String
"\1096"] = (String
"\1076\1078", Triple
Z) -- need further processing д дж
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089\1100",String
"\1094\1100"] = (String
"\1076\1079\1100", Triple
T) -- need further processing д дзь
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1079",String
"\1089",String
"\1094"] = (String
"\1076\1079", Triple
Z) -- need further processing  д дз
            | Bool
otherwise = (String
"\1076", Triple
Z)
дT [(String, Triple)]
_ = (String
"д", Triple
Z)

дзT :: [(String, Triple)] -> (String, Triple)
дзT :: [(String, Triple)] -> (String, Triple)
дзT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | [(String, Triple)] -> Bool
isSoftDOrL [(String, Triple)]
t1 = (String
"\1076\1079\1100", Triple
T)
             | Bool
otherwise = (String
"\1076\1079", Triple
Z)
дзT [(String, Triple)]
_ = (String
"дз", Triple
Z)

жT :: [(String, Triple)] -> (String, Triple)
жT :: [(String, Triple)] -> (String, Triple)
жT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT Int
2 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089\1100",String
"\1094\1100"] = (String
"\1079\1100", Triple
T)
            | Bool
otherwise = (String
"\1078", Triple
Z)
жT [(String, Triple)]
_ = (String
"ж", Triple
Z)

зT :: [(String, Triple)] -> (String, Triple)
зT :: [(String, Triple)] -> (String, Triple)
зT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1078",String
"\1095",String
"\1096"] Bool -> Bool -> Bool
|| Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1076\1078" = (String
"\1078", Triple
Z)
            | [(String, Triple)] -> Bool
isSoftDOrL [(String, Triple)]
t1 = (String
"\1079\1100", Triple
T)
            | Int -> [(String, Triple)] -> String
takeFromFT Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1095",String
"\1096"] = (String
"\1096", Triple
Z) -- need further processing з ш
            | Int -> [(String, Triple)] -> String
takeFromFT Int
1 [(String, Triple)]
t1  String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089",String
"\1094"] Bool -> Bool -> Bool
|| Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1082",String
"\1087",String
"\1090",String
"\1092",String
"\1093"] = (String
"\1089", Triple
Z) -- need further processing з с
            | Bool
otherwise = (String
"\1079", Triple
Z)
зT [(String, Triple)]
_ = (String
"з", Triple
Z)

кT :: [(String, Triple)] -> (String, Triple)
кT :: [(String, Triple)] -> (String, Triple)
кT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) = (String
"\1169", Triple
Z)
            | Bool
otherwise = (String
"\1082", Triple
Z)
кT [(String, Triple)]
_ = (String
"к", Triple
Z)

нтT :: [(String, Triple)] -> (String, Triple)
нтT :: [(String, Triple)] -> (String, Triple)
нтT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT Int
2 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1090" = (String
"\1085", Triple
Z)
             | Int -> [(String, Triple)] -> String
takeFromFT Int
3 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1100\1082" = (String
"\1085\1100", Triple
T)
             | Bool
otherwise = (String
"\1085\1090", Triple
Z)
нтT [(String, Triple)]
_ = (String
"нт", Triple
T)

пT :: [(String, Triple)] -> (String, Triple)
пT :: [(String, Triple)] -> (String, Triple)
пT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) = (String
"\1073", Triple
Z)
            | Bool
otherwise = (String
"\1087", Triple
Z)
пT [(String, Triple)]
_ = (String
"п", Triple
Z)

сT :: [(String, Triple)] -> (String, Triple)
сT :: [(String, Triple)] -> (String, Triple)
сT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") Bool -> Bool -> Bool
||
   (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
2 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") = (String
"\1079\1100", Triple
T)
            | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) = (String
"\1073", Triple
Z)
            | [(String, Triple)] -> Bool
isSoftDOrL [(String, Triple)]
t1 = (String
"\1089\1100", Triple
Z)
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1096" = (String
"\1096", Triple
Z)
            | Bool
otherwise = (String
"\1089", Triple
Z)
сT [(String, Triple)]
_ = (String
"с", Triple
Z)

стT :: [(String, Triple)] -> (String, Triple)
стT :: [(String, Triple)] -> (String, Triple)
стT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) = (String
"\1079", Triple
Z)
             | Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1100\1082" Bool -> Bool -> Bool
|| Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100" = (String
"\1089\1100", Triple
Z)
             | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089",String
"\1085"] = (String
"\1089", Triple
Z)
             | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1095" = (String
"\1096", Triple
Z)
             | Bool
otherwise = (String
"\1089\1090", Triple
T)
стT [(String, Triple)]
_ = (String
"ст", Triple
T)

сьT :: [(String, Triple)] -> (String, Triple)
сьT :: [(String, Triple)] -> (String, Triple)
сьT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1079\1100", Triple
T)
             | Bool
otherwise = (String
"\1089\1100", Triple
Z)
сьT [(String, Triple)]
_ = (String
"сь", Triple
Z)

тT :: [(String, Triple)] -> (String, Triple)
тT :: [(String, Triple)] -> (String, Triple)
тT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") Bool -> Bool -> Bool
||
   (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
2 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") = (String
"\1076\1100", Triple
T)
            | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1076", Triple
Z)
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100" = (String
"\1094\1100", Triple
Z)
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094" = (String
"\1094", Triple
Z)
            | [(String, Triple)] -> Bool
isSoftDen [(String, Triple)]
t1 = (String
"\1090\1100", Triple
T)
            | Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1095",String
"\1096"] = (String
"\1095", Triple
Z)
            | Bool
otherwise = (String
"\1090", Triple
Z)
тT [(String, Triple)]
_ = (String
"т", Triple
Z)

тсT :: [(String, Triple)] -> (String, Triple)
тсT :: [(String, Triple)] -> (String, Triple)
тсT [(String, Triple)]
_ = (String
"\1094", Triple
Z)

тьT :: [(String, Triple)] -> (String, Triple)
тьT :: [(String, Triple)] -> (String, Triple)
тьT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1076\1100", Triple
T)
             | Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1100\1072" = (String
"\1094\1100", Triple
Z)
             | Bool
otherwise = (String
"\1090\1100", Triple
T)
тьT [(String, Triple)]
_ = (String
"ть", Triple
T)

фT :: [(String, Triple)] -> (String, Triple)
фT :: [(String, Triple)] -> (String, Triple)
фT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1074", Triple
Z)
            | Bool
otherwise = (String
"\1092", Triple
Z)
фT [(String, Triple)]
_ = (String
"ф", Triple
Z)

хT :: [(String, Triple)] -> (String, Triple)
хT :: [(String, Triple)] -> (String, Triple)
хT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1075", Triple
Z)
            | Bool
otherwise = (String
"\1093", Triple
Z)
хT [(String, Triple)]
_ = (String
"х", Triple
Z)

хгT :: [(String, Triple)] -> (String, Triple)
хгT :: [(String, Triple)] -> (String, Triple)
хгT [(String, Triple)]
_ = (String
"\1075", Triple
Z)

цT :: [(String, Triple)] -> (String, Triple)
цT :: [(String, Triple)] -> (String, Triple)
цT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") Bool -> Bool -> Bool
||
   (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
2 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") = (String
"\1076\1079\1100", Triple
T)
            | [(String, Triple)] -> Bool
isSoftDOrL [(String, Triple)]
t1 = (String
"\1094\1100", Triple
Z)
            | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1076\1079", Triple
Z)
            | Bool
otherwise = (String
"\1094", Triple
Z)
цT [(String, Triple)]
_ = (String
"ц", Triple
Z)

цьT :: [(String, Triple)] -> (String, Triple)
цьT :: [(String, Triple)] -> (String, Triple)
цьT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") Bool -> Bool -> Bool
||
   (String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
&& Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
2 (Int -> [(String, Triple)] -> String
takeFromFT_ Int
3 [(String, Triple)]
t1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1100") = (String
"\1076\1079\1100", Triple
T)
             | Bool
otherwise = (String
"\1094\1100", Triple
Z)
цьT [(String, Triple)]
_ = (String
"ць", Triple
Z)

чT :: [(String, Triple)] -> (String, Triple)
чT :: [(String, Triple)] -> (String, Triple)
чT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089\1100",String
"\1094\1100"] = (String
"\1094\1100", Triple
Z)
            | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1076\1078", Triple
Z)
            | Bool
otherwise = (String
"\1095", Triple
Z)
чT [(String, Triple)]
_ = (String
"ч", Triple
Z)

шT :: [(String, Triple)] -> (String, Triple)
шT :: [(String, Triple)] -> (String, Triple)
шT t1 :: [(String, Triple)]
t1@((String, Triple)
_:[(String, Triple)]
_) | Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1 String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1089\1100",String
"\1094\1100"] = (String
"\1089\1100", Triple
Z)
            | String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
2 [(String, Triple)]
t1) Bool -> Bool -> Bool
|| String -> Bool
isVoicedObstruent (Int -> [(String, Triple)] -> String
takeFromFT_ Int
1 [(String, Triple)]
t1) = (String
"\1078", Triple
Z)
            | Bool
otherwise = (String
"\1096", Triple
Z)
шT [(String, Triple)]
_ = (String
"ш", Triple
Z)

correctA :: [(String, Triple)] -> [(String, Triple)]
correctA :: [(String, Triple)] -> [(String, Triple)]
correctA = [(String, Triple)] -> [(String, Triple)]
correctSomeW ([(String, Triple)] -> [(String, Triple)])
-> ([(String, Triple)] -> [(String, Triple)])
-> [(String, Triple)]
-> [(String, Triple)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(String, Triple)] -> [(String, Triple)]
separateSoftS

separateSoftS :: [(String, Triple)] -> [(String, Triple)]
separateSoftS :: [(String, Triple)] -> [(String, Triple)]
separateSoftS [(String, Triple)]
xss = ((String, Triple) -> Bool)
-> ((String, Triple) -> [(String, Triple)])
-> [(String, Triple)]
-> [(String, Triple)]
forall a. (a -> Bool) -> (a -> [a]) -> [a] -> [a]
mapI (\(String, Triple)
x -> (String, Triple) -> Triple
forall a b. (a, b) -> b
snd (String, Triple)
x Triple -> Triple -> Bool
forall a. Eq a => a -> a -> Bool
== Triple
T) (String, Triple) -> [(String, Triple)]
divideToParts [(String, Triple)]
xss

divideToParts :: (String, Triple) -> [(String, Triple)]
divideToParts :: (String, Triple) -> [(String, Triple)]
divideToParts (String
xs, Triple
_) = [(ShowS
forall a. [a] -> [a]
init String
xs, Triple
Z),([String -> Char
forall a. [a] -> a
last String
xs], Triple
Z)]

correctSomeW :: [(String, Triple)] -> [(String, Triple)]
correctSomeW :: [(String, Triple)] -> [(String, Triple)]
correctSomeW ((String, Triple)
x:(String, Triple)
y:(String, Triple)
z:[(String, Triple)]
xs) | (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100" Bool -> Bool -> Bool
&& (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1100" Bool -> Bool -> Bool
&& (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
z String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1072" = (String, Triple)
x(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String
"\1094\1100", Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String, Triple)
z(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
correctSomeW [(String, Triple)]
xs
                        | ((String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"1" Bool -> Bool -> Bool
|| (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"0") Bool -> Bool -> Bool
&& (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1081" Bool -> Bool -> Bool
&& (String, Triple) -> String
forall a b. (a, b) -> a
fst (String, Triple)
z String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1072" =
  if Int -> [(String, Triple)] -> String
takeFromFT Int
2 [(String, Triple)]
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1095\1085"
    then (String, Triple)
x(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String, Triple)
y(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String, Triple)
z(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String
"\1096", Triple
Z)(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
correctSomeW ([(String, Triple)] -> [(String, Triple)]
forall a. [a] -> [a]
tail [(String, Triple)]
xs)
    else (String, Triple)
x(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
correctSomeW ((String, Triple)
y(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String, Triple)
z(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
xs)
                        | Bool
otherwise = (String, Triple)
x(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)] -> [(String, Triple)]
correctSomeW ((String, Triple)
y(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:(String, Triple)
z(String, Triple) -> [(String, Triple)] -> [(String, Triple)]
forall a. a -> [a] -> [a]
:[(String, Triple)]
xs)
correctSomeW [(String, Triple)]
zs = [(String, Triple)]
zs

takeFromFT :: Int -> [(String, Triple)] -> String
takeFromFT :: Int -> [(String, Triple)] -> String
takeFromFT Int
n [(String, Triple)]
ts | if Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
0 Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT then Bool
True else [(String, Triple)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(String, Triple)]
ts = []
                | Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
k Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT = Int -> ShowS
forall a. Int -> [a] -> [a]
take Int
n String
ks
                | Bool
otherwise = String
ks String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [(String, Triple)] -> String
takeFromFT (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
k) ([(String, Triple)] -> [(String, Triple)]
forall a. [a] -> [a]
tail [(String, Triple)]
ts)
    where ks :: String
ks = (String, Triple) -> String
forall a b. (a, b) -> a
fst ([(String, Triple)] -> (String, Triple)
forall a. [a] -> a
head [(String, Triple)]
ts)
          k :: Int
k = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
ks

takeFromFT2 :: Int -> [String] -> [String]
takeFromFT2 :: Int -> [String] -> [String]
takeFromFT2 Int
n [String]
ts | if Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
0 Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT then Bool
True else [String] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
ts = []
                 | Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
k Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT = [String
ks]
                 | Bool
otherwise = String
ksString -> [String] -> [String]
forall a. a -> [a] -> [a]
:Int -> [String] -> [String]
takeFromFT2 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
k) ([String] -> [String]
forall a. [a] -> [a]
tail [String]
ts)
    where ks :: String
ks = [String] -> String
forall a. [a] -> a
head [String]
ts
          k :: Int
k = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
ks

dropFromFT2 :: Int -> [String] -> [String]
dropFromFT2 :: Int -> [String] -> [String]
dropFromFT2 Int
n [String]
ts | if Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
0 Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT then Bool
True else [String] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
ts = []
                 | Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
k Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT = [String] -> [String]
forall a. [a] -> [a]
tail [String]
ts
                 | Bool
otherwise = Int -> [String] -> [String]
dropFromFT2 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
k) ([String] -> [String]
forall a. [a] -> [a]
tail [String]
ts)
    where k :: Int
k = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([String] -> String
forall a. [a] -> a
head [String]
ts)

takeFromFT_ :: Int -> [(String, Triple)] -> String
takeFromFT_ :: Int -> [(String, Triple)] -> String
takeFromFT_ Int
n [(String, Triple)]
ts = Int -> [(String, Triple)] -> String
takeFromFT Int
n (((String, Triple) -> Bool)
-> [(String, Triple)] -> [(String, Triple)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(String
xs, Triple
_) -> (String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"1" Bool -> Bool -> Bool
&& String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"0")) [(String, Triple)]
ts)

toVector :: [(String, Triple)] -> VB.Vector String
toVector :: [(String, Triple)] -> Vector String
toVector [(String, Triple)]
ts = [String] -> Vector String
forall a. [a] -> Vector a
VB.fromList ([String] -> Vector String)
-> ([(String, Triple)] -> [String])
-> [(String, Triple)]
-> Vector String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
correctB ([String] -> [String])
-> ([(String, Triple)] -> [String])
-> [(String, Triple)]
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, Triple) -> Bool)
-> ((String, Triple) -> String)
-> ((String, Triple) -> [String])
-> [(String, Triple)]
-> [String]
forall a b. (a -> Bool) -> (a -> b) -> (a -> [b]) -> [a] -> [b]
mapI2 (\(String, Triple)
x -> Bool -> Bool
not (Bool -> Bool)
-> ((String, Triple) -> Bool) -> (String, Triple) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool)
-> ((String, Triple) -> String) -> (String, Triple) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, Triple) -> String
forall a b. (a, b) -> a
fst ((String, Triple) -> Bool) -> (String, Triple) -> Bool
forall a b. (a -> b) -> a -> b
$ (String, Triple)
x) (String, Triple) -> String
forall a b. (a, b) -> a
fst (\(String, Triple)
_ -> []) ([(String, Triple)] -> Vector String)
-> [(String, Triple)] -> Vector String
forall a b. (a -> b) -> a -> b
$ [(String, Triple)]
ts

isUkrainian :: Char -> Bool
isUkrainian :: Char -> Bool
isUkrainian Char
y | (Char
y Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'\1040' Bool -> Bool -> Bool
&& Char
y Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'\1065') Bool -> Bool -> Bool
|| (Char
y Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'\1070' Bool -> Bool -> Bool
&& Char
y Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'\1097') = Bool
True
              | Bool
otherwise = (Bool, Vector (Char, Bool)) -> Char -> Bool
forall a b.
(Ord a, Unbox a, Unbox b) =>
(b, Vector (a, b)) -> a -> b
getBFst' (Bool
False, [(Char, Bool)] -> Vector (Char, Bool)
forall a. Unbox a => [a] -> Vector a
V.fromList ([(Char, Bool)] -> Vector (Char, Bool))
-> (String -> [(Char, Bool)]) -> String -> Vector (Char, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> (Char, Bool)) -> String -> [(Char, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map (\Char
x -> (Char
x, Bool
True)) (String -> Vector (Char, Bool)) -> String -> Vector (Char, Bool)
forall a b. (a -> b) -> a -> b
$ String
"'-\700\1028\1030\1031\1068\1100\1102\1103\1108\1110\1111\1168\1169\8217") Char
y