{-# OPTIONS_HADDOCK show-extensions #-}
{-# LANGUAGE BangPatterns #-}

-- |
-- Module      :  Melodics.Ukrainian.ArrInt8
-- Copyright   :  (c) OleksandrZhabenko 2021-2022
-- 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. Is rewritten from the module Melodics.ByteString.Ukrainian.Arr
-- for optimization purposes.
-- Phonetic material is taken from the :
--
-- Solomija Buk, Ján Mačutek, Andrij Rovenchak. Some properties of
-- the Ukrainian writing system. [Electronic resource] https://arxiv.org/ftp/arxiv/papers/0802/0802.4198.pdf

module Melodics.Ukrainian.ArrInt8 (
  -- * Basic functions
  Sound8
  , FlowSound
  , convertToProperUkrainianI8WithTuples
  , convertToProperUkrainianI8
  , isUkrainianL
  , linkFileNameI8
  -- * Transformation functions
  , дзT
  , жT
  , дT
  , гT
  , зT
  , цT
  , чT
  , шT
  , фT
  , кT
  , пT
  , сT
  , тT
  , хT
  , сьT
  , нтT
  , стT
  , тьT
  , цьT
) where

import Data.Maybe (fromJust)
import Data.Char
import GHC.Arr
import CaseBi.Arr
import Data.List (uncons)
import GHC.Int
import Melodics.Ukrainian.Common2

-- | Is used to signify the optimization data type of 'Int8'.
type Sound8 = Int8

type FlowSound = [Sound8]

{-| The function that uses the following correspondence between the previous data type UZPP2 and the 'Sound8'.
@
UZ \'A\' D       дз (plain)                 8
UZ \'A\' K       дз (palatalized)           9
UZ \'B\' D       ж  (plain)                 10
UZ \'B\' K       ж  (semi-palatalized)      11
UZ \'C\' S       й                          27
UZ \'D\' N       сь                         54
UZ \'E\' L       ч  (plain)                 39
UZ \'E\' M       ч  (semi-palatalized)      40
UZ \'F\' L       ш  (plain)                 41
UZ \'F\' M       ш  (semi-palatalized)      42
     G                                      55
     H                                      56
     I                                      57
     J                                      58
     K                                      59
     L                                      60
     M                                      61
     N          нт                          62
     O          ст                          63
     P          ть                          64
     Q          дзь                         12
     R          зь                          13
     S          нь                          65
     T          дь                          14
UZ \'a\' W       а                          1
UZ \'b\' D       б  (plain)                 15
UZ \'b\' K       б  (semi-palatalized)      16
UZ \'c\' D       ц  (plain)                 38
UZ \'d\' D       д  (plain)                 17
UZ \'d\' K       д  (palatalized)           18
UZ \'e\' W       е                          2
UZ \'f\' L       ф  (plain)                 43
UZ \'f\' M       ф  (semi-palatalized)      44
UZ \'g\' D       ґ  (plain)                 19
UZ \'g\' K       ґ  (semi-palatalized)      20
UZ \'h\' D       г  (plain)                 21
UZ \'h\' K       г  (semi-palatalized)      22
UZ \'i\' W       і                          6
UZ \'j\' D       дж (plain)                 23
UZ \'j\' K       дж (palatalized)           24
UZ \'k\' L       к  (plain)                 45
UZ \'k\' M       к  (semi-palatalized)      46
UZ \'l\' S       л  (plain)                 28
UZ \'l\' O       л  (palatalized)           29
UZ \'m\' S       м  (plain)                 30
UZ \'m\' O       м  (semi-palatalized)      31
UZ \'n\' S       н  (plain)                 32
UZ \'n\' O       н  (palatalized)           33
UZ \'o\' W       о                          3
UZ \'p\' L       п  (plain)                 47
UZ \'p\' M       п  (semi-palatalized)      48
UZ \'q\' E       ь                          7
UZ \'r\' S       р  (plain)                 34
UZ \'r\' O       р  (palatalized)           35
UZ \'s\' L       с  (plain)                 49
UZ \'t\' L       т  (plain)                 50
UZ \'t\' M       т  (palatalized)           51
UZ \'u\' W       у                          4
UZ \'v\' S       в  (plain)                 36
UZ \'v\' O       в  (semi-palatalized)      37
UZ \'w\' N       ць                         66
UZ \'x\' L       х  (plain)                 52
UZ \'x\' M       х  (semi-palatalized)      53
UZ \'y\' W       и                          5
UZ \'z\' D       з  (plain)                 25
UZ \'z\' K       з  (palatalized)           26
@
-}
convertToProperUkrainianI8 :: String -> FlowSound
convertToProperUkrainianI8 :: String -> FlowSound
convertToProperUkrainianI8 =
      let !tup1 :: Array Int (Int8, Bool)
tup1 = (Int, Int) -> [(Int8, Bool)] -> Array Int (Int8, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
13) [(Int8
10,Bool
True),(Int8
17,Bool
True),(Int8
21,Bool
True),(Int8
25,Bool
True),(Int8
32,Bool
True),(Int8
38,Bool
True),(Int8
39,Bool
True),
              (Int8
41,Bool
True),(Int8
43,Bool
True),(Int8
45,Bool
True),(Int8
47,Bool
True),(Int8
49,Bool
True),(Int8
50,Bool
True),(Int8
52,Bool
True)]
          !tup2 :: Array Int (Int8, Bool)
tup2 = (Int, Int) -> [(Int8, Bool)] -> Array Int (Int8, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
19) [(Int8
10,Bool
True),(Int8
15,Bool
True),(Int8
17,Bool
True),(Int8
19,Bool
True),(Int8
21,Bool
True),(Int8
25,Bool
True),(Int8
28,Bool
True),
              (Int8
30,Bool
True),(Int8
32,Bool
True),(Int8
34,Bool
True),(Int8
36,Bool
True),(Int8
38,Bool
True),(Int8
39,Bool
True),(Int8
41,Bool
True),(Int8
43,Bool
True),(Int8
45,Bool
True),(Int8
47,Bool
True),
                (Int8
49,Bool
True),(Int8
50,Bool
True),(Int8
52,Bool
True)]
          !tup3 :: Array Int (Int8, Bool)
tup3 = (Int, Int) -> [(Int8, Bool)] -> Array Int (Int8, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
13) [(Int8
10,Bool
False),(Int8
17,Bool
False),(Int8
21,Bool
False),(Int8
25,Bool
False),(Int8
32,Bool
False),(Int8
38,Bool
False),(Int8
39,Bool
False),
                  (Int8
41,Bool
False),(Int8
43,Bool
False),(Int8
45,Bool
False),(Int8
47,Bool
False),(Int8
49,Bool
False),(Int8
50,Bool
False),(Int8
52,Bool
False)]
          !tup4 :: Array Int (Int8, Bool)
tup4 = (Int, Int) -> [(Int8, Bool)] -> Array Int (Int8, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
5) [(Int8
17,Bool
True),(Int8
32,Bool
True),(Int8
38,Bool
True),(Int8
49,Bool
True),(Int8
50,Bool
True),(Int8
52,Bool
True)]
          !tup5 :: Array Int (FlowSound, Bool)
tup5 = (Int, Int) -> [(FlowSound, Bool)] -> Array Int (FlowSound, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
8) [([Int8
17,Int8
10],Bool
True),([Int8
17,Int8
25],Bool
True),([Int8
32,Int8
50],Bool
True),([Int8
38,Int8
7],Bool
True),([Int8
49,Int8
7],Bool
True),
              ([Int8
49,Int8
50],Bool
True),([Int8
50,Int8
7],Bool
True),([Int8
50,Int8
49],Bool
True),([Int8
52,Int8
21],Bool
True)]
          !tup6 :: Array Int (FlowSound, Int8)
tup6 = (Int, Int) -> [(FlowSound, Int8)] -> Array Int (FlowSound, Int8)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
8) [([Int8
17,Int8
10],Int8
23),([Int8
17,Int8
25],Int8
8),([Int8
32,Int8
50],Int8
62),([Int8
38,Int8
7],Int8
66),([Int8
49,Int8
7],Int8
54), ([Int8
49,Int8
50],Int8
63),
              ([Int8
50,Int8
7],Int8
64),([Int8
50,Int8
49],Int8
38),([Int8
52,Int8
21],Int8
21)]
          !tup8 :: Array Int (Int8, Bool)
tup8 = (Int, Int) -> [(Int8, Bool)] -> Array Int (Int8, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
7) [(Int8
8,Bool
True),(Int8
10,Bool
True),(Int8
15,Bool
True),(Int8
17,Bool
True),(Int8
19,Bool
True),(Int8
21,Bool
True),(Int8
23,Bool
True),(Int8
25, Bool
True)]
          !tup9 :: Array Int (FlowSound, Bool)
tup9 = (Int, Int) -> [(FlowSound, Bool)] -> Array Int (FlowSound, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
10) [([Int8
15,Int8
7],Bool
True),([Int8
17,Int8
7],Bool
True),([Int8
28,Int8
7],Bool
True),([Int8
30,Int8
7],Bool
True),([Int8
32,Int8
7],Bool
True),([Int8
36,Int8
7],Bool
True),
              ([Int8
38,Int8
7],Bool
True),([Int8
43,Int8
7],Bool
True),([Int8
47,Int8
7],Bool
True),([Int8
49,Int8
7],Bool
True),([Int8
50,Int8
7],Bool
True)]
          !tup10 :: Array Int (FlowSound, Bool)
tup10 = (Int, Int) -> [(FlowSound, Bool)] -> Array Int (FlowSound, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
4) [([Int8
12],Bool
True),([Int8
13],Bool
True),([Int8
14],Bool
True),([Int8
64],Bool
True),([Int8
65],Bool
True)]
          !tup11 :: Array Int (FlowSound, Bool)
tup11 = (Int, Int) -> [(FlowSound, Bool)] -> Array Int (FlowSound, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
7) [([Int8
8,Int8
7],Bool
True),([Int8
17,Int8
7],Bool
True),([Int8
25,Int8
7],Bool
True),([Int8
28,Int8
7],Bool
True),([Int8
32,Int8
7],Bool
True),([Int8
38,Int8
7],Bool
True),
              ([Int8
49,Int8
7],Bool
True),([Int8
50,Int8
7],Bool
True)]
          tup7 :: Array Int (Int8, FlowSound -> Int8)
tup7 = (Int, Int)
-> [(Int8, FlowSound -> Int8)]
-> Array Int (Int8, FlowSound -> Int8)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
18) [(Int8
8, Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Int8
дзT Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10),(Int8
10, FlowSound -> Int8
жT),(Int8
17, FlowSound -> Int8
дT),(Int8
21, FlowSound -> Int8
гT),(Int8
25, Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Int8
зT Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10),(Int8
38, Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
цT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10),
              (Int8
39, FlowSound -> Int8
чT),(Int8
41, FlowSound -> Int8
шT),(Int8
43, FlowSound -> Int8
фT), (Int8
45, FlowSound -> Int8
кT),(Int8
47, FlowSound -> Int8
пT),(Int8
49, Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
сT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10),(Int8
50, Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
тT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup11 Array Int (FlowSound, Bool)
tup10),
                (Int8
52, FlowSound -> Int8
хT),(Int8
54, FlowSound -> Int8
сьT),(Int8
62, FlowSound -> Int8
нтT),(Int8
63, FlowSound -> Int8
стT),(Int8
64, FlowSound -> Int8
тьT),(Int8
66, FlowSound -> Int8
цьT)]
          !tup12 :: Array Int (Int8, FlowSound)
tup12 = (Int, Int) -> [(Int8, FlowSound)] -> Array Int (Int8, FlowSound)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
6) [(Int8
12,[Int8
8,Int8
7]),(Int8
13,[Int8
25,Int8
7]),(Int8
14,[Int8
17,Int8
7]),(Int8
62,[Int8
32,Int8
50]),(Int8
63,[Int8
49,Int8
50]),(Int8
64,[Int8
50,Int8
7]), (Int8
65,[Int8
32,Int8
7])]
          !tup13 :: Array Int (Char, Int8)
tup13 = (Int, Int) -> [(Char, Int8)] -> Array Int (Char, Int8)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
36) [(Char
'\'',-Int8
2),(Char
'-',-Int8
1),(Char
'\700',Int8
60),(Char
'\1072',Int8
1),(Char
'\1073',Int8
15),(Char
'\1074',Int8
36),(Char
'\1075',Int8
21),
              (Char
'\1076',Int8
17),(Char
'\1077',Int8
2),(Char
'\1078',Int8
10),(Char
'\1079',Int8
25),(Char
'\1080',Int8
5),(Char
'\1081',Int8
27),(Char
'\1082',Int8
45),(Char
'\1083',Int8
28),
                (Char
'\1084',Int8
30),(Char
'\1085',Int8
32),(Char
'\1086',Int8
3),(Char
'\1087',Int8
47),(Char
'\1088',Int8
34),(Char
'\1089',Int8
49),(Char
'\1090',Int8
50),(Char
'\1091',Int8
4),
                  (Char
'\1092',Int8
43),(Char
'\1093',Int8
52),(Char
'\1094',Int8
38),(Char
'\1095',Int8
39),(Char
'\1096',Int8
41),(Char
'\1097',Int8
55),(Char
'\1100',Int8
7),(Char
'\1102',Int8
56),
                    (Char
'\1103',Int8
57),(Char
'\1108',Int8
58),(Char
'\1110',Int8
6),(Char
'\1111',Int8
59),(Char
'\1169',Int8
19),(Char
'\8217',Int8
61)]
          !tup14 :: Array Int (Int8, FlowSound)
tup14 = (Int, Int) -> [(Int8, FlowSound)] -> Array Int (Int8, FlowSound)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
8) [(-Int8
2,[-Int8
1]),(-Int8
1,[-Int8
1]),(Int8
55,[Int8
41,Int8
39]),(Int8
56,[Int8
27,Int8
4]),(Int8
57,[Int8
27,Int8
1]),(Int8
58,[Int8
27,Int8
2]),(Int8
59,[Int8
27,Int8
6]),
              (Int8
60,[-Int8
1]),(Int8
61,[-Int8
1])]
          !tup15 :: Array Int (Char, Bool)
tup15 = (Int, Int) -> [(Char, Bool)] -> Array Int (Char, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
15) [(Char
'\'',Bool
True),(Char
'-',Bool
True),(Char
'\700',Bool
True),(Char
'\1028',Bool
True),(Char
'\1030',Bool
True),(Char
'\1031',Bool
True),
              (Char
'\1068',Bool
True),(Char
'\1100',Bool
True),(Char
'\1102',Bool
True),(Char
'\1103',Bool
True),(Char
'\1108',Bool
True),(Char
'\1110',Bool
True),(Char
'\1111',Bool
True),
                (Char
'\1168',Bool
True),(Char
'\1169',Bool
True),(Char
'\8217',Bool
True)]
          !tup16 :: Array Int (Char, Bool)
tup16 = (Int, Int) -> [(Char, Bool)] -> Array Int (Char, Bool)
forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
20) [(Char
'\1073',Bool
True),(Char
'\1074',Bool
True),(Char
'\1075',Bool
True),(Char
'\1076',Bool
True),(Char
'\1078',Bool
True),
              (Char
'\1079',Bool
True),(Char
'\1082',Bool
True),(Char
'\1083',Bool
True),(Char
'\1084',Bool
True),(Char
'\1085',Bool
True),(Char
'\1087',Bool
True),(Char
'\1088',Bool
True),
                (Char
'\1089',Bool
True),(Char
'\1090',Bool
True),(Char
'\1092',Bool
True),(Char
'\1093',Bool
True),(Char
'\1094',Bool
True),(Char
'\1095',Bool
True),(Char
'\1096',Bool
True),
                  (Char
'\1097',Bool
True),(Char
'\1169',Bool
True)] in
            FlowSound -> FlowSound
correctB (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
correctA Array Int (Int8, FlowSound)
tup12 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, FlowSound -> Int8) -> FlowSound -> FlowSound
applyChanges Array Int (Int8, FlowSound -> Int8)
tup7 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (FlowSound, Int8) -> [FlowSound] -> FlowSound
bsToCharUkr Array Int (FlowSound, Int8)
tup6 ([FlowSound] -> FlowSound)
-> (String -> [FlowSound]) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
createTuplesByAnalysis Array Int (Int8, Bool)
tup1 Array Int (Int8, Bool)
tup2 Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 (FlowSound -> [FlowSound])
-> (String -> FlowSound) -> String -> [FlowSound]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
              Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
secondConv Array Int (Int8, FlowSound)
tup14 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Char, Int8) -> String -> FlowSound
filterUkr Array Int (Char, Int8)
tup13 (String -> FlowSound) -> (String -> String) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Char, Bool) -> String -> String
changeIotated Array Int (Char, Bool)
tup16 (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
filter (\Char
x -> Array Int (Char, Bool) -> Char -> Bool
isUkrainianLTup Array Int (Char, Bool)
tup15 Char
x Bool -> Bool -> Bool
|| Char -> Bool
isSpace Char
x Bool -> Bool -> Bool
|| Char -> Bool
isControl Char
x Bool -> Bool -> Bool
|| Char -> Bool
isPunctuation Char
x) (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower

{-| A full variant of the 'convertToProperUkrainianI8' function with all the elements for the 'getBFst'' function being
provided as 'Array' 'Int' (data tuple). Can be useful to reduce number of calculations in the complex usage scenarios.
-}
convertToProperUkrainianI8WithTuples
  :: Array Int (Int8, Bool)
     -> Array Int (Int8, Bool)
     -> Array Int (Int8, Bool)
     -> Array Int (Int8, Bool)
     -> Array Int ([Int8], Bool)
     -> Array Int ([Int8], Int8)
     -> Array Int (Int8, FlowSound -> Sound8)
     -> Array Int (Int8, Bool)
     -> Array Int ([Int8], Bool)
     -> Array Int ([Int8], Bool)
     -> Array Int ([Int8], Bool)
     -> Array Int (Int8, [Int8])
     -> Array Int (Char,Int8)
     -> Array Int (Int8,[Int8])
     -> Array Int (Char, Bool)
     -> Array Int (Char, Bool)
     -> [Char]
     -> FlowSound
convertToProperUkrainianI8WithTuples :: Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Int8)
-> Array Int (Int8, FlowSound -> Int8)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (Int8, FlowSound)
-> Array Int (Char, Int8)
-> Array Int (Int8, FlowSound)
-> Array Int (Char, Bool)
-> Array Int (Char, Bool)
-> String
-> FlowSound
convertToProperUkrainianI8WithTuples !Array Int (Int8, Bool)
tup1 !Array Int (Int8, Bool)
tup2 !Array Int (Int8, Bool)
tup3 !Array Int (Int8, Bool)
tup4 !Array Int (FlowSound, Bool)
tup5 !Array Int (FlowSound, Int8)
tup6 Array Int (Int8, FlowSound -> Int8)
tup7 !Array Int (Int8, Bool)
tup8 !Array Int (FlowSound, Bool)
tup9 !Array Int (FlowSound, Bool)
tup10 !Array Int (FlowSound, Bool)
tup11 !Array Int (Int8, FlowSound)
tup12 !Array Int (Char, Int8)
tup13 !Array Int (Int8, FlowSound)
tup14 !Array Int (Char, Bool)
tup15 !Array Int (Char, Bool)
tup16 =
  FlowSound -> FlowSound
correctB (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
correctA Array Int (Int8, FlowSound)
tup12 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, FlowSound -> Int8) -> FlowSound -> FlowSound
applyChanges Array Int (Int8, FlowSound -> Int8)
tup7 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (FlowSound, Int8) -> [FlowSound] -> FlowSound
bsToCharUkr Array Int (FlowSound, Int8)
tup6 ([FlowSound] -> FlowSound)
-> (String -> [FlowSound]) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
createTuplesByAnalysis Array Int (Int8, Bool)
tup1 Array Int (Int8, Bool)
tup2 Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 (FlowSound -> [FlowSound])
-> (String -> FlowSound) -> String -> [FlowSound]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
secondConv Array Int (Int8, FlowSound)
tup14 (FlowSound -> FlowSound)
-> (String -> FlowSound) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Char, Int8) -> String -> FlowSound
filterUkr Array Int (Char, Int8)
tup13 (String -> FlowSound) -> (String -> String) -> String -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Char, Bool) -> String -> String
changeIotated Array Int (Char, Bool)
tup16 (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
filter (\Char
x -> Array Int (Char, Bool) -> Char -> Bool
isUkrainianLTup Array Int (Char, Bool)
tup15 Char
x Bool -> Bool -> Bool
|| Char -> Bool
isSpace Char
x Bool -> Bool -> Bool
|| Char -> Bool
isControl Char
x Bool -> Bool -> Bool
|| Char -> Bool
isPunctuation Char
x) (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower

changeIotated :: Array Int (Char,Bool) -> String -> String
changeIotated :: Array Int (Char, Bool) -> String -> String
changeIotated !Array Int (Char, Bool)
tup16 (Char
x:Char
y:String
zs)
  | (Char
y Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"\1102\1103\1108\1110"::String)) Bool -> Bool -> Bool
&& Array Int (Char, Bool) -> Char -> Bool
isConsNotJTup Array Int (Char, Bool)
tup16 Char
x = Char
xChar -> String -> String
forall a. a -> [a] -> [a]
:Char
'\1100'Char -> String -> String
forall a. a -> [a] -> [a]
:(case Char
y of { Char
'\1102' -> Char
'\1091' ; Char
'\1103' -> Char
'\1072' ; Char
'\1108' -> Char
'\1077' ; ~Char
r -> Char
'\1110' })Char -> String -> String
forall a. a -> [a] -> [a]
:Array Int (Char, Bool) -> String -> String
changeIotated Array Int (Char, Bool)
tup16 String
zs
  | Bool
otherwise = Char
xChar -> String -> String
forall a. a -> [a] -> [a]
:Array Int (Char, Bool) -> String -> String
changeIotated Array Int (Char, Bool)
tup16 (Char
yChar -> String -> String
forall a. a -> [a] -> [a]
:String
zs)
changeIotated Array Int (Char, Bool)
_ String
xs = String
xs

filterUkr :: Array Int (Char,Int8) -> String -> FlowSound
filterUkr :: Array Int (Char, Int8) -> String -> FlowSound
filterUkr Array Int (Char, Int8)
tup13 = let !tup :: (Int8, Array Int (Char, Int8))
tup = (Int8
0, Array Int (Char, Int8)
tup13) in (Char -> Int8) -> String -> FlowSound
forall a b. (a -> b) -> [a] -> [b]
map ((Int8, Array Int (Char, Int8)) -> Char -> Int8
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Int8, Array Int (Char, Int8))
tup)

secondConv :: Array Int (Int8,[Int8]) -> FlowSound -> FlowSound
secondConv :: Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
secondConv Array Int (Int8, FlowSound)
tup14 = (Int8 -> FlowSound) -> FlowSound -> FlowSound
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Int8
y -> (FlowSound, Array Int (Int8, FlowSound)) -> Int8 -> FlowSound
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' ([Int8
y], Array Int (Int8, FlowSound)
tup14) Int8
y)

createTuplesByAnalysis :: Array Int (Int8,Bool) -> Array Int (Int8,Bool) -> Array Int (Int8,Bool) -> Array Int (Int8,Bool) -> Array Int ([Int8],Bool) -> FlowSound -> [FlowSound]
createTuplesByAnalysis :: Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
createTuplesByAnalysis Array Int (Int8, Bool)
tup1 Array Int (Int8, Bool)
tup2 Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 x :: FlowSound
x@(Int8
h:FlowSound
ta)
  | (Bool, Array Int (Int8, Bool)) -> Int8 -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (Int8, Bool)
tup1) Int8
h = Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
x
  | Bool -> Bool
not (FlowSound -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null FlowSound
ta) Bool -> Bool -> Bool
&& (FlowSound -> Int8
forall a. [a] -> a
head FlowSound
ta Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
27 Bool -> Bool -> Bool
&& (Bool, Array Int (Int8, Bool)) -> Int8 -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (Int8, Bool)
tup2) Int8
h) = [Int8
h]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:[Int8
7]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
createTuplesByAnalysis Array Int (Int8, Bool)
tup1 Array Int (Int8, Bool)
tup2 Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 (Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
drop Int
1 FlowSound
ta)
  | Bool
otherwise = [Int8
h]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
createTuplesByAnalysis Array Int (Int8, Bool)
tup1 Array Int (Int8, Bool)
tup2 Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
ta
createTuplesByAnalysis Array Int (Int8, Bool)
_ Array Int (Int8, Bool)
_ Array Int (Int8, Bool)
_ Array Int (Int8, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = []

initialA :: Array Int (Int8,Bool) -> Array Int (Int8,Bool) -> Array Int ([Int8],Bool) -> FlowSound -> [FlowSound]
initialA :: Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 t1 :: FlowSound
t1@(Int8
t:FlowSound
ts)
  | Int8
t Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
1 = [Int8
0]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
ts
  | (Bool, Array Int (Int8, Bool)) -> Int8 -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
True, Array Int (Int8, Bool)
tup3) Int8
t = [Int8
t]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
ts
  | (Bool, Array Int (Int8, Bool)) -> Int8 -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (Int8, Bool)
tup4) Int8
t =
     let (FlowSound
us,FlowSound
vs) = Int -> FlowSound -> (FlowSound, FlowSound)
forall a. Int -> [a] -> ([a], [a])
splitAt Int
2 FlowSound
t1 in
       if (Bool, Array Int (FlowSound, Bool)) -> FlowSound -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (FlowSound, Bool)
tup5) FlowSound
us
        then FlowSound
usFlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
vs
        else [Int8
t]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
ts
  | Bool
otherwise = [Int8
t]FlowSound -> [FlowSound] -> [FlowSound]
forall a. a -> [a] -> [a]
:Array Int (Int8, Bool)
-> Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> [FlowSound]
initialA Array Int (Int8, Bool)
tup3 Array Int (Int8, Bool)
tup4 Array Int (FlowSound, Bool)
tup5 FlowSound
ts
initialA Array Int (Int8, Bool)
_ Array Int (Int8, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = []


bsToCharUkr :: Array Int ([Int8],Int8) -> [FlowSound] -> FlowSound
bsToCharUkr :: Array Int (FlowSound, Int8) -> [FlowSound] -> FlowSound
bsToCharUkr Array Int (FlowSound, Int8)
tup6 zs :: [FlowSound]
zs@(FlowSound
_:[FlowSound]
_) = (FlowSound -> Int8) -> [FlowSound] -> FlowSound
forall a b. (a -> b) -> [a] -> [b]
map (Array Int (FlowSound, Int8) -> FlowSound -> Int8
forall p. (Ord p, Num p) => Array Int ([p], p) -> [p] -> p
g Array Int (FlowSound, Int8)
tup6) [FlowSound]
zs
     where g :: Array Int ([p], p) -> [p] -> p
g Array Int ([p], p)
tup6 ts :: [p]
ts@(p
t:[p]
_) = (p, Array Int ([p], p)) -> [p] -> p
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (p
t, Array Int ([p], p)
tup6) [p]
ts
           g Array Int ([p], p)
_ [p]
_ = -p
1
bsToCharUkr Array Int (FlowSound, Int8)
_ [FlowSound]
_ = []

applyChanges
  :: Array Int (Int8,FlowSound -> Sound8)
  -> FlowSound
  -> FlowSound
applyChanges :: Array Int (Int8, FlowSound -> Int8) -> FlowSound -> FlowSound
applyChanges Array Int (Int8, FlowSound -> Int8)
tup7 FlowSound
ys = (Int8 -> FlowSound -> FlowSound)
-> FlowSound -> FlowSound -> FlowSound
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int8 -> FlowSound -> FlowSound
f FlowSound
forall a. [a]
v FlowSound
ys
  where v :: [a]
v = []
        f :: Int8 -> FlowSound -> FlowSound
f Int8
x xs :: FlowSound
xs@(Int8
_:FlowSound
_) = (FlowSound -> Int8, Array Int (Int8, FlowSound -> Int8))
-> Int8 -> FlowSound -> Int8
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (\FlowSound
_ -> Int8
x, Array Int (Int8, FlowSound -> Int8)
tup7) Int8
x FlowSound
xsInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound
xs
        f Int8
x FlowSound
_ = [Int8
x]

isVoicedObstruent :: FlowSound -> Bool
isVoicedObstruent :: FlowSound -> Bool
isVoicedObstruent (Int8
x:FlowSound
_) = Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
> Int8
7 Bool -> Bool -> Bool
&& Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
27
isVoicedObstruent FlowSound
_ = Bool
False

isVoicedObstruentH :: Array Int (Int8,Bool) -> FlowSound -> Bool
isVoicedObstruentH :: Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (Int8
x:FlowSound
_) = (Bool, Array Int (Int8, Bool)) -> Int8 -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (Int8, Bool)
tup8) Int8
x
isVoicedObstruentH Array Int (Int8, Bool)
_ FlowSound
_ = Bool
False

isVoicedObstruentS :: FlowSound -> Bool
isVoicedObstruentS :: FlowSound -> Bool
isVoicedObstruentS (Int8
x:FlowSound
_) = Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
> Int8
11 Bool -> Bool -> Bool
&& Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
15
isVoicedObstruentS FlowSound
_ = Bool
False

isSoftDOrL :: Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Bool
isSoftDOrL :: Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDOrL Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 FlowSound
xs = (Bool, Array Int (FlowSound, Bool)) -> FlowSound -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (FlowSound, Bool)
tup9) (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
xs) Bool -> Bool -> Bool
|| (Bool, Array Int (FlowSound, Bool)) -> FlowSound -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (FlowSound, Bool)
tup10) (Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
xs)

isSoftDen :: Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Bool
isSoftDen :: Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDen Array Int (FlowSound, Bool)
tup11 Array Int (FlowSound, Bool)
tup10 FlowSound
xs = (Bool, Array Int (FlowSound, Bool)) -> FlowSound -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (FlowSound, Bool)
tup11) (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
xs) Bool -> Bool -> Bool
|| (Bool, Array Int (FlowSound, Bool)) -> FlowSound -> Bool
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' (Bool
False, Array Int (FlowSound, Bool)
tup10) (Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
xs)

гT :: FlowSound -> Sound8
гT :: FlowSound -> Int8
гT (Int8
t:FlowSound
_) | Int8
t Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
45 Bool -> Bool -> Bool
|| Int8
t Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
50 = Int8
52 -- г х
         | Bool
otherwise = Int8
21
гT FlowSound
_ = Int8
21

дT :: FlowSound -> Sound8
дT :: FlowSound -> Int8
дT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
10],[Int8
39],[Int8
41]] = Int8
23 --  д дж
            | Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49,Int8
7],[Int8
38,Int8
7]] = Int8
12 --  д дзь
            | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
54],[Int8
66]] = Int8
12 --  д дзь
            | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
25],[Int8
49],[Int8
38]] = Int8
8 --   д дз
            | Bool
otherwise = Int8
17
дT FlowSound
_ = Int8
17

дзT :: Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Sound8
дзT :: Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Int8
дзT Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDOrL Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 FlowSound
t1 = Int8
12 -- дз дзь
                        | Bool
otherwise = Int8
8
дзT Array Int (FlowSound, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = Int8
8

жT :: FlowSound -> Sound8
жT :: FlowSound -> Int8
жT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT Int
2 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49,Int8
7],[Int8
38,Int8
7]] = Int8
13  -- ж зь
            | Int -> FlowSound -> FlowSound
takeFromFT Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
54],[Int8
66]] = Int8
13
            | Bool
otherwise = Int8
10
жT FlowSound
_ = Int8
10

зT :: Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Sound8
зT :: Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Int8
зT Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
10],[Int8
39],[Int8
41]] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
17,Int8
10] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
23] = Int8
10  -- з ж
                       | Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDOrL Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 FlowSound
t1 = Int8
13        -- з зь
                       | Int -> FlowSound -> FlowSound
takeFromFT Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
39],[Int8
41]] = Int8
41 --  з ш
                       | Int -> FlowSound -> FlowSound
takeFromFT Int
1 FlowSound
t1  FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49],[Int8
38]] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
45],[Int8
47],[Int8
50],[Int8
43],[Int8
52]] = Int8
49 --  з с
                       | Bool
otherwise = Int8
25
зT Array Int (FlowSound, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = Int8
25

кT :: FlowSound -> Sound8
кT :: FlowSound -> Int8
кT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
19
            | Bool
otherwise = Int8
45
кT FlowSound
_ = Int8
45

нтT :: FlowSound -> Sound8
нтT :: FlowSound -> Int8
нтT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT Int
2 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
49,Int8
50] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
63] = Int8
32
             | Int -> FlowSound -> FlowSound
takeFromFT Int
3 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
49,Int8
7,Int8
45] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT Int
2 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
54,Int8
45] = Int8
65
             | Bool
otherwise = Int8
62
нтT FlowSound
_ = Int8
62

пT :: FlowSound -> Sound8
пT :: FlowSound -> Int8
пT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
15
            | Bool
otherwise = Int8
47
пT FlowSound
_ = Int8
47

сT :: Array Int (Int8,Bool) -> Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Sound8
сT :: Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
сT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 t1 :: FlowSound
t1@(Int8
_:FlowSound
_)
  | ((Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1) Bool -> Bool -> Bool
&& Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1) FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
7]) Bool -> Bool -> Bool
||
      FlowSound -> Bool
isVoicedObstruentS (Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1) = Int8
13
  | Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
25
  | Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDOrL Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 FlowSound
t1 = Int8
54
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
41] = Int8
41
  | Bool
otherwise = Int8
49
сT Array Int (Int8, Bool)
_ Array Int (FlowSound, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = Int8
49

стT :: FlowSound -> Sound8
стT :: FlowSound -> Int8
стT t1 :: FlowSound
t1@(Int8
_:FlowSound
_)
  | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1  = Int8
25
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
3 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
49,Int8
7,Int8
45] Bool -> Bool -> Bool
|| (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
54,Int8
45],[Int8
38,Int8
7]]) Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
66] = Int8
54
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49],[Int8
32]] = Int8
49
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
39] = Int8
41
  | Bool
otherwise = Int8
63
стT FlowSound
_ = Int8
63

сьT :: FlowSound -> Sound8
сьT :: FlowSound -> Int8
сьT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
13
             | Bool
otherwise = Int8
54
сьT FlowSound
_ = Int8
54

тT :: Array Int (Int8,Bool) -> Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Sound8
тT :: Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
тT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup11 Array Int (FlowSound, Bool)
tup10 t1 :: FlowSound
t1@(Int8
_:FlowSound
_)
  | ((Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1) Bool -> Bool -> Bool
&& Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1) FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
7]) Bool -> Bool -> Bool
||
       FlowSound -> Bool
isVoicedObstruentS (Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1) = Int8
14
  | Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
17
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
38,Int8
7] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
66]  = Int8
66
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
38] = Int8
38
  | Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDen Array Int (FlowSound, Bool)
tup11 Array Int (FlowSound, Bool)
tup10 FlowSound
t1 = Int8
64
  | Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
39],[Int8
41]] = Int8
39
  | Bool
otherwise = Int8
50
тT Array Int (Int8, Bool)
_ Array Int (FlowSound, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = Int8
50

тьT :: FlowSound -> Sound8
тьT :: FlowSound -> Int8
тьT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
14
             | Int -> FlowSound -> FlowSound
takeFromFT_ Int
3 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
49,Int8
7,Int8
1] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
54,Int8
1] = Int8
66
             | Bool
otherwise = Int8
64
тьT FlowSound
_ = Int8
64

фT :: FlowSound -> Sound8
фT :: FlowSound -> Int8
фT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
36
            | Bool
otherwise = Int8
43
фT FlowSound
_ = Int8
43

хT :: FlowSound -> Sound8
хT :: FlowSound -> Int8
хT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
21
            | Bool
otherwise = Int8
52
хT FlowSound
_ = Int8
52

цT :: Array Int (Int8,Bool) -> Array Int ([Int8],Bool) -> Array Int ([Int8],Bool) -> FlowSound -> Sound8
цT :: Array Int (Int8, Bool)
-> Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool)
-> FlowSound
-> Int8
цT Array Int (Int8, Bool)
tup8 Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 t1 :: FlowSound
t1@(Int8
_:FlowSound
_)
  | ((Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1) Bool -> Bool -> Bool
&& Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1) FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
7]) Bool -> Bool -> Bool
||
      FlowSound -> Bool
isVoicedObstruentS (Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1) = Int8
12
  | Array Int (FlowSound, Bool)
-> Array Int (FlowSound, Bool) -> FlowSound -> Bool
isSoftDOrL Array Int (FlowSound, Bool)
tup9 Array Int (FlowSound, Bool)
tup10 FlowSound
t1 = Int8
66
  | Array Int (Int8, Bool) -> FlowSound -> Bool
isVoicedObstruentH Array Int (Int8, Bool)
tup8 (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
8
  | Bool
otherwise = Int8
38
цT Array Int (Int8, Bool)
_ Array Int (FlowSound, Bool)
_ Array Int (FlowSound, Bool)
_ FlowSound
_ = Int8
38

цьT :: FlowSound -> Sound8
цьT :: FlowSound -> Int8
цьT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | (FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1) Bool -> Bool -> Bool
&& Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
drop Int
1 (Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1) FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
7] = Int8
12
             | Bool
otherwise = Int8
66
цьT FlowSound
_ = Int8
66

чT :: FlowSound -> Sound8
чT :: FlowSound -> Int8
чT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49,Int8
7],[Int8
38,Int8
7]] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
54],[Int8
66]] = Int8
66
            | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
23
            | Bool
otherwise = Int8
39
чT FlowSound
_ = Int8
39

шT :: FlowSound -> Sound8
шT :: FlowSound -> Int8
шT t1 :: FlowSound
t1@(Int8
_:FlowSound
_) | Int -> FlowSound -> FlowSound
takeFromFT_ Int
2 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
49,Int8
7],[Int8
38,Int8
7]] Bool -> Bool -> Bool
|| Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 FlowSound
t1 FlowSound -> [FlowSound] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Int8
54],[Int8
66]] = Int8
54
            | FlowSound -> Bool
isVoicedObstruent (FlowSound -> Bool)
-> (FlowSound -> FlowSound) -> FlowSound -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  Int -> FlowSound -> FlowSound
takeFromFT_ Int
1 (FlowSound -> Bool) -> FlowSound -> Bool
forall a b. (a -> b) -> a -> b
$ FlowSound
t1 = Int8
10
            | Bool
otherwise = Int8
41
шT FlowSound
_ = Int8
41

takeFromFT :: Int -> FlowSound -> FlowSound
takeFromFT :: Int -> FlowSound -> FlowSound
takeFromFT Int
n FlowSound
ts | if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 then Bool
True else FlowSound -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null FlowSound
ts = []
                | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2 = [Int8
k]
                | Bool
otherwise = Int8
k Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
: Int -> FlowSound -> FlowSound
takeFromFT (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
take (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) FlowSound
ts)
    where k :: Int8
k = FlowSound -> Int8
forall a. [a] -> a
head FlowSound
ts

takeFromFT2 :: Int -> FlowSound -> FlowSound
takeFromFT2 :: Int -> FlowSound -> FlowSound
takeFromFT2 Int
n FlowSound
ts | if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 then Bool
True else FlowSound -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null FlowSound
ts = []
                 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2 = [Int8
ks]
                 | Bool
otherwise = Int8
ksInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int -> FlowSound -> FlowSound
takeFromFT2 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (FlowSound -> FlowSound
forall a. [a] -> [a]
tail FlowSound
ts)
    where ks :: Int8
ks = FlowSound -> Int8
forall a. [a] -> a
head FlowSound
ts

dropFromFT2 :: Int -> FlowSound -> FlowSound
dropFromFT2 :: Int -> FlowSound -> FlowSound
dropFromFT2 Int
n FlowSound
ts | if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 then Bool
True else FlowSound -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null FlowSound
ts = []
                 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2 = FlowSound -> FlowSound
forall a. [a] -> [a]
tail FlowSound
ts
                 | Bool
otherwise = Int -> FlowSound -> FlowSound
dropFromFT2 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (FlowSound -> FlowSound
forall a. [a] -> [a]
tail FlowSound
ts)

takeFromFT_ :: Int -> FlowSound -> FlowSound
takeFromFT_ :: Int -> FlowSound -> FlowSound
takeFromFT_ Int
n = Int -> FlowSound -> FlowSound
takeFromFT Int
n (FlowSound -> FlowSound)
-> (FlowSound -> FlowSound) -> FlowSound -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int8 -> Bool) -> FlowSound -> FlowSound
forall a. (a -> Bool) -> [a] -> [a]
filter (Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
>Int8
0)

correctA :: Array Int (Int8,[Int8]) -> FlowSound -> FlowSound
correctA :: Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
correctA Array Int (Int8, FlowSound)
tup12 = FlowSound -> FlowSound
correctSomeW (FlowSound -> FlowSound)
-> (FlowSound -> FlowSound) -> FlowSound -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
separateSoftS Array Int (Int8, FlowSound)
tup12

separateSoftS :: Array Int (Int8,[Int8]) -> FlowSound -> FlowSound
separateSoftS :: Array Int (Int8, FlowSound) -> FlowSound -> FlowSound
separateSoftS Array Int (Int8, FlowSound)
tup12 = (Int8 -> FlowSound) -> FlowSound -> FlowSound
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Int8
x -> (FlowSound, Array Int (Int8, FlowSound)) -> Int8 -> FlowSound
forall a b. Ord a => (b, Array Int (a, b)) -> a -> b
getBFst' ([Int8
x], Array Int (Int8, FlowSound)
tup12) Int8
x)

correctSomeW :: FlowSound -> FlowSound
correctSomeW :: FlowSound -> FlowSound
correctSomeW (Int8
x:Int8
y:Int8
z:xs :: FlowSound
xs@(Int8
t:FlowSound
ys))
 | Int8
x Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
50 Bool -> Bool -> Bool
&& Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
7 Bool -> Bool -> Bool
&& Int8
z Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
54 Bool -> Bool -> Bool
&& Int8
t Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
1 = Int8
66Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
66Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
1Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound -> FlowSound
correctSomeW FlowSound
ys
 | (Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
1) Bool -> Bool -> Bool
&& Int8
y Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
27 Bool -> Bool -> Bool
&& Int8
z Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
1 =
  if Int -> FlowSound -> FlowSound
forall a. Int -> [a] -> [a]
take Int
2 FlowSound
xs FlowSound -> FlowSound -> Bool
forall a. Eq a => a -> a -> Bool
== [Int8
39,Int8
32]
    then Int8
xInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
yInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
zInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
41Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound -> FlowSound
correctSomeW FlowSound
ys
    else Int8
xInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound -> FlowSound
correctSomeW (Int8
yInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
zInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound
xs)
                        | Bool
otherwise = Int8
xInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound -> FlowSound
correctSomeW (Int8
yInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:Int8
zInt8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound
xs)
correctSomeW FlowSound
zs = FlowSound
zs

correctB :: FlowSound -> FlowSound
correctB :: FlowSound -> FlowSound
correctB ys :: FlowSound
ys@(Int8
x:FlowSound
xs)
  | (FlowSound -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (FlowSound -> Int) -> (FlowSound -> FlowSound) -> FlowSound -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int8 -> Bool) -> FlowSound -> FlowSound
forall a. (a -> Bool) -> [a] -> [a]
filter (Int8 -> Int8 -> Bool
forall a. Eq a => a -> a -> Bool
== Int8
0) (FlowSound -> FlowSound)
-> (FlowSound -> FlowSound) -> FlowSound -> FlowSound
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> FlowSound -> FlowSound
takeFromFT2 Int
6 (FlowSound -> Int) -> FlowSound -> Int
forall a b. (a -> b) -> a -> b
$ FlowSound
ys) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 = (Int8 -> Int8) -> FlowSound -> FlowSound
forall a b. (a -> b) -> [a] -> [b]
map (\Int8
t -> if Int8
t Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int8
0 then -Int8
1 else Int8
t) (Int -> FlowSound -> FlowSound
takeFromFT2 Int
6 FlowSound
ys) FlowSound -> FlowSound -> FlowSound
forall a. [a] -> [a] -> [a]
++ FlowSound -> FlowSound
correctB (Int -> FlowSound -> FlowSound
dropFromFT2 Int
6 FlowSound
ys)
  | Bool
otherwise = (if Int8
x Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
0 then -Int8
1 else Int8
x)Int8 -> FlowSound -> FlowSound
forall a. a -> [a] -> [a]
:FlowSound -> FlowSound
correctB FlowSound
xs
correctB FlowSound
_ = []

-- | Can be used to map the 'Sound8' representation and the mmsyn6ukr-array files with some recordings.
linkFileNameI8 :: Sound8 -> Char
linkFileNameI8 :: Int8 -> Char
linkFileNameI8 Int8
x = Char -> [(Int8, Char)] -> Int8 -> Char
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted' Char
'0' ([(Int8
1,Char
'A'),(Int8
2,Char
'H'),(Int8
3,Char
'Q'),(Int8
4,Char
'W'),(Int8
5,Char
'K'),(Int8
6,Char
'e'),(Int8
7,Char
'd'),(Int8
8,Char
'G'),(Int8
10,Char
'I'),(Int8
15,Char
'B'),
  (Int8
17,Char
'E'),(Int8
19,Char
'f'),(Int8
21,Char
'D'),(Int8
23,Char
'F'),(Int8
25,Char
'J'),(Int8
27,Char
'L'),(Int8
28,Char
'N'),(Int8
30,Char
'O'),(Int8
32,Char
'P'),(Int8
34,Char
'S'),(Int8
36,Char
'C'),(Int8
38,Char
'Z'),(Int8
39,Char
'b'),
    (Int8
41,Char
'c'),(Int8
43,Char
'X'),(Int8
45,Char
'M'),(Int8
47,Char
'R'),(Int8
49,Char
'T'),(Int8
50,Char
'V'),(Int8
52,Char
'Y'),(Int8
54,Char
'U'),(Int8
60,Char
'0'),(Int8
61,Char
'0'),(Int8
66,Char
'a')]) Int8
x