{-# OPTIONS_GHC -threaded -rtsopts #-}
{-# OPTIONS_HADDOCK show-extensions #-}
{-# LANGUAGE BangPatterns, FlexibleContexts, NoImplicitPrelude #-}

-- |
-- Module      :  Phladiprelio.Ukrainian.CommonE
-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  oleksandr.zhabenko@yahoo.com
--
-- Some functions to provide show and print functionality for PhLADiPreLiO for Ukrainian language.
--

module Phladiprelio.Ukrainian.CommonE (
  fLinesN
  , fLines
  , fLinesNIO
  , fLinesIO
) where

import GHC.Base hiding (foldr)
import GHC.List (filter, break, dropWhile, init)
import Phladiprelio.Ukrainian.PrepareText
import Data.Char (isAlpha,isSpace)
import Data.Monoid (mappend)
import Data.Foldable (Foldable (..), any)
import GHC.Num ((+),(-))
import Text.Show (show)
import System.IO (putStrLn)

fLinesN :: Int -> Int -> String -> [String]
fLinesN :: Int -> Int -> String -> [String]
fLinesN Int
n !Int
toOneLine String
ys = forall a. (a -> Bool) -> [a] -> [a]
filter (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Char
x -> Char -> Bool
isUkrainianL Char
x Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
x)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
prepareTextN Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  (\String
z -> if Int
toOneLine forall a. Eq a => a -> a -> Bool
== Int
1 then String -> String
unls String
z else String
z) forall a b. (a -> b) -> a -> b
$ String
ys
   -- the 'unls' is taken from the 'Data.List.words' and rewritten to be equal to 'unwords' . 'words'
   where unls :: String -> String
unls String
s  =  case forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace String
s of
                      String
"" -> []
                      String
s' -> String
w forall a. Monoid a => a -> a -> a
`mappend` (Char
' ' forall a. a -> [a] -> [a]
: String -> String
unls String
s'')
                        where (String
w, String
s'') = forall a. (a -> Bool) -> [a] -> ([a], [a])
break Char -> Bool
isSpace String
s'

fLines :: Int -> String -> [String]
fLines :: Int -> String -> [String]
fLines = Int -> Int -> String -> [String]
fLinesN Int
7
{-# INLINE fLines #-}

fLinesNIO :: Int -> String -> IO ()
fLinesNIO :: Int -> String -> IO ()
fLinesNIO Int
n String
ys = forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM String -> IO ()
putStrLn (forall a b. (a -> b) -> [a] -> [b]
map (\(Int
i,String
x) -> forall a. Show a => a -> String
show (Int
i forall a. Num a => a -> a -> a
+ Int
1) forall a. Monoid a => a -> a -> a
`mappend` String
"\t" forall a. Monoid a => a -> a -> a
`mappend` String
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
helpG3 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) b. Foldable t => b -> t b -> [(Int, b)]
indexedL String
"" forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall a. (a -> Bool) -> [a] -> [a]
filter (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Char
x -> Char -> Bool
isUkrainianL Char
x Bool -> Bool -> Bool
&& Char -> Bool
isAlpha Char
x)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
prepareTextN Int
n forall a b. (a -> b) -> a -> b
$ String
ys) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()

fLinesIO :: String -> IO ()
fLinesIO :: String -> IO ()
fLinesIO = Int -> String -> IO ()
fLinesNIO Int
7
{-# INLINE fLinesIO #-}

-- | Is taken mostly from the Phonetic.Languages.Ukrainian.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.
indexedL :: Foldable t => b -> t b -> [(Int, b)]
indexedL :: forall (t :: * -> *) b. Foldable t => b -> t b -> [(Int, b)]
indexedL b
y t b
zs = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall {a} {b}. Num a => b -> [(a, b)] -> [(a, b)]
f [(Int, b)]
v t b
zs
  where !v :: [(Int, b)]
v = [(forall (t :: * -> *) a. Foldable t => t a -> Int
length t b
zs,b
y)]
        f :: b -> [(a, b)] -> [(a, b)]
f b
x ((a
j,b
z):[(a, b)]
ys) = (a
jforall a. Num a => a -> a -> a
-a
1,b
x)forall a. a -> [a] -> [a]
:(a
j,b
z)forall a. a -> [a] -> [a]
:[(a, b)]
ys
{-# INLINE indexedL #-}

helpG3 :: [a] -> [a]
helpG3 :: forall a. [a] -> [a]
helpG3 [a]
xs
 | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
xs = []
 | Bool
otherwise = forall a. [a] -> [a]
init [a]
xs