dobutokO-poetry 0.7.0.0 → 0.8.0.0

raw patch · 11 files changed

+574/−352 lines, 11 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +5/−0
• DobutokO/Poetry.hs +3/−4
• DobutokO/Poetry/Basic.hs +4/−6
• DobutokO/Poetry/General.hs +452/−0
• DobutokO/Poetry/Norms.hs +12/−14
• DobutokO/Poetry/PrependAppend.hs +0/−303
• DobutokO/Poetry/StrictV.hs +26/−10
• DobutokO/Poetry/UniquenessPeriodsG.hs +17/−1
• Main.hs +9/−7
• README.md +39/−0
• dobutokO-poetry.cabal +7/−7

@@ -40,3 +40,8 @@ ## 0.7.0.0 -- 2020-07-29  * Seventh version. Changed the module structure. Added new modules and rewritten the old ones. Fixed unexact or not complete documentation for some functions.++## 0.8.0.0 -- 2020-07-31++* Eigth version. Changed the module structure. Removed the module DobutokO.Poetry.PrependAppend and added the module DobutokO.Poetry.General with more extended +possibilities. Addad also README.md file with some useful information. Some code and documentation improvements.

@@ -8,8 +8,6 @@ -- Helps to order the 7 or less Ukrainian words (or their concatenations)  -- to obtain (to some extent) suitable for poetry or music text.  -{-# LANGUAGE BangPatterns #-}- module DobutokO.Poetry (   -- * Main functions   uniq10Poetical4@@ -55,13 +53,14 @@ import DobutokO.Poetry.StrictV import DobutokO.Poetry.Basic --- | Generalization of the 'uniquenessVariantsG' with usage of several norms (instead of one). They constitute a 'V.Vector' of functions +-- | Returns the 'V.Vector' of all possible permutations of the 'String' that represent the Ukrainian text and the linked information with them for +-- analysis with usage of several norms (instead of one). They constitute a 'V.Vector' of functions  -- @norm :: [Int] -> Int@. So the inner vector in the each resulting 'Uniqueness' has the same length as the vector of norms. uniquenessVariantsGN :: V.Vector ([Int] -> Int) -> String -> V.Vector Uniqueness uniquenessVariantsGN vN = uniquenessVariants2GN vN (uniquenessPeriods) {-# INLINE uniquenessVariantsGN #-} --- | Generalized variant of the 'uniqMaxPoeticalG' with the several norms given as a 'V.Vector' of functions and an 'Int' parameter. The function evaluates +-- | A variant of the 'uniqMaxPoetical2GN' with the several norms given as a 'V.Vector' of functions and an 'Int' parameter. The function evaluates  -- the generated 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order and significance (principality)  -- of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is the 'Int' argument of the function  -- minus 1, then less significant is the next to the left norm and so on.

@@ -8,8 +8,6 @@ -- Helps to order the 7 or less Ukrainian words (or their concatenations)  -- to obtain (to some extent) suitable for poetry or music text.  -{-# LANGUAGE BangPatterns #-}- module DobutokO.Poetry.Basic (   Uniqueness   -- * Main functions@@ -40,8 +38,8 @@ -- which is given as the first argument. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@).  uniqInMaxPoeticalN :: Int -> V.Vector ([Int] -> Int) -> V.Vector Uniqueness -> IO (V.Vector Uniqueness) uniqInMaxPoeticalN k vN v = do-  let !uniq = uniqMaxPoeticalGNV k vN v-  let !fsT = (\(!ys,_,_) -> ys) uniq+  let uniq = uniqMaxPoeticalGNV k vN v+  let fsT = (\(ys,_,_) -> ys) uniq   putStr (filter (not . isPunctuation) . lastFrom3 $ uniq) >> putStrLn ""   return . V.filter (\(xs,_,_) -> xs /= fsT) $ v @@ -53,8 +51,8 @@ -- | Generalized variant of the 'uniqInMaxPoeticalN' with usage of the several norms and all the information is printed on the same line.  uniqInMaxPoeticalNLine :: Int -> V.Vector ([Int] -> Int) -> V.Vector Uniqueness -> IO (V.Vector Uniqueness) uniqInMaxPoeticalNLine k vN v = do-  let !uniq = uniqMaxPoeticalGNV k vN v-  let !fsT = (\(!ys,_,_) -> ys) uniq+  let uniq = uniqMaxPoeticalGNV k vN v+  let fsT = (\(ys,_,_) -> ys) uniq   putStr (filter (not . isPunctuation) . lastFrom3 $ uniq) >> putStr " "   return . V.filter (\(xs,_,_) -> xs /= fsT) $ v 

@@ -0,0 +1,452 @@+-- |+-- Module      :  DobutokO.Poetry.General+-- Copyright   :  (c) OleksandrZhabenko 2020+-- License     :  MIT+-- Stability   :  Experimental+-- Maintainer  :  olexandr543@yahoo.com+--+-- Helps to order the 7 or less Ukrainian words (or their concatenations) +-- to obtain (to some extent) suitable for poetry or music text. +-- Generalization of the functionality in the 'DobutokO.Poetry.Basic' +-- and 'DobutokO.Poetry' modules. The functions can only print the needed +-- strings or also return tha data needed to interconnect and link it with +-- other functions. There is also a possibility to use prepending and +-- postpending 'String' in the 'PreApp' data type so that they are added +-- respectively to the beginning or to the end of the strings.++{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}++module DobutokO.Poetry.General where++import Data.Maybe (fromJust)+import Data.Char (isPunctuation)+import qualified Data.Vector as V+import MMSyn7s+import DobutokO.Poetry.Norms+import DobutokO.Poetry.Auxiliary+import DobutokO.Poetry.UniquenessPeriodsG+import DobutokO.Poetry.StrictV+import DobutokO.Poetry.Basic (Uniqueness)++-- | The list in the 'PA' variant represent the prepending 'String' and the postpending one respectively. 'K' constuctor actually means no prepending and +-- postpending of the text. Are used basically to control the behaviour of the functions.+data PreApp a = K | PA [a] [a] deriving Eq++class G1 a b where+  get1m :: a -> [b]+  get2m :: a -> [b]+  getm :: Bool -> a -> [b]+  getm True = get1m+  getm _ = get2m+  preapp :: a -> [[b]] -> [[b]]+  setm :: [b] -> [b] -> a+  +instance G1 (PreApp Char) Char where+  get1m K = []+  get1m (PA xs _) = xs+  get2m K = []+  get2m (PA _ ys) = ys+  preapp K xss = xss+  preapp (PA xs ys) yss = xs:yss ++ [ys]+  setm [] [] = K+  setm xs ys = PA xs ys++type Preapp = PreApp Char++isPA :: PreApp a -> Bool+isPA K = False+isPA _ = True++isK :: PreApp a -> Bool+isK K = True+isK _ = False++-- | Is used to control whether to return data or only to print the needed information. The 'U' contstuctor corresponds to the information printing and 'UL' to +-- returning also data. The last one so can be further used.+data UniquenessG a b = U b | UL ([a],b) deriving Eq++instance Show (UniquenessG String (V.Vector Uniqueness)) where+  show (U v) = show . V.map (filter (not . isPunctuation) . lastFrom3) $ v+  show (UL (wss,_)) = show . map (filter (not . isPunctuation)) $ wss++type UniqG = UniquenessG String (V.Vector Uniqueness)  ++-- | Decomposes the data type 'UniqG' into its components. The inverse to the 'set2'.+get2 :: UniqG -> (Maybe [String], V.Vector Uniqueness)+get2 (U v) = (Nothing,v)+get2 (UL (wss,v)) = (Just wss,v)++-- | Compose the data type 'UniqG' from its components. The inverse to the 'get2'.+set2 :: (Maybe [String], V.Vector Uniqueness) -> UniqG+set2 (Just wss, v) = UL (wss,v)+set2 (Nothing, v) = U v++isU :: UniqG -> Bool+isU (U _) = True+isU _ = False++isUL :: UniqG -> Bool+isUL (UL _) = True+isUL _ = False++-- | Prints the maximum element with respect of the @k@ norms (the most significant of which is the rightest one, then to the left less significant etc.), +-- which is given as the first argument. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). +uniqInMaxPoeticalN :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqInMaxPoeticalN k vN x = do+  inner1 k vN x >>= \(fsT,x) -> +    if isU x then return (U (V.filter (\(xs,_,_) -> xs /= fsT) . snd . get2 $ x))+    else return (UL ((\(v1,v2) -> ((V.toList . V.map (filter (not . isPunctuation) . lastFrom3) $ v1) ++ (fromJust . fst . get2 $ x),v2)) . +      V.unstablePartition (\(xs,_,_) -> xs == fsT) . snd . get2 $ x))+{-# INLINE uniqInMaxPoeticalN #-}++-- | Is used internally in the 'uniqInMaxPoeticalN' to reduce duplication.+inner1 :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ([Int],UniqG)+inner1 k vN x = do +  let uniq = uniqMaxPoeticalGNV k vN x+  let fsT = (\(ys,_,_) -> ys) uniq+  putStr (filter (not . isPunctuation) . lastFrom3 $ uniq) >> putStrLn ""+  return (fsT,x)+{-# INLINE inner1 #-}  ++-- | Variant of 'uniqInMaxPoticalN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqInMaxPoeticalNL :: V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqInMaxPoeticalNL vN x = uniqInMaxPoeticalN (V.length vN) vN x+{-# INLINE uniqInMaxPoeticalNL #-}++-- | Generalized variant of the 'uniqInMaxPoeticalN' with usage of the several norms and all the information is printed on the same line. +uniqInMaxPoeticalNLine :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqInMaxPoeticalNLine k vN x = do+  inner2 k vN x >>= \(fsT,x) -> +    if isU x then return (U (V.filter (\(xs,_,_) -> xs /= fsT) . snd . get2 $ x))+    else return (UL ((\(v1,v2) -> ((V.toList . V.map (filter (not . isPunctuation) . lastFrom3) $ v1) ++ (fromJust . fst . get2 $ x),v2)) . +      V.unstablePartition (\(xs,_,_) -> xs == fsT) . snd . get2 $ x))+{-# INLINE uniqInMaxPoeticalNLine #-}++-- | Is used internally in the 'uniqInMaxPoeticalNLine' to reduce duplication.+inner2 :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ([Int],UniqG)+inner2 k vN x = do +  let uniq = uniqMaxPoeticalGNV k vN x+  let fsT = (\(ys,_,_) -> ys) uniq+  putStr (filter (not . isPunctuation) . lastFrom3 $ uniq) >> putStr " "+  return (fsT,x)+{-# INLINE inner2 #-}++-- | Variant of 'uniqInMaxPoticalNLine' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqInMaxPoeticalNLineL :: V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqInMaxPoeticalNLineL vN = uniqInMaxPoeticalNLine (V.length vN) vN+{-# INLINE uniqInMaxPoeticalNLineL #-}++-- | Prints @n@ (given as the first argument) maximum elements with respect to the several norms (their quantity is the second argument) starting +-- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). +uniqNPoeticalN :: Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ()+uniqNPoeticalN n k vN y  + | n <= 0 = return ()+ | compare (V.length . snd . get2 $ y) n == LT = V.mapM_ (\x -> putStr (filter (not . isPunctuation) . lastFrom3 $ x) >> putStrLn "" ) . snd . get2 $ y+ | otherwise = (uniqInMaxPoeticalN k vN y >>= uniqNPoeticalN (n - 1) k vN)+{-# INLINE uniqNPoeticalN #-}++-- | Variant of 'uniqNPoeticalN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqNPoeticalNL :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ()+uniqNPoeticalNL n vN = uniqNPoeticalN n (V.length vN) vN+{-# INLINE uniqNPoeticalNL #-}++-- | Variant of the 'uniqNPoeticalN' with its output being printed on the same line.+uniqNPoeticalNLine :: Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ()+uniqNPoeticalNLine n k vN y+ | n <= 0 = putStrLn ""+ | compare (V.length . snd . get2 $ y) n == LT = +    (V.mapM_ (\x -> putStr (filter (not . isPunctuation) . lastFrom3 $ x) >> putStr " " ) . snd . get2 $ y)  >> putStrLn ""+ | otherwise = (uniqInMaxPoeticalNLine k vN y >>= uniqNPoeticalNLine (n - 1) k vN)+{-# INLINE uniqNPoeticalNLine #-}+ +-- | Variant of 'uniqNPoeticalNLine' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqNPoeticalNLineL :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO ()+uniqNPoeticalNLineL n vN = uniqNPoeticalNLine n (V.length vN) vN+{-# INLINE uniqNPoeticalNLineL #-}++-- | Prints @n@ (given as the first argument) maximum elements with respect to the several norms (their quantity is the second argument) starting +-- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). Contrary to its pair function +-- 'uniqNPoeticalN' returns then the rest of the given 'V.Vector' 'Uniqueness' after filtering the printed elements 'String'.+uniqNPoeticalVN :: Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqNPoeticalVN n k vN y+ | n <= 0 || compare (V.length . snd . get2 $ y) n == LT = return y+ | otherwise = (uniqInMaxPoeticalN k vN y >>= uniqNPoeticalVN (n - 1) k vN)+{-# INLINE uniqNPoeticalVN #-}++-- | Variant of 'uniqNPoeticalVN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqNPoeticalVNL :: Int -> V.Vector ([Int] -> Int) -> UniqG -> IO UniqG+uniqNPoeticalVNL n vN = uniqNPoeticalVN n (V.length vN) vN+{-# INLINE uniqNPoeticalVNL #-}++-- | The function evaluates the 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order +-- and significance (principality)  of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is +-- the 'Int' argument of the function minus 1, then less significant is the next to the left norm and so on. Is similar to 'DobutokO.Poetry.uniqMaxPoeticalGN' +-- function.+uniqMaxPoeticalGNV :: Int -> V.Vector ([Int] -> Int) ->  UniqG -> Uniqueness+uniqMaxPoeticalGNV k vN y+ | compare k (V.length vN) == GT = error "DobutokO.Poetry.General.uniqMaxPoeticalGNV: undefined for that amount of norms. "+ | compare k 0 == GT =+   let maxK = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 (k - 1)) (V.unsafeIndex vN1 (k - 1))) . snd . get2 $ y+       vK = V.filter (\(_,vN2,_) -> V.unsafeIndex vN2 (k - 1) == ((\(_,vNk,_) -> V.unsafeIndex vNk (k - 1)) maxK)) . snd . get2 $ y in+         if isU y then uniqMaxPoeticalGNV (k - 1) (V.unsafeSlice 0 (V.length vN - 1) vN) (U vK)+         else uniqMaxPoeticalGNV (k - 1) (V.unsafeSlice 0 (V.length vN - 1) vN) (UL (fromJust . fst . get2 $ y,vK))+ | otherwise = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 0) (V.unsafeIndex vN1 0)) . snd . get2 $ y+{-# INLINE uniqMaxPoeticalGNV #-}++-- | Variant of 'uniqMaxPoeticalGNV' where all the elements in the norms 'V.Vector' are used as norms from right to left.+uniqMaxPoeticalGNVL :: V.Vector ([Int] -> Int) ->  UniqG -> Uniqueness+uniqMaxPoeticalGNVL vN = uniqMaxPoeticalGNV (V.length vN) vN+{-# INLINE uniqMaxPoeticalGNVL #-}++---------------------------------------------------------------------------------++-- | Returns the 'V.Vector' of all possible permutations of the 'String' that represent the Ukrainian text and the linked information with them for +-- analysis  with usage of several norms (instead of one). They constitute a 'V.Vector' of functions +-- @norm :: [Int] -> Int@. So the inner vector in the each resulting 'Uniqueness' has the same length as the vector of norms. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniquenessVariantsGN :: Preapp -> V.Vector ([Int] -> Int) -> String -> V.Vector Uniqueness+uniquenessVariantsGN (PA ts us) vN = uniquenessVariants2GNP ts us vN (uniquenessPeriods)+uniquenessVariantsGN K vN = uniquenessVariants2GN vN (uniquenessPeriods)+{-# INLINE uniquenessVariantsGN #-}++-- | A variant of the 'uniqMaxPoetical2GN' with the several norms given as a 'V.Vector' of functions and an 'Int' parameter. The function evaluates +-- the generated 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order and significance (principality) +-- of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is the 'Int' argument of the function +-- minus 1, then less significant is the next to the left norm and so on.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqMaxPoeticalGN :: Preapp -> Int -> V.Vector ([Int] -> Int) ->  String -> Uniqueness+uniqMaxPoeticalGN x k vN = uniqMaxPoetical2GN x k vN (uniquenessPeriods)+{-# INLINE uniqMaxPoeticalGN #-}++-- | Variant of 'uniqMaxPoeticalGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqMaxPoeticalGNL :: Preapp -> V.Vector ([Int] -> Int) ->  String -> Uniqueness+uniqMaxPoeticalGNL x vN = uniqMaxPoeticalGN x (V.length vN) vN+{-# INLINE uniqMaxPoeticalGNL #-}++-- | A variant of the 'uniqNPoeticalGN' with only one norm.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalG :: Preapp -> Int -> ([Int] -> Int) -> String -> IO ()+uniqNPoeticalG x n g = uniqNPoeticalGN x n 1 (V.singleton g)+{-# INLINE uniqNPoeticalG #-}++-- | A variant of the 'uniqNPoeticalG' function with the @n@ equal to 10.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniq10PoeticalG :: Preapp -> ([Int] -> Int) -> String -> IO ()+uniq10PoeticalG x = uniqNPoeticalG x 10+{-# INLINE uniq10PoeticalG #-}++-- | A variant of 'uniq10PoeticalG' with the 'norm4' applied. The list is (according to some model, not universal, but a reasonable one in the most cases) the +-- most suitable for intonation changing and, therefore, for the accompaniment of the highly changable or variative melody. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniq10Poetical4 :: Preapp -> String -> IO ()+uniq10Poetical4 x = uniq10PoeticalG x norm4+{-# INLINE uniq10Poetical4 #-}++-- | A variant of 'uniq10PoeticalG' with the 'norm5' applied. The list is (according to some model, not universal, but a reasonable one in the most cases) the +-- most suitable for rhythmic speech and two-syllabilistic-based poetry. Therefore, it can be used to create a poetic composition or to emphasize some +-- thoughts. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniq10Poetical5 :: Preapp -> String -> IO ()+uniq10Poetical5 x = uniq10PoeticalG x norm5+{-# INLINE uniq10Poetical5 #-}++-- | A variant of the 'uniqNPoetical2GN' with the conversion (\"uniquenessPeriods\" function) function 'uniquenessPeriods'.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalGN :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()+uniqNPoeticalGN x n k vN = uniqNPoetical2GN x n k vN (uniquenessPeriods)+{-# INLINE uniqNPoeticalGN #-}++-- | Variant of 'uniqNPoeticalGN' where all the elements in the norms 'V.Vector' are used as norms from right to left. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalGNL :: Preapp -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()+uniqNPoeticalGNL x n vN = uniqNPoetical2GNL x n vN (uniquenessPeriods)+{-# INLINE uniqNPoeticalGNL #-}++-- | Generalized variant of the 'uniqNPoeticalVG' with usage of several norms. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoeticalVGN :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> String -> IO UniqG+uniqNPoeticalVGN x n k vN = uniqNPoetical2VGN x n k vN (uniquenessPeriods)+{-# INLINE uniqNPoeticalVGN #-}++-- | Variant of 'uniqNPoeticalVGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoeticalVGNL :: Preapp -> Int -> V.Vector ([Int] -> Int) -> UniqG -> String -> IO UniqG+uniqNPoeticalVGNL x n vN = uniqNPoetical2VGN x n (V.length vN) vN (uniquenessPeriods)+{-# INLINE uniqNPoeticalVGNL #-}++-- | The function evaluates +-- the generated 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order and significance (principality) +-- of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is the 'Int' argument of the function +-- minus 1, then less significant is the next to the left norm and so on.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqMaxPoetical2GN :: Preapp -> Int -> V.Vector ([Int] -> Int) ->  (String -> [Int]) -> String -> Uniqueness+uniqMaxPoetical2GN rr k vN g xs+ | compare k (V.length vN) == GT = error "DobutokO.Poetry.General.uniqMaxPoetical2GN: undefined for that amount of norms. "+ | compare k 0 == GT =+   let vM = uniquenessVariants2GNP (get1m rr) (get2m rr) vN g xs+       maxK = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 (k - 1)) (V.unsafeIndex vN1 (k - 1))) vM+       vK = V.filter (\(_,vN2,_) -> V.unsafeIndex vN2 (k - 1) == ((\(_,vNk,_) -> V.unsafeIndex vNk (k - 1)) maxK)) vM in+         uniqMaxPoeticalGNV (k - 1) (V.unsafeSlice 0 (V.length vN - 1) vN) (U vK)+ | otherwise = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 0) (V.unsafeIndex vN1 0)) . uniquenessVariantsGN rr vN $ xs++-- | Variant of 'uniqMaxPoetical2GN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqMaxPoetical2GNL :: Preapp -> V.Vector ([Int] -> Int) ->  (String -> [Int]) -> String -> Uniqueness+uniqMaxPoetical2GNL rr vN = uniqMaxPoetical2GN rr (V.length vN) vN+{-# INLINE uniqMaxPoetical2GNL #-}+  +-- | Prints @n@ (given as the first 'Int' argument) maximum elements with respect to the several norms (their quantity is the second 'Int' argument) starting +-- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoetical2GN :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()+uniqNPoetical2GN rr n k vN g xs+ | n <= 0 = return ()+ | otherwise = do+   let v = uniquenessVariants2GNP (get1m rr) (get2m rr) vN g xs+   if compare (V.length v) n == LT+     then V.mapM_ (\x -> putStr ((filter (not . isPunctuation) . lastFrom3 $ x)) >> putStrLn "" ) v+     else (uniqInMaxPoeticalN k vN (U v) >>= uniqNPoeticalN (n - 1) k vN)++-- | Variant of 'uniqNPoetical2GN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoetical2GNL :: Preapp -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()+uniqNPoetical2GNL rr n vN = uniqNPoetical2GN rr n (V.length vN) vN+{-# INLINE uniqNPoetical2GNL #-}+ +-- | Generalized variant of the 'uniqNPoeticalG' with usage of the several norms, but prints its output on the same line. +-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoetical2GNLine :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()+uniqNPoetical2GNLine rr n k vN g xs+ | n <= 0 = putStrLn ""+ | otherwise = do+   let v = uniquenessVariants2GNP (get1m rr) (get2m rr) vN g xs+   if compare (V.length v) n == LT+     then V.mapM_ (\x -> putStr ((filter (not . isPunctuation) . lastFrom3 $ x)) >> putStr " " ) v >> putStrLn ""+     else (uniqInMaxPoeticalNLine k vN (U v) >>= uniqNPoeticalNLine (n - 1) k vN)++-- | Variant of 'uniqNPoetical2GNLine' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoetical2GNLineL :: Preapp -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()+uniqNPoetical2GNLineL rr n vN = uniqNPoetical2GNLine rr n (V.length vN) vN+{-# INLINE uniqNPoetical2GNLineL #-}+ +-- | Prints @n@ (given as the first 'Int' argument) maximum elements with respect to the several norms (their quantity is the second 'Int' argument) starting +-- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). Contrary to its pair function +-- 'uniqNPoetical2GN' returns then the rest of the given 'V.Vector' 'Uniqueness' after filtering the printed elements 'String'.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoetical2VGN :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> UniqG -> String -> IO UniqG+uniqNPoetical2VGN rr n k vN g y xs+ | n <= 0 = if isU y then return (U V.empty) else return (UL ([],V.empty))+ | otherwise = do+   let v = uniquenessVariants2GNP (get1m rr) (get2m rr) vN g xs+   if compare (V.length v) n == LT +     then if isU y then return (U v) else return (UL ([],v)) +     else if isU y then uniqNPoeticalVN n k vN (U v) else uniqNPoeticalVN n k vN (UL ([],v))++-- | Variant of 'uniqNPoetical2VGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoetical2VGNL :: Preapp -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> UniqG -> String -> IO UniqG+uniqNPoetical2VGNL rr n vN = uniqNPoetical2VGN rr n (V.length vN) vN+{-# INLINE uniqNPoetical2VGNL #-}+ +-- | Variant of the 'uniqNPoetical2GN', which uses as a function 'uniquenessPeriods2' with the first argument equal to the first 'Int' argument.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalUGN_ :: Preapp -> Int -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()+uniqNPoeticalUGN_ rr x n k vN = uniqNPoetical2GN rr n k vN (uniquenessPeriods2 x)+{-# INLINE uniqNPoeticalUGN_ #-}++-- | Variant of 'uniqNPoeticalUGN_' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalUGNL_ :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()+uniqNPoeticalUGNL_ rr x n vN = uniqNPoetical2GNL rr n vN (uniquenessPeriods2 x)+{-# INLINE uniqNPoeticalUGNL_ #-}++-- | Variant of the 'uniqNPoetical2VGN', which uses as a function 'uniquenessPeriods2' with the first argument equal to the first 'Int' argument.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoeticalUGN :: Preapp -> Int -> Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> String -> IO UniqG+uniqNPoeticalUGN rr x n k vN = uniqNPoetical2VGN rr n k vN (uniquenessPeriods2 x)+{-# INLINE uniqNPoeticalUGN #-}++-- | Variant of 'uniqNPoeticalUGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoeticalUGNL :: Preapp -> Int -> Int -> V.Vector ([Int] -> Int) -> UniqG -> String -> IO UniqG+uniqNPoeticalUGNL rr x n vN = uniqNPoetical2VGN rr n (V.length vN) vN (uniquenessPeriods2 x)+{-# INLINE uniqNPoeticalUGNL #-}++-- | Variant of the 'uniqNPoeticalUGN_', which uses as a single norm 'norm51'.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+uniqNPoeticalUGN51_ :: Preapp -> Int -> Int -> String -> IO ()+uniqNPoeticalUGN51_ rr x n = uniqNPoeticalUGN_ rr x n 1 (V.singleton norm51)+{-# INLINE uniqNPoeticalUGN51_ #-}++-- | Variant of the 'uniqNPoeticalUGN', which uses as a single norm 'norm51'.+-- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' that are lifted (if any) +-- to the 'PreApp' data type with the respective constuctors. The first one is prepended and the second one is appended to the processed 'String' to +-- be processed with it. This allows to create more connection with the previous and postpending text.+-- To specify whether the function returns also data suitable for usage with other functions or just usable mostly for printing it uses also a before 'String' +-- argument also 'UniqG' one with the 'U' data constructor corresponding to the printing (mostly) and 'UL' to possible reusage of data.+uniqNPoeticalUGN51 :: Preapp -> Int -> Int -> UniqG -> String -> IO UniqG+uniqNPoeticalUGN51 rr x n = uniqNPoeticalUGN rr x n 1 (V.singleton norm51)+{-# INLINE uniqNPoeticalUGN51 #-}+  

@@ -10,8 +10,6 @@ -- provides several different norms that allow to research the text and  -- to create interesting sequences. -{-# LANGUAGE BangPatterns #-}- module DobutokO.Poetry.Norms (   -- * Different norms   norm1@@ -30,33 +28,33 @@  -- | The first norm for the list of non-negative 'Int'. For not empty lists equals to the maximum element. norm1 :: [Int] -> Int -norm1 !xs +norm1 xs    | null xs = 0   | otherwise = maximum xs {-# INLINE norm1 #-}  -- | The second norm for the list of non-negative 'Int'. For not empty lists equals to the sum of the elements. norm2 :: [Int] -> Int-norm2 !xs = sum xs+norm2 xs = sum xs {-# INLINE norm2 #-}  -- | The third norm for the list of non-negative 'Int'. For not empty lists equals to the sum of the doubled maximum element and the rest elements of the list. norm3 :: [Int] -> Int-norm3 !xs +norm3 xs   | null xs = 0  | otherwise = maximum xs + sum xs {-# INLINE norm3 #-}   -- | The fourth norm for the list of non-negative 'Int'. Equals to the sum of the 'norm3' and 'norm2'. norm4 :: [Int] -> Int-norm4 !xs +norm4 xs   | null xs = 0  | otherwise = maximum xs + sum xs + maximum (xs \\ [maximum xs]) {-# INLINE norm4 #-}   -- | The fifth norm for the list of non-negative 'Int'. For not empty lists equals to the sum of the elements quoted with sum of the two most minimum elements. norm5 :: [Int] -> Int-norm5 !xs +norm5 xs   | null xs = 0  | minimum xs == 0 = norm5 . filter (/= 0) $ xs  | otherwise = sum xs `quot` (minimum xs + minimum (xs \\ [minimum xs]))@@ -64,27 +62,27 @@  -- | The fifth modified norm for the list of non-negative 'Int'. Tries to take into account doubled and prolonged sounds to reduce their influence on the 'norm5'. norm51 :: [Int] -> Int-norm51 !xs +norm51 xs   | null xs = 0- | compare (minimum xs) 1 /= GT = let !ys = filter (\t -> compare t 1 == GT) xs in (3 * sum xs) `quot` (minimum ys + minimum (ys \\ [minimum ys]))+ | compare (minimum xs) 1 /= GT = let ys = filter (\t -> compare t 1 == GT) xs in (3 * sum xs) `quot` (minimum ys + minimum (ys \\ [minimum ys]))  | otherwise = (3 * sum xs) `quot` (minimum xs + minimum (xs \\ [minimum xs])) {-# INLINE norm51 #-}   -- | The fifth modified (with three minimums) norm for the list of non-negative 'Int'. Tries to take into account doubled and prolonged sounds  -- to reduce their influence on the 'norm5'. norm513 :: [Int] -> Int-norm513 !xs +norm513 xs   | null xs = 0  | compare (minimum xs) 1 /= GT = -   let !ys = filter (\t -> compare t 1 == GT) xs -       !zs = ys \\ [minimum ys] in (3 * sum xs) `quot` (minimum ys + minimum zs + minimum (zs \\ [minimum zs]))+   let ys = filter (\t -> compare t 1 == GT) xs +       zs = ys \\ [minimum ys] in (3 * sum xs) `quot` (minimum ys + minimum zs + minimum (zs \\ [minimum zs]))  | otherwise = -   let !zs = xs \\ [minimum xs] in (3 * sum xs) `quot` (minimum xs + minimum zs + minimum (zs \\ [minimum zs]))+   let zs = xs \\ [minimum xs] in (3 * sum xs) `quot` (minimum xs + minimum zs + minimum (zs \\ [minimum zs])) {-# INLINE norm513 #-}     -- | The sixth norm for the list of non-negative 'Int'. norm6 :: [Int] -> Int-norm6 !xs = floor (fromIntegral (norm5 xs * sum xs) / fromIntegral (norm3 xs))+norm6 xs = floor (fromIntegral (norm5 xs * sum xs) / fromIntegral (norm3 xs)) {-# INLINE norm6 #-}  -- | Splits a given list of non-negative integers into lists of elements not equal to zero and then applies to them the norms from the 'V.Vector' starting 

@@ -1,303 +0,0 @@--- |--- Module      :  DobutokO.Poetry.PrependAppend--- Copyright   :  (c) OleksandrZhabenko 2020--- License     :  MIT--- Stability   :  Experimental--- Maintainer  :  olexandr543@yahoo.com------ Helps to order the 7 or less Ukrainian words (or their concatenations) --- to obtain (to some extent) suitable for poetry or music text. --- In contrast to the the same named functions from the 'DobutokO.Poetry' module each its function uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.--{-# LANGUAGE BangPatterns #-}--module DobutokO.Poetry.PrependAppend (-  -- * Main functions-  uniq10Poetical4-  , uniq10Poetical5-  , uniq10PoeticalG-  , uniqNPoeticalG-  , uniqNPoeticalGN-  , uniqNPoeticalN-  , uniqNPoeticalVN-  , uniqNPoeticalVGN-  -- * Additional functions-  , uniquenessVariantsGN-  , uniqMaxPoeticalGN-  , uniqMaxPoeticalGNV-  , uniqInMaxPoeticalN-  -- * Generalized variants-  -- ** Main ones-  , uniqNPoetical2GN-  , uniqNPoetical2VGN-  , uniqNPoeticalUGN_-  , uniqNPoeticalUGN-  , uniqNPoeticalUGN51_-  , uniqNPoeticalUGN51-  -- ** Additional functions-  , uniqMaxPoetical2GN-  -- * On one line output-  , uniqInMaxPoeticalNLine-  , uniqNPoeticalNLine-  , uniqNPoetical2GNLine-  -- * With all the norms used-  , uniqMaxPoeticalGNL-  , uniqInMaxPoeticalNL-  , uniqInMaxPoeticalNLineL-  , uniqNPoeticalNL-  , uniqNPoeticalNLineL-  , uniqNPoeticalVNL-  , uniqNPoeticalGNL-  , uniqNPoeticalVGNL-  , uniqMaxPoetical2GNL-  , uniqMaxPoeticalGNVL-  , uniqNPoetical2GNL-  , uniqNPoetical2GNLineL-  , uniqNPoetical2VGNL-  , uniqNPoeticalUGNL_-  , uniqNPoeticalUGNL-) where--import Data.Char (isPunctuation)-import qualified Data.Vector as V-import Data.List ((\\))-import MMSyn7s-import DobutokO.Poetry.Norms-import DobutokO.Poetry.Auxiliary-import DobutokO.Poetry.UniquenessPeriodsG-import DobutokO.Poetry.StrictV-import DobutokO.Poetry.Basic---- | Generalization of the 'uniquenessVariantsG' with usage of several norms (instead of one). They constitute a 'V.Vector' of functions --- @norm :: [Int] -> Int@. So the inner vector in the each resulting 'Uniqueness' has the same length as the vector of norms. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniquenessVariantsGN :: String -> String -> V.Vector ([Int] -> Int) -> String -> V.Vector Uniqueness-uniquenessVariantsGN !ts !us vN = uniquenessVariants2GNP ts us vN (uniquenessPeriods)-{-# INLINE uniquenessVariantsGN #-}---- | Generalized variant of the 'uniqMaxPoeticalG' with the several norms given as a 'V.Vector' of functions and an 'Int' parameter. The function evaluates --- the generated 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order and significance (principality) --- of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is the 'Int' argument of the function --- minus 1, then less significant is the next to the left norm and so on.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqMaxPoeticalGN :: String -> String -> Int -> V.Vector ([Int] -> Int) ->  String -> Uniqueness-uniqMaxPoeticalGN !ts !us k vN = uniqMaxPoetical2GN ts us k vN (uniquenessPeriods)-{-# INLINE uniqMaxPoeticalGN #-}---- | Variant of 'uniqMaxPoeticalGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqMaxPoeticalGNL :: String -> String -> V.Vector ([Int] -> Int) ->  String -> Uniqueness-uniqMaxPoeticalGNL !ts !us vN = uniqMaxPoeticalGN ts us (V.length vN) vN-{-# INLINE uniqMaxPoeticalGNL #-}---- | A variant of the 'uniqNPoeticalGN' with only one norm.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalG :: String -> String -> Int -> ([Int] -> Int) -> String -> IO ()-uniqNPoeticalG !ts !us n g = uniqNPoeticalGN ts us n 1 (V.singleton g)-{-# INLINE uniqNPoeticalG #-}---- | A variant of the 'uniqNPoeticalG' function with the @n@ equal to 10.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniq10PoeticalG :: String -> String -> ([Int] -> Int) -> String -> IO ()-uniq10PoeticalG !ts !us = uniqNPoeticalG ts us 10-{-# INLINE uniq10PoeticalG #-}---- | A variant of 'uniq10PoeticalG' with the 'norm4' applied. The list is (according to some model, not universal, but a reasonable one in the most cases) the --- most suitable for intonation changing and, therefore, for the accompaniment of the highly changable or variative melody. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniq10Poetical4 :: String -> String -> String -> IO ()-uniq10Poetical4 !ts !us = uniq10PoeticalG ts us norm4-{-# INLINE uniq10Poetical4 #-}---- | A variant of 'uniq10PoeticalG' with the 'norm5' applied. The list is (according to some model, not universal, but a reasonable one in the most cases) the --- most suitable for rhythmic speech and two-syllabilistic-based poetry. Therefore, it can be used to create a poetic composition or to emphasize some --- thoughts. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniq10Poetical5 :: String -> String -> String -> IO ()-uniq10Poetical5 !ts !us = uniq10PoeticalG ts us norm5-{-# INLINE uniq10Poetical5 #-}---- | A variant of the 'uniqNPoetical2GN' with the conversion (\"uniquenessPeriods\" function) function 'uniquenessPeriods'.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalGN :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()-uniqNPoeticalGN !ts !us n k vN = uniqNPoetical2GN ts us n k vN (uniquenessPeriods)-{-# INLINE uniqNPoeticalGN #-}---- | Variant of 'uniqNPoeticalGN' where all the elements in the norms 'V.Vector' are used as norms from right to left. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalGNL :: String -> String -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()-uniqNPoeticalGNL !ts !us n vN = uniqNPoetical2GNL ts us n vN (uniquenessPeriods)-{-# INLINE uniqNPoeticalGNL #-}---- | Generalized variant of the 'uniqNPoeticalVG' with usage of several norms. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalVGN :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO (V.Vector Uniqueness)-uniqNPoeticalVGN !ts !us n k vN = uniqNPoetical2VGN ts us n k vN (uniquenessPeriods)-{-# INLINE uniqNPoeticalVGN #-}---- | Variant of 'uniqNPoeticalVGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalVGNL :: String -> String -> Int -> V.Vector ([Int] -> Int) -> String -> IO (V.Vector Uniqueness)-uniqNPoeticalVGNL !ts !us n vN = uniqNPoetical2VGN ts us n (V.length vN) vN (uniquenessPeriods)-{-# INLINE uniqNPoeticalVGNL #-}---- | The function evaluates --- the generated 'V.Vector' of 'Uniqueness' elements to retrieve the possibly maximum element in it with respect to the order and significance (principality) --- of the norms being evaluated. The most significant and principal is the norm, which index in the 'V.Vector' of them is the 'Int' argument of the function --- minus 1, then less significant is the next to the left norm and so on.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqMaxPoetical2GN :: String -> String -> Int -> V.Vector ([Int] -> Int) ->  (String -> [Int]) -> String -> Uniqueness-uniqMaxPoetical2GN !ts !us k vN g !xs- | compare k (V.length vN) == GT = error "DobutokO.Poetry.PrependAppend.uniqMaxPoetical2GN: undefined for that amount of norms. "- | compare k 0 == GT =-   let vM = uniquenessVariants2GNP ts us vN g xs-       maxK = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 (k - 1)) (V.unsafeIndex vN1 (k - 1))) vM-       vK = V.filter (\(_,vN2,_) -> V.unsafeIndex vN2 (k - 1) == ((\(_,vNk,_) -> V.unsafeIndex vNk (k - 1)) maxK)) vM in-         uniqMaxPoeticalGNV (k - 1) (V.unsafeSlice 0 (V.length vN - 1) vN) vK- | otherwise = V.maximumBy (\(_,vN0,_) (_,vN1,_) -> compare (V.unsafeIndex vN0 0) (V.unsafeIndex vN1 0)) . uniquenessVariantsGN ts us vN $ xs---- | Variant of 'uniqMaxPoetical2GN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqMaxPoetical2GNL :: String -> String -> V.Vector ([Int] -> Int) ->  (String -> [Int]) -> String -> Uniqueness-uniqMaxPoetical2GNL !ts !us vN = uniqMaxPoetical2GN ts us (V.length vN) vN-{-# INLINE uniqMaxPoetical2GNL #-}-  --- | Prints @n@ (given as the first 'Int' argument) maximum elements with respect to the several norms (their quantity is the second 'Int' argument) starting --- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2GN :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()-uniqNPoetical2GN !ts !us n k vN g !xs- | n == 0 = return ()- | otherwise = do-   let v = uniquenessVariants2GNP ts us vN g xs-   if compare (V.length v) n == LT-     then V.mapM_ (\x -> putStrLn ((filter (not . isPunctuation) . lastFrom3 $ x)) >> putStrLn "" ) v-     else (uniqInMaxPoeticalN k vN v >>= uniqNPoeticalN (n - 1) k vN)---- | Variant of 'uniqNPoetical2GN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2GNL :: String -> String -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()-uniqNPoetical2GNL !ts !us n vN = uniqNPoetical2GN ts us n (V.length vN) vN-{-# INLINE uniqNPoetical2GNL #-}- --- | Generalized variant of the 'uniqNPoeticalG' with usage of the several norms, but prints its output on the same line. --- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2GNLine :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()-uniqNPoetical2GNLine !ts !us n k vN g !xs- | n == 0 = putStrLn ""- | otherwise = do-   let v = uniquenessVariants2GNP ts us vN g xs-   if compare (V.length v) n == LT-     then V.mapM_ (\x -> putStr ((filter (not . isPunctuation) . lastFrom3 $ x)) >> putStr " " ) v >> putStrLn ""-     else (uniqInMaxPoeticalNLine k vN v >>= uniqNPoeticalNLine (n - 1) k vN)---- | Variant of 'uniqNPoetical2GNLine' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2GNLineL :: String -> String -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO ()-uniqNPoetical2GNLineL !ts !us n vN = uniqNPoetical2GNLine ts us n (V.length vN) vN-{-# INLINE uniqNPoetical2GNLineL #-}- --- | Prints @n@ (given as the first 'Int' argument) maximum elements with respect to the several norms (their quantity is the second 'Int' argument) starting --- from the right to the left. The last norm is the first element in the 'V.Vector' of norms (@[Int] -> Int@). Contrary to its pair function --- 'uniqNPoetical2GN' returns then the rest of the given 'V.Vector' 'Uniqueness' after filtering the printed elements 'String'.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2VGN :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO (V.Vector Uniqueness)-uniqNPoetical2VGN !ts !us n k vN g !xs- | n == 0 = return V.empty- | otherwise = do-   let v = uniquenessVariants2GNP ts us vN g xs-   if compare (V.length v) n == LT then return v else uniqNPoeticalVN n k vN v---- | Variant of 'uniqNPoetical2VGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoetical2VGNL :: String -> String -> Int -> V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> IO (V.Vector Uniqueness)-uniqNPoetical2VGNL !ts !us n vN = uniqNPoetical2VGN ts us n (V.length vN) vN-{-# INLINE uniqNPoetical2VGNL #-}- --- | Variant of the 'uniqNPoetical2GN', which uses as a function 'uniquenessPeriods2' with the first argument equal to the first 'Int' argument.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGN_ :: String -> String -> Int -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()-uniqNPoeticalUGN_ !ts !us x n k vN = uniqNPoetical2GN ts us n k vN (uniquenessPeriods2 x)-{-# INLINE uniqNPoeticalUGN_ #-}---- | Variant of 'uniqNPoeticalUGN_' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGNL_ :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO ()-uniqNPoeticalUGNL_ !ts !us x n vN = uniqNPoetical2GNL ts us n vN (uniquenessPeriods2 x)-{-# INLINE uniqNPoeticalUGNL_ #-}---- | Variant of the 'uniqNPoetical2VGN', which uses as a function 'uniquenessPeriods2' with the first argument equal to the first 'Int' argument.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGN :: String -> String -> Int -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO (V.Vector Uniqueness)-uniqNPoeticalUGN !ts !us x n k vN = uniqNPoetical2VGN ts us n k vN (uniquenessPeriods2 x)-{-# INLINE uniqNPoeticalUGN #-}---- | Variant of 'uniqNPoeticalUGN' where all the elements in the norms 'V.Vector' are used as norms from right to left.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGNL :: String -> String -> Int -> Int -> V.Vector ([Int] -> Int) -> String -> IO (V.Vector Uniqueness)-uniqNPoeticalUGNL !ts !us x n vN = uniqNPoetical2VGN ts us n (V.length vN) vN (uniquenessPeriods2 x)-{-# INLINE uniqNPoeticalUGNL #-}---- | Variant of the 'uniqNPoeticalUGN_', which uses as a single norm 'norm51'.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGN51_ :: String -> String -> Int -> Int -> String -> IO ()-uniqNPoeticalUGN51_ !ts !us x n = uniqNPoeticalUGN_ ts us x n 1 (V.singleton norm51)-{-# INLINE uniqNPoeticalUGN51_ #-}---- | Variant of the 'uniqNPoeticalUGN', which uses as a single norm 'norm51'.--- In contrast to the the same named function from the 'DobutokO.Poetry' module uses in the processment prepending and appending 'String' given --- as the first two arguments. The first one is prepended and the second one is appended to the processed 'String' to be processed with it. --- This allows to create more connection with the previous and postpending text.-uniqNPoeticalUGN51 :: String -> String -> Int -> Int -> String -> IO (V.Vector Uniqueness)-uniqNPoeticalUGN51 !ts !us x n = uniqNPoeticalUGN ts us x n 1 (V.singleton norm51)-{-# INLINE uniqNPoeticalUGN51 #-}

@@ -9,17 +9,20 @@ -- to obtain (to some extent) suitable for poetry or music text. The main  -- module in the library that imports all other ones except Main. -{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE CPP, BangPatterns #-}  module DobutokO.Poetry.StrictV where ---import Data.Maybe (fromJust)---import Data.Char (isPunctuation)+#ifdef __GLASGOW_HASKELL__+#if __GLASGOW_HASKELL__>=710+/* code that applies only to GHC 7.10.* and higher versions */+import GHC.Base ((<>))+import Prelude hiding ((<>))+#endif+#endif+ import qualified Data.Vector as V import qualified Data.List as L (permutations)---import MMSyn7s---import DobutokO.Poetry.Norms---import DobutokO.Poetry.UniquenessPeriodsG  -- | Given a 'String' consisting of no more than 7 Ukrainian words [some of them can be created by concatenation with preserving the Ukrainian  -- pronunciation of the parts, e. g. \"так як\" (actually two correct Ukrainian words and a single conjunction) can be written \"такйак\" @@ -27,7 +30,7 @@ -- it returns a 'V.Vector' of possible combinations without repeating of the words in different order and for each of them appends also  -- the information about 'uniquenessPeriods' to it and finds out three different metrics -- named \"norms\".  -- --- Afterwards, depending on these norms it can be specified some phonetical properties of the words that +-- Afterwards, depending on these norms some phonetical properties of the words can be specified that  -- allow to use them poetically or to create a varied melody with them.  uniquenessVariants2GN :: V.Vector ([Int] -> Int) -> (String -> [Int]) -> String -> V.Vector ([Int],V.Vector Int, String) uniquenessVariants2GN vN g !xs = uniquenessVariants2GNP [] [] vN g xs @@ -38,6 +41,19 @@ uniquenessVariants2GNP !ts !us vN g !xs    | null . words $ xs = V.empty   | otherwise = let !v0 = V.fromList . take 8 . words $ xs in-     V.fromList . map ((\vs -> let !rs = g vs in (rs, (V.map (\f -> f rs) vN), vs)) . unwords . (ts:) . (++ [us]) . V.toList . -        V.backpermute v0 . V.fromList) . L.permutations $ ([0..(V.length v0 - 1)]::[Int])-{-# INLINE uniquenessVariants2GNP #-}+     V.fromList . map ((\vs -> let !rs = g vs in (rs, (V.map (\f -> f rs) vN), vs)) . unwords . preAppend ts [us] . V.toList . +       V.backpermute v0 . V.fromList) . L.permutations $ ([0..(V.length v0 - 1)]::[Int])+++preAppend :: [a] -> [[a]] -> [[a]] -> [[a]]+#ifdef __GLASGOW_HASKELL__+#if __GLASGOW_HASKELL__>=710+preAppend ts !uss tss = ts:tss <> uss+#endif+#endif+#ifdef __GLASGOW_HASKELL__+#if __GLASGOW_HASKELL__==708+preAppend ts !uss tss = ts:tss ++ uss+#endif+#endif+{-# INLINE preAppend #-}

@@ -9,13 +9,29 @@ -- to obtain (to some extent) suitable for poetry or music text. This module  -- provides a functionality to define more complex uniquenessPeriods functions. +{-# LANGUAGE CPP #-}+ module DobutokO.Poetry.UniquenessPeriodsG where +#ifdef __GLASGOW_HASKELL__+#if __GLASGOW_HASKELL__>=710+/* code that applies only to GHC 7.10.* and higher versions */+import GHC.Base (mconcat)+#endif+#endif+ import qualified Data.Vector as V import Data.List ((\\),nubBy) import MMSyn7s import Melodics.Ukrainian (convertToProperUkrainian) +#ifdef __GLASGOW_HASKELL__+#if __GLASGOW_HASKELL__==708+/* code that applies only to GHC 7.8.* */+mconcat = concat+#endif+#endif+ -- | More complicated and longer variant of the 'MMSyn7s.uniquenessPeriods' that takes into account the second order structure of uniqueness with 'uniquenessP2' and  -- can be therefore more fruitful (probably, it is a hypothesis itself that is needed to be tested). Is provided here as an example of the more complex  -- \"uniqueness function\". Uses both 'uniqueness2' and 'uniqueness2n' inside and is actually their composition with some (hopefully, natural) parameter functions.@@ -28,7 +44,7 @@  | null xs = ([],[])  | otherwise =      let ys = f xs-        y2s = concat . g $ ys in (ys,y2s)+        y2s = mconcat . g $ ys in (ys,y2s)  -- | Being given two functions as parameters uses them to create a longer list of 'Int' then application of only one of them. Besides, it can take into  -- account the possible 0 and to create a non-negative list of 'Int' that can be used e. g. by 'DobutokO.Norms.splitNorm'.

@@ -12,16 +12,17 @@  import Control.Exception (onException) import System.IO-import DobutokO.Poetry (uniq10Poetical4,uniq10Poetical5,uniqNPoeticalG)-import DobutokO.Poetry.Norms (norm4,norm5)+import DobutokO.Poetry (uniqNPoeticalG)+import DobutokO.Poetry.Norms (norm4,norm5,norm51,norm513,norm6) import System.Environment (getArgs) import Melodics.Executable (recFileName, printInfoF, rawToSoundFile) import Melodics.Ukrainian (appendS16LEFile, convertToProperUkrainian) import EndOfExe (showE) import Data.Maybe (fromJust,isJust) --- | The first command line argument specifies which function to run. If given \"4\" it runs 'uniqNPoeticalG' 'norm4', otherwise 'uniqNPoeticalG' 'norm5'. --- The second command line argument (by default is considered equal to 10::Int) is an 'Int' number of the needed printed variants. The next 7 +-- | The first command line argument specifies which function to run. If given \"4\" it runs 'uniqNPoeticalG' 'norm4', \"51\" it runs 'uniqNPoeticalG' 'norm51', +-- \"513\" it runs 'uniqNPoeticalG' 'norm513', \"6\" it runs 'uniqNPoeticalG' 'norm6', otherwise 'uniqNPoeticalG' 'norm5'. +-- The second command line argument is an 'Int' number of the needed printed variants. The next 7  -- are treated as the Ukrainian words to be ordered accordingly to the norm. For more information, please, refer to the documentation for the abovementioned  -- functions.  -- @@ -36,9 +37,10 @@     let aa = read arg01::Int     return aa) (return 10)   case (arg0,arg1) of-   ("4",10) -> uniq10Poetical4 word1s -   (_,10) -> uniq10Poetical5 word1s-   ("4",n) -> uniqNPoeticalG n norm4 word1s +   ("4",n) -> uniqNPoeticalG n norm4 word1s+   ("51",n) -> uniqNPoeticalG n norm51 word1s +   ("513",n) -> uniqNPoeticalG n norm513 word1s+   ("6",n) -> uniqNPoeticalG n norm6 word1s     ~(_,n) -> uniqNPoeticalG n norm5 word1s    putStrLn "What string would you like to record as a Ukrainian text sounding by mmsyn6ukr package? "   str <- getLine

@@ -0,0 +1,39 @@+There are different languages. They have different structure and rules. +But there is a possibility to create and use (on the one of the existing +vastly used and well spreaded languages basis, in this work, the +Ukrainian one) the "phonetical" language more suitable for poetry and +music. Even there can be different variants of the +phonetical language. This work proposes to create at least two new +"phonetical" languages on the Ukrainian basis. ++Imagine, you can understand the information in the text no matter of +the words order and only with the most needed grammar preserved (for +example, the rule not to separate the preposition and the next word +is preserved). Understand just like you can read the text (after +some instruction and training might be) the text with the words where +only the first and the last letters are preserved on their places and +the rest are interchangeably mixed. So imagine, you can understand (and +express your thoughts, feeling, motives and so on) the message of the +text with no strict word order preserved. ++In such a case, you can rearrange words (preserving the most important +rules in this case to reduce or even completely eliminate ambiguity) so +that they can obtain more interesting phonetical sounding. You can try +to create poetic (at least somewhat rhythmic and expressive) text or +music. This can be an inspiring and developing exercise itself. But +how can you quickly find out which combinations are more or less suitable? +Besides, can the complexity of the algorithms be reduced? ++These are some of the interesting questions. The work does not at the +moment answers them, but is experimental, still may be valueable. ++Ukrainian is the language with no strict words order needed (though there +do exist some preferences in it) and have rather pleasant sounding. So it +can be a good example and instance. Besides for the author it is a native +language.++Even if you would not like to create and use "phonetical" languages where +phonetics is of more importance than the grammar, then you can evaluate the +phonetical potential of the words used in the text in producing specially +sounding texts. This can also be helpful in poetry writing and other +probably related fields.

@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                dobutokO-poetry-version:             0.7.0.0+version:             0.8.0.0 synopsis:            Helps to order the 7 or less Ukrainian words to obtain somewhat suitable for poetry or music text description:         Helps to order the 7 or less Ukrainian words (or their concatenations) to obtain somewhat suitable for poetry or music text. Can be also used as a research instrument with generalized functions. @@ -11,24 +11,24 @@ license-file:        LICENSE author:              OleksandrZhabenko maintainer:          olexandr543@yahoo.com--- copyright:+copyright:           Oleksandr Zhabenko category:            Language, Game build-type:          Simple-extra-source-files:  ChangeLog.md+extra-source-files:  ChangeLog.md, README.md cabal-version:       >=1.10  library-  exposed-modules:     DobutokO.Poetry.Basic, DobutokO.Poetry, DobutokO.Poetry.PrependAppend, DobutokO.Poetry.StrictV, DobutokO.Poetry.Auxiliary, DobutokO.Poetry.Norms, DobutokO.Poetry.UniquenessPeriodsG, Main+  exposed-modules:     DobutokO.Poetry.Basic, DobutokO.Poetry, DobutokO.Poetry.StrictV, DobutokO.Poetry.Auxiliary, DobutokO.Poetry.Norms, DobutokO.Poetry.UniquenessPeriodsG, Main, DobutokO.Poetry.General   -- other-modules:-  other-extensions:    BangPatterns+  other-extensions:    BangPatterns, CPP, FlexibleInstances, MultiParamTypeClasses   build-depends:       base >=4.7 && <4.15, vector >=0.11 && <0.14, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.6.7 && <1, mmsyn6ukr >=0.7.3 && <1   -- hs-source-dirs:   default-language:    Haskell2010  executable dobutokO-poetry   main-is:             Main.hs-  other-modules:       DobutokO.Poetry.Basic, DobutokO.Poetry, DobutokO.Poetry.PrependAppend, DobutokO.Poetry.StrictV, DobutokO.Poetry.Auxiliary, DobutokO.Poetry.Norms, DobutokO.Poetry.UniquenessPeriodsG-  other-extensions:    BangPatterns+  other-modules:       DobutokO.Poetry.Basic, DobutokO.Poetry, DobutokO.Poetry.StrictV, DobutokO.Poetry.Auxiliary, DobutokO.Poetry.Norms, DobutokO.Poetry.UniquenessPeriodsG+  other-extensions:    BangPatterns, CPP   build-depends:       base >=4.7 && <4.15, vector >=0.11 && <0.14, mmsyn3 >=0.1.5 && <1, mmsyn7s >=0.6.7 && <1, mmsyn6ukr >=0.7.3 && <1   -- hs-source-dirs:   default-language:    Haskell2010