phonetic-languages-phonetics-basics 0.6.3.0 → 0.7.0.0

raw patch · 6 files changed

+77/−159 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• Data/Phonetic/Languages/Base.hs +38/−41
• Data/Phonetic/Languages/Syllables.hs +23/−20
• Data/Phonetic/Languages/Undefined.hs +0/−95
• README.md +5/−0
• phonetic-languages-phonetics-basics.cabal +3/−3

@@ -82,3 +82,11 @@  * Sixth version revised D. Added Read and added / changed Show instances to the data types in the SegmentRulesG data type in the Data.Phonetic.Languages.Syllables module. ++## 0.7.0.0 -- 2021-06-04++* Seventh version. Introduces breaking changes, so the related code must be revised and probably rewritten.+The changes are related with the introducing the possibilities to represent also appearance of the sounds+in the written text being pronounced and the introduction more general concept of phonemes that creates+syllable instead of simpler vowel notion.+Removed the module Data.Phonetic.Languages.Undefined as one being not necessary.

@@ -61,11 +61,7 @@ import GHC.Arr import GHC.Exts --- | The intended conversion to the syllables for a written word is: --- @--- toSyllables . map rulesPR . stringToPRPL--- @--- The syllable after this is encoded with the representation with every 'Char' being some phonetic language phenomenon.+-- | The syllable after this is encoded with the representation with every 'Char' being some phonetic language phenomenon. -- To see its usual written representation, use the defined 'showRepr' function (please, implement your own one). data PhoneticsRepresentationPL = PR { string :: String, afterString :: String, beforeString :: String } |   PRAfter { string :: String, afterString :: String } |@@ -103,67 +99,68 @@  -- | Extended variant of the 'PhoneticsRepresentationPL' data type where the information for the 'Char' is encoded into the -- data itself. Is easier to implement the rules in the separate file by just specifying the proper and complete list of--- 'PhoneticsRepresentationPLX' values. -data PhoneticsRepresentationPLX = PRC { stringX :: String, afterStringX :: String, beforeStringX :: String, char :: Char } |-  PRAfterC { stringX :: String, afterStringX :: String, char :: Char } |-  PRBeforeC { stringX :: String, beforeStringX :: String, char :: Char } |-  PREmptyC { stringX :: String, char :: Char }+-- 'PhoneticsRepresentationPLX' values. While the 'char' function can be used to group 'PhoneticRepresentationPLX'+-- that represents some phenomenae, for the phonetic languages approach the 'string1' is used in the most cases.+data PhoneticsRepresentationPLX = PRC { stringX :: String, afterStringX :: String, beforeStringX :: String, char :: Char, string1 :: String } |+  PRAfterC { stringX :: String, afterStringX :: String, char :: Char, string1 :: String } |+  PRBeforeC { stringX :: String, beforeStringX :: String, char :: Char, string1 :: String } |+  PREmptyC { stringX :: String, char :: Char, string1 :: String }     deriving (Eq, Ord)  instance Show PhoneticsRepresentationPLX where-  show (PRC xs ys zs c) = intercalate " " ["RC", show zs, show xs, show ys, '\'':c:"\'"]-  show (PRAfterC xs ys c) = intercalate " " ["AC", show xs, show ys, '\'':c:"\'"]-  show (PRBeforeC xs zs c) = intercalate " " ["BC", show zs, show xs, '\'':c:"\'"]-  show (PREmptyC xs c) = "EC " `mappend` show xs `mappend` (' ':'\'':c:"\'")+  show (PRC xs ys zs c us) = intercalate " " ["RC", show zs, show xs, show ys, '\'':c:"\'", us]+  show (PRAfterC xs ys c us) = intercalate " " ["AC", show xs, show ys, '\'':c:"\'", us]+  show (PRBeforeC xs zs c us) = intercalate " " ["BC", show zs, show xs, '\'':c:"\'", us]+  show (PREmptyC xs c us) = "EC " `mappend` show xs `mappend` (' ':'\'':c:"\'") `mappend` us  instance PhoneticElement PhoneticsRepresentationPLX where   readPEMaybe rs     | not . any isLetter $ rs = Nothing     | otherwise = case ys of         "RC" -> case yss of-           [zs,xs,ts,cs] -> case cs of-               '\'':c:"\'" -> Just (PRC xs ts zs c)+           [zs,xs,ts,cs,us] -> case cs of+               '\'':c:"\'" -> Just (PRC xs ts zs c us)                _ -> Nothing            _ -> Nothing         "AC" -> case yss of-           [xs,ts,cs] -> case cs of-               '\'':c:"\'" -> Just (PRAfterC xs ts c)+           [xs,ts,cs,us] -> case cs of+               '\'':c:"\'" -> Just (PRAfterC xs ts c us)                _ -> Nothing            _ -> Nothing         "BC" -> case yss of-           [zs,xs,cs] -> case cs of-               '\'':c:"\'" -> Just (PRBeforeC xs zs c)+           [zs,xs,cs,us] -> case cs of+               '\'':c:"\'" -> Just (PRBeforeC xs zs c us)                _ -> Nothing            _ -> Nothing         "EC" -> case yss of-           [xs,cs] -> case cs of-               '\'':c:"\'" -> Just (PREmptyC xs c)+           [xs,cs,us] -> case cs of+               '\'':c:"\'" -> Just (PREmptyC xs c us)                _ -> Nothing            _ -> Nothing         _ -> Nothing        where (ys:yss) = words rs      isPRC :: PhoneticsRepresentationPLX -> Bool-isPRC (PRC _ _ _ _) = True+isPRC (PRC _ _ _ _ _) = True isPRC _ = False  isPRAfterC :: PhoneticsRepresentationPLX -> Bool-isPRAfterC (PRAfterC _ _ _) = True+isPRAfterC (PRAfterC _ _ _ _) = True isPRAfterC _ = False  isPRBeforeC :: PhoneticsRepresentationPLX -> Bool-isPRBeforeC (PRBeforeC _ _ _) = True+isPRBeforeC (PRBeforeC _ _ _ _) = True isPRBeforeC _ = False  isPREmptyC :: PhoneticsRepresentationPLX -> Bool-isPREmptyC (PREmptyC _ _) = True+isPREmptyC (PREmptyC _ _ _) = True isPREmptyC _ = False  fromX2PRPL :: PhoneticsRepresentationPLX -> PhoneticsRepresentationPL-fromX2PRPL (PREmptyC xs _) = PREmpty xs-fromX2PRPL (PRAfterC xs ys _) = PRAfter xs ys-fromX2PRPL (PRBeforeC xs zs _) = PRBefore xs zs-fromX2PRPL (PRC xs ys zs _) = PR xs ys zs+fromX2PRPL (PREmptyC xs _ _) = PREmpty xs+fromX2PRPL (PRAfterC xs ys _ _) = PRAfter xs ys+fromX2PRPL (PRBeforeC xs zs _ _) = PRBefore xs zs+fromX2PRPL (PRC xs ys zs _ _) = PR xs ys zs {-# INLINE fromX2PRPL #-}  -- | An analogue of the 'rulesPR' function for 'PhoneticsRepresentationPLX'. @@ -239,36 +236,36 @@ -- | Partial equivalence that is used to find the appropriate 'PhoneticsRepresentationPL' for the class of -- 'PhoneticsRepresentationPLX' values.  (~=) :: PhoneticsRepresentationPL -> PhoneticsRepresentationPLX -> Bool-(PR xs ys zs) ~= (PRC xs1 ys1 zs1 _) = xs == xs1 && ys == ys1 && zs == zs1-(PRAfter xs ys) ~= (PRAfterC xs1 ys1 _) = xs == xs1 && ys == ys1-(PRBefore ys zs) ~= (PRBeforeC ys1 zs1 _) = ys == ys1 && zs == zs1-(PREmpty xs) ~= (PREmptyC xs1 _) = xs1 == xs1+(PR xs ys zs) ~= (PRC xs1 ys1 zs1 _ _) = xs == xs1 && ys == ys1 && zs == zs1+(PRAfter xs ys) ~= (PRAfterC xs1 ys1 _ _) = xs == xs1 && ys == ys1+(PRBefore ys zs) ~= (PRBeforeC ys1 zs1 _ _) = ys == ys1 && zs == zs1+(PREmpty xs) ~= (PREmptyC xs1 _ _) = xs1 == xs1 _ ~= _ = False  -- | Partial equivalence that is used to find the appropriate 'PhoneticsRepresentationPL' for the class of -- 'PhoneticsRepresentationPLX' values.  compareG :: PhoneticsRepresentationPL -> PhoneticsRepresentationPLX -> Ordering-compareG (PR xs ys zs) (PRC xs1 ys1 zs1 _)+compareG (PR xs ys zs) (PRC xs1 ys1 zs1 _ _)  | xs /= xs1 = compare xs xs1  | ys /= ys1 = compare ys ys1  | zs /= zs1 = compare zs zs1  | otherwise = EQ compareG (PR _ _ _) _ = LT-compareG (PREmpty xs) (PREmptyC xs1 _)+compareG (PREmpty xs) (PREmptyC xs1 _ _)  | xs /= xs1 = compare xs xs1  | otherwise = EQ compareG (PREmpty _) _ = GT-compareG (PRAfter xs ys) (PRAfterC xs1 ys1 _)+compareG (PRAfter xs ys) (PRAfterC xs1 ys1 _ _)  | xs /= xs1 = compare xs xs1  | ys /= ys1 = compare ys ys1  | otherwise = EQ-compareG (PRAfter _ _) (PRC _ _ _ _) = GT+compareG (PRAfter _ _) (PRC _ _ _ _ _) = GT compareG (PRAfter _ _) _ = LT-compareG (PRBefore ys zs) (PRBeforeC ys1 zs1 _)+compareG (PRBefore ys zs) (PRBeforeC ys1 zs1 _ _)  | ys /= ys1 = compare ys ys1  | zs /= zs1 = compare zs zs1  | otherwise = EQ-compareG (PRBefore _ _) (PREmptyC _ _) = LT+compareG (PRBefore _ _) (PREmptyC _ _ _) = LT compareG (PRBefore _ _) _ = GT  -- | Is somewhat rewritten from the 'CaseBi.Arr.gBF3' function (not exported) from the @mmsyn2-array@ package.@@ -323,7 +320,7 @@   -> Array Int PhoneticsRepresentationPLX   -> Maybe PhoneticsRepresentationPLX findSAI repr (xs,ys) arr- | isLeft repr = gBF3 (# i#, k #) (# j#, m #) (fromX2PRPL . fromLeft (PREmptyC " " ' ') $ repr) arr+ | isLeft repr = gBF3 (# i#, k #) (# j#, m #) (fromX2PRPL . fromLeft (PREmptyC " " ' ' " ") $ repr) arr  | otherwise = gBF3 (# i#, k #) (# j#, m #) (str2PRPL (fromRight [] repr) (xs,ys)) arr      where !(I# i#,I# j#) = bounds arr            !k = unsafeAt arr (I# i#)

@@ -39,16 +39,16 @@   , groupSnds   , divCnsnts   , reSyllableCntnts-  , divVwls+  , divSylls   , createSyllablesPL   -- * Auxiliary functions   , gBF4   , findC-  , isVowel1+  , createsSyllable   , isSonorous1   , isVoicedC1   , isVoicelessC1-  , isNotVowel2+  , notCreatesSyllable2   , notEqC   , fromPhoneticType ) where@@ -133,10 +133,13 @@ str2PRSs :: CharPhoneticClassification -> String -> StringRepresentation str2PRSs arr = map (\c -> fromJust . findC c $ arr)   --- | Function-predicate 'isVowel1' checks whether its argument is a vowel representation in the 'PRS' format.-isVowel1 :: PRS -> Bool-isVowel1 = (== P 0) . phoneType-{-# INLINE isVowel1 #-}+-- | Function-predicate 'createsSyllable' checks whether its argument is a phoneme representation that+-- every time being presented in the text leads to the creation of the new syllable (in the 'PRS' format).+-- Usually it is a vowel, but in some languages there can be syllabic phonemes that are not considered to be+-- vowels.+createsSyllable :: PRS -> Bool+createsSyllable = (== P 0) . phoneType+{-# INLINE createsSyllable #-}  -- | Function-predicate 'isSonorous1' checks whether its argument is a sonorous consonant representation in the 'PRS' format. isSonorous1 :: PRS -> Bool@@ -153,12 +156,12 @@ isVoicelessC1 =  (`elem` [P 5,P 6]) . phoneType {-# INLINE isVoicelessC1 #-} --- | Binary function-predicate 'isNotVowel2' checks whether its arguments are both consonant representations in the 'PRS' format.-isNotVowel2 :: PRS -> PRS -> Bool-isNotVowel2 x y+-- | Binary function-predicate 'notCreatesSyllable2' checks whether its arguments are both consonant representations in the 'PRS' format.+notCreatesSyllable2 :: PRS -> PRS -> Bool+notCreatesSyllable2 x y   | phoneType x == P 0 || phoneType y == P 0 = False   | otherwise = True-{-# INLINE isNotVowel2 #-}+{-# INLINE notCreatesSyllable2 #-}  -- | Binary function-predicate 'notEqC' checks whether its arguments are not the same consonant sound representations (not taking palatalization into account). notEqC@@ -175,11 +178,11 @@ -- | Function 'sndGroups' converts a word being a list of 'PRS' to the list of phonetically similar (consonants grouped with consonants and each vowel separately) -- sounds representations in 'PRS' format. sndGroups :: [PRS] -> [[PRS]]-sndGroups ys@(_:_) = L.groupBy isNotVowel2 ys+sndGroups ys@(_:_) = L.groupBy notCreatesSyllable2 ys sndGroups _ = []  groupSnds :: [PRS] -> [[PRS]]-groupSnds = L.groupBy (\x y -> ((== P 0) . phoneType $ x) == ((== P 0) . phoneType $ y))+groupSnds = L.groupBy (\x y -> createsSyllable x == createsSyllable y)  data SegmentationInfo1 = SI {  fieldN :: !Int8,  -- ^ Number of fields in the pattern matching that are needed to apply the segmentation rules. Not less than 1.@@ -289,10 +292,10 @@ reSyllableCntnts _ _ (xs:ys:_) = [(xs `mappend` ys)] reSyllableCntnts _ _ xss = xss -divVwls :: [[PRS]] -> [[PRS]]-divVwls = mapI (\ws -> (length . filter ((== P 0) . phoneType) $ ws) > 1) h3-  where h3 us = [ys `mappend` take 1 zs] `mappend` (L.groupBy (\x y -> phoneType x == P 0 && phoneType y /= P 0) . drop 1 $ zs)-                  where (ys,zs) = span (\t -> phoneType t /= P 0) us+divSylls :: [[PRS]] -> [[PRS]]+divSylls = mapI (\ws -> (length . filter createsSyllable $ ws) > 1) h3+  where h3 us = [ys `mappend` take 1 zs] `mappend` (L.groupBy (\x y -> createsSyllable x && phoneType y /= P 0) . drop 1 $ zs)+                  where (ys,zs) = break createsSyllable us  {-| The function actually creates syllables using the provided data. Each resulting inner-most list is a phonetic language representation of the syllable according to the rules provided.@@ -306,14 +309,14 @@   -> String -- ^ Corresponds to the \'1\' and \'-\' symbol delimiters in the @ukrainian-phonetics-basic-array@ package.   -> String -- ^ Actually the converted 'String'.   -> [[[PRS]]]-createSyllablesPL wrs ks arr gs us vs = map (divVwls . reSyllableCntnts ks gs . groupSnds . str2PRSs arr) . words1 . mapMaybe g . convertToProperPL . map (\x -> if x == '-' then ' ' else x)+createSyllablesPL wrs ks arr gs us vs = map (divSylls . reSyllableCntnts ks gs . groupSnds . str2PRSs arr) . words1 . mapMaybe g . convertToProperPL . map (\x -> if x == '-' then ' ' else x)   where g x           | x `elem` us = Nothing           | x `notElem` vs = Just x           | otherwise = Just ' '         words1 xs = if null ts then [] else w : words1 s'' -- Practically this is an optimized version for this case 'words' function from Prelude.           where ts = dropWhile (== ' ') xs-                (w, s'') = span (/= ' ') ts+                (w, s'') = break (== ' ') ts         {-# NOINLINE words1 #-}-        convertToProperPL = map char . stringToXG wrs+        convertToProperPL = concatMap string1 . stringToXG wrs {-# INLINE createSyllablesPL #-}

@@ -1,95 +0,0 @@-{-# OPTIONS_HADDOCK show-extensions #-}---- |--- Module      :  Data.Phonetic.Languages.Undefined--- Copyright   :  (c) OleksandrZhabenko 2021--- License     :  MIT--- Stability   :  Experimental--- Maintainer  :  olexandr543@yahoo.com------ This is a computational scheme for generalized usage of the phonetic languages approach. --- The functions themselves are 'undefined' but with some type. They are just templates and some general idea.--- Please, provide your own implementation instead of using these ones.--module Data.Phonetic.Languages.Undefined {-# WARNING "This module contains just some templates and ideas. Please, provide the analogous functions by yourself, these ones while used return 'undefined'. " #-} (-  -- * Convert to the 'PhoneticsRepresentationPL'.-  stringToPRPL-  -- * Apply conversion from 'PhoneticsRepresentationPL'.-  , fromPRPL2X-  , rules-  , rulesPR-  -- * Convert from the 'PhoneticsRepresentationPL' after applying 'rulesPR' function-  -- or from the 'PhoneticsRepresentationPLX' after applying 'rulesX' function.-  , showRepr-  -- * Divide into syllables after both conversions.-  , toSyllables-) where--import Data.Phonetic.Languages.Base--{-| Every 'Char' value represents here the phonetic phenomenon, mostly (usually, or often) some phoneme.--}-rulesPR :: PhoneticsRepresentationPL -> Char-rulesPR (PREmpty xs) = rules xs Nothing Nothing-rulesPR (PRAfter xs ys) = rules xs (Just ys) Nothing-rulesPR (PRBefore xs zs) = rules xs Nothing (Just zs)-rulesPR (PR xs ys zs) = rules xs (Just ys) (Just zs)-{-# INLINE rulesPR #-}--fromPRPL2X :: PhoneticsRepresentationPL -> PhoneticsRepresentationPLX-fromPRPL2X y@(PREmpty xs) = PREmptyC xs (rulesPR y)-fromPRPL2X y@(PRAfter xs ys) = PRAfterC xs ys (rulesPR y)-fromPRPL2X y@(PRBefore xs zs) = PRBeforeC xs zs (rulesPR y)-fromPRPL2X y@(PR xs ys zs) = PRC xs ys zs (rulesPR y)-{-# INLINE fromPRPL2X #-}--{-| The text is converted to the phonetic languages representation by this function.-It is intended to be exported qualified, so that the function in every language-implementation has the same name and signature as here and the data type is used there.-Please, use this function only as a type and semantics template and implement your own one where needed.-If you can define some function 'stringToPRPL' where every 'PhoneticRepresentationPL' corresponds to the distinguishable-phonetic phenomenae then it is a considerable application for the possible phonetic languages approach usability for the-data.--}-stringToPRPL :: String -> [PhoneticsRepresentationPL]-stringToPRPL = undefined--{-| Every 'Char' value represents here the phonetic phenomenon, mostly (usually, or often) some phoneme.-It is intended to be exported qualified, so that the function in every language-implementation has the same name and signature as here and the data type is used there.-Please, use this function only as a type and semantics template and implement your own one where needed.--}-rules-  :: String -- ^ Is gotten as 'string' from 'PhoneticsRepresentationPL'-  -> Maybe String -- ^ Is gotten as 'afterString' from 'PhoneticsRepresentationPL'. Is 'Nothing' if there is no any.-  -> Maybe String -- ^ Is gotten as 'beforeString' from 'PhoneticsRepresentationPL'. Is 'Nothing' if there is no any.-  -> Char -rules = undefined--{-| Converts the converted from the 'PhoneticsRepresentationPL' conversion 'String' to syllables. -It is intended to be exported qualified, so that the function in every language-implementation has the same name and signature as here and the data type is used there.-Please, use this function only as a type and semantics template and implement your own one where needed.--}-toSyllables :: String -> [String]-toSyllables = undefined--{-| Converts the converted from the 'PhoneticsRepresentationPL' conversion 'Char' to the usual written-in the language 'String' for the phenomenon. -It is intended to be exported qualified, so that the function in every language-implementation has the same name and signature as here and the data type is used there.-Please, use this function only as a type and semantics template and implement your own one where needed.-After you have defined the 'rules' and 'showRepr' functions, you can implement the instance for 'Show' class-for the 'PhoneticsRepresentationPL' as:-instance Show PhoneticsRepresentationPL where-  show = showRepr . rulesPR-  {-# INLINE show #-}--Similarly for the 'PhoneticsRepresentationPLX':-instance Show PhoneticsRepresentationPLX where-  show = showRepr . rulesX-  {-# INLINE show #-}--}-showRepr :: Char -> String-showRepr = undefined-

@@ -1,3 +1,8 @@+The version 0.7.0.0 introduces breaking changes, so the related code must be revised and probably rewritten.+The changes are related with the introducing the possibilities to represent also appearance of the sounds+in the written text being pronounced and the introduction more general concept of phonemes that creates+syllable instead of simpler vowel notion.+ The executable pldPL is intended to use the functionality of the :  1) R programming language https://www.r-project.org/

@@ -3,7 +3,7 @@ -- http://haskell.org/cabal/users-guide/  name:                phonetic-languages-phonetics-basics-version:             0.6.3.0+version:             0.7.0.0 synopsis:            A library for working with generalized phonetic languages usage. description:         There already exists a Ukrainian implementation for the phonetic languages approach published at: https://hackage.haskell.org/package/phonetic-languages-simplified-examples-array. It is optimized for the Ukrainian only and needs to be rewritten for every new language mostly from scratch using it as a template. To avoid this boilerplate, this one is provided. It can be used for different languages and even for music or other fields. Now it combines the functionality of the @r-glpk-phonetic-languages-ukrainian-durations@ and @phonetic-languages-ukrainian-array@ and some dependencies of the mentioned one. homepage:            https://hackage.haskell.org/package/phonetic-languages-phonetics-basics@@ -18,7 +18,7 @@ cabal-version:       >=1.10  library-  exposed-modules:     Data.Phonetic.Languages.Undefined, Data.Phonetic.Languages.Base, Data.Phonetic.Languages.Syllables, Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations, Data.Phonetic.Languages.SpecificationsRead, Data.Phonetic.Languages.PrepareText+  exposed-modules:     Data.Phonetic.Languages.Base, Data.Phonetic.Languages.Syllables, Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations, Data.Phonetic.Languages.SpecificationsRead, Data.Phonetic.Languages.PrepareText   other-modules:       Main   other-extensions:    CPP, BangPatterns, UnboxedTuples, MagicHash, MultiParamTypeClasses, FlexibleInstances   ghc-options:         -funbox-strict-fields -fobject-code@@ -28,7 +28,7 @@  executable pldPL   main-is:             Main.hs-  other-modules:       Data.Phonetic.Languages.Undefined, Data.Phonetic.Languages.Base, Data.Phonetic.Languages.Syllables, Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations, Data.Phonetic.Languages.SpecificationsRead, Data.Phonetic.Languages.PrepareText+  other-modules:       Data.Phonetic.Languages.Base, Data.Phonetic.Languages.Syllables, Numeric.Wrapper.R.GLPK.Phonetic.Languages.Durations, Data.Phonetic.Languages.SpecificationsRead, Data.Phonetic.Languages.PrepareText   -- other-extensions:   build-depends:       base >=4.8 && <4.15, mmsyn2-array >=0.1.1 && <1, mmsyn5 >=0.5 && <1, lists-flines >=0.1.1 && <1, foldable-ix >=0.1 && <1   -- hs-source-dirs: