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

{- |
Module      :  Aftovolio.Ukrainian.PrepareText
Copyright   :  (c) OleksandrZhabenko 2020-2024
License     :  MIT
Stability   :  Experimental
Maintainer  :  oleksandr.zhabenko@yahoo.com

Earlier it has been a module DobutokO.Poetry.Ukrainian.PrepareText
from the @dobutokO-poetry@ package.
In particular, this module can be used to prepare the Ukrainian text
by applying the most needed grammar for AFTOVolio to avoid misunderstanding
for the produced text. The attention is paid to the prepositions, pronouns, conjunctions
and particles that are most commonly connected (or not) in a significant way
with the next text.
Uses the information from:
https://uk.wikipedia.org/wiki/%D0%A1%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%BD%D0%B8%D0%BA
and
https://uk.wikipedia.org/wiki/%D0%A7%D0%B0%D1%81%D1%82%D0%BA%D0%B0_(%D0%BC%D0%BE%D0%B2%D0%BE%D0%B7%D0%BD%D0%B0%D0%B2%D1%81%D1%82%D0%B2%D0%BE)

Uses arrays instead of vectors.
-}
module Aftovolio.Ukrainian.PrepareText (
    -- * Basic functions
    complexWords,
    participleConc,
    splitLines,
    splitLinesN,
    auxiliary1,
    isPreposition,
    isParticipleAppended,
    isPrepended,
    isConcatenated,
    isSpC,
    isUkrainianL,
    concatenated2,
    jottedConv,
    jottedCnv,

    -- * The end-user functions
    prepareText,
    prepareTextN,
    prepareTextN2,
    prepareTextN3,
    prepareTextNG,
    growLinesN,
    prepareGrowTextMN,
    prepareGrowTextMNG,
    tuneLinesN,
    prepareTuneTextMN,
    prepareTuneTextMNG,

    -- * Used to transform after convertToProperUkrainian from mmsyn6ukr package
    aux4,
) where

import CaseBi.Arr (getBFstLSorted')
import Data.Bits (shiftR)
import Data.Char (isAlpha, isDigit, toLower)
import Data.IntermediateStructures1 (mapI)
import Data.List
import GHC.Arr
import GHC.Base
import GHC.Num ((+))

{- | Is used to convert a Ukrainian text into list of 'String' each of which is ready to be
used by the functions of the modules for the phonetic languages approach.
It applies minimal grammar links and connections between the most commonly used Ukrainian
words that \"should\" be paired and not dealt with separately
to avoid the misinterpretation and preserve maximum of the semantics for the
\"phonetic\" language on the Ukrainian basis.
-}
prepareText :: String -> [String]
prepareText :: String -> [String]
prepareText = Int -> String -> [String]
prepareTextN Int
7
{-# INLINE prepareText #-}

{- | Concatenates complex words in Ukrainian so that they are not separated further by possible words order rearrangements (because they are treated
as a single word). This is needed to preserve basic grammar in phonetic languages.
-}
complexWords :: [String] -> [String]
complexWords :: [String] -> [String]
complexWords wwss :: [String]
wwss@(String
xs : String
ys : String
zs : String
ts : [String]
xss) =
    [String] -> [(String, [String])] -> String -> [String]
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
        (String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
complexWords (String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss))
        ( [
              ( String
"\1074"
              , if String
ys
                    String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1084\1110\1088\1091"
                    Bool -> Bool -> Bool
&& String
zs
                    String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1086\1075\1086"
                    Bool -> Bool -> Bool
&& String
ts
                    String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ts) [String]
xss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1076\1072\1088\1084\1072"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1076\1083\1103"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1086\1075\1086" Bool -> Bool -> Bool
&& String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086\1073"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ts) [String]
xss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1079"
              , case String
ys of
                    String
"\1090\1080\1084" ->
                        if String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086\1073"
                            then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                            else [String] -> [String]
auxiliary4 [String]
wwss
                    String
"\1090\1086\1075\1086" ->
                        if String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1095\1072\1089\1091" Bool -> Bool -> Bool
&& String
ts String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                            then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
"\1081\1072\1082") [String]
xss
                            else [String] -> [String]
auxiliary4 [String]
wwss
                    String
_ -> [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1079\1072\1083\1077\1078\1085\1086"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1074\1110\1076" then [String] -> [String]
auxiliary3 [String]
wwss else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1079\1072\1084\1110\1089\1090\1100"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1086\1075\1086" Bool -> Bool -> Bool
&& String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086\1073"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1087\1086\1087\1088\1080"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1077" Bool -> Bool -> Bool
&& String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1085\1077\1079\1072\1083\1077\1078\1085\1086"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1074\1110\1076" then [String] -> [String]
auxiliary3 [String]
wwss else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1085\1077\1079\1074\1072\1078\1072\1102\1095\1080"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1085\1072"
                    then
                        if String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1077" Bool -> Bool -> Bool
&& String
ts String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086"
                            then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ts) [String]
xss
                            else [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1087\1088\1080"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100\1086\1084\1091"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1087\1110\1089\1083\1103"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1086\1075\1086" Bool -> Bool -> Bool
&& String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1072\1082"
              , if (String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086") Bool -> Bool -> Bool
|| (String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082")
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1080\1084\1095\1072\1089\1086\1084"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1086\1084\1091"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
"\1081\1072\1082") (String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1091"
              , if ( String
ys
                        String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1079\1074'\1103\1079\1082\1091"
                        Bool -> Bool -> Bool
|| String
ys
                        String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1079\1074\x02BC\1103\1079\1082\1091"
                   )
                    Bool -> Bool -> Bool
&& String
zs
                    String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1079"
                    then
                        String -> [String] -> [String]
auxiliary2Inner
                            (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
"\1079\1074\1081\1072\1079\1082\1091" String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs)
                            (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else
                        if String
ys
                            String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1084\1110\1088\1091"
                            Bool -> Bool -> Bool
&& String
zs
                            String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1086\1075\1086"
                            Bool -> Bool -> Bool
&& String
ts
                            String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                            then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ts) [String]
xss
                            else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1093\1086\1095"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1073\1080"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1093\1086\1095\1072"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1073"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1095\1077\1088\1077\1079"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1090\1077" Bool -> Bool -> Bool
&& String
zs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) (String
ts String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ]
        )
        String
xs
complexWords wwss :: [String]
wwss@(String
xs : String
ys : String
zs : [String]
xss) =
    [String] -> [(String, [String])] -> String -> [String]
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
        (String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
complexWords [String
ys, String
zs])
        ( [
              ( String
"\1076\1072\1088\1084\1072"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1079\1072\1083\1077\1078\1085\1086"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1074\1110\1076" then [String] -> [String]
auxiliary3 [String]
wwss else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1085\1077\1079\1072\1083\1077\1078\1085\1086"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1074\1110\1076" then [String] -> [String]
auxiliary3 [String]
wwss else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1087\1088\1080"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100\1086\1084\1091"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1072\1082"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086" Bool -> Bool -> Bool
|| String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1080\1084\1095\1072\1089\1086\1084"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1090\1086\1084\1091"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1103\1082"
                    then String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
"\1081\1072\1082") (String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1093\1086\1095"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1073\1080"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ,
              ( String
"\1093\1086\1095\1072"
              , if String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1073"
                    then [String] -> [String]
auxiliary3 [String]
wwss
                    else [String] -> [String]
auxiliary4 [String]
wwss
              )
          ]
        )
        String
xs
complexWords [String
xs, String
ys]
    | String
ys String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1073", String
"\1073\1060", String
"\1078\1077", String
"\1078"] = [String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys]
    | String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1076\1072\1088\1084\1072" Bool -> Bool -> Bool
&& String
ys String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1097\1086" = [String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys]
    | Bool
otherwise = [String
xs, String
ys]
complexWords [String]
xss = [String]
xss

auxiliary2Inner :: String -> [String] -> [String]
auxiliary2Inner :: String -> [String] -> [String]
auxiliary2Inner String
ts (String
xs : String
ys : [String]
xss)
    | ([String] -> [String]
concatenated2 ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
auxiliary1 ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [String
xs, String
ys]) [String] -> [String] -> Bool
forall a. Eq a => a -> a -> Bool
/= [String
xs, String
ys] =
        let ([String]
rs, [String]
ws) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
1 ([String] -> [String]
concatenated2 ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
auxiliary1 ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [String
xs, String
ys])
         in (String
ts String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` [String] -> String
forall a. HasCallStack => [a] -> a
head [String]
rs) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
complexWords ([[String]] -> [String]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[String]
ws, [String]
xss])
    | Bool
otherwise = (String
ts String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
xs) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
complexWords (String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
auxiliary2Inner String
ts [String
xs] = [String
ts String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
xs]
auxiliary2Inner String
ts [String]
_ = [String
ts]

auxiliary3 :: [String] -> [String]
auxiliary3 :: [String] -> [String]
auxiliary3 (String
xs : String
ys : [String]
xss) = String -> [String] -> [String]
auxiliary2Inner (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys) [String]
xss
auxiliary3 [String]
xss = [String]
xss
{-# INLINE auxiliary3 #-}

auxiliary4 :: [String] -> [String]
auxiliary4 :: [String] -> [String]
auxiliary4 (String
xs : [String]
xss) = String -> [String] -> [String]
auxiliary2Inner String
xs [String]
xss
auxiliary4 [String]
xss = [String]
xss
{-# INLINE auxiliary4 #-}

-- | Since 0.2.1.0 version the function is recursive and is applied so that all returned elements ('String') are no longer than 7 words in them.
splitLines :: [String] -> [String]
splitLines :: [String] -> [String]
splitLines = Int -> [String] -> [String]
splitLinesN Int
7
{-# INLINE splitLines #-}

-- | A generalized variant of the 'splitLines' with the arbitrary maximum number of the words in the lines given as the first argument.
splitLinesN :: Int -> [String] -> [String]
splitLinesN :: Int -> [String] -> [String]
splitLinesN Int
n [String]
xss
    | [String] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
xss Bool -> Bool -> Bool
|| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = []
    | Bool
otherwise =
        (String -> Bool) -> (String -> [String]) -> [String] -> [String]
forall a. (a -> Bool) -> (a -> [a]) -> [a] -> [a]
mapI
            (\String
xs -> Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([String] -> Int
forall a. [a] -> 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 -> [String]
words (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
xs) Int
n Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT)
            ( \String
xs ->
                let yss :: [String]
yss = String -> [String]
words String
xs
                 in [String] -> [String]
splitLines ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([String] -> String) -> [[String]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map [String] -> String
unwords ([[String]] -> [String])
-> ([String] -> [[String]]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\([String]
q, [String]
r) -> [[String]
q, [String]
r]) (([String], [String]) -> [[String]])
-> ([String] -> ([String], [String])) -> [String] -> [[String]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftR ([String] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
yss) Int
1) ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$
                        [String]
yss
            )
            ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [String]
xss

-- | A generalized variant of the 'prepareText' with the arbitrary maximum number of the words in the lines given as the first argument.
prepareTextN :: Int -> String -> [String]
prepareTextN :: Int -> String -> [String]
prepareTextN = (Char -> Bool) -> Int -> String -> [String]
prepareTextNG (\Char
t -> Char -> Bool
isAlpha Char
t Bool -> Bool -> Bool
|| Char -> Bool
isSpC Char
t)
{-# INLINE prepareTextN #-}

-- | A generalized variant of the 'prepareText' with the arbitrary maximum number of the words in the lines given as the first argument. The \'_\' is not filtered out.
prepareTextN2 :: Int -> String -> [String]
prepareTextN2 :: Int -> String -> [String]
prepareTextN2 = (Char -> Bool) -> Int -> String -> [String]
prepareTextNG (\Char
t -> Char -> Bool
isAlpha Char
t Bool -> Bool -> Bool
|| Char -> Bool
isSpC Char
t Bool -> Bool -> Bool
|| Char
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
t)
{-# INLINE prepareTextN2 #-}

-- | A generalized variant of the 'prepareText' with the arbitrary maximum number of the words in the lines given as the first argument. Both \'_\' and \'=\' are not filtered out.
prepareTextN3 :: Int -> String -> [String]
prepareTextN3 :: Int -> String -> [String]
prepareTextN3 =
    (Char -> Bool) -> Int -> String -> [String]
prepareTextNG (\Char
t -> Char -> Bool
isAlpha Char
t Bool -> Bool -> Bool
|| Char -> Bool
isSpC Char
t Bool -> Bool -> Bool
|| Char
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
t Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=' Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
t)
{-# INLINE prepareTextN3 #-}

-- | An even more generalized variant of the 'prepareTextN' with the arbitrary maximum number of the words in the lines given as the second argument and the possibility to provide custom function for filtering.
prepareTextNG ::
    -- | A predicate to filter the symbols during preparation.
    (Char -> Bool) ->
    Int ->
    String ->
    [String]
prepareTextNG :: (Char -> Bool) -> Int -> String -> [String]
prepareTextNG Char -> Bool
f Int
n =
    (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Char -> Bool
isUkrainianL)
        ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> [String]
splitLinesN Int
n
        ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map
            ( [String] -> String
unwords
                ([String] -> String) -> (String -> [String]) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
concatenated2
                ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
participleConc
                ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
auxiliary1
                ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
complexWords
                ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words
                (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 -> Bool
f
            )
        ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (String -> Bool) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null)
        ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
lines
{-# INLINE prepareTextNG #-}

participleConc :: [String] -> [String]
participleConc :: [String] -> [String]
participleConc (String
xs : String
ys : String
zs : [String]
yss)
    | String -> Bool
isParticipleAppended String
ys =
        if String -> Bool
isParticipleAppended String
zs
            then (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
zs) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
participleConc [String]
yss
            else [String] -> [String]
participleConc (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
yss)
    | Bool
otherwise = String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
participleConc (String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
yss)
participleConc (String
xs : String
ys : [String]
yss)
    | String -> Bool
isParticipleAppended String
ys = (String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String
ys) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
participleConc [String]
yss
    | Bool
otherwise = String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
participleConc (String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
yss)
participleConc [String]
yss = [String]
yss

isParticipleAppended :: String -> Bool
isParticipleAppended :: String -> Bool
isParticipleAppended String
xs = String
xs String -> [String] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"\1073", String
"\1073\1080", String
"\1078\1077", String
"\1078"]

isPrepended :: String -> Bool
isPrepended :: String -> Bool
isPrepended String
xs
    | String -> Bool
isParticipleAppended String
xs = Bool
True
    | String -> Bool
isPreposition String
xs = Bool
True
    | Bool
otherwise = String -> Bool
isConcatenated String
xs

jottedCnv :: String -> String
jottedCnv :: String -> String
jottedCnv String
xs = Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
1 (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
jottedConv (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ Char
' ' Char -> String -> String
forall a. a -> [a] -> [a]
: String
xs

auxiliary1 :: [String] -> [String]
auxiliary1 :: [String] -> [String]
auxiliary1 yss :: [String]
yss@(String
xs : String
zs : [String]
xss)
    | String -> Bool
isParticipleAppended String
xs = String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
auxiliary1 (String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
    | String -> Bool
isPreposition String
xs Bool -> Bool -> Bool
|| String -> Bool
isConcatenated String
xs =
        [String] -> [String]
auxiliary1 ((String -> String) -> [String] -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap String -> String
jottedCnv ([String]
tss [String] -> [String] -> [String]
forall a. Monoid a => a -> a -> a
`mappend` [String]
wss) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
vss)
    | Bool
otherwise = String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
auxiliary1 (String
zs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss)
  where
    ([String]
tss, [String]
uss) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span String -> Bool
isPrepended [String]
yss
    ([String]
wss, [String]
vss) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
1 [String]
uss
auxiliary1 [String]
xss = [String]
xss

isPreposition :: String -> Bool
isPreposition :: String -> Bool
isPreposition String
ts =
    Bool -> [(String, Bool)] -> String -> Bool
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
        Bool
False
        ( [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip
            [ String
"\1030\1079"
            , String
"\1041\1077\1079"
            , String
"\1041\1110\1083\1103"
            , String
"\1042"
            , String
"\1042\1110\1076"
            , String
"\1044\1083\1103"
            , String
"\1044\1086"
            , String
"\1047"
            , String
"\1047\1072"
            , String
"\1047\1072\1088\1072\1076\1080"
            , String
"\1047\1110"
            , String
"\1050"
            , String
"\1050\1086\1083\1086"
            , String
"\1050\1088\1110\1079\1100"
            , String
"\1050\1088\1110\1084"
            , String
"\1052\1077\1078"
            , String
"\1052\1077\1078\1080"
            , String
"\1052\1110\1078"
            , String
"\1053\1072"
            , String
"\1053\1072\1076"
            , String
"\1054"
            , String
"\1054\1073"
            , String
"\1054\1076"
            , String
"\1054\1082\1088\1110\1084"
            , String
"\1055\1077\1088\1077\1076"
            , String
"\1055\1086"
            , String
"\1055\1088\1080"
            , String
"\1055\1088\1086"
            , String
"\1055\1088\1086\1090\1080"
            , String
"\1055\1110\1076"
            , String
"\1055\1110\1089\1083\1103"
            , String
"\1057\1077\1088\1077\1076"
            , String
"\1057\1077\1088\1077\1076\1080"
            , String
"\1059"
            , String
"\1063\1077\1088\1077\1079"
            , String
"\1073\1077\1079"
            , String
"\1073\1110\1083\1103"
            , String
"\1074"
            , String
"\1074\1110\1076"
            , String
"\1076\1083\1103"
            , String
"\1076\1086"
            , String
"\1079"
            , String
"\1079\1072"
            , String
"\1079\1072\1088\1072\1076\1080"
            , String
"\1079\1110"
            , String
"\1082"
            , String
"\1082\1086\1083\1086"
            , String
"\1082\1088\1110\1079\1100"
            , String
"\1082\1088\1110\1084"
            , String
"\1084\1077\1078"
            , String
"\1084\1077\1078\1080"
            , String
"\1084\1110\1078"
            , String
"\1085\1072"
            , String
"\1085\1072\1076"
            , String
"\1086"
            , String
"\1086\1073"
            , String
"\1086\1076"
            , String
"\1086\1082\1088\1110\1084"
            , String
"\1087\1077\1088\1077\1076"
            , String
"\1087\1086"
            , String
"\1087\1088\1080"
            , String
"\1087\1088\1086"
            , String
"\1087\1088\1086\1090\1080"
            , String
"\1087\1110\1076"
            , String
"\1087\1110\1089\1083\1103"
            , String
"\1089\1077\1088\1077\1076"
            , String
"\1089\1077\1088\1077\1076\1080"
            , String
"\1091"
            , String
"\1095\1077\1088\1077\1079"
            , String
"\1110\1079"
            ]
            ([Bool] -> [(String, Bool)]) -> [Bool] -> [(String, Bool)]
forall a b. (a -> b) -> a -> b
$ Int -> Bool -> [Bool]
forall a. Int -> a -> [a]
replicate Int
200 Bool
True
        )
        String
ts
{-# INLINE isPreposition #-}

{- | Since the dobutokO-poetry version 0.16.3.0 the (||) operator has been changed to the (&&).
The idea is that these words are the ones that are pronouns and they \"should\" be treated
(by the author's understanding) as independent words.
-}
isConcatenated :: String -> Bool
isConcatenated :: String -> Bool
isConcatenated String
ts
    | String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ts = Bool
False
    | Bool
otherwise =
        Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
ts) Int
2
            Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT
            Bool -> Bool -> Bool
&& Bool -> [(String, Bool)] -> String -> Bool
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
                Bool
True
                ( [String] -> [Bool] -> [(String, Bool)]
forall a b. [a] -> [b] -> [(a, b)]
zip
                    [ String
"\1028"
                    , String
"\1042\1080"
                    , String
"\1052\1080"
                    , String
"\1058\1080"
                    , String
"\1058\1110"
                    , String
"\1062\1110"
                    , String
"\1071"
                    , String
"\1074\1080"
                    , String
"\1084\1080"
                    , String
"\1090\1080"
                    , String
"\1090\1110"
                    , String
"\1094\1110"
                    , String
"\1103"
                    , String
"\1108"
                    ]
                    ([Bool] -> [(String, Bool)]) -> [Bool] -> [(String, Bool)]
forall a b. (a -> b) -> a -> b
$ Int -> Bool -> [Bool]
forall a. Int -> a -> [a]
replicate Int
14 Bool
False
                )
                String
ts
            Bool -> Bool -> Bool
&& (String -> Char
forall a. HasCallStack => [a] -> a
head String
ts Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` String
"\1031\1111")
{-# INLINE isConcatenated #-}

concatenated2 :: [String] -> [String]
concatenated2 :: [String] -> [String]
concatenated2 (String
xs : String
ys : [String]
xss) =
    [String] -> [(String, [String])] -> String -> [String]
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
        (String
xs String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
concatenated2 (String
ys String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
xss))
        ( [String] -> [[String]] -> [(String, [String])]
forall a b. [a] -> [b] -> [(a, b)]
zip
            [ String
"\1040\1073\1086"
            , String
"\1040\1076\1078\1077"
            , String
"\1040\1083\1077"
            , String
"\1040\1085\1110\1078"
            , String
"\1041\1086\1076\1072\1081"
            , String
"\1041\1091\1094\1110\1084\1090\1086"
            , String
"\1042\1078\1077"
            , String
"\1042\1080\1082\1083\1102\1095\1085\1086"
            , String
"\1042\1083\1072\1089\1085\1077"
            , String
"\1042\1090\1110\1084"
            , String
"\1044\1072\1074\1072\1081"
            , String
"\1047\1072\1090\1077"
            , String
"\1050\1086\1083\1080"
            , String
"\1051\1077\1076\1074\1077"
            , String
"\1051\1080\1096\1077"
            , String
"\1052\1072\1081\1078\1077"
            , String
"\1052\1086\1074"
            , String
"\1052\1086\1074\1073\1080"
            , String
"\1052\1086\1074\1073\1080\1090\1086"
            , String
"\1053\1072\1074\1110\1090\1100"
            , String
"\1053\1072\1089\1082\1110\1083\1100\1082\1080"
            , String
"\1053\1072\1095\1077"
            , String
"\1053\1072\1095\1077\1073"
            , String
"\1053\1072\1095\1077\1073\1090\1086"
            , String
"\1053\1077\1074\1078\1077"
            , String
"\1053\1077\1084\1086\1074"
            , String
"\1053\1077\1084\1086\1074\1073\1080"
            , String
"\1053\1077\1084\1086\1074\1073\1080\1090\1086"
            , String
"\1053\1077\1085\1072\1095\1077"
            , String
"\1053\1077\1085\1072\1095\1077\1073\1090\1086"
            , String
"\1053\1077\1093\1072\1081"
            , String
"\1053\1090\1078\1077"
            , String
"\1053\1110\1073\1080"
            , String
"\1053\1110\1073\1080\1090\1086"
            , String
"\1053\1110\1078"
            , String
"\1054\1090\1086\1078"
            , String
"\1055\1088\1080\1090\1086\1084\1091"
            , String
"\1055\1088\1080\1090\1110\1084"
            , String
"\1055\1088\1080\1095\1086\1084\1091"
            , String
"\1055\1088\1080\1095\1110\1084"
            , String
"\1055\1088\1086\1090\1077"
            , String
"\1057\1072\1084\1077"
            , String
"\1057\1077\1073\1090\1086"
            , String
"\1058\1072\1082\1080"
            , String
"\1058\1086\1073\1090\1086"
            , String
"\1058\1110\1083\1100\1082\1080"
            , String
"\1061\1072\1081"
            , String
"\1061\1086\1095"
            , String
"\1061\1110\1073\1072"
            , String
"\1062\1077\1073\1090\1086"
            , String
"\1065\1086\1073"
            , String
"\1071\1082\1073\1080"
            , String
"\1071\1082\1088\1072\1079"
            , String
"\1071\1082\1097\1086"
            , String
"\1072\1073\1086"
            , String
"\1072\1076\1078\1077"
            , String
"\1072\1083\1077"
            , String
"\1072\1085\1110\1078"
            , String
"\1073\1086\1076\1072\1081"
            , String
"\1073\1091\1094\1110\1084\1090\1086"
            , String
"\1074\1078\1077"
            , String
"\1074\1080\1082\1083\1102\1095\1085\1086"
            , String
"\1074\1083\1072\1089\1085\1077"
            , String
"\1074\1090\1110\1084"
            , String
"\1076\1072\1074\1072\1081"
            , String
"\1079\1072\1090\1077"
            , String
"\1082\1086\1083\1080"
            , String
"\1083\1077\1076\1074\1077"
            , String
"\1083\1080\1096\1077"
            , String
"\1084\1072\1081\1078\1077"
            , String
"\1084\1086\1074"
            , String
"\1084\1086\1074\1073\1080"
            , String
"\1084\1086\1074\1073\1080\1090\1086"
            , String
"\1085\1072\1074\1110\1090\1100"
            , String
"\1085\1072\1089\1082\1110\1083\1100\1082\1080"
            , String
"\1085\1072\1095\1077"
            , String
"\1085\1072\1095\1077\1073"
            , String
"\1085\1072\1095\1077\1073\1090\1086"
            , String
"\1085\1077\1074\1078\1077"
            , String
"\1085\1077\1084\1086\1074"
            , String
"\1085\1077\1084\1086\1074\1073\1080"
            , String
"\1085\1077\1084\1086\1074\1073\1080\1090\1086"
            , String
"\1085\1077\1085\1072\1095\1077"
            , String
"\1085\1077\1085\1072\1095\1077\1073\1090\1086"
            , String
"\1085\1077\1093\1072\1081"
            , String
"\1085\1110\1073\1080"
            , String
"\1085\1110\1073\1080\1090\1086"
            , String
"\1085\1110\1078"
            , String
"\1086\1090\1078\1077"
            , String
"\1086\1090\1086\1078"
            , String
"\1087\1088\1080\1090\1086\1084\1091"
            , String
"\1087\1088\1080\1090\1110\1084"
            , String
"\1087\1088\1080\1095\1086\1084\1091"
            , String
"\1087\1088\1080\1095\1110\1084"
            , String
"\1087\1088\1086\1090\1077"
            , String
"\1089\1072\1084\1077"
            , String
"\1089\1077\1073\1090\1086"
            , String
"\1090\1072\1082\1080"
            , String
"\1090\1086\1073\1090\1086"
            , String
"\1090\1110\1083\1100\1082\1080"
            , String
"\1093\1072\1081"
            , String
"\1093\1086\1095"
            , String
"\1093\1110\1073\1072"
            , String
"\1094\1077\1073\1090\1086"
            , String
"\1097\1086\1073"
            , String
"\1103\1082\1073\1080"
            , String
"\1103\1082\1088\1072\1079"
            , String
"\1103\1082\1097\1086"
            ]
            ([[String]] -> [(String, [String])])
-> [[String]] -> [(String, [String])]
forall a b. (a -> b) -> a -> b
$ Int -> [String] -> [[String]]
forall a. Int -> a -> [a]
replicate Int
200 ((String
xs String -> String -> String
forall a. Monoid a => a -> a -> a
`mappend` String -> String
jottedCnv String
ys) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String] -> [String]
concatenated2 [String]
xss)
        )
        String
xs
concatenated2 [String]
xss = [String]
xss

isSpC :: Char -> Bool
isSpC :: Char -> Bool
isSpC Char
x = Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'' Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ' Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\x2019' Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\x02BC' Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-'
{-# INLINE isSpC #-}

jottedConv :: String -> String
jottedConv :: String -> String
jottedConv (Char
x : Char
y : String
xs)
    | Char -> Bool
isSpC Char
x =
        Char
x
            Char -> String -> String
forall a. a -> [a] -> [a]
: ( String -> [(Char, String)] -> Char -> String
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
                    (String -> String
jottedConv (Char
y Char -> String -> String
forall a. a -> [a] -> [a]
: String
xs))
                    [ (Char
'\1028', Char
'\1049' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1077' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1031', Char
'\1049' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1110' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1070', Char
'\1049' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1091' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1071', Char
'\1049' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1072' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1102', Char
'\1081' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1091' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1103', Char
'\1081' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1072' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1108', Char
'\1081' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1077' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    , (Char
'\1111', Char
'\1081' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'\1110' Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv String
xs)
                    ]
                    Char
y
              )
    | Bool
otherwise = Char
x Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
jottedConv (Char
y Char -> String -> String
forall a. a -> [a] -> [a]
: String
xs)
jottedConv String
xs = String
xs

{- | Can be used to prepare the text after 'convertToProperUkrainian' from 'Melodics.Ukrainian' module from @mmsyn6ukr@ package so that all the 'String' can
be represented as unique 'Char'.
-}
aux4 :: String -> Char
aux4 :: String -> Char
aux4 String
xs
    | String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1076\1078" = Char
'j'
    | String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1076\1079" = Char
'z'
    | String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1089\1100" = Char
's'
    | String
xs String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"\1094\1100" = Char
'c'
    | String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
xs = String -> Char
forall a. HasCallStack => String -> a
error String
"Aftovolio.Ukrainian.PrepareText.aux4: Empty String. "
    | Bool
otherwise = String -> Char
forall a. HasCallStack => [a] -> a
head String
xs

-- | Is taken from the @mmsyn6ukr@ package version 0.8.1.0 so that the amount of dependencies are reduced (and was slightly modified).
isUkrainianL :: Char -> Bool
isUkrainianL :: Char -> Bool
isUkrainianL 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 -> [(Char, Bool)] -> Char -> Bool
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted'
            Bool
False
            ( (Char -> (Char, Bool)) -> String -> [(Char, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map (\Char
x -> (Char
x, Bool
True)) (String -> [(Char, Bool)]) -> String -> [(Char, Bool)]
forall a b. (a -> b) -> a -> b
$
                String
"\1028\1030\1031\1068\1100\1102\1103\1108\1110\1111\1168\1169\8217"
            )
            Char
y

-------------------------------------

{- | @ since 0.2.0.0
Given a positive number and a list tries to rearrange the list's 'String's by concatenation of the several elements of the list
so that the number of words in every new 'String' in the resulting list is not greater than the 'Int' argument. If some of the
'String's have more than that number quantity of the words then these 'String's are preserved.
-}
growLinesN :: Int -> [String] -> [String]
growLinesN :: Int -> [String] -> [String]
growLinesN Int
n [String]
xss
    | [String] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
xss Bool -> Bool -> Bool
|| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = []
    | Bool
otherwise = [String] -> String
unwords [String]
yss String -> [String] -> [String]
forall a. a -> [a] -> [a]
: Int -> [String] -> [String]
growLinesN Int
n [String]
zss
  where
    l :: Int
l = [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Int] -> Int) -> ([String] -> [Int]) -> [String] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
n) ([Int] -> [Int]) -> ([String] -> [Int]) -> [String] -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int) -> [Int] -> [Int]
forall a. (a -> a -> a) -> [a] -> [a]
scanl1 Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) ([Int] -> [Int]) -> ([String] -> [Int]) -> [String] -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Int) -> [String] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map ([String] -> Int
forall a. [a] -> 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 -> [String]
words) ([String] -> Int) -> [String] -> Int
forall a b. (a -> b) -> a -> b
$ [String]
xss -- the maximum number of lines to be taken
    ([String]
yss, [String]
zss) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
l Int
1) [String]
xss

{- | @ since 0.2.0.0
The function combines the 'prepareTextN' and 'growLinesN' function. Applies needed phonetic language preparations
to the Ukrainian text and tries to \'grow\' the resulting 'String's in the list so that the number of the words in every
of them is no greater than the given first 'Int' number.
-}
prepareGrowTextMN ::
    -- | A maximum number of the words or their concatenations in the resulting list of 'String's.
    Int ->
    -- | A number of words in every 'String' that the function firstly forms. To have some sense of usage, must be less than the first argument.
    Int ->
    String ->
    [String]
prepareGrowTextMN :: Int -> Int -> String -> [String]
prepareGrowTextMN Int
m Int
n = Int -> [String] -> [String]
growLinesN Int
m ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
prepareTextN Int
n
{-# INLINE prepareGrowTextMN #-}

{- | @ since 0.11.0.0
The generalized version of the 'prepareGrowTextMN' with additional possibility to provide custom function for symbols filtering inside.
-}
prepareGrowTextMNG ::
    -- | A predicate to filter the symbols during preparation.
    (Char -> Bool) ->
    -- | A maximum number of the words or their concatenations in the resulting list of 'String's.
    Int ->
    -- | A number of words in every 'String' that the function firstly forms. To have some sense of usage, must be less than the first argument.
    Int ->
    String ->
    [String]
prepareGrowTextMNG :: (Char -> Bool) -> Int -> Int -> String -> [String]
prepareGrowTextMNG Char -> Bool
f Int
m Int
n = Int -> [String] -> [String]
growLinesN Int
m ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Int -> String -> [String]
prepareTextNG Char -> Bool
f Int
n
{-# INLINE prepareGrowTextMNG #-}

-------------------------------------

{- | @ since 0.6.0.0
Recursively splits the concatenated list of lines of words so that in every resulting 'String' in the list
except the last one there is just 'Int' -- the first argument -- words.
-}
tuneLinesN :: Int -> [String] -> [String]
tuneLinesN :: Int -> [String] -> [String]
tuneLinesN Int
n [String]
xss
    | [String] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
xss Bool -> Bool -> Bool
|| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = []
    | Bool
otherwise =
        let wss :: [String]
wss = String -> [String]
words (String -> [String])
-> ([String] -> String) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unwords ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [String]
xss
            ([String]
yss, [String]
zss) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n [String]
wss
         in [String] -> String
unwords [String]
yss String -> [String] -> [String]
forall a. a -> [a] -> [a]
: Int -> [String] -> [String]
tuneLinesN Int
n [String]
zss

{- | @ since 0.6.0.0
The function combines the 'prepareTextN' and 'tuneLinesN' functions. Applies needed phonetic language preparations
to the Ukrainian text and splits the list of 'String's so that the number of the words in each of them (except the last one)
is equal the given first 'Int' number.
-}
prepareTuneTextMN ::
    -- | A number of the words or their concatenations in the resulting list of 'String's (except probably the last one).
    Int ->
    -- | A number of words in every 'String' that the function firstly forms. To have some sense of usage, must be less than the first argument.
    Int ->
    String ->
    [String]
prepareTuneTextMN :: Int -> Int -> String -> [String]
prepareTuneTextMN Int
m Int
n = Int -> [String] -> [String]
tuneLinesN Int
m ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
prepareTextN Int
n
{-# INLINE prepareTuneTextMN #-}

{- | @ since 0.11.0.0
The generalized version of the 'prepareTuneTextMN' with additional possibility to provide custom function for symbols filtering inside.
-}
prepareTuneTextMNG ::
    -- | A predicate to filter the symbols during preparation.
    (Char -> Bool) ->
    -- | A number of the words or their concatenations in the resulting list of 'String's (except probably the last one).
    Int ->
    -- | A number of words in every 'String' that the function firstly forms. To have some sense of usage, must be less than the first argument.
    Int ->
    String ->
    [String]
prepareTuneTextMNG :: (Char -> Bool) -> Int -> Int -> String -> [String]
prepareTuneTextMNG Char -> Bool
f Int
m Int
n = Int -> [String] -> [String]
tuneLinesN Int
m ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Int -> String -> [String]
prepareTextNG Char -> Bool
f Int
n
{-# INLINE prepareTuneTextMNG #-}