diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -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.
diff --git a/Data/Phonetic/Languages/Base.hs b/Data/Phonetic/Languages/Base.hs
--- a/Data/Phonetic/Languages/Base.hs
+++ b/Data/Phonetic/Languages/Base.hs
@@ -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#)
diff --git a/Data/Phonetic/Languages/Syllables.hs b/Data/Phonetic/Languages/Syllables.hs
--- a/Data/Phonetic/Languages/Syllables.hs
+++ b/Data/Phonetic/Languages/Syllables.hs
@@ -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 #-}
diff --git a/Data/Phonetic/Languages/Undefined.hs b/Data/Phonetic/Languages/Undefined.hs
deleted file mode 100644
--- a/Data/Phonetic/Languages/Undefined.hs
+++ /dev/null
@@ -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
-
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -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/
diff --git a/phonetic-languages-phonetics-basics.cabal b/phonetic-languages-phonetics-basics.cabal
--- a/phonetic-languages-phonetics-basics.cabal
+++ b/phonetic-languages-phonetics-basics.cabal
@@ -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: