-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Helps to create experimental music from a file (or its part) and a Ukrainian text.
--   
--   It can also generate a timbre for the notes. Uses SoX inside.
@package algorithmic-composition-basic
@version 0.2.2.0


-- | Helps to create experimental music from a file (or its part) and a
--   Ukrainian text. It can also generate a timbre for the notes. Uses SoX
--   inside.
module Composition.Sound.IntermediateF

-- | Gets sizes of the "result*.wav" files in the current directory.
getFileRSizes :: IO (Array Int Integer)

-- | Similar to <a>getFileRSizes</a>, but sizes are <a>Int</a>, not
--   <a>Integer</a>. For most cases it is more memory efficient.
getFileRSizesS :: IO (Array Int Int)

-- | Variant of <a>getFileRSizes</a> function.
getFileRSizesS2 :: IO (Array Int Int)

-- | Gets 'Array Int' of tuples of the pairs of "result*.wav" files and
--   their respective sizes.
getFileRTuples :: IO (Array Int (FilePath, Integer))

-- | Gets <a>Array</a> <a>Int</a> of the filenames for "result*.wav" files
--   in the current directory.
listVDirectory :: IO [FilePath]

-- | Function-predicate to check whether a file corresponding to its
--   <a>String</a> argument is considered as one of higher quality and
--   therefore can be used to replace the not so suitable ones while
--   processing.
isHighQ :: String -> Bool

-- | Function-predicate to check whether a file corresponding to its
--   <a>String</a> argument is needed to be replaced while processing.
shouldBeReplaced :: String -> Bool

-- | Gets an index of the element corresponding to the <a>String</a>
--   generated by <a>playAndMark</a> function. Partial function.
indexesFromMrk :: String -> Int

-- | During function evaluation you can listen to the sound files and mark
--   them with "1" and "0". The first one means that the sound is
--   considered of higher quality and is intended to be used as a
--   replacement for the worse sounds marked by "0". The function returns a
--   <a>Array</a> <a>Int</a> of specially formatted <a>String</a> that
--   represents only those files that are connected with the replacement
--   procedure.
playAndMark :: [FilePath] -> IO [String]

-- | Function <a>playAndMark</a> applied to all the "result*.wav" files in
--   the current directory.
playAMrk :: IO [String]

-- | Process the sound corresponding to the first element in the first
--   argument. Returns a <a>tail</a> of the first element of the first
--   command line argument. Replaces (if specified) the sound with a
--   sequence of (or just one, or made no replacement at all) sounds
--   considered of higher quality.
pAnR1 :: [String] -> IO [String]

-- | Process the WAV sounds consequently corresponding to the elements in
--   the first argument. Replaces (if specified) the sounds with a sequence
--   of (or just one, or made no replacement at all) sounds considered of
--   higher quality for every sound needed.
pAnR2 :: [String] -> IO ()

-- | Marks the needed WAV files as of needed to be replaced or those ones
--   considered of higher quality that will replace the needed ones. Then
--   actually replaces them as specified. Uses internally <a>playAMrk</a>
--   and <a>pAnR2</a> functions.
pAnR_ :: IO ()

-- | Generalized variant of the <a>playAMrk</a> with a possibility to play
--   and mark either FLAC or WAV files. For more information, please, refer
--   to <a>soxBasicParams</a>.
playAMrk2G :: String -> IO [String]

-- | Generalized variant of the <a>pAnR1</a> with a possibility to work
--   either with FLAC files or with WAV files. Please, use with the FLAC
--   files or with the WAV files separately. Do not intend to work with
--   both types of them simultaneously using this function.
pAnR12G :: String -> [String] -> IO [String]

-- | Generalized variant of the <a>pAnR2</a> with a possibility to work
--   either with FLAC files or with WAV files. Please, use with the FLAC
--   files or with the WAV files separately. Do not intend to work with
--   both types of them simultaneously using this function.
pAnR22G :: String -> [String] -> IO ()

-- | Generalized variant of the <a>pAnR_</a> with a possibility to work
--   either with FLAC files or with WAV files. Please, use with the FLAC
--   files or with the WAV files separately. Do not intend to work with
--   both types of them simultaneously using this function.
pAnR_2G :: String -> IO ()

-- | Parser to the result of <a>listVDirectory2G</a> function to get the
--   needed information.
infoFromV :: [String] -> [([Int], [String])]

-- | Used to obtain parameters for processment. Partial function.
internalConv :: ([String], [String]) -> ([Int], [String])

-- | Axiliary function to get a <a>String</a> of consequent digits in the
--   name of the "result*.wav" file.
ixFromRes :: String -> String

-- | Given an index of the element in the <a>listVDirectory</a> output
--   returns a tuple of the boundaries of the indexes usable for playback.
--   Note: index0 is probably from [0..], l1 is necessarily from [0..].
--   Interesting case is: 0 &lt;= index0 &lt; l1.
ixInterv :: Int -> IO (Int, Int)

-- | Given an index of the element in the <a>listVDirectory2G</a> (with the
--   same <a>String</a> as the second argument) output returns a tuple of
--   the boundaries of the indexes usable for playback. Note: index0 is
--   probably from [0..], l1 is necessarily from [0..]. Interesting case
--   is: 0 &lt;= index0 &lt; l1.
ixInterv2G :: String -> Int -> IO (Int, Int)

-- | <a>IO</a> checkbox whether to add the sound played to the sequence of
--   sounds that will replace the needed one.
thisOne :: IO Bool

-- | Plays a sequence of sounds in the interval of them obtained by
--   <a>ixInterv</a> function.
playSeqAR :: Int -> IO ()

-- | Plays a sequence of consequential sounds in the melody in the interval
--   of them obtained by <a>ixInterv</a> function for each element index
--   from [<a>Int</a>] of indexes.
playSeqARV :: [Int] -> IO ()

-- | Plays a sequence of WAV sounds considered of higher quality.
playSeqARV2 :: [String] -> IO ()

-- | Plays a sound file considered to be of higher quality and then you
--   define whether to use the played sound to replace that one considered
--   to be replaced.
playCollect1Dec :: Array Int String -> Int -> IO Bool

-- | The same as <a>playSeqARV2</a>, but additionally collects the
--   resulting <a>Bool</a> values and then returns them. It is used to
--   define, which sounds from those of higher quality will replace those
--   ones considered to be replaced.
playCollectDec :: [String] -> IO [Bool]

-- | Actually replaces the file represented by <a>FilePath</a> argument
--   with no (then there is no replacement at all), or with just one, or
--   with a sequence of sounds being considered of higher quality to form a
--   new melody. If the lengths of the second and the third arguments
--   differs from each other then the function uses as these arguments
--   truncated vectors of the minimal of the two lengths.
replaceWithHQs :: FilePath -> [Bool] -> [FilePath] -> IO ()

-- | A predicate to decide whether an element <tt>a</tt> belongs to the odd
--   number of the lists of <tt>a</tt>.
isOddAsElem :: Eq a => a -> [[a]] -> Bool

-- | All <tt>[a]</tt> must be finite. To obtain <tt>Just a0</tt> as a
--   result, at least one of the <tt>[a]</tt> must be not empty and the
--   [[a]] must have finite length. If the argument is [] or all
--   <tt>[a]</tt> are null (the vector has finite length), then the result
--   is <a>Nothing</a>. Otherwise, it will run infinitely just until it
--   runs over the available memory.
maxLinV :: Ord a => [[a]] -> Maybe a

-- | All <tt>[a]</tt> must be finite. To obtain <tt>Just a0</tt> as a
--   result, at least one of the <tt>[a]</tt> must be not empty and the
--   [[a]] must have finite length. If the argument is [] or all
--   <tt>[a]</tt> are null (the vector has finite length), then the result
--   is <a>Nothing</a>. Otherwise, it will run infinitely just until it
--   runs over the available memory.
minLinV :: Ord a => [[a]] -> Maybe a

-- | Applied to list of <tt>[a]</tt> where a is an instance for <a>Ord</a>
--   class gives a sorted in the ascending order [[a]], each of them being
--   unique.
doubleLtoV :: Ord a => [[a]] -> [a]

-- | Filters <a>Int</a> elements in a list so that they are limited with
--   the first two <a>Int</a> arguments of the function as a lower and a
--   higher bounds.
filterToBnds :: Int -> Int -> [Int] -> [Int]

-- | Generalized variant of the <a>getFileRSizes</a> with a possibility to
--   get sizes either of FLAC or of WAV files. For more information,
--   please, refer to <a>soxBasicParams</a>.
getFileRSizes2G :: String -> IO (Array Int Integer)

-- | Generalized variant of the <a>getFileRSizesS</a> with a possibility to
--   get sizes either of FLAC or of WAV files. For more information,
--   please, refer to <a>soxBasicParams</a>.
getFileRSizesS2G :: String -> IO (Array Int Int)

-- | Generalized variant of the <a>getFileRTuples</a> with a possibility to
--   get sizes either of FLAC or of WAV files. For more information,
--   please, refer to <a>soxBasicParams</a>.
getFileRTuples2G :: String -> IO (Array Int (FilePath, Integer))

-- | Generalized variant of the <a>listVDirectory</a> with a possibility to
--   get <a>FilePath</a> for either FLAC or WAV files. For more
--   information, please, refer to <a>soxBasicParams</a>.
listVDirectory2G :: String -> IO [FilePath]

-- | Generalized variant of the <a>listVDirectory2G</a> with a possibility
--   to get <a>FilePath</a> for not only "result*" files, but to specify
--   their beginning with the second <a>String</a> argument. For example:
--   
--   <pre>
--   elems . listVDirectory3G ys $ "result" == listVDirectory2G ys
--   </pre>
listVDirectory3G :: String -> String -> IO (Array Int FilePath)

-- | Generalized variant of the <a>playSeqAR</a> with a possibility to play
--   and mark either FLAC or WAV files. For more information, please, refer
--   to <a>soxBasicParams</a>.
playSeqAR2G :: String -> Int -> IO ()

-- | Generalized variant of the <a>playSeqARV</a> with a possibility to
--   play and mark either FLAC or WAV files. For more information, please,
--   refer to <a>soxBasicParams</a>.
playSeqARV2G :: String -> [Int] -> IO ()

-- | Plays a sequence of sounds considered of higher quality.
playSeqARV22G :: String -> [String] -> IO ()

-- | Generalized variant of the <a>playCollectDec</a> with a possibility to
--   play and mark either FLAC or WAV files. For more information, please,
--   refer to <a>soxBasicParams</a>.
playCollectDec2G :: String -> [String] -> IO [Bool]

-- | Generalized variant of the <a>replaceWithHQs</a> with a possibility to
--   work either with FLAC files or with WAV files. Please, use with the
--   FLAC files or with the WAV files separately. Do not intend to work
--   with both types of them simultaneously using this function.
replaceWithHQs2G :: String -> FilePath -> [Bool] -> [FilePath] -> IO ()

-- | Is used internally in the functions to specify different SoX
--   parameters for the sound synthesis (rate, bit depth and file
--   extension). Possible file extensions are: ".wav" (a default one) and
--   ".flac" (being lossless compressed); rates -- 8000, 11025, 16000,
--   22050 (a default one), 32000, 44100, 48000, 88200, 96000, 176400,
--   192000 Hz; bit depths -- 16 bits and 24 bits. The first two digits in
--   a <a>String</a> argument encodes rate, the next one -- bit depth and
--   the last symbol -- letter 'w' or 'f' -- file extension. Because of SoX
--   uses FLAC optionally, before use it, please, check whether your
--   installation supports it.
soxBasicParams :: String -> [String] -> [String]

-- | Takes a filename to be applied a SoX "reverb" effect with parameters
--   of list of <a>String</a> (the second argument). Produces the temporary
--   new file with the name ((name-of-the-file) ++ ("reverb.wav" OR
--   "reverb.flac") -- the type is preserved), which then is removed.
--   Please, remember that for the mono audio the after applied function
--   file is stereo with 2 channels.
--   
--   Besides, you can specify other SoX effects after reverberation in a
--   list of <a>String</a>. The syntaxis is that every separate literal
--   must be a new element in the list. If you plan to create again mono
--   audio in the end of processment, then probably use <a>reverb1E</a>
--   funcion instead. If you would like to use instead of "reverb" its
--   modification "reverb -w" effect (refer to SoX documentation), then
--   probably it is more convenient to use <a>reverbWE</a> function.
--   Please, check by yourself whether you have enough permissions to read
--   and write to the <a>FilePath</a>-specified file and to the containing
--   it directory. The function is not intended to be used in otherwise
--   cases.
reverbE :: FilePath -> [String] -> IO ()

-- | The same as <a>reverbE</a>, but uses "reverb -w" effect instead of
--   "reverb". The name of the temporary file is ((name-of-the-file) ++
--   ("reverbW.wav" OR "reverbW.flac") -- the type is preserved). Please,
--   for more information, refer to SoX documentation. Please, check by
--   yourself whether you have enough permissions to read and write to the
--   <a>FilePath</a>-specified file and to the containing it directory. The
--   function is not intended to be used in otherwise cases.
reverbWE :: FilePath -> [String] -> IO ()

-- | The same as <a>reverbE</a>, but at the end file is being mixed to
--   obtain mono audio. The name of the temporary file is
--   ((name-of-the-file) ++ ("reverb1.wav" OR "reverb1.flac") -- the type
--   is preserved). Please, check by yourself whether you have enough
--   permissions to read and write to the <a>FilePath</a>-specified file
--   and to the containing it directory. The function is not intended to be
--   used in otherwise cases.
reverb1E :: FilePath -> [String] -> IO ()

-- | The same as <a>reverbWE</a>, but at the end file is being mixed to
--   obtain mono audio. The name of the temporary file is
--   ((name-of-the-file) ++ ("reverbW1.wav" OR "reverbW1.flac") -- the type
--   is preserved). Please, check by yourself whether you have enough
--   permissions to read and write to the <a>FilePath</a>-specified file
--   and to the containing it directory. The function is not intended to be
--   used in otherwise cases.
reverbW1E :: FilePath -> [String] -> IO ()

-- | Similar to <a>reverbE</a>, but replaces the primary WAV file with the
--   new FLAC file (or vice versa). So if successful the resulting file has
--   another extension and type.
reverbE2C :: FilePath -> [String] -> IO ()

-- | Similar to <a>reverbWE</a>, but replaces the primary WAV file with the
--   new FLAC file (or vice versa). So if successful the resulting file has
--   another extension and type.
reverbWE2C :: FilePath -> [String] -> IO ()

-- | Similar to <a>reverb1E</a>, but replaces the primary WAV file with the
--   new FLAC file (or vice versa). So if successful the resulting file has
--   another extension and type.
reverb1E2C :: FilePath -> [String] -> IO ()

-- | Similar to <tt>reverb1WE</tt>, but replaces the primary WAV file with
--   the new FLAC file (or vice versa). So if successful the resulting file
--   has another extension and type.
reverb1WE2C :: FilePath -> [String] -> IO ()

-- | The same as <a>soxE</a>, but at the end file is being mixed to obtain
--   mono audio. Please, check by yourself whether you have enough
--   permissions to read and write to the <a>FilePath</a>-specified file
--   and to the containing it directory. The function is not intended to be
--   used in otherwise cases.
soxE1 :: FilePath -> [String] -> IO ()

-- | Changes the volume of the given <a>FilePath</a> with supported by SoX
--   sound file type so that it becomes 0 (zero). Makes so it a silence
--   file with the same parameters for duration, rate, bit depth and file
--   type.
getSilenceF :: FilePath -> IO ()

-- | Applies <a>fadeEnds</a> to all the "zs*.wav" (or instead all the
--   "zs*.flac") files in the current directory. The file extension is
--   defined by the first <a>String</a> argument in accordance with
--   <a>soxBasicParams</a>. <tt>zs</tt> here is given by the second
--   <a>String</a> argument.
fadeAllE :: String -> String -> IO ()

-- | Applies <a>fadeEndsMilN</a> to all the "zs*.wav" (or instead all the
--   "zs*.flac") files in the current directory. The file extension is
--   defined by the first <a>String</a> argument in accordance with
--   <a>soxBasicParams</a>. <tt>zs</tt> here is given by the second
--   <a>String</a> argument. The <a>Int</a> argument defines a number of
--   miliseconds to be under fading effect (no more than 10).
fadeAllEMilN :: Int -> String -> String -> IO ()

-- | Similar to <a>soxE</a>, but replaces the primary WAV file with the new
--   FLAC file (or vice versa). So if successful the resulting file has
--   another extension and type.
soxE2C :: FilePath -> [String] -> IO ()

-- | Similar to <a>soxE1</a>, but replaces the primary WAV file with the
--   new FLAC file (or vice versa). So if successful the resulting file has
--   another extension and type.
soxE12C :: FilePath -> [String] -> IO ()

-- | Function takes a <a>FilePath</a> for the new recorded file (if it
--   already exists then it is overwritten) and a list of <a>String</a>.
--   The last one is sent to SoX rec or something equivalent as its
--   arguments after the filename. If you plan just afterwards to produce
--   mono audio, it's simpler to use <a>rec1E</a> function instead. Please,
--   check by yourself whether you have enough permissions to read and
--   write to the <a>FilePath</a>-specified file and to the containing it
--   directory. The function is not intended to be used in otherwise cases.
--   Function is adopted and changed <a>recA</a> function.
recE :: FilePath -> [String] -> IO ()

-- | Function takes a <a>FilePath</a> for the new recorded file (if it
--   already exists then it is overwritten) and a list of <a>String</a>.
--   The last one is sent to SoX rec or something equivalent as its
--   arguments after the filename. Please, check by yourself whether you
--   have enough permissions to read and write to the
--   <a>FilePath</a>-specified file and to the containing it directory. The
--   function is not intended to be used in otherwise cases. Function is
--   adopted and changed <a>recA</a> function.
rec1E :: FilePath -> [String] -> IO ()

-- | Plays a <a>FilePath</a> file with a SoX further effects specified by
--   the list of <a>String</a>. It can be e. g. used to (safely) test the
--   result of applying some SoX effects and only then to use <a>soxE</a>
--   or some similar functions to actually apply them. Please, check by
--   yourself whether you have enough permissions to read the
--   <a>FilePath</a>-specified file and the containing it directory. The
--   function is not intended to be used in otherwise cases. Function is
--   adopted and changed <a>playA</a> function.
playE :: FilePath -> [String] -> IO ()
f2w :: FilePath -> FilePath
w2f :: FilePath -> FilePath
cfw2wf :: FilePath -> FilePath
efw2 :: FilePath -> String
efw2vv :: FilePath -> String
wOrf :: FilePath -> String

-- | Converts WAV file to FLAC file using SoX (please, check before whether
--   your installation supports FLAC files) using possible rate and bit
--   depth conversion accordingly to <tt>soxBasicParams</tt> format. If the
--   conversion is successful (<a>ExitCode</a> is <a>ExitSuccess</a>) then
--   removes the primary file.
wavToFlac :: String -> FilePath -> IO ()

-- | Converts FLAC file to WAV file using SoX (please, check before whether
--   your installation supports FLAC files) using possible rate and bit
--   depth conversion accordingly to <tt>soxBasicParams</tt> format. If the
--   conversion is successful (<a>ExitCode</a> is <a>ExitSuccess</a>) then
--   removes the primary file.
flacToWav :: String -> FilePath -> IO ()

-- | Applies a special chain of the SoX effects to a file to obtain a
--   somewhat similar to some instruments sound for some values of the
--   <a>Int</a> parameters. These last ones are used (after some
--   normalizing transformation) as the arguments for the SoX "reverb -w"
--   effect. For more information about their meaning, please, refer to the
--   SoX and reverberation documentation, besides you can give them a try.
soxREw1 :: Int -> Int -> Int -> Int -> Int -> Int -> FilePath -> IO ()

-- | Applies a special chain of the SoX effects to a file to obtain a
--   somewhat other its sounding. Similar to <a>soxREw1</a> in realization,
--   but can give rather another sounding.
soxRE1 :: Int -> Int -> Int -> Int -> Int -> Int -> FilePath -> IO ()

-- | Applies a special chain of the SoX effects to the files which are
--   obtained as a result of the <a>listVDirectory3G</a> in the current
--   directory. For some values of the first six <a>Int</a> parameters you
--   obtain somewhat similar to some instruments sounds. These parameters
--   are used (after some normalizing transformation) as the arguments for
--   the SoX "reverb -w" effect. For more information about their meaning,
--   please, refer to the SoX and reverberation documentation, besides you
--   can give them a try. The last <a>Int</a> parameter is the first
--   argument for the afterwards general SoX "reverb" effect. <a>String</a>
--   arguments are that ones for the <a>listVDirectory3G</a>. The
--   <a>FilePath</a> argument is a name for the resulting file (in the
--   supported by the SoX format).
soxREA1 :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> String -> String -> FilePath -> IO ()


-- | Helps to create experimental music from a file (or its part) and a
--   Ukrainian text. It can also generate a timbre for the notes. Uses SoX
--   inside. Is more complicated than dobutokO2 and uses its functionality.
module Composition.Sound.Functional.Basics

-- | Is used to represent a sequence of intervals, each note being a
--   <a>Float</a> value (its frequency in Hz).
type SoundsO = Array Int (Float, Float)

-- | Is used to represent a set of overtones for the single sound, the
--   first <a>Float</a> value is a frequency and the second one -- an
--   amplitude.
type OvertonesO = [(Float, Float)]

-- | Is used to represent a set of pairs of notes for each element of which
--   the <a>Float</a> values (notes frequencies in Hz) are somewhat
--   musically connected one with another..
type NotePairs = Array Int (Float, Float)

-- | <a>Array</a> of musical notes in Hz.
notes :: Array Int Float

-- | Function returns either the nearest two musical notes if frequency is
--   higher than one for C0 and lower than one for B8 or the nearest note
--   duplicated in a tuple.
neighbourNotes :: Float -> (Int, Int) -> (Float, Float)

-- | Returns the closest note to the given frequency in Hz.
closestNote :: Float -> Float

-- | Returns a pure quint lower than the given note.
pureQuintNote :: Float -> Float

-- | For the given frequency of the note it generates a list of the tuples,
--   each one of which contains the harmonics' frequency and amplitude.
overTones :: Float -> OvertonesO
overTonesALaClarinet :: Float -> OvertonesO

-- | For the given frequency it generates a musical sound with a timbre.
--   The main component of the sound includes the lower pure quint, which
--   can be in the same octave or in the one with the number lower by one.
--   Please, check before executing whether there is no "x.wav", "test*",
--   "result*" and "end.wav" files in the current directory, because they
--   can be overwritten.
overSoXSynth :: Float -> IO ()

-- | Similar to <a>overSoXSynth</a> but uses <a>overTonesALaClarinet</a>
--   instead of <a>overTones</a>.
overSoXSynthALaClarinet :: Float -> IO ()

-- | Generalized variant of the <a>overSoXSynth</a> with the possibility to
--   set the variant of the overtones for the notes as the first argument.
--   @ since 0.2.0.0 removed some extra processment with uncertain
--   semantics.
overSoXSynthG :: (Float -> OvertonesO) -> Float -> IO ()

-- | Generalized variant of the <a>overSoXSynth</a> with the possibility to
--   set the variant of the overtones for the notes as the first argument
--   and the harmonizers rules by the first list argument. The first list
--   is intended to contain no more than 9 elements (this will generate
--   containing no more than 10 different notes chord at once).
overSoXSynthGG :: [Float -> Float] -> (Float -> OvertonesO) -> Float -> IO ()

-- | Returns a <a>Array</a> <a>Int</a> of tuples with the lowest and
--   highest frequencies for the notes in the sets consisting of <tt>n</tt>
--   consequential notes (including semi-tones). An <a>Int</a> argument
--   defines this <tt>n</tt>. It can be 2, 3, 4, 6, 9, or 12 (the last one
--   is for default octaves, see <a>octavesT</a>). So for different valid
--   <tt>n</tt> you obtain doubles, triples and so on. The function being
--   applied returns a <a>Array</a> <a>Int</a> of such sets with their
--   respective lowest and highest frequencies.
nkyT :: Int -> NotePairs

-- | Function can be used to determine to which octave (in the American
--   notation for the notes, this is a number in the note written form, e.
--   g. for C4 this is 4) the frequency belongs (to be more exact, the
--   closest note for the given frequency -- see <a>closestNote</a> taking
--   into account its lower pure quint, which can lay in the lower by 1
--   octave). If it is not practical to determine the number, then the
--   function returns <a>Nothing</a>.
whichOctave :: Float -> Maybe Int

-- | Generalized version of the <a>whichOctave</a>.
whichOctaveG :: Float -> Maybe Int

-- | Similarly to <a>whichOctave</a> returns a <a>Maybe</a> number for the
--   n-th elements set of notes (see <a>nkyT</a>). An <a>Int</a> parameter
--   defines that <tt>n</tt>.
whichEnka :: Int -> Float -> Maybe Int

-- | Returns an analogous note in the higher n-th elements set (its
--   frequency in Hz) (see <a>nkyT</a>). An <a>Int</a> parameter defines
--   this <tt>n</tt>.
enkuUp :: Int -> Float -> Float

-- | Returns an analogous note in the lower n-th elements set (its
--   frequency in Hz) (see <a>nkyT</a>). An <a>Int</a> parameter defines
--   this <tt>n</tt>.
enkuDown :: Int -> Float -> Float

-- | Similarly to <tt>liftInOctaveV</tt> returns a [<a>Float</a>] (actually
--   frequencies) for the n-th elements set of notes (see <a>nkyT</a>)
--   instead of octaves. A second <a>Int</a> parameter defines that
--   <tt>n</tt>.
liftInEnkuV :: Int -> Int -> [Float] -> [Float]

-- | Similarly to <tt>liftInOctave</tt> returns a <a>Maybe</a> number
--   (actually frequency) for the n-th elements set of notes (see
--   <a>nkyT</a>). A second <a>Int</a> parameter defines that <tt>n</tt>.
--   Not all pairs return <a>Just</a> <tt>x</tt>.
liftInEnku :: Int -> Int -> Float -> Maybe Float

-- | Returns a <a>Array</a> <a>Int</a> of tuples with the lowest and
--   highest frequencies for the notes in the octaves.
octavesT :: NotePairs

-- | Combines (mixes) all "test*" files in the given directory. The files
--   should be similar in parameters and must be sound files for SoX to
--   work on them properly. Afterwards, the function deletes these combined
--   files.
mixTest :: IO ()

-- | Combines (mixes) all "test*" files in the given directory. The files
--   should be similar in parameters and must be sound files for SoX to
--   work on them properly. Afterwards, the function deletes these combined
--   files. The name of the resulting file depends on the first two command
--   line arguments so that it is easy to produce unique names for the
--   consequent call for the function. The function works properly only for
--   the amount of the files not greater than several hundreds. If
--   possible, use <a>mixTest</a> function instead.
mixTest2 :: Int -> Int -> IO ()

-- | Gets <a>Int</a> frequencies from the given <a>FilePath</a> using SoX.
--   The frequencies are "rough" according to the SoX documentation and the
--   duration is too small so they can be definitely other than expected
--   ones. Is used as a source of variable numbers (somewhat close each to
--   another in their order but not neccessarily). .
freqsFromFile :: FilePath -> Int -> IO [Int]

-- | Gets an "end.wav" file from the intermediate "result*.wav" files in
--   the current directory. If it is not successful, produces the
--   notification message and exits without error. If you would like to
--   create the file if there are too many intermediate ones, please, run
--   "dobutokO2 8" or "dobutokO2 80" in the current directory.
endFromResult :: IO ()

-- | Function to get from the number of semi-tones and a note a
--   <a>Maybe</a> note for the second lower note in the interval if any. If
--   there is no need to obtain such a note, then the result is
--   <a>Nothing</a>.
dNote :: Int -> Float -> Maybe Float

-- | Similar to <a>mixTest</a>, but allows to change the sound quality
--   parameters for the resulting file. For more information, please, refer
--   to <a>soxBasicParams</a>.
mixTest2G :: String -> IO ()

-- | Similar to <a>mixTest</a>, but allows to change the sound quality
--   parameters for the resulting file. For more information, please, refer
--   to <a>soxBasicParams</a>. The name of the resulting file depends on
--   the first two command line arguments so that it is easy to produce
--   unique names for the consequent call for the function. The function
--   works properly only for the amount of the files not greater than
--   several hundreds. If possible, use <a>mixTest2G</a> function instead.
mixTest22G :: Int -> Int -> String -> IO ()

-- | Similar to <a>endFromResult</a>, but uses additional <a>String</a>
--   argument to change sound quality parameters. For more information,
--   please, refer to <a>soxBasicParams</a>.
endFromResult2G :: String -> IO ()

-- | Generates part of the "test*" files with the additional volume
--   adjustment in dB given by <a>Array</a> <a>Int</a> <a>Float</a>.
partialTest_k1G :: OvertonesO -> Int -> String -> Array Int Float -> IO ()

-- | Generalized version of the <a>partialTest_k1G</a> with a possibility
--   to change sound quality parameters using the additional second
--   <a>String</a> argument. For more information, please, refer to
--   <a>soxBasicParams</a>.
partialTest_k2G :: OvertonesO -> Int -> String -> Array Int Float -> String -> IO ()

-- | Additional function to prepend zeroes to the given <a>String</a>. The
--   number of them are just that one to fulfill the length to the given
--   <a>Int</a> parameter.
prependZeroes :: Int -> String -> String
nOfZeroesLog :: Int -> Maybe Int

-- | Is a minimal number of decimal places that are just enough to
--   represent a length of the list given. For an [] returns 0.
numVZeroesPre :: [a] -> Int

-- | Auxiliary function to get from a sound file specified a duration
--   parameter <tt>n</tt> that can be used further.
duration1000 :: FilePath -> IO Int

-- | Is used internally in the <a>readProcessWithExitCode</a> to adjust
--   volume for the sound with additional dB value given by <a>Float</a>
--   argument.
adjust_dbVol :: [String] -> Float -> [String]


-- | Helps to create experimental music from a file (or its part) and a
--   Ukrainian text. It can also generate a timbre for the notes. Uses SoX
--   inside. Is more complicated than dobutokO2 and uses its functionality.
module Composition.Sound.Functional.Params

-- | Representation of the scales and modes for the notes. Can be extended
--   further, but for a lot of situations the following realization is
--   sufficient. See, for example, <a>filterInParams</a> and so on.
--   <a>String</a> is (are) used as a general classification name, for some
--   of them there are provided two <a>String</a> to classify. Lists are
--   used to specify remainders in some meaning. See also,
--   <a>liftInParams</a> and <a>toneE</a> (<a>toneD</a>) functions,
--   <a>elemP</a> and <a>elemCloseP</a>, <a>lengthP</a> and <a>showD</a>.
data Params
P2 :: Int -> Int -> Params
P2s :: Int -> Int -> String -> Params
P3sf :: Int -> Int -> Int -> String -> Params
P4lsf :: Int -> Int -> Int -> [Int] -> String -> Params
P32sf :: Int -> Int -> Int -> String -> String -> Params
P3lf :: Int -> Int -> [Int] -> Params

-- | Is used to represent a set of durations parameters of the sounds and
--   pauses. The positive value corresponds to the sound and the negative
--   one -- to the pause.
type Durations = Array Int Float

-- | Is used to represent a set of volumes in the amplitude scale for SoX
--   "vol" effect.
type Strengths = Array Int Float

-- | Is used to represent a set of intervals for notes (each element is a
--   number of semi-tones between parts of interval). Positive values
--   corresponds to lower notes and negative to higher ones.
type Intervals = Array Int Int

-- | A way to get from a <a>Params</a> a corresponding <a>Array</a>
--   <a>Int</a> of <a>Float</a> (if any) and so to work with them further.
--   May contain some issues so please, before production usage check
--   thoroughly. For information there were used the following:
--   
--   <a>https://en.wikipedia.org/wiki/Mode_(music)</a>
--   
--   <a>https://en.wikipedia.org/wiki/Ukrainian_Dorian_scale</a>
--   
--   <a>https://en.wikipedia.org/wiki/List_of_musical_scales_and_modes</a>
--   
--   <a>https://en.wikipedia.org/wiki/Octatonic_scale</a>
--   
--   several other articles in the English Wikipedia
--   
--   and in Ukrainian: Смаглій Г., Маловик Л. Теорія музики : Підруч. для
--   навч. закл. освіти, культури і мистецтв / Г.А. Смаглій. -- Х. : Вид-во
--   "Ранок", 2013. -- 392 с. ISBN 978-617-09-1294-7
filterInParams :: Params -> Maybe (Array Int Float)

-- | For the list of <tt>a</tt> from the <tt>Ord</tt> class it builds a
--   sorted in the ascending order list without duplicates.
--   
--   <pre>
--   sortNoDup [2,1,4,5,6,78,7,7,5,4,3,2,5,4,2,4,54,3,5,65,4,3,54,56,43,5,2] = [1,2,3,4,5,6,7,43,54,56,65,78]
--   </pre>
sortNoDup :: Ord a => [a] -> [a]

-- | Checks whether its first <a>Int</a> argument does not belong to those
--   ones that are included into the list argument on the reminders basis.
--   The opposite to <a>toneE</a> with the same arguments. The list
--   argument must be sorted in the ascending order.
toneD :: Int -> Int -> Int -> [Int] -> Bool

-- | Checks whether its first <a>Int</a> argument does belong to those ones
--   that are included into the list argument on the reminders basis. The
--   opposite to <a>toneD</a> with the same arguments. The list argument
--   must be sorted in the ascending order.
toneE :: Int -> Int -> Int -> [Int] -> Bool

-- | Analogous to <a>liftInEnku</a> lifts a frequency into a tonality (or
--   something that can be treated alike one) specified by <a>Params</a>.
--   If not reasonably one exists then the result is 11440 (Hz). Partial
--   function.
liftInParams :: Float -> Params -> Float

-- | Application of the <a>liftInParams</a> to a list. Partial function.
liftInParamsV :: Params -> [Float] -> [Float]

-- | Gets a length of the <a>Array</a> <a>Int</a> of <a>Float</a> being
--   represented as <a>Params</a>. This is a number of the notes contained
--   in the <a>Params</a>.
lengthP :: Params -> Int

-- | Check whether a given <a>Float</a> value (frequency of a note) is in
--   the vector of Floats that corresponds to the given <a>Params</a>.
elemP :: Float -> Params -> Bool

-- | Check whether a given <a>Float</a> value (frequency of the closest
--   note to the given frequency) is in the vector of Floats that
--   corresponds to the given <a>Params</a>.
elemCloseP :: Float -> Params -> Bool

-- | A way to show not the (somewhat algebraic) structure of the
--   <a>Params</a> (as the usual <a>show</a> does), but the contained
--   frequencies in it.
showD :: Params -> String

-- | Check whether for the given arguments there are the notes and whether
--   <a>String</a> is a name signature for the scale in <a>Params</a> (can
--   they be used together to correspond to a non-empty set of notes).
isStrParams :: String -> Params -> Bool

-- | Check whether for the given arguments there are the notes and whether
--   list of <a>Int</a> is a part of the constructed <a>Params</a> (can
--   they be used together to correspond to a non-empty set of notes).
isListParams :: [Int] -> Params -> Bool

-- | Generalized version of the <tt>overSoXSynthGen2FDN_SG4G</tt> where
--   instead of lifting with <a>liftInEnkuV</a> <a>liftInParamsV</a> is
--   used. It allows e. g. to use some tonality. For more information,
--   please, refer to <a>filterInParams</a>.
overSoXSynthGen2FDN_SG4GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Durations -> String -> ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> IO ()

-- | Generalized version of the <tt>overSoXSynthGen2FDN_SG6G</tt> where
--   instead of lifting with <a>liftInEnkuV</a> <a>liftInParamsV</a> is
--   used. It allows e. g. to use some tonality. For more information,
--   please, refer to <a>filterInParams</a>.
overSoXSynthGen2FDN_SG6GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Durations -> String -> ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> IO ()) -> Strengths -> Float -> IO ()

-- | Generalized version of the <tt>overSoXSynthGen2FDN_SG2G</tt> where
--   instead of lifting with <a>liftInEnkuV</a> <a>liftInParamsV</a> is
--   used. It allows e. g. to use some tonality. For more information,
--   please, refer to <a>filterInParams</a>.
overSoXSynthGen2FDN_SG2GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> String -> String -> ((Float -> OvertonesO) -> (Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO ()

-- | Generalized version of the <tt>overSoXSynthGen2FDN_Sf3G</tt> where
--   instead of lifting with <a>liftInEnkuV</a> <a>liftInParamsV</a> is
--   used. It allows e. g. to use some tonality. For more information,
--   please, refer to <a>filterInParams</a>.
overSoXSynthGen2FDN_Sf3GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Float -> String -> String -> ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> IO ()) -> IO ()

-- | Generalized version of the <tt>overSoXSynthGen2FDN_Sf3G2G</tt> where
--   instead of lifting with <a>liftInEnkuV</a> <a>liftInParamsV</a> is
--   used. It allows e. g. to use some tonality. For more information,
--   please, refer to <a>filterInParams</a>.
overSoXSynthGen2FDN_Sf3G2GPar :: FilePath -> Params -> (Float -> OvertonesO) -> Float -> Float -> String -> String -> ((Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> String -> IO ()) -> String -> IO ()

-- | Generates melody for the given parameters. The idea is that every
--   application of the function <tt>f :: Float -&gt; OvertonesO</tt> to
--   its argument possibly can produce multiple overtones being represented
--   as list of tuples of pairs of <a>Float</a>. We can use the first
--   element in the tuple to obtain a new sound parameters and the second
--   one -- to obtain its new duration in the melody. Additional function
--   <tt>g :: Float -&gt; Float</tt> is used to avoid the effect of
--   becoming less and less -- closer to the zero for the higher overtones
--   so the durations will become also less. Besides it allows to rescale
--   the durations in a much more convenient way.
--   
--   The first <a>Float</a> parameter is a multiplication coefficient to
--   increase or to decrease the durations (values with an absolute values
--   greater than one correspond to increasing inside the <tt>g</tt>.
--   function applied afterwards with function composition and the values
--   with an absolute values less than one and not equal to zero correspond
--   to decreasing inside the <tt>g</tt> function. The second <a>Float</a>
--   parameter is a usual frequency which is used instead of the 11440.0
--   (Hz) value. The third <a>Float</a> parameter is a main argument -- the
--   frequency for which the <a>OvertonesO</a> are generated as a first
--   step of the computation.
overMeloPar :: (Float -> OvertonesO) -> (Float -> Float) -> Params -> Float -> Float -> Float -> IO ()

-- | A default way to get <a>Durations</a> for the sounds up to 0.35.2.0
--   version of the package including. It is based on the number of
--   Ukrainian sounds representations (see,
--   <a>convertToProperUkrainianS</a>) in a Ukrainian syllables or somewhat
--   generated by the same rules as they. The rhythm using the function is
--   very often not binary but its ratios are almost always a ratios of the
--   small natural numbers (1, 2, 3, 4, 5, 6, 7 etc.). Partial function.
str2DurationsDef :: Int -> String -> Float -> Durations

-- | Additional function to produce signs from the given <a>String</a> of
--   the Ukrainian text. Ukrainian vowels and voiced consonants gives "+"
--   sign (+1), voiceless and sonorous consonants gives "-" sign (-1). "сь"
--   and "ць" gives "0". Other symbols are not taken into account.
signsFromString :: Int -> String -> Array Int Int

-- | Apply volume adjustment to the sound file. It must not be silent.
--   Otherwise, it leads to likely noise sounding or errors. The code is
--   adapted from the MMSyn7l module from the <tt>mmsyn7l</tt> package.
apply6Gf :: Float -> FilePath -> IO ()
apply6GSilentFile :: FilePath -> Float -> Float -> IO ()

-- | Generatlized version of the <tt>vStrToVInt</tt> with a possibility to
--   specify your own <a>Intervals</a>.
vStrToVIntG :: Intervals -> String -> Intervals

-- | Generatlized version of the <tt>strToInt</tt> with a possibility to
--   specify your own <a>Intervals</a>.
strToIntG :: Intervals -> Char -> Int

-- | Default values for <tt>strToInt</tt>. All the intervals are not
--   greater than one full octave.
defInt :: Intervals

-- | Function is used to generate a rhythm of the resulting file 'end.wav'
--   from the Ukrainian text and a number of sounds either in the syllables
--   or in the words without vowels.
syllableStr :: Int -> String -> [Int]

-- | Generalized variant of the <tt>overSoXSynth2FDN_Sf31G</tt> with a
--   possibility to specify sound quality using the second <a>String</a>
--   parameter. For more information, please, refer to
--   <a>soxBasicParams</a>.
overSoXSynth2FDN_Sf32G :: (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> String -> Array Int Float -> String -> IO ()

-- | Function is used to get numbers of intervals from a Ukrainian
--   <a>String</a>. It is used internally in the
--   <tt>uniqOverSoXSynthN4</tt> function.
intervalsFromString :: String -> Intervals

-- | Generates a melodic line (a somewhat complex changing sound) with a
--   possibility to specify sound quality using the <a>String</a> argument.
--   For more information, please, refer to <a>soxBasicParams</a>.
soundGenF32G :: [Float -> Float] -> [Float] -> [Int] -> (Float -> OvertonesO) -> (Float, Float, Float) -> Int -> Array Int Float -> String -> IO ()
helpF0 :: Int -> String
helpF1 :: [Float -> Float] -> [Float] -> [Int] -> [Maybe Float]

-- | Generates a list of <a>OvertonesO</a> that represents the melodic
--   line.
doubleVecFromVecOfFloat :: (Float -> OvertonesO) -> Float -> [Maybe Float] -> [OvertonesO]
instance GHC.Show.Show Composition.Sound.Functional.Params.Params
instance GHC.Classes.Ord Composition.Sound.Functional.Params.Params
instance GHC.Classes.Eq Composition.Sound.Functional.Params.Params


-- | Helps to create experimental music from a file (or its part) and a
--   Ukrainian text. It can also generate a timbre for the notes. Uses SoX
--   inside.
module Composition.Sound.Functional.Elements

-- | Renormalizes amplitudes for the frequencies so that the maximum one of
--   them (if <a>OvertonesO</a> is not []) is equal by the absolute value
--   to 1.0 and the mutual ratios of the amplitudes are preserved.
renormF :: OvertonesO -> OvertonesO
uniq :: Eq a => [a] -> [a]
luniq :: Eq a => [a] -> Int

-- | Renormalizes amplitudes for the frequencies so that the maximum one of
--   them (if <a>OvertonesO</a> is not []) is equal by the absolute value
--   to <a>Float</a> argument and the mutual ratios of the amplitudes are
--   preserved.
renormFD :: Float -> OvertonesO -> OvertonesO

-- | Predicate to check whether all tuples in the list have the same first
--   element.
sameOvertone :: OvertonesO -> Bool

-- | <tt>g :: (Float,Float) -&gt; OvertonesO -&gt; OvertonesO</tt> is a
--   function that defines how the new element is added to the
--   <a>OvertonesO</a>. It depends only on the element being added and the
--   actual <a>OvertonesO</a>. It does not depend on the <a>Float</a>
--   argument for <tt>f :: Float -&gt; OvertonesO</tt> so for different
--   <a>Float</a> for <tt>f</tt> it gives the same result.
sameFreqF :: Float -> (Float, Float) -> (Float -> OvertonesO) -> ((Float, Float) -> OvertonesO -> OvertonesO) -> OvertonesO

-- | <tt>g :: (Float,Float) -&gt; OvertonesO -&gt; OvertonesO</tt> is a
--   function that defines how the new element is added to the
--   <a>OvertonesO</a>. Variant of <a>sameFreqF</a> where g depends only on
--   the elements of the <a>OvertonesO</a>, which first elements in the
--   tuples equal to the first element in the <tt>(Float,Float)</tt>. It
--   does not depend on the <a>Float</a> argument for <tt>f :: Float -&gt;
--   OvertonesO</tt> so for different <a>Float</a> for <tt>f</tt> it gives
--   the same result.
sameFreqFI :: Float -> (Float, Float) -> (Float -> OvertonesO) -> ((Float, Float) -> OvertonesO -> OvertonesO) -> OvertonesO

-- | <tt>gAdd :: (Float,Float) -&gt; Float -&gt; (Float -&gt; OvertonesO)
--   -&gt; OvertonesO</tt> is a function that defines how the element is
--   added to the <a>OvertonesO</a>. <a>fAddFElem</a> is actually a
--   higher-order function, it changes the function <tt>f</tt> and returns
--   a new one. It can be an interesting task (in general) to look at such
--   a function through a prism of notion of operator (mathematical, for
--   example similar to that ones that are used for quantum mechanics and
--   quantum field theory). <tt>gAdd</tt> allows not only to insert an
--   element if missing, but to change all the <a>OvertonesO</a> system. So
--   depending on the complexity, it can produce rather complex behaviour.
fAddFElem :: (Float, Float) -> (Float -> OvertonesO) -> ((Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO) -> Float -> OvertonesO

-- | <tt>gRem:: (Float,Float) -&gt; Float -&gt; (Float -&gt; OvertonesO)
--   -&gt; OvertonesO</tt> is a function that defines how the element is
--   removed from the <a>OvertonesO</a>. <a>fRemoveFElem</a> is actually a
--   higher-order function, it changes the function <tt>f</tt> and returns
--   a new one. It can be an interesting task (in general) to look at such
--   a function through a prism of notion of operator (mathematical, for
--   example that ones that are used for quantum mechanics and quantum
--   field theory). <tt>gRem</tt> allows not only to delete an element if
--   existing, but to change all the <a>OvertonesO</a> system. So depending
--   on the complexity, it can produce rather complex behaviour.
fRemoveFElem :: (Float, Float) -> (Float -> OvertonesO) -> ((Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO) -> Float -> OvertonesO

-- | Changes elements of the <a>OvertonesO</a> using two functions. It is a
--   generalization of the <a>fAddFElem</a> and <a>fRemoveFElem</a>
--   functions. For example, if the first of the two inner functional
--   arguments acts as <a>gAdd01</a> or similar, then it adds element to
--   the <a>OvertonesO</a>, if it acts as <a>gRem01</a>, then it removes
--   the element. Its behaviour is defined by the <a>Float</a> parameter
--   (meaning frequency, probably), so you can change elements depending on
--   what point it is applied.
fChangeFElem :: (Float, Float) -> Float -> (Float -> (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO) -> (Float -> OvertonesO) -> Float -> OvertonesO

-- | Example of the function gAdd for the <a>fAddFElem</a>. If the
--   frequency is already in the <a>OvertonesO</a> then the corresponding
--   amplitude is divided equally between all the elements with the
--   repeated given frequency from <tt>(Float, Float)</tt>. Otherwise, it
--   is just concatenated to the <a>OvertonesO</a>.
gAdd01 :: (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Can be used to produce an example of the function <tt>gAdd</tt> for
--   the <a>fAddFElem</a>. Similar to <a>gAdd01</a>, but uses its first
--   argument to renorm the result of the <a>gAdd01</a> so that its maximum
--   by absolute value amplitude equals to the first argument.
gAdd02 :: Float -> (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Example of the function <tt>gAdd</tt>. for the <a>fAddFElem</a>. If
--   the frequency is not already in the <a>OvertonesO</a> then the
--   corresponding element is added and the <a>OvertonesO</a> are renormed
--   with <a>renormF</a>. Otherwise, the element is tried to be inserted
--   with a new frequency between the greatest by an absolute values notes
--   as an intermediate value with the respective amplitude, or if there is
--   only one element, to produce two elements in the resulting list with
--   two consequent harmonics.
gAdd03 :: (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Example of the function <tt>gAdd</tt>. for the <a>fAddFElem</a>. It
--   tries to insert the given (<a>Float</a>,<a>Float</a>) into the less
--   dense frequency region.
gAdd04 :: (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Example of the function gRem for the <a>fRemoveFElem</a>. If the
--   element is already in the <a>OvertonesO</a> then it is removed (if
--   there are more than 5 elements already) and <a>OvertonesO</a> are
--   renormalized. Otherwise, all the same for the element already existing
--   elements become less in an amlitude for a numbers that in sum equal to
--   amplitude of the removed element.
gRem01 :: (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Can be used to produce an example of the function <tt>gRem</tt> for
--   the <a>fRemoveFElem</a>. Similar to <a>gRem01</a>, but uses its first
--   argument to renorm the result of the <a>gRem01</a> so that its maximum
--   by absolute value amplitude equals to the first argument.
gRem02 :: Float -> (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Example of the function <tt>gRem</tt> for the <tt>fRemFElem</tt>. It
--   tries not to remove elements from the less than 6 elements
--   <a>OvertonesO</a> and to remove all the elements in the given range
--   with the width of the twice as many as the second <a>Float</a> in the
--   first argument tuple and the centre in the first <a>Float</a> in the
--   tuple. Similar to somewhat bandreject filter but with more complex
--   behaviour for the sound to be more complex.
gRem03 :: (Float, Float) -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Similar to <a>fAddFElem</a>, but instead of one element
--   <tt>(Float,Float)</tt> it deals with a list of such elements that is
--   <a>OvertonesO</a>.
fAddFElems :: OvertonesO -> (Float -> OvertonesO) -> (OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO) -> Float -> OvertonesO

-- | Similar to <a>fRemoveFElem</a>, but instead of one element
--   <tt>(Float,Float)</tt> it deals with a list of such elements that is
--   <a>OvertonesO</a>.
fRemoveFElems :: OvertonesO -> (Float -> OvertonesO) -> (OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO) -> Float -> OvertonesO

-- | Similar to <a>fChangeFElem</a>, but use another form of the changing
--   function, so it can deal with not only single element of the
--   <a>OvertonesO</a>, but also with several ones.
fChangeFElems :: OvertonesO -> Float -> (Float -> OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO) -> (Float -> OvertonesO) -> Float -> OvertonesO

-- | Binary predicate to check whether two given <a>OvertonesO</a> both
--   have the elements with the same first element in the tuples. If
--   <a>True</a> then this means that <a>OvertonesO</a> are at least
--   partially overlaped by the first elements in the tuples (meaning
--   frequencies).
freqsOverlapOvers :: OvertonesO -> OvertonesO -> Bool

-- | Similar to <a>freqsOverlapOvers</a>, but checks whether the whole
--   tuples are the same instead of the first elements in the tuples are
--   the same.
elemsOverlapOvers :: OvertonesO -> OvertonesO -> Bool

-- | Example of the function <tt>gAdds</tt> for the <a>fAddFElems</a>.
--   Partial function.
gAdds01 :: OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO

-- | Can be used to produce an example of the function <tt>gAdds</tt> for
--   the <a>fAddFElems</a>. Similar to <a>gAdds01</a>, but uses its first
--   argument to renorm the result of the <a>gAdds01</a> so that its
--   maximum by absolute value amplitude equals to the first argument.
gAdds02 :: Float -> OvertonesO -> Float -> (Float -> OvertonesO) -> OvertonesO


-- | Helps to create experimental music from a file (or its part) and a
--   Ukrainian text. It can also generate a timbre for the notes. Uses SoX
--   inside.
module Composition.Sound.Keyboard

-- | Converts a string of lowercase ASCII letters being typed on the QWERTY
--   keyboard layout into corresponding Dvorak keyboard layout.
qwerty2dvorak :: ByteString -> ByteString

-- | Vice versa to <a>qwerty2dvorak</a>.
dvorak2qwerty :: ByteString -> ByteString

-- | Get contents into lazy <a>ByteString</a> with filtering of all
--   characters that are not a lower case ascii letters.
input2BL :: IO ByteString

-- | Like <a>input2BL</a>, but takes only first <tt>n</tt> symbols
--   specified with the first <a>Int64</a> argument.
input2BLN :: Int64 -> IO ByteString

-- | Like <a>input2BL</a>, but takes only first <tt>n</tt> symbols
--   specified with the second <a>Int64</a> argument dropping before this
--   the first <tt>m</tt> symbols specified with the first <a>Int64</a>
--   argument.
input2BLMN :: Int64 -> Int64 -> IO ByteString

-- | Usual way the function <a>readFile2BLGen</a> is used. The text in a
--   file being read is treated as a properly typed (entered) one. So there
--   is no keyboard layout conversion at all.
readFile2BL :: FilePath -> IO ByteString

-- | Like <a>readFile2BL</a>, but reads only first <tt>n</tt> symbols
--   specified with the first <a>Int64</a> argument.
readFile2BLN :: Int64 -> FilePath -> IO ByteString

-- | Like <a>readFile2BL</a>, but reads only first <tt>n</tt> symbols
--   specified with the second <a>Int64</a> argument dropping before this
--   the first <tt>m</tt> symbols specified with the first <a>Int64</a>
--   argument.
readFile2BLMN :: Int64 -> Int64 -> FilePath -> IO ByteString

-- | Reads a given file into a lazy <a>ByteString</a> with filtering of all
--   characters that are not a lower case ascii letters. It has additional
--   first command line argument to control the way of treating letters: as
--   being typed (entered) properly (null <a>String</a>), or needed to be
--   converted from qwerty to dvorak layout ("q" <a>String</a>), or vice
--   versa (otherwise).
readFile2BLGen :: String -> FilePath -> IO ByteString

-- | Like <a>readFile2BLGen</a>, but reads only first <tt>n</tt> symbols
--   specified with the first <a>Int64</a> argument.
readFile2BLGenN :: Int64 -> String -> FilePath -> IO ByteString

-- | Like <a>readFile2BLGen</a>, but reads only first <tt>n</tt> symbols
--   specified with the second <a>Int64</a> argument dropping before this
--   the first <tt>m</tt> symbols specified with the first <a>Int64</a>
--   argument.
readFile2BLGenMN :: Int64 -> Int64 -> String -> FilePath -> IO ByteString

-- | Usual way the function <a>readFileDoublesGen</a> is used. The text in
--   a file being read is treated as a properly typed (entered) one. So
--   there is no keyboard layout conversion at all.
readFileDoubles :: FilePath -> IO [Int]

-- | Like <a>readFileDoubles</a>, but returns only first <tt>n</tt>
--   elements of the list specified with the first <a>Int64</a> argument.
readFileDoublesN :: Int64 -> FilePath -> IO [Int]

-- | Like <a>readFileDoubles</a>, but returns only first <tt>n</tt>
--   elements of the list specified with the second <a>Int64</a> argument
--   dropping before this the first <tt>m</tt> elements specified with the
--   first <a>Int64</a> argument.
readFileDoublesMN :: Int64 -> Int64 -> FilePath -> IO [Int]

-- | After reading a file into a filtered lazy <a>ByteString</a> (see,
--   <a>readFile2BLGen</a>) converts the resulting <a>ByteString</a> into a
--   list of <a>Int</a>. The arguments have the same meaning as for
--   <a>readFile2BLGen</a>.
readFileDoublesGen :: String -> FilePath -> IO [Int]

-- | Like <a>readFileDoublesGen</a>, but returns only first <tt>n</tt>
--   elements of the list specified with the first <a>Int64</a> argument.
readFileDoublesGenN :: Int64 -> String -> FilePath -> IO [Int]

-- | Like <a>readFileDoublesGen</a>, but returns only first <tt>n</tt>
--   symbols specified with the second <a>Int64</a> argument dropping
--   before this the first <tt>m</tt> symbols specified with the first
--   <a>Int64</a> argument.
readFileDoublesGenMN :: Int64 -> Int64 -> String -> FilePath -> IO [Int]

-- | Converts a lazy <a>ByteString</a> into a list of <a>Int</a> using
--   <a>hashStr2</a>.
takeDoubles :: ByteString -> [Int]

-- | Hashes two lower case ascii characters. Is used for controlling
--   frequencies and operators.
hashStr2 :: Char -> Char -> Int

-- | Auxiliary function to define how is a <a>ByteString</a> treated, see
--   <a>readFile2BLGen</a>.
convH :: String -> (ByteString -> ByteString) -> ByteString -> ByteString