packages feed

phonetic-languages-simplified-examples-common 0.5.1.0 → 0.6.2.0

raw patch · 9 files changed

Files

CHANGELOG.md view
@@ -72,3 +72,17 @@  * Fifth version revised A. Updated the dependencies to use the new functionality. +## 0.6.0.0 -- 2023-03-01++* Sixth version. Switched to NoImplicitPrelude extension. Updated the dependencies boundaries+to support the new functionality.++## 0.6.1.0 -- 2023-03-02++* Sixth version revised A. Fixed issue with the same name of the module from the phonetic-languages-simplified-properties-array-common package.++## 0.6.2.0 -- 2023-03-15++* Sixth version revised B. Updated the dependencies boundaries so that to support the +new code deduplication for different implementations of PhLADiPreLiO.+
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) 2020-2022 OleksandrZhabenko+Copyright (c) 2020-2023 Oleksandr Zhabenko  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the
+ Phladiprelio/Ukrainian/CommonE.hs view
@@ -0,0 +1,63 @@+{-# OPTIONS_GHC -threaded -rtsopts #-}+{-# OPTIONS_HADDOCK show-extensions #-}+{-# LANGUAGE BangPatterns, FlexibleContexts, NoImplicitPrelude #-}++-- |+-- Module      :  Phladiprelio.Ukrainian.CommonE+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023+-- License     :  MIT+-- Stability   :  Experimental+-- Maintainer  :  oleksandr.zhabenko@yahoo.com+--+-- Some functions to provide show and print functionality for PhLADiPreLiO for Ukrainian language.+--++module Phladiprelio.Ukrainian.CommonE (+  fLinesN+  , fLines+  , fLinesNIO+  , fLinesIO+) where++import GHC.Base hiding (foldr)+import GHC.List (filter, break, dropWhile, init)+import Phladiprelio.Ukrainian.PrepareText+import Data.Char (isAlpha,isSpace)+import Data.Monoid (mappend)+import Data.Foldable (Foldable (..), any)+import GHC.Num ((+),(-))+import Text.Show (show)+import System.IO (putStrLn)++fLinesN :: Int -> Int -> String -> [String]+fLinesN n !toOneLine ys = filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n .+  (\z -> if toOneLine == 1 then unls z else z) $ ys+   -- the 'unls' is taken from the 'Data.List.words' and rewritten to be equal to 'unwords' . 'words'+   where unls s  =  case dropWhile isSpace s of+                      "" -> []+                      s' -> w `mappend` (' ' : unls s'')+                        where (w, s'') = break isSpace s'++fLines :: Int -> String -> [String]+fLines = fLinesN 7+{-# INLINE fLines #-}++fLinesNIO :: Int -> String -> IO ()+fLinesNIO n ys = mapM putStrLn (map (\(i,x) -> show (i + 1) `mappend` "\t" `mappend` x) . helpG3 . indexedL "" .+   filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n $ ys) >> return ()++fLinesIO :: String -> IO ()+fLinesIO = fLinesNIO 7+{-# INLINE fLinesIO #-}++-- | Is taken mostly from the Phonetic.Languages.Ukrainian.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.+indexedL :: Foldable t => b -> t b -> [(Int, b)]+indexedL y zs = foldr f v zs+  where !v = [(length zs,y)]+        f x ((j,z):ys) = (j-1,x):(j,z):ys+{-# INLINE indexedL #-}++helpG3 :: [a] -> [a]+helpG3 xs+ | null xs = []+ | otherwise = init xs
+ Phladiprelio/Ukrainian/DeEnCoding.hs view
@@ -0,0 +1,151 @@+{-# OPTIONS_GHC -threaded -rtsopts #-}+{-# OPTIONS_HADDOCK show-extensions #-}+{-# LANGUAGE BangPatterns, NoImplicitPrelude #-}++-- |+-- Module      :  Phladiprelio.Ukrainian.DeEnCoding+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023+-- License     :  MIT+-- Stability   :  Experimental+-- Maintainer  :  oleksandr.zhabenko@yahoo.com+--+-- Functions to encode and decode 'String' -> \['Int8'\] used in the Simple/Main.hs code.+-- Is taken from the @phonetic-languages-simplified-lists-examples@ package.++module Phladiprelio.Ukrainian.DeEnCoding where++import GHC.Base hiding (foldr)+import GHC.Num ((+),(-),(*))+import GHC.Real (quotRem)+import GHC.Enum (fromEnum,toEnum)+import Data.Tuple (fst,snd)+import qualified Data.Heap as Heap+import GHC.Int+import System.IO+import Data.Maybe (fromJust)+import Numeric (showHex,readHex)+import Phladiprelio.Ukrainian.Emphasis+import Phladiprelio.Ukrainian.Melodics (FlowSound)+import Phladiprelio.Ukrainian.Syllable+import Data.Foldable (Foldable, foldr,null,foldl')+import Data.List (sort,head,words,zip,length,unwords,init,partition,sortOn)++--default (Int, Double)++encodeToInt :: Ord a => [[a]] -> Int+encodeToInt yss+ | null ks = -1+ | otherwise = fst . head $ ks+  where ks = readHex (showHex (foldl' (\x y -> x * 16 + y) 0 . map (\(j,_) -> fromEnum j) . sortOn snd . trans2 $ yss) $ "")+{-# INLINABLE encodeToInt #-}++-- | Is taken mostly from the Phonetic.Languages.Ukrainian.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.+indexedL :: Foldable t => b -> t b -> [(Int8, b)]+indexedL y zs = foldr f v zs+  where !v = [(toEnum (length zs + 1),y)]+        f x ((j,z):ys) = (j-1,x):(j,z):ys+{-# INLINE indexedL #-}++trans2 :: [[a]] -> [(Int8, [a])]+trans2 = init . indexedL []+{-# INLINE trans2 #-}++trans232 :: [[a]] -> [(Int, [a])]+trans232 zs = init . foldr f v $ zs+  where !v = [(length zs + 1,[])]+        f x ((j,z):ys) = (j-1,x):(j,z):ys+{-# INLINE trans232 #-}++int2l :: Int -> [Int8]+int2l n+ | n < 16 = [toEnum n]+ | otherwise = int2l n1 `mappend` [l]+     where (!n1,!l0) = quotRem n 16+           !l = toEnum l0+{-# INLINABLE int2l #-}++-- | So for the strings consisting of no more than 10 words:+-- > decodeToStr (int2l . encodeToInt . words $ xs) xs == unwords . words $ xs+--+decodeToStr :: [Int8] -> String -> String+decodeToStr ys = unwords . map snd . sortOn fst . zip ys . sort . words+{-# INLINE decodeToStr #-}++-- | For the 'ReadyForConstructionUkr' that corresponds to the 'String' consisting of no more than 10 words.+--+decodeToReadyFCUkr :: [Int8] -> ReadyForConstructionUkr -> ReadyForConstructionUkr+decodeToReadyFCUkr ys (Str ts) = Str . unwords . map snd . sortOn fst . zip ys . sort . words $ ts+decodeToReadyFCUkr ys (FSL tsss) = FSL . map snd . sortOn fst . zip ys . sort $ tsss+{-# INLINE decodeToReadyFCUkr #-}++-- | Every 'String' consists of words with whitespace symbols in between.+toHeap :: [String] -> Heap.Heap Int+toHeap yss@(xs:xss)+  | null xss = Heap.singleton . encodeToInt . words $ xs+  | otherwise = Heap.fromList . map (encodeToInt . words) $ yss+toHeap _ = Heap.empty+{-# INLINE toHeap #-}++-- | Every 'ReadyForConstructionUkr' corresponds to the 'String' that consists of words with whitespace symbols in between.+-- The list must be consistent -- either 'FSL'-constructed or 'Str'-constructed.+toHeapR :: [ReadyForConstructionUkr] -> Heap.Heap Int+toHeapR yss@(xs@(Str ts):xss)+  | null xss = Heap.singleton . encodeToInt . words $ ts+  | otherwise = Heap.fromList . map (encodeToInt . words . fromJust . fromReadyFCUkrS) $ yss+toHeapR yss@(xs@(FSL tsss):xss)+  | null xss = Heap.singleton . encodeToInt $ tsss+  | otherwise = Heap.fromList . map (encodeToInt . fromJust . fromReadyFCUkrF) $ yss  +toHeapR _ = Heap.empty+{-# INLINE toHeapR #-}++fromHeap :: String -> Heap.Heap Int -> [String]+fromHeap ys heap+ | Heap.null heap = []+ | otherwise = map (flip decodeToStr ys . int2l) . Heap.toUnsortedList $ heap+{-# INLINE fromHeap #-}++fromHeapReadyFCUkr :: ReadyForConstructionUkr -> Heap.Heap Int -> [ReadyForConstructionUkr]+fromHeapReadyFCUkr ys heap+ | Heap.null heap = []+ | otherwise = map (flip decodeToReadyFCUkr ys . int2l) . Heap.toUnsortedList $ heap+{-# INLINE fromHeapReadyFCUkr #-}++intersectInterResults :: [String] -> [String] -> [String]+intersectInterResults zss+ | null zss = const []+ | otherwise = fromHeap (head zss) . Heap.intersect (toHeap zss) . toHeap+{-# INLINE intersectInterResults #-}++intersectInterReadyFCUkr :: (String -> [[FlowSound]]) -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]+intersectInterReadyFCUkr convF zss tss+ | null zss = []+ | null tss = []+ | (isStr . head $ tss) && (isStr . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss+ | (isFSL . head $ tss) && (isFSL . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss+ | isStr . head $ tss = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ tss+ | otherwise = fromHeapReadyFCUkr (head tss) . Heap.intersect (toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ zss) . toHeapR $ tss+{-# INLINE intersectInterReadyFCUkr #-}++intersectInterReadyFCUkr2 :: String -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]+intersectInterReadyFCUkr2 ts = intersectInterReadyFCUkr (convFI ts)+{-# INLINE intersectInterReadyFCUkr2 #-}++-- | Auxiliary printing function to define the line ending in some cases. Is taken from the+-- Languages.UniquenessPeriods.Vector.General.DebugG module from the @phonetic-languages-general@ package+newLineEnding :: String+newLineEnding+  | nativeNewline == LF = "\n"+  | otherwise = "\r\n"+  +foldlI :: String -> [[ReadyForConstructionUkr]] -> [ReadyForConstructionUkr]+foldlI ts jss@((!xs):ys:xss) + | null pss = foldlI' ts qss+ | null qss = foldlI' ts pss+ | otherwise = intersectInterReadyFCUkr2 ts (foldlI' ts pss) (foldlI' ts qss) +  where (pss,qss) = partition (< [FSL []]) jss+        foldlI' ts rss@(rs:ps:yss) = foldlI' ts (intersectInterReadyFCUkr2 ts rs ps : yss)+        foldlI' ts ((!xs):_) = xs+        foldlI' _ _ = []+foldlI _ ((!xs):_) = xs+foldlI _ _ = []+
+ Phladiprelio/Ukrainian/SimpleConstraints.hs view
@@ -0,0 +1,22 @@+-- |+-- Module      :  Phladiprelio.Ukrainian.SimpleConstraints+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023+-- License     :  MIT+-- Stability   :  Experimental+-- Maintainer  :  oleksandr.zhabenko@yahoo.com+--+-- Some code shared for different Main modules.++{-# LANGUAGE NoImplicitPrelude #-}++module Phladiprelio.Ukrainian.SimpleConstraints where++import GHC.Base+import Text.Show (show)+import GHC.Num ((-))+import GHC.List (concatMap)++showB :: Int -> Bool -> String+showB n bool+ | n >= 2 && bool == True = 'B':show (n - 1) `mappend` concatMap show [0..n - 2]+ | otherwise = ""
− Phonetic/Languages/Common.hs 
@@ -1,57 +0,0 @@-{-# OPTIONS_GHC -threaded -rtsopts #-}-{-# OPTIONS_HADDOCK show-extensions #-}-{-# LANGUAGE BangPatterns, FlexibleContexts #-}---- |--- Module      :  Phonetic.Languages.Common--- Copyright   :  (c) OleksandrZhabenko 2020-2021--- License     :  MIT--- Stability   :  Experimental--- Maintainer  :  olexandr543@yahoo.com-----------module Phonetic.Languages.Common (-  fLinesN-  , fLines-  , fLinesNIO-  , fLinesIO-) where--import Phonetic.Languages.Ukrainian.PrepareText-import Data.Char (isAlpha,isSpace)-import Data.Monoid (mappend)--fLinesN :: Int -> Int -> String -> [String]-fLinesN n !toOneLine ys = filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n .-  (\z -> if toOneLine == 1 then unls z else z) $ ys-   -- the 'unls' is taken from the 'Data.List.words' and rewritten to be equal to 'unwords' . 'words'-   where unls s  =  case dropWhile isSpace s of-                      "" -> []-                      s' -> w `mappend` (' ' : unls s'')-                        where (w, s'') = break isSpace s'--fLines :: Int -> String -> [String]-fLines = fLinesN 7-{-# INLINE fLines #-}--fLinesNIO :: Int -> String -> IO ()-fLinesNIO n ys = mapM_ putStrLn . map (\(i,x) -> show (i + 1) ++ "\t" ++ x) . helpG3 . indexedL "" .-   filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n $ ys--fLinesIO :: String -> IO ()-fLinesIO = fLinesNIO 7-{-# INLINE fLinesIO #-}---- | Is taken mostly from the Phonetic.Languages.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.-indexedL :: Foldable t => b -> t b -> [(Int, b)]-indexedL y zs = foldr f v zs-  where !v = [(length zs,y)]-        f x ((j,z):ys) = (j-1,x):(j,z):ys-{-# INLINE indexedL #-}--helpG3 :: [a] -> [a]-helpG3 xs- | null xs = []- | otherwise = init xs
− Phonetic/Languages/Simplified/DeEnCoding.hs 
@@ -1,150 +0,0 @@-{-# OPTIONS_GHC -threaded -rtsopts #-}-{-# OPTIONS_HADDOCK show-extensions #-}-{-# LANGUAGE BangPatterns #-}---- |--- Module      :  Phonetic.Languages.Simplified.DeEnCoding--- Copyright   :  (c) OleksandrZhabenko 2020-2022--- License     :  MIT--- Stability   :  Experimental--- Maintainer  :  olexandr543@yahoo.com------ Functions to encode and decode 'String' -> \['Int8'\] used in the Simple/Main.hs code.--- Is taken from the @phonetic-languages-simplified-lists-examples@ package.--module Phonetic.Languages.Simplified.DeEnCoding where--import Data.Heap (Heap)-import qualified Data.Heap as Heap-import GHC.Int-import Data.Foldable (foldl')-import Data.List (sortBy,sort,partition)-import System.IO-import Data.Maybe (fromJust)-import Numeric-import Phonetic.Languages.Emphasis-import Melodics.Ukrainian.ArrInt8 (FlowSound)-import Languages.Phonetic.Ukrainian.Syllable.ArrInt8----default (Int, Double)--encodeToInt :: Ord a => [[a]] -> Int-encodeToInt yss- | null ks = -1- | otherwise = fst . head $ ks-  where ks = readHex (showHex (foldl' (\x y -> x * 16 + y) 0 . map (\(j,_) -> fromEnum j) . sortBy (\x y -> compare (snd x) (snd y)) . trans2 $ yss) $ "")-{-# INLINABLE encodeToInt #-}----- | Is taken mostly from the Phonetic.Languages.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.-indexedL :: Foldable t => b -> t b -> [(Int8, b)]-indexedL y zs = foldr f v zs-  where !v = [(toEnum (length zs + 1),y)]-        f x ((j,z):ys) = (j-1,x):(j,z):ys-{-# INLINE indexedL #-}--trans2 :: [[a]] -> [(Int8, [a])]-trans2 = init . indexedL []-{-# INLINE trans2 #-}--trans232 :: [[a]] -> [(Int, [a])]-trans232 zs = init . foldr f v $ zs-  where !v = [(length zs + 1,[])]-        f x ((j,z):ys) = (j-1,x):(j,z):ys-{-# INLINE trans232 #-}--int2l :: Int -> [Int8]-int2l n- | n < 16 = [toEnum n]- | otherwise = int2l n1 `mappend` [l]-     where (!n1,!l0) = quotRem n 16-           !l = toEnum l0-{-# INLINABLE int2l #-}---- | So for the strings consisting of no more than 10 words:--- > decodeToStr (int2l . encodeToInt . words $ xs) xs == unwords . words $ xs----decodeToStr :: [Int8] -> String -> String-decodeToStr ys = unwords . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort . words-{-# INLINE decodeToStr #-}---- | For the 'ReadyForConstructionUkr' that corresponds to the 'String' consisting of no more than 10 words.----decodeToReadyFCUkr :: [Int8] -> ReadyForConstructionUkr -> ReadyForConstructionUkr-decodeToReadyFCUkr ys (Str ts) = Str . unwords . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort . words $ ts-decodeToReadyFCUkr ys (FSL tsss) = FSL . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort $ tsss-{-# INLINE decodeToReadyFCUkr #-}---- | Every 'String' consists of words with whitespace symbols in between.-toHeap :: [String] -> Heap Int-toHeap yss@(xs:xss)-  | null xss = Heap.singleton . encodeToInt . words $ xs-  | otherwise = Heap.fromList . map (encodeToInt . words) $ yss-toHeap _ = Heap.empty-{-# INLINE toHeap #-}---- | Every 'ReadyForConstructionUkr' corresponds to the 'String' that consists of words with whitespace symbols in between.--- The list must be consistent -- either 'FSL'-constructed or 'Str'-constructed.-toHeapR :: [ReadyForConstructionUkr] -> Heap Int-toHeapR yss@(xs@(Str ts):xss)-  | null xss = Heap.singleton . encodeToInt . words $ ts-  | otherwise = Heap.fromList . map (encodeToInt . words . fromJust . fromReadyFCUkrS) $ yss-toHeapR yss@(xs@(FSL tsss):xss)-  | null xss = Heap.singleton . encodeToInt $ tsss-  | otherwise = Heap.fromList . map (encodeToInt . fromJust . fromReadyFCUkrF) $ yss  -toHeapR _ = Heap.empty-{-# INLINE toHeapR #-}--fromHeap :: String -> Heap Int -> [String]-fromHeap ys heap- | Heap.null heap = []- | otherwise = map (flip decodeToStr ys . int2l) . Heap.toUnsortedList $ heap-{-# INLINE fromHeap #-}--fromHeapReadyFCUkr :: ReadyForConstructionUkr -> Heap Int -> [ReadyForConstructionUkr]-fromHeapReadyFCUkr ys heap- | Heap.null heap = []- | otherwise = map (flip decodeToReadyFCUkr ys . int2l) . Heap.toUnsortedList $ heap-{-# INLINE fromHeapReadyFCUkr #-}--intersectInterResults :: [String] -> [String] -> [String]-intersectInterResults zss- | null zss = const []- | otherwise = fromHeap (head zss) . Heap.intersect (toHeap zss) . toHeap-{-# INLINE intersectInterResults #-}---- | It seems like it works, but it isn't. (??). The main reason is the hardness with defining convF to work properly.-intersectInterReadyFCUkr :: (String -> [[FlowSound]]) -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]-intersectInterReadyFCUkr convF zss tss- | null zss = []- | null tss = []- | (isStr . head $ tss) && (isStr . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss- | (isFSL . head $ tss) && (isFSL . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss- | isStr . head $ tss = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ tss- | otherwise = fromHeapReadyFCUkr (head tss) . Heap.intersect (toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ zss) . toHeapR $ tss-{-# INLINE intersectInterReadyFCUkr #-}--intersectInterReadyFCUkr2 :: String -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]-intersectInterReadyFCUkr2 ts = intersectInterReadyFCUkr (convFI ts)-{-# INLINE intersectInterReadyFCUkr2 #-}---- | Auxiliary printing function to define the line ending in some cases. Is taken from the--- Languages.UniquenessPeriods.Vector.General.DebugG module from the @phonetic-languages-general@ package-newLineEnding :: String-newLineEnding-  | nativeNewline == LF = "\n"-  | otherwise = "\r\n"--  -foldlI :: String -> [[ReadyForConstructionUkr]] -> [ReadyForConstructionUkr]-foldlI ts jss@((!xs):ys:xss) - | null pss = foldlI' ts qss- | null qss = foldlI' ts pss- | otherwise = intersectInterReadyFCUkr2 ts (foldlI' ts pss) (foldlI' ts qss) -  where (pss,qss) = partition (< [FSL []]) jss-        foldlI' ts rss@(rs:ps:yss) = foldlI' ts (intersectInterReadyFCUkr2 ts rs ps : yss)-        foldlI' ts ((!xs):_) = xs-        foldlI' _ _ = []-foldlI _ ((!xs):_) = xs-foldlI _ _ = []-
− Phonetic/Languages/Simplified/SimpleConstraints.hs 
@@ -1,17 +0,0 @@--- |--- Module      :  Phonetic.Languages.Simplified.SimpleConstraints--- Copyright   :  (c) OleksandrZhabenko 2020--- License     :  MIT--- Stability   :  Experimental--- Maintainer  :  olexandr543@yahoo.com------ Some code shared for different Main modules.--module Phonetic.Languages.Simplified.SimpleConstraints where--import Data.Monoid--showB :: Int -> Bool -> String-showB n bool- | n >= 2 && bool == True = 'B':show (n - 1) `mappend` concatMap show [0..n - 2]- | otherwise = ""
phonetic-languages-simplified-examples-common.cabal view
@@ -2,24 +2,24 @@ -- further documentation, see http://haskell.org/cabal/users-guide/  name:                phonetic-languages-simplified-examples-common-version:             0.5.1.0+version:             0.6.2.0 synopsis:            Some commonly used by phonetic-languages-simplified* series functions. description:         Are intended to be used by the phonetic-languages-simplified-lists-examples and phonetic-languages-simplified-examples-array packages. homepage:            https://hackage.haskell.org/package/phonetic-languages-simplified-examples-common license:             MIT license-file:        LICENSE author:              OleksandrZhabenko-maintainer:          olexandr543@yahoo.com-copyright:           (c) 2020-2022 Oleksandr Zhabenko+maintainer:          oleksandr.zhabenko@yahoo.com+copyright:           (c) 2020-2023 Oleksandr Zhabenko category:            Language, Math, Game build-type:          Simple extra-source-files:  CHANGELOG.md cabal-version:       >=1.10  library-  exposed-modules:     Phonetic.Languages.Simplified.DeEnCoding, Phonetic.Languages.Simplified.SimpleConstraints, Phonetic.Languages.Common+  exposed-modules:     Phladiprelio.Ukrainian.DeEnCoding, Phladiprelio.Ukrainian.SimpleConstraints, Phladiprelio.Ukrainian.CommonE   -- other-modules:-  other-extensions:    BangPatterns-  build-depends:       base >=4.8 && <5, heaps >= 0.3.6.1 && <1, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-simplified-properties-array ==0.16.0.0, ukrainian-phonetics-basic-array ==0.6.0.0+  other-extensions:    BangPatterns, NoImplicitPrelude+  build-depends:       base >=4.13 && <5, heaps >= 0.3.6.1 && <1, phonetic-languages-ukrainian-array ==0.10.0.0, phonetic-languages-simplified-properties-array ==0.17.2.0, ukrainian-phonetics-basic-array ==0.7.0.0   -- hs-source-dirs:   default-language:    Haskell2010