packages feed

hommage (empty) → 0.0.5

raw patch · 93 files changed

+34433/−0 lines, 93 filesdep +arraydep +basedep +directorysetup-changedbinary-added

Dependencies added: array, base, directory, haskell98, random, time

Files

+ LICENSE view
+ Main.hs view
@@ -0,0 +1,8 @@+{-# OPTIONS_GHC -Wall -Werror #-}+module Main where++import Sound.Hommage++-- | main, do nothing+main :: IO ()+main = return ()
+ Setup.hs view
@@ -0,0 +1,4 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMain+
+ Sound/Hommage.hs view
@@ -0,0 +1,440 @@+-- | HOMMAGE - Haskell Offline Music Manipulation And Generation EDSL
+--   
+--   Daniel van den Eijkel  <mailto:dvde@gmx.net>
+module Sound.Hommage
+ ( 
+ 
+ -- * Basic sound stuff
+ 
+ -- | Mono and stereo signals:
+   module Sound.Hommage.Signal
+ -- | Oscillators
+ , module Sound.Hommage.Osc
+ -- | Envelopes
+ , module Sound.Hommage.Envelope
+ -- | Filter
+ , module Sound.Hommage.Filter
+
+ -- * Musical Notation and Sythesizers
+ 
+  -- | A datatype for representing musical structures (idea stolen from Haskore)
+ , module Sound.Hommage.Notation
+ -- | The Play Monad
+ , module Sound.Hommage.Play
+ -- | The Sound and Effect classes
+ , module Sound.Hommage.Sound
+
+ -- * More usable stuff
+ 
+ -- | A datatype for buffered audio data
+ , module Sound.Hommage.Sample
+ -- | Creating MIDI files
+ , module Sound.Hommage.Midi
+ -- | Experimental: A kind of record datatype
+ , module Sound.Hommage.Parameter
+ -- | Pure Haskell FFT Filter
+ , module Sound.Hommage.FFT   
+ -- | Random Notation
+ , module Sound.Hommage.Rand
+ -- Tools
+ , module Sound.Hommage.Tools
+ 
+ -- * Internals
+ 
+ -- | File Input\/Output for binary files and WAV files:
+ , module Sound.Hommage.WavFile
+ -- | Basic module for DFT transforming (depends on a C-code file):
+ , module Sound.Hommage.DFTFilter
+ -- | Audio rendering
+ , module Sound.Hommage.Seq
+ -- | Miscelaneous convenient functions, collected in an independent module:
+ , module Sound.Hommage.Misc
+ )
+ where
+
+import Sound.Hommage.Misc
+import Sound.Hommage.WavFile
+import Sound.Hommage.DFTFilter
+import Sound.Hommage.Signal
+import Sound.Hommage.Sample
+
+import Sound.Hommage.Midi
+import Sound.Hommage.Notation
+import Sound.Hommage.Seq
+
+import Sound.Hommage.Osc
+import Sound.Hommage.Envelope
+import Sound.Hommage.Filter
+
+import Sound.Hommage.Play
+import Sound.Hommage.Sound
+import Sound.Hommage.Parameter
+import Sound.Hommage.FFT
+import Sound.Hommage.Rand
+import Sound.Hommage.Tools
+
+{-
+
+module Sound.Hommage.WavFile
+ (
+ -- * Binary Files
+   writeDataFile 
+ , readDataFile 
+ , openDataFile 
+
+ -- * WAV-Files
+ , writeWavFile 
+ , writeWavFileMono
+ , writeWavFileStereo
+ , readWavFile 
+ , openWavFile 
+
+ -- * Cast between Int16 and Double representation of WAV-data
+ , wavInt16ToDouble   
+ , wavDoubleToInt16   
+
+ -- * Low-Level implemetation issues
+ -- ** Arrays and Files
+ , readArrayFromFile 
+ , writeArrayToFileWithHeader 
+ , writeArrayToFile 
+
+ -- ** Single Stream
+ , openSingleInputFile 
+ , openSingleOutputFile 
+
+ , openSingleInputWavFile 
+ , openSingleOutputWavFileMono 
+ , openSingleOutputWavFileStereo 
+
+ -- ** Buffered Stream
+ , openInputFile 
+ , openOutputFile 
+ , openOutputFileWithHeader 
+ , openInputWavFile 
+ , openOutputWavFileMono 
+ , openOutputWavFileStereo
+
+ -- ** Header Stuff and others
+ , HeaderFun 
+ , HeaderSize
+ , noHeader 
+
+ , wavHeaderFunMono 
+ , wavHeaderFunStereo
+ , wavHeaderSize 
+
+ , initWriteWavHeaderMono 
+ , initWriteWavHeaderStereo 
+ , initReadWavHeader 
+ , closeWriteWavHeader 
+ , encode 
+ , decode 
+ , encodeWavLengt 
+ , initWavHeaderMono 
+ , initWavHeaderStereo 
+ , sizeOfArrayElements 
+ , inferSizeOfArrayElements 
+ , inferSizeOfArrayElements' 
+ )
+
+
+module Sound.Hommage.Signal
+ ( Mono 
+ , Stereo (..)
+ , leftStereo 
+ , rightStereo 
+ , stereoToMono 
+ , monoToStereo 
+ , Signal (..)
+ , signalToMono 
+ , signalToStereo 
+ , eitherSignal 
+ , readWavSignal 
+ , openWavSignal 
+ , writeWavMono 
+ , writeWavStereo 
+ , writeWavSignal 
+ )
+
+
+module Sound.Hommage.Seq
+ ( mixdownNumNotation 
+ , runReaderWithBPM 
+ , Seq (..)
+ , noteSeq
+ , noteSeq'
+ , mixdownNumSeq
+ , applySeq
+ , applySeqS
+ , applySeqE
+ , filterSeq 
+ )
+
+module Sound.Hommage.Sample
+ (
+ -- * Sample Datastructure
+   Sample 
+ , arraySample 
+ , sizeSample  
+ , newSample 
+ , newSampleFromList
+
+ -- * File Operations
+ , openWavSample 
+ , saveWavSampleMono 
+ , saveWavSampleStereo
+
+ -- * Pitching, Playing and Scratching
+ , pitchWavSignal 
+ , scratchWavSignal
+ , playSample
+ , pitchSample 
+ , scratchSample
+ , playCoeffs 
+
+ -- * Transforming Samples
+ , mapSample 
+ , foldlSample 
+ , updateSample 
+ , normaliseSample 
+ , fadeinoutSample 
+ , stretchSample 
+
+ -- * Filter and Fourier Coeffs
+ , Coeffs 
+ , arrayCoeffs     
+ , sizeCoeffs      
+ , wavesizeCoeffs  
+ , syntheseSample   
+ , analyseSample    
+ , filterCoeffs     
+ , mkPlayCoeffs 
+ , readCoeffs 
+ , writeCoeffs 
+
+ -- * Playing a Sample
+ , mkTriggerSample 
+ , mkPlaySample 
+ , mkScratchSample 
+ , mkPitchSample 
+
+ -- * Array functions
+ , interpolArray       
+ , mkLoopArray         
+ , mkPlayArray         
+
+ )
+
+module Sound.Hommage.Osc
+ (
+ -- * Sound Generators
+   osc
+ , sinus 
+ , cosinus 
+ , rect
+ , saw
+ , tri
+
+ -- * Functions for Lists
+-- , amplify
+ , sampleAndHold
+ , average 
+ , terminateAt
+ , follow
+-- , variableDelay 
+
+ -- * Functions for single values
+ -- | These Functions can be used with 'map':
+ , compress
+ , noteToFrequency 
+ , adjustFrequency 
+
+ -- * Other Functions
+ -- | These Functions are not simple (i. e. linear) list transformers:
+ , splitWaves 
+ , crossfade 
+ )
+
+
+module Sound.Hommage.Notation
+ ( 
+ -- * Duration
+   Dur 
+ , absDur 
+ -- * Music Notation
+ , Notation (..)
+ , unmaybeNotation 
+ , runNotation 
+ , runNotationWith
+ -- * Musical class
+ , Stretchable (..)
+ , Arrangeable (..)
+ , Musical (..)
+
+ -- * Notation and Midi 
+ , writeMidiSyncNotation 
+ , midi 
+ , midi' 
+ , midiSyncFile
+
+ -- * More Notation functions
+ , note 
+ , mapNotation 
+
+ )
+
+module Sound.Hommage.Misc
+ ( 
+ -- * Imperative control structure
+   for                 
+ , for'                
+
+ -- * Usefull list functions 
+ , map_ 
+ , foldr_ 
+ , merge 
+ , uneitherlist 
+
+ , walk
+ , appendmaps 
+ , appendmaps'
+
+ , qsort 
+ , qsortM 
+
+ -- * Embedding IO in a list (-map)
+ , inList
+ , inList' 
+ , inList''
+ , toList
+ , toList'
+ , inListE
+ , inListE' 
+ , inListE''
+ , toListE
+ , toListE'
+
+ )
+
+module Sound.Hommage.Midi
+ ( Ticks 
+ , MidiFile (..)
+ , writeMidiFile 
+ , Delta 
+ , MidiTrack 
+
+ , Chan 
+ , MidiValue 
+ , MidiMusic
+ , MidiNote (..)
+
+ , noteMidiMusic 
+ , restMidiMusic 
+ , appendMidiMusic 
+ , mergeMidiMusic 
+ , runMidiMusic 
+
+ , MidiEvent (..)
+ , encodeMidiFile 
+ , midiHeaderSync 
+ , encodeMidiTrack
+ , encodeDelta 
+ , encodeMidiDeltaEvent 
+ , encodeEvent 
+ , lastByte 
+ , nextByte 
+ , toBytes 
+ )
+
+module Sound.Hommage.Filter
+ (
+ -- * Filters
+   lowpassfilter 
+ , highpassfilter
+ , bandpassfilter
+ , stretchfilter 
+ , morphfilter 
+ , vocoder
+
+ -- * FilterSpec
+ , specfilter 
+ , FilterSpec  
+ , shiftFilterSpec 
+
+ -- * FilterSpec and Lists
+ , filterSpecToList
+ , filterSpecsToLists
+ , interpolFilterLists 
+
+ -- * Other
+ , ffreq 
+ , ffreqi
+ , average512 
+
+ -- * Filterfunctions
+ , lowpassFS
+ , highpassFS
+ , bandpassFS 
+ , lowp0FS 
+ , lowp1FS
+ , bandp0FS 
+ , bandp1FS 
+ , highp0FS 
+ , highp1FS 
+
+ )
+
+module Sound.Hommage.Envelope
+ ( 
+
+ -- * ADSR
+   ADSR 
+ -- * ADSR Functions
+ , listADSR 
+ , listADSR' 
+ , stretchADSR 
+ , stretchToADSR 
+ , envpart 
+ , envpart_cos 
+ -- * Envelope
+ , EnvShape (..)
+ , EnvMode (..)
+ , playADSR 
+ , Env (..)
+ , playEnv 
+ )
+
+module Sound.Hommage.DFTFilter 
+ ( 
+ -- * User-Level Filter Functions
+   dftfilter 
+ , dftsynthese 
+ , dftanalyse 
+ , dftfilterWith
+
+ -- * IO and Array 
+ -- ** CoeffArr
+ , CoeffArr 
+ , readCoeffArr 
+ , writeCoeffArr
+ , storeCoeff 
+ , unstoreCoeff 
+ -- ** CoeffMap
+ , CoeffMap 
+ , mkCoeffMap 
+ , coeffmap 
+ -- ** Analyse
+ , mkAnalyse 
+ -- ** Synthese
+ , mkSynthese 
+ -- ** Transform
+ , mkFilterBuffered 
+ -- ** Interface to C-code
+ , analyseDFT   
+ , syntheseDFT  
+ , kurveDFT     
+ ) 
+
+-}
+

+ Sound/Hommage/DFTFilter.hs view
@@ -0,0 +1,529 @@+-- This file is the new version for C-code FFT algorithm with Nyquist allready on position 1.
+
+-- | This module imports the C-functions for a Fast Fourier Transform and encapsulates them in
+--   list-mapping functions. (At first it was a DFT algoritm which I changed, but I didn'd change
+--   all the names of the functions, so it is called dft...)
+--   The functionality of this module is used for filtering audio data, i. e. for building
+--   audio filters.
+
+module Sound.Hommage.DFTFilter 
+ ( 
+
+-- | Filtering is done with an FFT algorithm written in C (in the file dft.c). 
+--   This module imports the c-functions for fft ('analyseDFT') and inverse fft ('syntheseDFT'),
+--   which operate on Arrays with 1024 Double values. 
+--   The array-operations are embedded in a mechanism that does buffering, overlapping and windowing 
+--   and works like a black box that maps one input value to one output value in the IO monad 
+--   ('mkAnalyse', 'mkSynthese', 'mkFilterBuffered'). 
+--   Around these IO's some list mapping functions are wrapped ('dftanalyse', 'dftsynthese', 'dftfilter',
+--   'dftfilterBy') for convenient use in a Haskell programm.
+--
+--   Mapping the Fourier coefficients during the filter process means filtering the data. 
+--   The result depends on the way the coefficients are mapped resp. modified while mapping.
+--   The function to do this has the type of 'CoeffMap'.
+--
+--   /Description of the filtering process:/ 
+--
+--   Filtering is done by mapping the coefficients with 'CoeffMap'. 
+--   For this the wave data is split into parts of 1024 values, where every part overlaps with the 
+--   preceeding and succeeding part by 512 values. Via the fourier-transform (analyse) every part 
+--   is mapped  to its frequency spectrum, i. e. its fourier coefficients. 
+--   
+--   The 'CoeffMap' action is applied to every frequency spectrum (see 'CoeffArr') in sequence. 
+--   It reads the coefficients from the first 'CoeffArr' where the input is stored and writes it 
+--   (or some data derived from it) to the second one. This is the point where the \'real\' filtering
+--   happens. Via the inverse fourier-transform (synthese) the resulting coefficients are mapped 
+--   to their real signal values. These signal values are multiplied with a half cosinus curve for 
+--   fading in and out (windowing). Then they are mixed in the way their source data was split: 
+--   Every part overlaps for 512 values with the last and the next one. 
+
+ -- * User-Level Filter Functions
+   dftanalyse 
+ , dftsynthese 
+ , dftfilter 
+ , dftfilterBy
+ , dftfilterBy' 
+
+ -- * CoeffArr
+ , CoeffArr 
+ , readCoeffArr 
+-- , readCoeffArr'
+ , writeCoeffArr
+-- , writeCoeffArr'
+ , storeCoeff 
+ , unstoreCoeff 
+ -- * CoeffMap
+ , CoeffMap 
+ , mkCoeffMap 
+ , coeffmap 
+ -- * IO Wrapper 
+ , mkAnalyse 
+ , mkSynthese 
+ , mkFilterBuffered 
+ -- * Interface to C-code
+ , analyseDFT   
+ , syntheseDFT  
+ , kurveDFT     
+ ) 
+ where
+
+import GHC.Weak
+import GHC.IOBase
+import Foreign.ForeignPtr
+import Foreign.Ptr
+import Foreign.Storable
+import Data.Array.Storable
+import Data.Complex
+import Data.Array.IO
+
+import Sound.Hommage.Misc
+---------------------------------------------------------------------------------------------------
+-- ([Complex Double] -> [Complex Double]) -> IO CoeffMap
+
+-- | (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.
+dftfilterBy :: IO (CoeffMap ()) -> [Double] -> [Double]
+dftfilterBy cm = drop 1536 . inList (mkFilterBuffered cm) . (++ replicate 512 0.0)
+
+-- | (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.
+dftfilterBy' :: s -> IO (s -> CoeffMap s) -> [Double] -> [Double]
+dftfilterBy' s cm = drop 1536 . inList (mkFilterBuffered' s cm) . (++ replicate 512 0.0)
+
+-- | (Fast) Fourier Transformation and Inverse with an additional argument with sublists of
+--   factors to weight the coefficients. See 'mkCoeffMap' for a decription of that argument.
+dftfilter :: [Double] -> [Double] -> [Double]
+dftfilter ds = dftfilterBy (mkCoeffMap (replicate 512 0 ++ ds))
+
+-- | Inverse (Fast) Fourier Transformation
+dftsynthese :: [Complex Double] -> [Double]
+dftsynthese = inList mkSynthese
+
+-- | (Fast) Fourier Transformation. 
+dftanalyse :: [Double] -> [(Complex Double)] 
+dftanalyse = inList mkAnalyse
+
+---------------------------------------------------------------------------------------------------
+foreign import ccall "cinit" initfou :: Int
+
+foreign import ccall "canalyse" cAnalyse :: Ptr Double -> Ptr Double -> IO ()
+
+foreign import ccall "csynthese" cSynthese :: Ptr Double -> Ptr Double -> IO ()
+
+foreign import ccall "ckurve" cKurve :: Ptr Double -> IO ()
+---------------------------------------------------------------------------------------------------
+-- | Maps an array with 1024 real values to its frequency spectrum with 512 complex values.
+--   The spectrum is stored in the second array with 1024 Doubles which are the real and imaginary
+--   parts of the complex values. See 'CoeffArr' for a detailed frequency spectrum
+--   desription.
+analyseDFT :: StorableArray Int Double -> StorableArray Int Double -> IO ()
+analyseDFT wave coeffs = seq initfou $
+ withStorableArray wave $ \ptr_w ->
+ withStorableArray coeffs $ \ptr_c -> 
+ cAnalyse ptr_w ptr_c
+
+-- | Maps a frequency spectrum to its signal value. Both arrays have a length of 1024; the first one
+--   contains the 512 complex values of the spectrum. The real signal value will be stored in
+--   the second array. See 'CoeffArr' for a detailed frequency spectrum
+--   desription.
+syntheseDFT :: StorableArray Int Double -> StorableArray Int Double -> IO ()
+syntheseDFT coeffs wave = seq initfou $
+ withStorableArray wave $ \ptr_w ->
+ withStorableArray coeffs $ \ptr_c -> 
+ cSynthese ptr_c ptr_w 
+
+-- | Fades a signal which is stored in an array of length 1024 in and out.
+--   The signal is multiplied with a cosinus curve with range 0..pi. 
+kurveDFT :: StorableArray Int Double -> IO ()
+kurveDFT wave = seq initfou $
+ withStorableArray wave $ \ptr_w ->
+ cKurve ptr_w
+---------------------------------------------------------------------------------------------------
+-- 
+---------------------------------------------------------------------------------------------------
+-- | Represents a frequency spectrum. 
+--   Range is from 0 to 1023 (N=1024).
+--   Index 0 is constant value, index 1 is Nyquest frequency (real part of the N\/2 frequency). 
+--   Index 2 and 3 are the complex value for the basefrequency, index 4 and 5
+--   are the complex value for the double basefrequency, 6 and 7 for 3 * basefrequency and so on:
+--
+-- > arr [0] = real part of zero frequency (imaginary part is allways 0)
+-- > arr [1] = real part of Nyquest frequency (N/2) (imaginary part is allways 0)
+-- > arr [2] = real part of base frequency
+-- > arr [3] = imag part of base frequency
+-- > arr [4] = real part of base frequency * 2
+-- > arr [5] = imag part of base frequency * 2
+-- > arr [6] = real part of base frequency * 3
+-- > arr [7] = imag part of base frequency * 3
+-- > ...
+-- > arr [N-4] = real part of base frequency * (N/2 - 2)
+-- > arr [N-3] = imag part of base frequency * (N/2 - 2)
+-- > arr [N-2] = real part of base frequency * (N/2 - 1)
+-- > arr [N-1] = imag part of base frequency * (N/2 - 1)
+--
+-- Pseudocode:
+--
+-- > c (0)   = (arr [0] :+ 0)
+-- > c (512) = (arr [1] :+ 0)
+-- 
+--  and for all i=[1..511]:
+--
+-- > c (i) = (arr [i*2] :+ arr [i*2+1])
+--
+type CoeffArr = StorableArray Int Double
+
+{-
+-- | Reads a Complex value of a CoeffArr as described at 'CoeffArr'.
+readCoeffArr :: CoeffArr -> Int -> IO (Complex Double)
+readCoeffArr arr n = if n == 0 then readArray arr 0 >>= \x -> readArray arr 1023 >>= \y -> return (x :+ y)
+                               else let j  = 2*n
+                                        j' = j-1 
+                                    in readArray arr j' >>= \x -> readArray arr j >>= \y -> return (x :+ y)
+
+-- | Writes a Complex value of a CoeffArr as described at 'CoeffArr'.
+writeCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()
+writeCoeffArr arr n c = if n == 0 then writeArray arr 0 (realPart c) >> writeArray arr 1023 (imagPart c)
+                                  else let j  = 2*n
+                                           j' = j-1 
+                                  in writeArray arr j' (realPart c) >> writeArray arr j (imagPart c)
+-}
+
+-- | Reads a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).
+readCoeffArr :: CoeffArr -> Int -> IO (Complex Double)
+readCoeffArr arr n = 
+ let j  = 2*n
+     j' = j+1 
+ in readArray arr j >>= \x -> readArray arr j' >>= \y -> return (x :+ y)
+
+-- | Writes a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).
+writeCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()
+writeCoeffArr arr n c = 
+ let j  = 2*n
+     j' = j+1 
+ in writeArray arr j (realPart c) >> writeArray arr j' (imagPart c)
+
+storeCoeff :: IOArray Int (Complex Double) -> CoeffArr -> IO ()
+storeCoeff arr brr = do
+ for 0 (<512) (+1) $ \i -> let i1 = i * 2
+                               i2 = i1 + 1
+                           in do (x :+ y) <- readArray arr i
+                                 writeArray brr i1 x
+                                 writeArray brr i2 y
+
+unstoreCoeff :: CoeffArr -> IOArray Int (Complex Double) -> IO ()
+unstoreCoeff brr arr = do
+ for 0 (<512) (+1) $ \i -> let i1 = i * 2
+                               i2 = i1 + 1
+                           in do x <- readArray brr i1
+                                 y <- readArray brr i2
+                                 writeArray arr i (x :+ y) 
+---------------------------------------------------------------------------------------------------
+-- | An action that maps the fourier coefficients from the first array to the second.
+--   Modifying the data while mapping means filtering. See 'CoeffArr' for a description of the arrays.
+type CoeffMap a = CoeffArr -> CoeffArr -> IO a
+
+-- | Constructs a Coeffmap.
+--   The sublists contain the 512 real values with which the basefrequency and the 511 complex fourier coefficients 
+--   are multiplied (the Nyquist frequency will be zero). 
+--   The first value is the factor for the constant coefficient, the second for the base frequency, the next one 
+--   for the double base freq and so on. 
+--   If the sublists have more than 512 elements, these elements are thrown away. 
+--   If it is shorter, the array will be filled up with zeros.
+{-
+mkCoeffMap :: [[Double]] -> IO (CoeffMap ())
+mkCoeffMap cs = do
+ r <- newIORef cs
+ b <- newArray (0,511) 0.0
+ return $ \a1 a2 -> let loop i (x:xs) = if i >= 512 then return () else
+                                        writeArray b i x >> loop (i+1) xs
+                        loop i []     = for i (<512) (+1) (\i -> writeArray b i 0.0) 
+                    in do xs <- readIORef r
+                          let (xi,xr) | null xs   = ([], [])
+                                      | otherwise = (head xs, tail xs)
+                          writeIORef r xr
+                          loop 0 xi
+                          coeffmap b a1 a2
+-}
+
+mkCoeffMap :: [Double] -> IO (CoeffMap ())
+mkCoeffMap cs = do
+ r <- newIORef cs
+ b <- newArray (0,511) 0.0
+ return $ \a1 a2 -> let loop i (x:xs) = if i >= 512 
+                                         then writeIORef r (x:xs)
+                                         else writeArray b i x >> loop (i+1) xs
+                        loop i []     = for i (<512) (+1) (\i -> writeArray b i 0.0) 
+                                        >> writeIORef r []
+                    in do xs <- readIORef r
+                          loop 0 xs
+                          coeffmap b a1 a2
+
+
+-- | 'coeffmap' takes an Array with 512 values and uses them for a weigted map of the fourier 
+--   coefficients. The Nyquist frequency is muliplied with 0.0.
+coeffmap :: StorableArray Int Double -> CoeffMap ()
+coeffmap filt coeffs coeffs' = do
+ for 0 (<512) (+1) (\i -> let j  = 2*i
+                              j' = j + 1
+                          in 
+                          readArray filt i >>= \c ->
+                          readArray coeffs j  >>= \c1 ->
+                          readArray coeffs j' >>= \c2 ->
+                          writeArray coeffs' j  (c * c1) >>
+                          writeArray coeffs' j' (c * c2) )
+ writeArray coeffs' 1 0.0
+
+{-
+coeffmap' :: ([Complex Double] -> [Complex Double]) -> IO (CoeffMap ())
+coeffmap' f = do
+ let toDest arr 1024 _   = return ()
+     toDest arr n (x:xs) = writeArray arr n x >> toDest arr (n+1) xs
+     toDest arr n []     = writeArray arr n 0 >> toDest arr (n+1) []
+ return $ \arr brr -> getElems arr >>= toDest brr 0 . f
+-}
+---------------------------------------------------------------------------------------------------
+-- | Constructs an action that maps wave-data to coefficient-data.
+--   Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)
+--   512 elemets more than the input.
+mkAnalyse :: IO (Maybe Double -> IO (Maybe (Complex Double)))
+mkAnalyse = do
+ warr <- newArray (0, 1023) 0.0
+ carr <- newArray (0, 1023) 0.0
+ oarr <- newArray (0, 511) (0.0 :+ 0.0)
+-- SIGNALSTREAM reada closea <- openSignalStream sa
+ rpos <- newIORef 0
+ rcnt <- newIORef Nothing
+ let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest
+     more ma = maybe irest snext ma
+     rest k | k <= 0    = return Nothing 
+            | otherwise =        do writeIORef rcnt $ Just (k-1)
+                                    pos <- readIORef rpos
+                                    x <- readArray oarr pos
+                                    writeIORef rpos (pos + 1)
+                                    return $ Just x
+     irest =        do writeIORef rcnt (Just 511) 
+                       pos <- readIORef rpos
+                       fillrest pos
+                       x <- readArray oarr pos
+                       writeIORef rpos (pos + 1)
+                       return $ Just x
+     snext a =        do pos <- readIORef rpos
+                         x <- readArray oarr pos
+                         writeArray warr (pos+512) a
+                         writeIORef rpos (pos + 1)
+                         return $ Just x
+     checkpos = readIORef rpos >>= \p -> if p < 512 then return () else do
+                writeIORef rpos 0 
+                analyseDFT warr carr
+                unstoreCoeff carr oarr
+                for 0 (<512) (+1) (\i -> readArray warr (i+512) >>= writeArray warr i)
+     fillrest k = for (512+k) (<1024) (+1) (\i -> writeArray warr i 0.0)
+ return read
+---------------------------------------------------------------------------------------------------
+-- | Constructs an action that maps coefficient-data to wave-data.
+--   Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)
+--   512 elemets more than the input.
+mkSynthese :: IO (Maybe (Complex Double) -> IO (Maybe Double))
+mkSynthese = do
+ iarr <- newArray (0, 511) (0.0 :+ 0.0)
+ carr <- newArray (0, 1023) 0.0
+ warr <- newArray (0, 1023) 0.0
+ (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0
+-- SIGNALSTREAM reada closea <- openSignalStream sa
+ rpos <- newIORef 0
+ rcnt <- newIORef Nothing
+ let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest
+     more ma = maybe irest snext ma
+     rest k | k <= 0    = return Nothing 
+            | otherwise =        do writeIORef rcnt $ Just (k-1)
+                                    pos <- readIORef rpos
+                                    x <- readArray oarr pos
+                                    writeIORef rpos (pos + 1)
+                                    return $ Just x
+     irest =        do writeIORef rcnt (Just 511) 
+                       pos <- readIORef rpos
+                       fillrest pos
+                       x <- readArray oarr pos
+                       writeIORef rpos (pos + 1)
+                       return $ Just x
+     snext a =        do pos <- readIORef rpos
+                         x <- readArray oarr pos
+                         writeArray iarr pos a
+                         writeIORef rpos (pos + 1)
+                         return $ Just x
+     checkpos = readIORef rpos >>= \p -> if p < 512 then return () else do
+                writeIORef rpos 0
+                storeCoeff iarr carr 
+                for 0 (<512) (+1) (\i -> readArray warr (i+512) >>= writeArray oarr i)
+                syntheseDFT carr warr
+                kurveDFT warr
+                for 0 (<512) (+1) (\i -> readArray warr i >>= \x ->
+                                         readArray oarr i >>= \y ->  writeArray oarr i (x+y))
+     fillrest k = for k (<512) (+1) (\i -> writeArray iarr i (0.0 :+ 0.0))
+ return read
+---------------------------------------------------------------------------------------------------
+-- | Constructs an action that maps wave-data to wave-data via a Fast Foutrier Transform and inverse,
+--   filtered by the given 'CoeffMap'.
+--   Has a delay of 1024.
+mkFilterBuffered :: IO (CoeffMap ()) -> IO (Maybe Double -> IO (Maybe Double))
+mkFilterBuffered mkf = do
+ f <- mkf
+ warr <- newArray (0, 1023) 0.0
+ carr <- newArray (0, 1023) 0.0
+ carr' <- newArray (0, 1023) 0.0
+ warr' <- newArray (0, 1023) 0.0
+ (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0
+-- SIGNALSTREAM reada closea <- openSignalStream sa
+ rpos <- newIORef 0
+ rcnt <- newIORef Nothing
+ let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest
+     more ma = maybe irest snext ma
+     rest k | k <= 0    = return Nothing 
+            | otherwise =        do writeIORef rcnt $ Just (k-1)
+                                    pos <- readIORef rpos
+                                    x <- readArray oarr pos
+                                    writeIORef rpos (pos + 1)
+                                    return $ Just x
+     irest =        do writeIORef rcnt (Just 511) 
+                       pos <- readIORef rpos
+                       fillrest pos
+                       x <- readArray oarr pos
+                       writeIORef rpos (pos + 1)
+                       return $ Just x
+     snext a =        do pos <- readIORef rpos
+                         x <- readArray oarr pos
+                         writeArray warr (pos+512) a
+                         writeIORef rpos (pos + 1)
+                         return $ Just x
+     checkpos = readIORef rpos >>= \p -> if p < 512 then return () else do
+                writeIORef rpos 0 
+                analyseDFT warr carr
+                for 0 (<512) (+1) (\i -> readArray warr (i+512) >>= writeArray warr i >>
+                                         readArray warr' (i+512) >>= writeArray oarr i)
+                f carr carr'
+                syntheseDFT carr' warr'
+                kurveDFT warr'
+                for 0 (<512) (+1) (\i -> readArray warr' i >>= \x ->
+                                         readArray oarr i >>= \y ->  writeArray oarr i (x+y))
+
+     fillrest k = for (512+k) (<1024) (+1) (\i -> writeArray warr i 0.0)
+ return read
+---------------------------------------------------------------------------------------------------
+
+-- | Constructs an action that maps wave-data to wave-data via a Fast Foutrier Transform and inverse,
+--   filtered by the given 'CoeffMap'.
+--   Has a delay of 1024.
+mkFilterBuffered' :: s -> IO (s -> CoeffMap s) -> IO (Maybe Double -> IO (Maybe Double))
+mkFilterBuffered' st mkf = do
+ stref <- newIORef st
+ f <- mkf
+ warr <- newArray (0, 1023) 0.0
+ carr <- newArray (0, 1023) 0.0
+ carr' <- newArray (0, 1023) 0.0
+ warr' <- newArray (0, 1023) 0.0
+ (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0
+-- SIGNALSTREAM reada closea <- openSignalStream sa
+ rpos <- newIORef 0
+ rcnt <- newIORef Nothing
+ let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest
+     more ma = maybe irest snext ma
+     rest k | k <= 0    = return Nothing 
+            | otherwise =        do writeIORef rcnt $ Just (k-1)
+                                    pos <- readIORef rpos
+                                    x <- readArray oarr pos
+                                    writeIORef rpos (pos + 1)
+                                    return $ Just x
+     irest =        do writeIORef rcnt (Just 511) 
+                       pos <- readIORef rpos
+                       fillrest pos
+                       x <- readArray oarr pos
+                       writeIORef rpos (pos + 1)
+                       return $ Just x
+     snext a =        do pos <- readIORef rpos
+                         x <- readArray oarr pos
+                         writeArray warr (pos+512) a
+                         writeIORef rpos (pos + 1)
+                         return $ Just x
+     checkpos = readIORef rpos >>= \p -> if p < 512 then return () else do
+                writeIORef rpos 0 
+                analyseDFT warr carr
+                for 0 (<512) (+1) (\i -> readArray warr (i+512) >>= writeArray warr i >>
+                                         readArray warr' (i+512) >>= writeArray oarr i)
+                s <- readIORef stref
+                s' <- f s carr carr'
+                writeIORef stref s'
+                syntheseDFT carr' warr'
+                kurveDFT warr'
+                for 0 (<512) (+1) (\i -> readArray warr' i >>= \x ->
+                                         readArray oarr i >>= \y ->  writeArray oarr i (x+y))
+
+     fillrest k = for (512+k) (<1024) (+1) (\i -> writeArray warr i 0.0)
+ return read
+---------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{-
+-- | Reads a Complex value of a CoeffArr 
+readCoeffArr :: CoeffArr -> Int -> IO (Complex Double)
+readCoeffArr arr n = if n == 0 then readArray arr 0 >>= \x -> readArray arr 1023 >>= \y -> return (x :+ y)
+                               else let j  = 2*n
+                                        j' = j-1 
+                                    in readArray arr j' >>= \x -> readArray arr j >>= \y -> return (x :+ y)
+
+-- | Writes a Complex value of a CoeffArr 
+writeCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()
+writeCoeffArr arr n c = if n == 0 then writeArray arr 0 (realPart c) >> writeArray arr 1023 (imagPart c)
+                                  else let j  = 2*n
+                                           j' = j-1 
+                                  in writeArray arr j' (realPart c) >> writeArray arr j (imagPart c)
+
+-- | Copies coefficient data from an IOArray with Complex values (512 elements) to a
+--   StorableArray with Doubles (1024 elements)
+storeCoeff :: IOArray Int (Complex Double) -> CoeffArr -> IO ()
+storeCoeff arr brr = do
+ for 1 (<512) (+1) $ \i -> let i2 = i * 2
+                               i1 = i2 - 1
+                           in do (x :+ y) <- readArray arr i
+                                 writeArray brr i1 x
+                                 writeArray brr i2 y
+ (x :+ y) <- readArray arr 0
+ writeArray brr 0 x
+ writeArray brr 1023 y
+
+-- | Copies coefficient data from a StorableArray with Doubles (1024 elements) to 
+--   an IOArray with Complex values (512 elements).
+unstoreCoeff :: CoeffArr -> IOArray Int (Complex Double) -> IO ()
+unstoreCoeff brr arr = do
+ for 1 (<512) (+1) $ \i -> let i2 = i * 2
+                               i1 = i2 - 1
+                           in do x <- readArray brr i1
+                                 y <- readArray brr i2
+                                 writeArray arr i (x :+ y) 
+ x <- readArray brr 0
+ y <- readArray brr 1023
+ writeArray arr 0 (x :+ y)
+
+coeffmap :: StorableArray Int Double -> CoeffMap ()
+coeffmap filt coeffs coeffs' = do
+ for 1 (<512) (+1) (\i -> let j' = 2*i
+                              j  = j' - 1
+                          in 
+                          readArray filt i >>= \c ->
+                          readArray coeffs j  >>= \c1 ->
+                          readArray coeffs j' >>= \c2 ->
+                          writeArray coeffs' j  (c * c1) >>
+                          writeArray coeffs' j' (c * c2) )
+ readArray filt 0 >>= \c -> readArray coeffs 0 >>= \c' -> writeArray coeffs' 0 (c * c')
+ writeArray coeffs' 1023 0.0
+-}

+ Sound/Hommage/Envelope.hs view
@@ -0,0 +1,179 @@+-- | This module contains some functions and datatypes for envelopes.
+--   An envelope in generall is a kind of controll signal that modulates 
+--   (for example) the volume of a sound in a non-periodic way (getting
+--   loud at the beginning and fading out at the end...). It is
+--   also used to controll the duration of a sound, since (here) envelopes
+--   always produce finite signals.
+module Sound.Hommage.Envelope
+ ( 
+
+ -- | An envelope is represented by a function of type 'Env'. 
+ --   Such functions (or instances of class 'IsEnv') can be combined
+ --   into a sequence where every 'Env' is given a 'EnvLength' (using the
+ --   binary operator '<?>'.
+ --   The whole sequence can be turnde into an 'Env' (and be played then)
+ --   with 'runEnv'.
+
+ -- * Env
+   Env
+ , runEnv
+ , (<?>) 
+ , IsEnv (..)
+ -- * EnvLength
+ , calculateEnvLengths 
+ , EnvLength (..)
+
+ -- * ADSR
+ , ADSR 
+ , EnvShape (..)
+ , EnvMode (..)
+ , playADSR 
+
+ -- | Here is the code of 'playADSR' to show the use of 'Env', '<?>' and 'EnvLength':
+ -- 
+ -- > playADSR :: EnvMode -> EnvShape -> ADSR -> Int -> [Double]
+ -- > playADSR mode shape (a,d,s,r) = case mode of
+ -- >  FitADR -> runEnv
+ -- >            [ Interpolate shape (0.0,1.0) <?> Flex (fromIntegral a)
+ -- >            , Interpolate shape (1.0, s) <?> Flex (fromIntegral d)
+ -- >            , Interpolate shape (s, 0.0) <?> Flex (fromIntegral r)
+ -- >            ]
+ -- >  FitS   -> runEnv
+ -- >            [ Interpolate shape (0.0,1.0) <?> Abs a
+ -- >            , Interpolate shape (1.0, s) <?> Abs d
+ -- >            , Constant s <?> Flex 1.0
+ -- >            , Interpolate shape (s, 0.0) <?> Abs r
+ -- >            ]
+ -- >  HoldS  -> runEnv
+ -- >            [ Interpolate shape (0.0,1.0) <?> Abs a
+ -- >            , Interpolate shape (1.0, s) <?> Abs d
+ -- >            , Constant s <?> Flex 1.0
+ -- >            , Interpolate shape (s, 0.0) <?> Abs_ r
+ -- >            ]
+
+ -- * Interpolate
+ , Interpolate (..)
+ , Constant (..)
+ , interpolate
+ , interpolate_cos
+
+
+ )
+ where
+
+import Data.Ratio
+
+---------------------------------------------------------------------------------------------------
+-- | 'EnvLength' represents the length of a segment of an Envelope. 
+data EnvLength = Abs Int            -- ^ A fixed length.
+               | Abs_ Int           -- ^ A fixed length that is not subtracted from the total time.
+               | Flex Double        -- ^ A flexible length. Resuming length is distributed to all 
+                                    --   flexible lengths proportionally to its value.
+               | Rel (Ratio Int)    -- ^ A length relative to the total length.
+               | Rel_ (Ratio Int)   -- ^ A relative length that is not subtracted from the total time.
+
+-- | Takes an absolute total length and a list of EnvLengths. Each 'EnvLength' is mapped
+--   to its length with respect to the total length and a resuming length that is
+--   the result of @ total length - (all fixed lengths + all relative lengths) @. 
+--   This resuming lengths is distributed to the flexible lengths.
+calculateEnvLengths :: Int -> [EnvLength] -> [Int]
+calculateEnvLengths n eds = map lengthE normed_eds
+ where
+  fixlen = sum ( eds >>= \ed -> case ed of { Abs i -> [i]; _ -> [] } )
+  rellen = round (fromIntegral n * sum (eds >>= \ed -> case ed of { Rel r -> [r]; _ -> [] } ))
+  len = max 0 (n - (fixlen + rellen))
+  flexsum = sum (eds >>= \ed -> case ed of { Flex d -> [abs d]; _ -> [] })
+  normed_eds = if flexsum == 0.0 then eds else 
+               map (\e -> case e of { Flex d -> Flex (d / flexsum); a -> a }) eds
+  lengthE :: EnvLength -> Int
+  lengthE (Abs i)     = i
+  lengthE (Abs_ i)    = i
+  lengthE (Flex d)  = round (d * fromIntegral len)
+  lengthE (Rel r)  = round (r * fromIntegral n)
+  lengthE (Rel_ r) = round (r * fromIntegral n)
+---------------------------------------------------------------------------------------------------
+type Env = Int -> [Double]
+
+runEnv :: [(Env, EnvLength)] -> Env
+runEnv eps n = concat $ zipWith ($) (map fst eps) $ calculateEnvLengths n $ map snd eps
+---------------------------------------------------------------------------------------------------
+class IsEnv a where
+ toEnv :: a -> Env
+
+instance IsEnv Env where
+ toEnv = id
+
+(<?>) :: IsEnv a => a -> EnvLength -> (Env, EnvLength)
+a <?> l = (toEnv a, l)
+---------------------------------------------------------------------------------------------------
+-- | A linear or a cosinus-like shape
+data EnvShape = Linear | CosLike
+ deriving (Eq, Read, Show)
+
+data Interpolate = Interpolate EnvShape (Double, Double)
+
+instance IsEnv Interpolate where
+ toEnv (Interpolate Linear v) = interpolate v
+ toEnv (Interpolate CosLike v) = interpolate_cos v
+
+-- | produces a line with given length that starts with fst value and ends with snd value
+interpolate :: Fractional a => (a, a) -> Int -> [a]
+interpolate (i,e) len = 
+ let d = (e - i) / fromIntegral len 
+ in take len (iterate (+d) i) 
+
+-- | produces a curve with given length that starts with fst value and ends with snd value. 
+--   this curve has the shape of a half cosinus curve (values for 0 to PI).
+interpolate_cos :: Floating a => (a, a) -> Int -> [a]
+interpolate_cos (i,e) len = map fun [0 .. len-1]
+ where
+     dlen = fromIntegral len
+     diff = e - i
+     d   = diff * 0.5
+     fak = pi / dlen
+     fun x = i + d * (1.0 - cos (fak * fromIntegral x))
+---------------------------------------------------------------------------------------------------
+data Constant = Constant Double
+
+instance IsEnv Constant where
+ toEnv (Constant d) = flip replicate d
+---------------------------------------------------------------------------------------------------
+-- | The four components of 'ADSR' are:
+--
+--   * Attack (time to reach value 1.0, starting from 0.0)
+--
+--   * Decay (time to reach sustain level)
+--
+--   * Sustain (level to hold until note is released, should be a value between 0.0 and 1.0)
+--
+--   * Release (time to reach value 0.0 after note is released)
+--
+-- time is measured in sample points, 44100 is one second.
+type ADSR = (Int,Int,Double,Int)
+---------------------------------------------------------------------------------------------------
+data EnvMode = HoldS   -- ^ Sustain value is kept until duration is over, Release part is appended.
+             | FitS    -- ^ Envelope has given duration by fitting only duration of constant Sustain level.
+             | FitADR  -- ^ Attack, Decay and Released are together stretched to given duration.
+ deriving (Eq, Read, Show)
+
+-- | Playing an ADSR
+playADSR :: EnvMode -> EnvShape -> ADSR -> Int -> [Double]
+playADSR mode shape (a,d,s,r) = case mode of
+ FitADR -> runEnv
+           [ Interpolate shape (0.0,1.0) <?> Flex (fromIntegral a)
+           , Interpolate shape (1.0, s) <?> Flex (fromIntegral d)
+           , Interpolate shape (s, 0.0) <?> Flex (fromIntegral r)
+           ]
+ FitS   -> runEnv
+           [ Interpolate shape (0.0,1.0) <?> Abs a
+           , Interpolate shape (1.0, s) <?> Abs d
+           , Constant s <?> Flex 1.0
+           , Interpolate shape (s, 0.0) <?> Abs r
+           ]
+ HoldS  -> runEnv
+           [ Interpolate shape (0.0,1.0) <?> Abs a
+           , Interpolate shape (1.0, s) <?> Abs d
+           , Constant s <?> Flex 1.0
+           , Interpolate shape (s, 0.0) <?> Abs_ r
+           ]
+

+ Sound/Hommage/FFT.hs view
@@ -0,0 +1,283 @@+-- | This module implements the Fast Fourier Transformation purely in Haskell.
+module Sound.Hommage.FFT
+ ( 
+ -- * FFT
+   fft
+ , fft'
+ , fftt 
+
+ -- * FFT
+ , fftc
+ , fftc' 
+
+ , ffttv 
+
+ , fftco 
+ , fftco'
+
+ , rect_transform 
+ , rect_filter 
+ , rect_filter' 
+
+ , i 
+ , w 
+ , ws 
+ , map2 
+ , zip2 
+ , evens 
+ , odds 
+ , drop_odds 
+ , appendpair
+-- , fitlastlength 
+ , reorder 
+ , reorder_init 
+ , reorder_init'
+-- , reorder_overlap 
+ , butterfly 
+ , butterfly'
+ , fft_level 
+ , fft_merge 
+ , fft_init_overlap 
+ , fft_level' 
+ , fft_merge' 
+ , fft_init 
+ , fft_overlap_loop 
+ , expandComplex 
+ , overlap_curve 
+ , mix_overlap 
+
+ )
+ where
+import Data.Complex
+import Sound.Hommage.Misc
+-------------------------------------------------------------------------------
+-- | The complex value 'i' = @(0 :+ 1)@
+i :: Complex Double
+i = 0.0 :+ 1.0
+
+-- | The n-th root of 1
+w :: Int -> Complex Double
+w n = exp (-2 * i * pi / fromIntegral n)
+
+-- | the 2n-th root with exponents 0, 1, .. n. False=inverse (exponents are negated)
+ws :: Bool -> Int -> [Complex Double]
+ws b n = take n $ map (w1^^) ix 
+ where
+  w1 = exp (-i * pi / fromIntegral n)
+  ix | b         = [0, 1 ..]
+     | otherwise = [0, (-1) ..]
+-------------------------------------------------------------------------------
+map2 :: (a -> a -> b) -> [a] -> [b]
+map2 f (x:y:r) = f x y : map2 f r
+map2 _ _       = []
+
+map2opt :: (a -> a -> b) -> a -> [a] -> [b]
+map2opt f a = loop 
+ where
+  loop (x:y:r) = f x y : loop r
+  loop [x]     = [f x a]
+  loop _       = []
+
+zip2 :: [a] -> [a] -> [a]
+zip2 (x:xs) (y:ys) = x : y : zip2 xs ys
+zip2 _ _ = []
+
+evens (x:xs) = x : odds xs
+evens []     = []
+
+odds (_:xs) = evens xs
+odds []     = []
+
+-- | returns [] if argument has zero or one element.
+drop_odds (x:y:r) = x : evens r
+drop_odds _       = []
+
+appendpair :: ([a], [a]) -> [a]
+appendpair (x,y) = x++y
+
+--fitlastlength :: Int -> a -> [[a]] -> [[a]]
+--fitlastlength n a = loop
+-- where
+--  loop (x:xs) = case loop xs of
+--                [] -> [take n (x ++ repeat a)]
+--                xs -> x : xs
+--  loop []     = []
+-------------------------------------------------------------------------------
+-- | list is grouped into sublists with length N (must be power of 2) and bitwise reverse order
+reorder :: Int -> [[a]] -> [[a]]
+reorder 0 = id
+reorder n = map2 zip2 . reorder (n-1)
+
+reorder_r2 :: Int -> a -> [[a]] -> [[a]]
+reorder_r2 n a = loop n
+ where
+  loop 0 = id
+  loop n = map2opt zip2 (repeat a) . loop (n-1)
+
+reorder_init (x1:x2:x3:x4:xs) = [x1 :+ x2, x3 :+ x4] : reorder_init xs
+reorder_init [x1,x2,x3]       = [[x1 :+ x2, x3 :+ 0]]
+reorder_init [x1,x2]          = [[x1 :+ x2, 0]]
+reorder_init [x1]             = [[x1 :+ 0, 0]]
+reorder_init _                = []
+
+reorder_init' :: [a] -> [[a]]
+reorder_init' (x:y:r) = [x,y] : reorder_init' r
+reorder_init' _       = []
+
+reorder_init_r2' :: a -> [a] -> [[a]]
+reorder_init_r2' a = loop
+ where
+  loop (x:y:r) = [x,y] : loop r
+  loop [x]     = [[x,a]]
+  loop _       = []
+  
+--reorder_overlap :: [[a]] -> [a]
+--reorder_overlap (xs:ys:r) = (zip2 xs ys) ++ reorder_overlap (ys:r)
+--reorder_overlap _       = []
+-------------------------------------------------------------------------------
+butterfly :: Complex Double ->  Complex Double -> Complex Double -> (Complex Double, Complex Double)
+butterfly (wr :+ wi) (xr :+ xi) (yr :+ yi) = (a, b)
+ where
+  wyr = wr*yr-wi*yi 
+  wyi = wr*yi+yr*wi
+  a = ( (xr + wyr) * 0.5 :+ (xi + wyi) * 0.5 )
+  b = ( (xr - wyr) * 0.5 :+ (xi - wyi) * 0.5 )
+
+butterfly' :: Complex Double ->  Complex Double -> Complex Double -> (Complex Double, Complex Double)
+butterfly' (wr :+ wi) (xr :+ xi) (yr :+ yi) = (a, b)
+ where
+  wyr = wr*yr-wi*yi 
+  wyi = wr*yi+yr*wi
+  a = ( (xr + wyr) :+ (xi + wyi) )
+  b = ( (xr - wyr) :+ (xi - wyi) )
+-------------------------------------------------------------------------------
+-- | FFT transformation. Input is grouped into overlapping parts of 2^(N+2) reals and mapped to sublists 
+--   with 2^(N+1) complex numbers. 
+fft :: Int -> [Double] -> [[Complex Double]]
+fft n = fft_level (ws True (2^n)) . fft_init_overlap . reorder_r2 (n-1) 0 . reorder_init
+
+fft_level :: [Complex Double] -> [[Complex Double]] -> [[Complex Double]] 
+fft_level [_] = id
+fft_level ws  = map2 (\x -> appendpair . fft_merge ws x) . fft_level (drop_odds ws)
+
+fft_merge :: [Complex Double] -> [Complex Double] -> [Complex Double] -> ([Complex Double], [Complex Double])
+fft_merge (w:ws) (x:xs) (y:ys) = let (xs', ys') = fft_merge ws xs ys
+                                     (x', y') = butterfly w x y
+                                 in (x' : xs', y' : ys')
+fft_merge _ _ _ = ([], [])
+
+fft_init_overlap (x:y:r) = (zipWith (\x y -> [(x + y)*0.5, (x - y)*0.5]) x y) ++ fft_init_overlap (y:r)
+fft_init_overlap _       = []
+
+fft_init (x:y:r) = (zipWith (\x y -> [(x + y)*0.5, (x - y)*0.5]) x y) ++ fft_init r
+fft_init _       = []
+-------------------------------------------------------------------------------
+-- | Inverse FFT transformation. Complex input is grouped into parts with length 2^(N+1) and mapped to 
+--   sublists with 2^(N+2) reals, which are overlapped and mixed.
+fft' :: Int -> [Complex Double] -> [Double]
+fft' n = mix_overlap (2^(n+2)) . map expandComplex . fft_level' (ws False (2^n)) . fft_init' . reorder (n-1) . reorder_init'
+
+fft_level' :: [Complex Double] -> [[Complex Double]] -> [[Complex Double]] 
+fft_level' [_] = id
+fft_level' ws  = map2 (\x -> appendpair . fft_merge' ws x) . fft_level' (drop_odds ws)
+
+fft_merge' :: [Complex Double] -> [Complex Double] -> [Complex Double] -> ([Complex Double], [Complex Double])
+fft_merge' (w:ws) (x:xs) (y:ys) = let (xs', ys') = fft_merge' ws xs ys
+                                      (x', y') = butterfly' w x y
+                                  in (x' : xs', y' : ys')
+fft_merge' _ _ _ = ([], [])
+
+fft_init' (x:y:r) = (zipWith (\x y -> [x + y, x - y]) x y) ++ fft_init' r
+fft_init' _       = []
+
+fft_overlap_loop (x:r@(y:_)) = (concat $ zipWith (\x y -> [x + y, x - y]) x y) : fft_overlap_loop r
+fft_overlap_loop _           = []
+
+expandComplex ((x:+y):r) = x : y : expandComplex r
+expandComplex _ = []
+-------------------------------------------------------------------------------
+-- | Creates a fade with length N
+overlap_curve :: Int -> [Double]
+overlap_curve n = take n $ map (\k -> 0.5 - 0.5 * cos (fromIntegral k * 2 * pi / fromIntegral n )) [0..]
+
+-- | Overlaps a sequence of parts of length N (overlaps by N\/2).
+mix_overlap :: Int -> [[Double]] -> [Double]
+mix_overlap n xs = merge (+) l r
+  where 
+  c = cycle $ overlap_curve n
+  l = zipWith (*) c $ concat $ evens xs
+  r = replicate (div n 2) 0.0 ++ (zipWith (*) c $ concat $ odds xs)
+-------------------------------------------------------------------------------
+-- | FFT transformation with overlapping and windowing. 
+--   Argument function maps the coefficients. Windowsize: 2^(N+2), i. e. 2^(N+1) coefficients
+fftt :: Int -> ([[Complex Double]] -> [Complex Double]) -> [Double] -> [Double]
+fftt n f = 
+ mix_overlap (2^(n+2)) . 
+ map expandComplex . 
+ fft_level' (ws False (2^n)) . 
+ fft_init' . 
+ reorder (n-1) . 
+ reorder_init' .
+ f .
+ fft_level (ws True (2^n)) . 
+ fft_init_overlap . 
+ reorder_r2 (n-1) 0 . 
+ reorder_init
+
+ffttv :: Int -> [Double] -> [Double] -> [Double]
+ffttv n vs = fftt n (zipWith (\v (x:+y) -> (v*x) :+ (v*y)) vs . concat . map (\((a:+_):r) -> (a:+0):r))
+-------------------------------------------------------------------------------
+-- | FFT transformation for complex input (segments of length 2^n). 
+--   No overlapping or windowing.
+fftc :: Int -> [Complex Double] -> [[Complex Double]]
+fftc n = fft_level (ws True (2^n)) . fft_init . reorder_r2 (n-1) 0 . reorder_init_r2' 0
+
+-- | Inverse FFT transformation for complex input (segments of length 2^n). 
+--   No overlapping or windowing.
+fftc' :: Int -> [Complex Double] -> [[Complex Double]]
+fftc' n = fft_level' (ws False (2^n)) . fft_init' . reorder (n-1) . reorder_init'
+-------------------------------------------------------------------------------
+-- | FFT for complex input with overlapping. Segment-size: 2^(n+1)
+fftco :: Int -> [Complex Double] -> [[Complex Double]]
+fftco n = fft_level (ws True (2^n)) . fft_init_overlap . reorder_r2 (n-1) 0 . reorder_init_r2' 0
+
+fftco' :: Int -> [Complex Double] -> [Complex Double]
+fftco' n = mix_overlapc (2^(n+1)) . fft_level' (ws False (2^n)) . fft_init' . reorder (n-1) . reorder_init'
+
+-- | Overlaps a sequence of parts of length N (overlaps by N\/2).
+mix_overlapc :: Int -> [[Complex Double]] -> [Complex Double]
+mix_overlapc n xs = merge (+) l r
+  where 
+  c = cycle $ map (:+0) $ overlap_curve n
+  l = zipWith (*) c $ concat $ evens xs
+  r = replicate (div n 2) 0.0 ++ (zipWith (*) c $ concat $ odds xs)
+-------------------------------------------------------------------------------
+
+-- | A self-inverse transformation similar to FFT but with a simple butterfly
+--   operation that uses always W=1. Modifying the data between application
+--   and inverse is similar to filtering but the result will be built up from
+--   rectangle waves instead of sinus waves.
+rect_transform :: Floating a => Int -> [a] -> [[a]]
+rect_transform n = run n . map (:[])
+ where
+  sq = 1 / sqrt 2
+  add x y = (x+y) * sq
+  sub x y = (x-y) * sq
+  run 0 = id
+  run n = loop . run (n-1)
+  loop (x:y:r) = iter True x y : loop r
+  loop [x]     = [iter True x (repeat 0)]
+  loop _       = []
+  iter True  (x:xs) (y:ys) = add x y : sub x y : iter False xs ys
+  iter False (x:xs) (y:ys) = sub x y : add x y : iter True  xs ys
+  iter _     _      _      = []
+
+rect_filter :: Floating a => Int -> ([[a]] -> [[a]]) -> [a] -> [a]
+rect_filter n f =  concat . rect_transform n . concat . f . rect_transform n
+
+rect_filter' :: Floating a => Int -> [[a]] -> [a] -> [a]
+rect_filter' n vs =  concat . rect_transform n . concat . zipWith f vs . rect_transform n
+ where
+  f v c = zipWith (*) (v ++ repeat 0) c
+
+

+ Sound/Hommage/Filter.hs view
@@ -0,0 +1,268 @@+module Sound.Hommage.Filter
+ (
+ -- * Filters
+   lowpass
+ , highpass
+ , bandpass
+ , stretchpass
+ , morphpass 
+-- , vocoder
+
+-- , lowpassrect 
+
+ -- * FilterSpec
+-- , specfilter 
+ , FilterSpec  
+ , shiftFilterSpec 
+
+ -- * FilterSpec and Lists
+ , filterSpecToList
+ , filterSpecsToLists
+ , interpolFilterLists 
+
+ -- * Other
+ , ffreq 
+ , ffreqi
+ , average512 
+
+ -- * Filterfunctions
+ , lowpassFS
+ , highpassFS
+ , bandpassFS 
+ , lowp0FS 
+ , lowp1FS
+ , bandp0FS 
+ , bandp1FS 
+ , highp0FS 
+ , highp1FS 
+
+ )
+ where
+
+--import Sound.Hommage.DFTFilter
+import Data.Complex
+
+--import Sound.Hommage.FFT
+---------------------------------------------------------------------------------------------------
+lowpass :: [Double] -> [Double] -> [Double]
+lowpass s c = concat $ map filterSpecToList $ 
+ zipWith lowpassFS (average512 s) (average512 c)
+
+highpass :: [Double] -> [Double] -> [Double]
+highpass s c = concat $ map filterSpecToList $ 
+ zipWith highpassFS (average512 s) (average512 c)
+
+bandpass :: [Double] -> [Double] -> [Double] -> [Double] 
+bandpass r s c = concat $ map filterSpecToList $ 
+ zipWith3 bandpassFS (average512 r) (average512 s) (average512 c)
+
+stretchpass:: FilterSpec -> [Double] -> [Double] 
+stretchpass fs c = concat $ map filterSpecToList $ 
+ map (flip shiftFilterSpec fs) $ map (2.0**) $ average512 c
+ 
+morphpass:: FilterSpec -> FilterSpec -> [Double] -> [Double]
+morphpass f1 f2 c = 
+ let l1 = filterSpecToList f1
+     l2 = filterSpecToList f2
+ in concat $ map (interpolFilterLists l1 l2) $ average512 c
+---------------------------------------------------------------------------------------------------
+{-
+
+
+
+
+-- | first argument is width of filter, second is cutoff
+lowpassfilter :: [Double] -> [Double] -> [Double] -> [Double]
+lowpassfilter s c = 
+
+lowpassrect :: [Double] -> [Double] -> [Double] -> [Double]
+lowpassrect s c =  
+ let i = ([]:) $ map filterSpecToList $ zipWith lowpassFS (average512 s) (average512 c)
+ in rect_filter' 9 i
+
+{-
+specfilterFFT :: [FilterSpec] -> [Double] -> [Double]
+specfilterFFT fs = fftt 8 (concat . zipWith fun fs )
+
+fun :: FilterSpec -> [Complex Double] -> [Complex Double] 
+fun fs ((c0 :+ _) : cs) = zipWith f ((c0 :+ 0) : cs) (filterSpecToList fs)
+ where
+  f (x:+y) v = (x * v) :+ (y * v)
+-}
+
+-- | first argument is width of filter, second is cutoff
+highpassfilter :: [Double] -> [Double] -> [Double] -> [Double]
+highpassfilter s c = 
+ let i = concat $ map filterSpecToList $ zipWith highpassFS (average512 s) (average512 c)
+ in dftfilter i
+
+-- | first argument is width of filter, second is slope, third is cutoff
+bandpassfilter :: [Double] -> [Double] -> [Double] -> [Double] -> [Double]
+bandpassfilter r s c = 
+ let i = concat $ map filterSpecToList $ zipWith3 bandpassFS (average512 r) (average512 s) (average512 c)
+ in dftfilter i
+
+stretchfilter :: FilterSpec -> [Double] -> [Double] -> [Double]
+stretchfilter fs c = 
+ let i = concat $ map filterSpecToList $ map (flip shiftFilterSpec fs) $ map (2.0**) $ average512 c
+ in dftfilter i
+
+morphfilter :: FilterSpec -> FilterSpec -> [Double] -> [Double] -> [Double]
+morphfilter f1 f2 c = 
+ let l1 = filterSpecToList f1
+     l2 = filterSpecToList f2
+     i = concat $ map (interpolFilterLists l1 l2) $ average512 c
+ in dftfilter i
+
+---------------------------------------------------------------------------------------------------
+specfilter :: [FilterSpec] -> [Double] -> [Double]
+specfilter fs = 
+ let i = concat $ map filterSpecToList fs
+ in dftfilter i
+-}
+---------------------------------------------------------------------------------------------------
+-- | for filter coefficient number: (0.0 .. 1.0) -> (1.0 .. 512.0)
+ffreq :: Double -> Double
+ffreq k = r
+ where
+  k' = abs k 
+  r | k' > 1.0  = 512.0
+    | otherwise = 2 ** (9.0 * k')
+
+-- | floor of 'ffreq' 
+ffreqi :: Double -> Int
+ffreqi = floor . ffreq 
+
+-- | the resulting list is 1 \/ 512 as long as the input list. 
+--   512 elements are read and their average is the next output value.
+average512 :: [Double] -> [Double]
+average512 = loop 512 0.0
+ where
+  loop 0 s xs     = (s / 512.0) : loop 512 0.0 xs
+  loop k s (x:xs) = loop (k-1) (s+x) xs
+  loop _ _ _      = []
+--mkFilterFun :: (Double -> FilterSpec) -> (Double, Double) -> FilterFun Double
+--mkFilterFun filt (cutoff, fmod) = withFilterEnv . mkFilterEnv . filt . (+cutoff) . (*fmod)
+---------------------------------------------------------------------------------------------------
+-- | Filtering starts at coeff nr 0 and value 0.0 (constant coeff is always zero). 
+--   The elements in FilterSpec define the next value and how many 
+--   coeffs it takes to reach this value. 
+type FilterSpec   = [(Int, Double)] 
+
+-- | 0..1: lower, 1..: higher
+shiftFilterSpec :: Double -> FilterSpec -> FilterSpec 
+shiftFilterSpec d fs = map f fs
+ where
+  f (n,v) = (round (d * fromIntegral n), v)
+
+-- | Converting a FilterSpec to a list of 512 Doubles
+filterSpecToList :: FilterSpec -> [Double]
+filterSpecToList xs = take 512 $ loop 0.0 xs
+ where
+  loop c []          = repeat c
+  loop c ((n,d): ls) = let f = (d-c) / fromIntegral n in take n (iterate (+f) c) ++ loop d ls
+
+
+-- | Converting and interpolating a sequence of FilterSpecs to a list of lists. The first elemet of the
+-- tuple, an Int, describes how many lists it takes to reach the given FilterSpec. 
+filterSpecsToLists :: [(Int, FilterSpec)] -> [[Double]]
+filterSpecsToLists = loop (filterSpecToList  [])
+ where
+  loop l []         = []
+  loop l ((n,f):xs) = let f' = filterSpecToList f 
+                      in fun n l f' ++ loop f' xs
+  fun n f1 f2       = let d = 1.0 / fromIntegral n
+                      in take n $ map (interpolFilterLists f1 f2) $ iterate (+d) 0.0
+
+interpolFilterLists :: [Double] -> [Double] -> Double -> [Double]
+interpolFilterLists f1 f2 n | n >= 1.0  = f2
+                            | n <= 0.0  = f1
+                            | otherwise = let n' = 1.0 - n in 
+                                          zipWith (\a b -> a * n' + b * n) f1 f2
+
+---------------------------------------------------------------------------------------------------
+lowpassFS :: Double -> Double -> FilterSpec
+lowpassFS d c = [(1,1.0), (round fd, 1.0), (round (fd * abs d), 0.0)]
+ where
+  fd = ffreq c
+
+highpassFS :: Double -> Double -> FilterSpec
+highpassFS d c = [(round fd, 0.0), (round (fd * abs d), 1.0)]
+ where
+  fd = ffreq c
+
+-- | range, curve, cutoff
+bandpassFS :: Double -- ^ width of freq-window
+           -> Double -- 
+           -> Double -- ^ cutoff
+           -> FilterSpec
+bandpassFS r s f = [(l1, 0.0), (l2, 1.0), (l3, 1.0), (l4, 0.0)]
+ where
+
+  m1 = abs r + 1
+  m2 = m1 + abs s
+  a = ffreqi (f / m2)
+  b = ffreqi (f / m1)
+  c = ffreqi (f * m1)
+  d = ffreqi (f * m2)
+  
+  l1 = a
+  l2 = b - a
+  l3 = c - b
+  l4 = d - c
+
+bandpassFS' :: Double -- ^ width of freq-window
+           -> Double -- 
+           -> Double -- ^ cutoff
+           -> FilterSpec
+bandpassFS' r s f = [(1 + round a, 0.0), (1 + round b, 1.0), (1 + round c, 1.0), (1 + round d, 0.0)]
+ where
+  r' = 1.0 + abs r
+  s' = 1.0 + abs s
+  fd = ffreq f
+  a  = fd
+  b  = fd * s' - a
+  c  = b * r'  - b
+  d  = c * s'  - c
+---------------------------------------------------------------------------------------------------
+lowp0FS :: Double -> FilterSpec
+lowp0FS f = [(0, 1.0), (fr, 1.0), (1, 0.0)]
+ where
+  fr = ffreqi f
+
+lowp1FS :: Double -> FilterSpec
+lowp1FS f = [(0, 1.0), (fr, 1.0), (fr, 0.0)]
+ where
+  fr = ffreqi f
+
+bandp0FS :: Double -> FilterSpec
+bandp0FS f = [(f0-1, 0.0), (f0, 1.0), (fr, 1.0), (1, 0.0)]
+ where
+  fr = ffreqi f
+  f0 = fr - (div fr 2) + 1
+
+bandp1FS :: Double -> FilterSpec
+bandp1FS f = [(fh, 0.0), (fh, 1.0), (fh, 0.0)]
+ where
+  fr = ffreqi f
+  fh = div fr 2
+
+highp0FS :: Double -> FilterSpec
+highp0FS f = [(fr, 0.0), (1, 1.0)]
+ where
+  fr = ffreqi f
+
+highp1FS :: Double -> FilterSpec
+highp1FS f = [(fh, 0.0), (fh, 1.0)]
+ where
+  fr = ffreqi f
+  fh = div fr 2
+---------------------------------------------------------------------------------------------------
+{-
+-- | first argument is control signal
+vocoder :: [Double] -> [Double] -> [Double]
+vocoder xs ys = dftsynthese $ zipWith f (dftanalyse xs) (dftanalyse ys)
+ where
+  f x (a :+ b) = let z = magnitude x in (a*z :+ b*z)
+-}
+---------------------------------------------------------------------------------------------------

+ Sound/Hommage/Midi.hs view
@@ -0,0 +1,169 @@+module Sound.Hommage.Midi
+ ( 
+ -- | The action 'writeMidiFile' stores the datatype 'MidiFile' in a MIDI-File. 
+ --   It consists of a field for the 'Ticks' per quarter and a 'MidiTrack' (or some). 
+ --   The function 'runMidiMusic' produces such a track from a 'MidiMusic', which can
+ --   be created using the functions 'noteMidiMusic', 'restMidiMusic', 'appendMidiMusic' and
+ --   'mergeMidiMusic'. 
+ --   'MidiNote' is used to create note or controller events; it consists of the Midi-Channel
+ --   ('Chan') and two fields with a 'MidiValue'.
+
+ -- * MidiFile
+   MidiFile (..)
+ , writeMidiFile 
+ , Ticks 
+ -- * MidiNote
+ , MidiNote (..)
+ , Chan 
+ , MidiValue 
+ -- * MidiMusic 
+ , MidiMusic
+ , noteMidiMusic 
+ , restMidiMusic 
+ , appendMidiMusic 
+ , mergeMidiMusic 
+ , runMidiMusic 
+ -- * MidiTrack
+ , MidiTrack 
+ , Delta 
+ -- * MidiEvent
+ , MidiEvent (..)
+ -- * Encoding
+ , encodeMidiFile 
+ , midiHeaderSync 
+ , midiHeaderSingle
+ , midiHeaderAsync  
+ , encodeMidiTrack
+ , encodeDelta 
+ , encodeMidiDeltaEvent 
+ , encodeEvent 
+ , lastByte 
+ , nextByte 
+ , toBytes 
+ )
+ where
+
+import Sound.Hommage.WavFile
+
+import Data.Word
+import Data.Bits
+import Data.Ratio
+---------------------------------------------------------------------------------------------------
+type Delta = Int
+-- | A kind of extended MidiTrack type, that allows delta-times without events 
+--   (will be summed up by converting to 'MidiTrack').
+type MidiMusic = [(Delta, Maybe MidiEvent)]
+-- | A sequence of MidiEvents with a delta-time which means the number of ticks
+--   before the event happens (relative to the last event). 
+type MidiTrack = [(Delta, MidiEvent)]
+-- | Ticks per Quarter. For some unknown reasons it does not work with any value.
+--   96 seems to be ok. 
+type Ticks = Int
+---------------------------------------------------------------------------------------------------
+-- | Converts a 'MidiMusic' to a 'MidiTrack'. 
+runMidiMusic :: MidiMusic -> MidiTrack 
+runMidiMusic mt = loop 0 mt
+ where
+  loop delta ((d, Just e)  : r) = (delta + d, e) : loop 0 r
+  loop delta ((d, Nothing) : r) = loop (d+delta) r
+  loop delta []                 = [(delta, MidiEndOfTrack)]
+
+-- | Writes a 'MidiFile' to a File.
+writeMidiFile :: FilePath -> MidiFile -> IO ()
+writeMidiFile fp mf = writeDataFile fp $ encodeMidiFile mf
+---------------------------------------------------------------------------------------------------
+-- | A Midi-Channel (0-15)
+type Chan = Word8
+-- | A Midi-Value (0-127)
+type MidiValue = Word8
+---------------------------------------------------------------------------------------------------
+data MidiNote = MidiNote Chan MidiValue MidiValue -- ^ A note with pitch and volume
+              | MidiCtrl Chan MidiValue MidiValue -- ^ Controllernumber and value
+---------------------------------------------------------------------------------------------------
+-- | Creates a note or controller event with given length (relative to 'Ticks'). 
+--   The length means the delta-time between note-on and note-off resp. the time after
+--   the controller event.
+noteMidiMusic :: Int -> MidiNote -> MidiMusic
+noteMidiMusic d (MidiNote c n v) = 
+ [(0, Just $ MidiNoteOn c n v), (d, Just $ MidiNoteOff c n v)]
+noteMidiMusic d (MidiCtrl c n v) = 
+ [(0, Just $ MidiControl c n v), (d, Nothing)]
+
+-- | A pause with given length.
+restMidiMusic :: Int -> MidiMusic
+restMidiMusic d = [(d, Nothing)]
+---------------------------------------------------------------------------------------------------
+-- | Parallel composition of 'MidiMusic'.
+mergeMidiMusic :: MidiMusic -> MidiMusic -> MidiMusic
+mergeMidiMusic ((d1,m1):r1) ((d2,m2):r2) | d1 < d2   = (d1,m1) : mergeMidiMusic r1 ((d2-d1,m2):r2)
+                                         | d1 > d2   = (d2,m2) : mergeMidiMusic ((d1-d2,m1):r1) r2
+                                         | otherwise = (d1,m1) : (0, m2) : mergeMidiMusic r1 r2
+mergeMidiMusic [] r2 = r2
+mergeMidiMusic r1 [] = r1
+
+-- | Sequencial composition of 'MidiMusic'.
+appendMidiMusic :: MidiMusic -> MidiMusic -> MidiMusic
+appendMidiMusic = (++)
+---------------------------------------------------------------------------------------------------
+data MidiFile = MidiSync   Ticks [MidiTrack] -- ^ Some parallel (synchronous) MidiTracks. 
+              | MidiSingle Ticks MidiTrack   -- ^ A single MidiTrack. (Seems not to work yet)
+              | MidiAsync  Ticks [MidiTrack] -- ^ Some asynchronous MidiTracks. (Seems not to work yet)
+
+data MidiEvent = MidiNoteOff  !Chan !MidiValue !MidiValue     -- note-nr and velocity
+               | MidiNoteOn   !Chan !MidiValue !MidiValue     -- note-nr and velocity
+               | MidiKeyAfter !Chan !MidiValue !MidiValue     -- note-nr and velocity
+               | MidiControl  !Chan !MidiValue !MidiValue     -- controller-nr and value
+               | MidiEndOfTrack
+--               | MidiProgram  !Chan !MidiValue                -- program-nr
+--               | MidiChannelAfter !Chan !MidiValue            -- channel-nr
+--               | MidiPitchWheel   !Chan !MidiValue !MidiValue -- bottom, top
+---------------------------------------------------------------------------------------------------
+encodeMidiFile :: MidiFile -> [Word8]
+encodeMidiFile mf =
+ case mf of        -- HEADER              TRACKS                    TICKS
+  MidiSync tc  mts -> midiHeaderSync   ++ toBytes 2 (length mts) ++ toBytes 2 tc ++ (mts >>= encodeMidiTrack)
+  MidiSingle tc mt -> midiHeaderSingle ++ toBytes 2 1            ++ toBytes 2 tc  ++ encodeMidiTrack mt
+  MidiAsync tc mts -> midiHeaderAsync  ++ toBytes 2 (length mts) ++ toBytes 2 tc ++ (mts >>= encodeMidiTrack)
+---------------------------------------------------------------------------------------------------
+midiHeaderSingle :: [Word8]
+midiHeaderSingle = [ 77, 84, 104, 100, 0, 0, 0, 6, 0, 0]
+
+midiHeaderSync :: [Word8]
+midiHeaderSync = [ 77, 84, 104, 100, 0, 0, 0, 6, 0, 1]
+
+midiHeaderAsync :: [Word8]
+midiHeaderAsync = [ 77, 84, 104, 100, 0, 0, 0, 6, 0, 2]
+---------------------------------------------------------------------------------------------------
+encodeMidiTrack :: MidiTrack -> [Word8]
+encodeMidiTrack ms = [ 77, 84, 114, 107 ] ++ toBytes 4 (length t) ++ t
+ where
+  t = (ms >>= encodeMidiDeltaEvent) 
+---------------------------------------------------------------------------------------------------
+encodeDelta :: Int -> [Word8]
+encodeDelta n = loop n
+ where 
+  loop n | n < 128   = [fromIntegral n]
+         | otherwise = fromIntegral (128 + mod n 128) : loop (div n 128)
+---------------------------------------------------------------------------------------------------
+encodeMidiDeltaEvent :: (Delta, MidiEvent) -> [Word8]
+encodeMidiDeltaEvent (delta, me) = encodeDelta delta ++ encodeEvent me
+
+encodeEvent :: MidiEvent -> [Word8]
+encodeEvent me = 
+ case me of
+  MidiNoteOff ch no va  -> [ch + 128, no, va]
+  MidiNoteOn  ch no va  -> [ch + 144, no, va]
+  MidiKeyAfter ch no va -> [ch + 160, no, va]
+  MidiControl ch no va  -> [ch + 176, no, va]
+  MidiEndOfTrack        -> [255,47,0]
+--------------------------------------------------------------------------------------------------
+lastByte :: Int -> Word8
+lastByte n = fromIntegral (mod n 256)
+
+nextByte :: Int -> Int
+nextByte n = div n 256
+
+toBytes :: Int -> Int -> [Word8]
+toBytes k n = reverse $ take k $ map lastByte $ iterate nextByte n  -- reverse?
+---------------------------------------------------------------------------------------------------
+

+ Sound/Hommage/Misc.hs view
@@ -0,0 +1,206 @@+module Sound.Hommage.Misc
+ ( 
+ -- * Imperative control structure
+   for                 
+ , for'                
+
+ -- * Usefull list functions 
+ , map_ 
+ , foldr_ 
+ , merge 
+ , mergeSet 
+ , uneitherlist 
+
+ , walk
+ , appendmaps 
+ , appendmaps'
+
+ , qsort 
+ , qsortM 
+
+ -- * More usefull functions
+ , head_opt 
+ , newFilePath 
+
+ -- * Embedding IO in a list (-map)
+ , inList
+ , inList' 
+ , inList''
+ , toList
+ , toList'
+ , inListE
+ , inListE' 
+ , inListE''
+ , toListE
+ , toListE'
+
+ )
+ where
+
+import System.Directory
+import System.IO.Unsafe
+import Data.Int
+import Data.List
+
+---------------------------------------------------------------------------------------------------
+for :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m b) -> m ()
+for count test step fun | test count = fun count >> for (step count) test step fun
+                        | otherwise  = return ()
+
+for' :: Monad m => a -> (a -> Bool) -> (a -> a) -> b -> (a -> b -> m b) -> m b
+for' count test step state fun | test count = do state' <- fun count state
+                                                 for' (step count) test step state' fun 
+                               | otherwise  = return state
+---------------------------------------------------------------------------------------------------
+-- | a pseudo-strict 'map' version. does not touch the elements but reconstructs the whole list 
+--   structure before the function is applied to the value
+map_ :: (a -> b) -> [a] -> [b]
+map_ f []     = []
+map_ f (x:xs) = let r = map_ f xs in seq r (f x : r)
+
+-- | a pseudo-strict 'foldr' version. does not touch the elements but reconstructs the whole list 
+--   structure  before the function is applied to the values. 
+foldr_ :: (a -> b -> b) -> b -> [a] -> b
+foldr_ f e []     = e
+foldr_ f e (x:xs) = let r = foldr_ f e xs in seq r (f x r)
+
+-- | Similar to 'zipWith', but the result has the length of the longer input list.
+merge :: (a -> a -> a) -> [a] -> [a] -> [a]
+merge f = loop
+ where
+  loop (x:xs) (y:ys) = (f x y) : loop xs ys
+  loop xs     []     = xs
+  loop []     ys     = ys
+
+mergeSet :: ([a] -> b) -> [[a]] -> [b]
+mergeSet f = map f . transpose
+
+mergeSet_ :: ([a] -> b) -> [[a]] -> [b]
+mergeSet_ f = strict . map f . transpose
+
+strict :: [a] -> [a]
+strict (x:xs) = seq x (x : strict xs)
+strict []     = []
+
+head_opt :: a -> [a] -> a
+head_opt _ (x:xs) = x 
+head_opt x _      = x
+
+uneitherlist :: [Either a b] -> ([a],[b])
+uneitherlist []            = ([],[])
+uneitherlist (Left  a : s) = let (l,r) = uneitherlist s in (a:l,r)
+uneitherlist (Right b : s) = let (l,r) = uneitherlist s in (l,b:r)
+
+walk :: ([a] -> [b]) -> [a] -> ([a],[b])
+walk f a = loop a (f a)
+ where
+  loop (a:as) (b:bs) = let (as',bs') = loop as bs in (as',b : bs')
+  loop as     []     = (as, [])
+  loop []     bs     = ([], bs)
+
+appendmaps :: [[a] -> [b]] -> [a] -> [b]
+appendmaps (f:fs) as = let (as', bs) = walk f as in bs ++ appendmaps fs as'
+appendmaps _      _  = []
+
+appendmaps' :: [[a] -> [b]] -> [a] -> [[b]]
+appendmaps' (f:fs) as = let (as', bs) = walk f as in bs : appendmaps' fs as'
+appendmaps' _      _  = []
+---------------------------------------------------------------------------------------------------
+qsort :: (a -> a -> Bool) -> [a] -> [a]
+qsort p i = so i
+ where
+  so [x]    = [x]
+  so (x:xs) = let (l,r) = sp x xs in so l ++ [x] ++ so r
+  so []     = []
+  sp x (y:ys) = let (l,r) = sp x ys in if p y x then (y:l,r) else (l,y:r)
+  sp x []     = ([],[])
+
+
+qsortM :: Monad m => (a -> a -> m Bool) -> [a] -> m [a]
+qsortM p = sort 
+ where
+  sort [x]    = return [x]
+  sort (x:xs) = do (l,r) <- split x xs 
+                   l'    <- sort l 
+                   r'    <- sort r 
+                   return (l' ++ (x : r'))
+  sort []     = return []
+
+  split y (x:xs) = do (l,r) <- split y xs 
+                      b <- p x y
+                      if b then return (x:l,r) else return (l,x:r)
+  split y []     = return ([],[])
+---------------------------------------------------------------------------------------------------
+inList :: IO (Maybe a -> IO (Maybe b)) -> [a] -> [b]
+inList mkf la = unsafePerformIO (mkf >>= \f -> loop f la)
+ where
+  loop f []    = f Nothing  >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f [])))
+  loop f (a:r) = f (Just a) >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f r)))
+
+inList' :: IO (a -> IO b) -> [a] -> [b]
+inList' mkf la = unsafePerformIO (mkf >>= \f -> loop f la)
+ where
+  loop f []    = return []
+  loop f (a:r) = f a >>= \b -> return (b : unsafePerformIO (loop f r))
+
+inList'' :: IO (a -> IO (Maybe b)) -> [a] -> [b]
+inList'' mkf la = unsafePerformIO (mkf >>= \f -> loop f la)
+ where
+  loop f []    = return []
+  loop f (a:r) = f a >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f r)))
+
+toList :: IO (IO a) -> [a]
+toList f = unsafePerformIO (f >>= loop)
+ where
+  loop m = m >>= \a -> return (a : unsafePerformIO (loop m))
+
+toList' :: IO (IO (Maybe a)) -> [a]
+toList' f = unsafePerformIO (f >>= loop)
+ where
+  loop m = m >>= maybe (return []) (\a -> return (a : unsafePerformIO (loop m)))
+
+---------------------------------------------------------------------------------------------------
+inListE :: IO (Either (Maybe a -> IO (Maybe b)) (Maybe a -> IO (Maybe c))) -> [a] -> Either [b] [c]
+inListE mkf la = unsafePerformIO (mkf >>= either (\f -> fmap Left $ loop f la) (\f -> fmap Right $ loop f la) )
+ where
+  loop f []    = f Nothing  >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f [])))
+  loop f (a:r) = f (Just a) >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f r)))
+
+inListE' :: IO (Either (a -> IO b) (a -> IO c)) -> [a] -> Either [b] [c]
+inListE' mkf la = unsafePerformIO (mkf >>= either (\f -> fmap Left $ loop f la) (\f -> fmap Right $ loop f la) )
+ where
+  loop f []    = return []
+  loop f (a:r) = f a >>= \b -> return (b : unsafePerformIO (loop f r))
+
+inListE'' :: IO (Either (a -> IO (Maybe b)) (a -> IO (Maybe c))) -> [a] -> Either [b] [c]
+inListE'' mkf la = unsafePerformIO (mkf >>= either (\f -> fmap Left $ loop f la) (\f -> fmap Right $ loop f la) )
+ where
+  loop f []    = return []
+  loop f (a:r) = f a >>= maybe (return []) (\b -> return (b : unsafePerformIO (loop f r)))
+
+toListE :: IO (Either (IO a) (IO b)) -> Either [a] [b]
+toListE f = unsafePerformIO (f >>= either (fmap Left . loop) (fmap Right . loop))
+ where
+  loop m = m >>= \a -> return (a : unsafePerformIO (loop m))
+
+toListE' :: IO (Either (IO (Maybe a)) (IO (Maybe b))) -> Either [a] [b]
+toListE' f = unsafePerformIO (f >>= either (fmap Left . loop) (fmap Right . loop))
+ where
+  loop m = m >>= maybe (return []) (\a -> return (a : unsafePerformIO (loop m)))
+-------------------------------------------------------------------------------
+-- | the given function must create a filepath using the Int-argument. The filepath must be 
+--   different for different arguments. 'newFilePath' works like Gödels mu-operator and terminates 
+--   only if the filepath does not exist.
+newFilePath :: (Int -> FilePath) -> IO FilePath
+newFilePath filename = loop 0
+ where
+  loop n = do let fn = filename n 
+              b <- doesFileExist fn
+              if b then loop (n+1) else return fn
+
+
+
+
+
+
+

+ Sound/Hommage/Notation.hs view
@@ -0,0 +1,446 @@+module Sound.Hommage.Notation
+ ( 
+ -- * Duration
+   Dur 
+ , absDur 
+ , IsDur (..)
+ , WithDur (..)
+ -- * Music Notation
+ , Notation (..)
+ , runNotation 
+ , runNotationWith
+ -- * Musical class
+ , Stretchable (..)
+ , Arrangeable (..)
+ , Musical (..)
+ , rest0
+ , (-=-) 
+ , (->-) 
+ , line
+ , line'
+ , chord
+ , proportional
+
+ -- * Notation and Midi 
+ , writeMidiSyncNotation 
+ , midi 
+ , midi' 
+ , midiSyncFile
+
+ -- * More Notation functions
+ , note 
+ , mapNotation 
+ , joinNotation 
+ , unmaybeNotation 
+ , durationNotation 
+ , positionNotation 
+ , reverseNotation 
+ , takeNotation 
+ , dropNotation 
+-- , chordNotation 
+-- , lineNotation 
+-- , lineNotation'
+-- , propNotation 
+ , filterNotation 
+ , filterNotation'
+ , sequenceNotation 
+ )
+ where
+
+import Sound.Hommage.Midi
+
+import Data.Ratio
+-------------------------------------------------------------------------------
+-- | The duration (of a note, e. g).
+type Dur = Ratio Int
+
+-- | Calculates the absolute duration by dividing the numerator with the denominator. 
+--   Because of rounding error this makes only sense if the result is a relative big 
+--   number. 
+absDur :: Dur -> Int
+absDur d = div (numerator d) (denominator d)
+-------------------------------------------------------------------------------
+newtype IsDur d => WithDur d a = WithDur { unWithDur :: d -> a }
+--
+instance IsDur d => Stretchable (WithDur d a) where
+ stretch dur (WithDur f) = WithDur $ \d -> f (durUpdate (*dur) d)
+
+instance (IsDur d, Arrangeable a) => Arrangeable (WithDur d a) where
+ parallel (WithDur r1) (WithDur r2) = WithDur $ \d -> 
+                                      parallel (r1 d) (r2 d) 
+ sequent (WithDur r1) (WithDur r2) = WithDur $ \d -> 
+                                      sequent (r1 d) (r2 d) 
+-------------------------------------------------------------------------------
+instance Stretchable a => Stretchable (s -> a) where
+ stretch d f = stretch d . f
+
+instance Arrangeable a => Arrangeable (s -> a) where
+ parallel f g = \s -> parallel (f s) (g s)
+ sequent f g = \s -> sequent (f s) (g s)
+
+instance Musical a => Musical (s -> a) where
+ rest = const rest
+-------------------------------------------------------------------------------
+class IsDur d where
+ durFrom :: d -> Dur
+ durUpdate :: (Dur -> Dur) -> d -> d
+
+instance IsDur Dur where
+ durFrom = id
+ durUpdate f = f 
+-------------------------------------------------------------------------------
+-- | A type\/structure that can be stretched.
+class Stretchable a where
+ stretch :: Dur -> a -> a
+-------------------------------------------------------------------------------
+-- | Types\/structures that can be composed in two ways, parallel and sequent.
+class Arrangeable a where
+ parallel :: a -> a -> a
+ sequent  :: a -> a -> a
+
+(-=-) :: Arrangeable a => a -> a -> a
+(-=-) = parallel
+
+(->-) :: Arrangeable a => a -> a -> a
+(->-) = sequent
+
+{-
+instance Functor ((->)s) where
+ fmap f g = f . g
+-}
+-------------------------------------------------------------------------------
+-- | Instances of class 'Musical' must be 'Stretchable', 'Arrangeable' and
+--   they must implement the method 'rest'. 
+class (Stretchable a, Arrangeable a) => Musical a where
+ rest :: a
+
+rest0 :: Musical a => a
+rest0 = stretch 0 rest
+
+-- | A sequence of sounds
+line :: Musical a => [a] -> a
+line = foldr (->-) rest0
+
+-- | A sequence of sounds that will be stretched to length=1
+line' :: Musical a => [a] -> a
+line' [] = rest
+line' xs = stretch (1 % length xs) $ foldr1 (->-) xs
+
+chord :: Musical a => [a] -> a
+chord = foldr (-=-) rest0
+
+-- | Composes the notations sequentially and stretches them proportionally.
+proportional :: Musical a => (Int, Int) -> a -> a -> a
+proportional (l,r) c1 c2 | l == r    = stretch (1 % 2) (c1 ->- c2)
+                         | otherwise = let l' = abs l
+                                           r' = abs r
+                                       in stretch (l' % (l'+r')) c1
+                                      ->- stretch (r' % (l'+r')) c2
+-------------------------------------------------------------------------------
+-- | A 'Notation' is a constant, tree-like structure that represents a musical
+--   notation. It has a type parameter for flexible usage reasons. 
+data Notation a = Note Dur a                  -- ^ A note with given duration and a value of type @a@.
+                | Rest Dur                    -- ^ A rest with given duration.
+                | Notation a :+: Notation a   -- ^ Sequential composition of two notations.
+                | Notation a :=: Notation a   -- ^ Parallel composition of two notations.
+                | Stretch Dur (Notation a)    -- ^ Stretches the duration of the sub-music by given factor.
+
+-- | Creates a note with length 1. Is a synonym for @Note (1%1)@
+note :: a -> Notation a
+note a = Note (1%1) a
+
+instance Functor Notation where
+ fmap = mapNotation
+ 
+instance Stretchable (Notation a) where
+ stretch = Stretch
+
+instance Arrangeable (Notation a) where
+ sequent  = (:+:)
+ parallel = (:=:)
+
+instance Musical (Notation a) where
+ rest = Rest (1%1)
+
+instance Monad Notation where
+ return a = Note (1%1) a
+ na >>= f = joinNotation $ fmap f na
+-------------------------------------------------------------------------------
+-- | A 'Notation' can be interpreted if the contained type is an
+--   instance of class 'Musical'.
+runNotation :: Musical m => Notation m -> m
+runNotation = loop
+ where
+  loop m = case m of
+   Note d a     -> stretch d a
+   Rest d       -> stretch d rest
+   m1 :+: m2    -> loop m1 `sequent` loop m2
+   m1 :=: m2    -> loop m1 `parallel` loop m2
+   Stretch d m1 -> stretch d $ loop m1 
+
+runNotationWith :: Musical m => (a -> m) -> Notation a -> m
+runNotationWith note = loop
+ where
+  loop m = case m of
+   Note d a     -> stretch d $ note a
+   Rest d       -> stretch d rest
+   m1 :+: m2    -> loop m1 `sequent` loop m2
+   m1 :=: m2    -> loop m1 `parallel` loop m2
+   Stretch d m1 -> stretch d $ loop m1 
+-------------------------------------------------------------------------------
+-- | 'Notation' is instance of the class Functor.
+mapNotation :: (a -> b) -> Notation a -> Notation b
+mapNotation f m = case m of
+ Note d a     -> Note d (f a)
+ Rest d       -> Rest d
+ m1 :+: m2    -> mapNotation f m1 :+: mapNotation f m2
+ m1 :=: m2    -> mapNotation f m1 :=: mapNotation f m2
+ Stretch d m1 -> Stretch d (mapNotation f m1)
+
+-- | 'Notation' is instance of the class Monad. Joining will replace
+--    every (outer) Note by its contained (inner) Notation. The inner
+--    Notation will be stretched by the duration of the (outer) Note.
+joinNotation :: Notation (Notation a) -> Notation a
+joinNotation m = case m of
+ Note d a     -> Stretch d a
+ Rest d       -> Rest d
+ m1 :+: m2    -> joinNotation m1 :+: joinNotation m2
+ m1 :=: m2    -> joinNotation m1 :=: joinNotation m2
+ Stretch d m1 -> Stretch d (joinNotation m1)
+
+
+-- | Replaces any Note that contains Nothing by a rest (with same duration).
+unmaybeNotation :: Notation (Maybe a) -> Notation a
+unmaybeNotation = loop
+ where
+  loop m = case m of
+   Note d (Just a) -> Note d a
+   Note d _        -> Rest d
+   Rest d          -> Rest d
+   m1 :+: m2       -> loop m1 :+: loop m2
+   m1 :=: m2       -> loop m1 :=: loop m2
+   Stretch d m1    -> Stretch d $ loop m1 
+-------------------------------------------------------------------------------
+-- | A @ Notation MidiNote @ can be interpreted using 'runNotationWith' and 'midi'. 
+midi :: IsDur d => MidiNote -> WithDur d MidiMusic
+midi n = WithDur $ \d -> noteMidiMusic (fromIntegral $ absDur $ durFrom d) n
+
+midi' :: IsDur d => WithDur d MidiNote -> WithDur d MidiMusic
+midi' rn = WithDur $ \d -> unWithDur (midi $ unWithDur rn d) d
+
+midiSyncFile :: Ticks -> [WithDur Dur MidiMusic] -> MidiFile
+midiSyncFile ticks = 
+ let dur = ((4 * fromIntegral ticks) % 1)
+ in  MidiSync ticks . map (runMidiMusic . (flip unWithDur dur)) 
+
+-- | A convenient function to write a set of midi notations to a synchronous MIDI-file.
+--   NOTE: For unknown reasons not any Ticks value seemes to work. This function uses
+--   96 Ticks per quarter. 
+writeMidiSyncNotation ::  FilePath -> [Notation MidiNote] -> IO ()
+writeMidiSyncNotation fp = writeMidiFile fp . midiSyncFile 96 . map (runNotationWith midi)
+
+instance Arrangeable MidiMusic where
+ parallel = mergeMidiMusic 
+ sequent  = appendMidiMusic
+
+instance IsDur d => Musical (WithDur d MidiMusic) where
+ rest = WithDur $ \d -> restMidiMusic (fromIntegral $ absDur $ durFrom d)
+-------------------------------------------------------------------------------
+-- | Calculates the (relative) duration of a 'Notation' (Must be finite!).
+durationNotation :: Notation a -> Ratio Int
+durationNotation m =
+ case m of
+  Note d a     -> d
+  Rest d       -> d
+  m1 :+: m2    -> durationNotation m1   +   durationNotation m2
+  m1 :=: m2    -> durationNotation m1 `max` durationNotation m2
+  Stretch r m' -> r * durationNotation m'
+
+-- | Calculates the offset for each note.
+positionNotation :: Notation a -> Notation (Dur, a)
+positionNotation = fst . loop 1 0
+ where
+ loop l p m = case m of
+  Note d a     -> let d' = (d*l) in (Note d' (p, a), p+d')
+  Rest d       -> let d' = (d*l) in (Rest d', p+d')
+  m1 :+: m2    -> let (m1', p1) = loop l p m1 
+                      (m2', p2) = loop l p1 m2 
+                  in (m1' :+: m2', p2)
+  m1 :=: m2    -> let (m1', p1) = loop l p m1 
+                      (m2', p2) = loop l p m2 
+                  in (m1' :=: m2', max p1 p2)
+  Stretch r m' -> loop (r*l) p m'
+
+
+
+-- | Reverses a 'Notation' (Must be finite!).
+reverseNotation :: Notation a -> Notation a
+reverseNotation m =
+ case m of
+  Note d a     -> m
+  Rest d       -> m
+  m1 :+: m2    -> reverseNotation m2 :+: reverseNotation m1
+  m1 :=: m2    -> let d1 = durationNotation m1
+                      d2 = durationNotation m2
+                      re | d1 < d2   = (Rest (d2 - d1) :+: reverseNotation m1) :=: reverseNotation m2
+                         | d1 > d2   = reverseNotation m1 :=: (Rest (d1 - d2) :+: reverseNotation m2)
+                         | otherwise = reverseNotation m1 :=: reverseNotation m2
+                  in re
+  Stretch r m' -> Stretch r $ reverseNotation m'
+
+
+-- | Takes the beginning of 'Notation', result has the given duration if possible or is shorter otherwise.
+--   Notes that overlap with the end of duration are not taken but replaced by the (fitted) rests.
+takeNotation :: Ratio Int -> Notation a -> Notation a
+takeNotation len mus = fst $ take len mus
+ where
+  take :: Ratio Int -> Notation a -> (Notation a, Ratio Int)
+  take r m = if r <= 0 % 1 then (Rest (0%1), 0%1) else
+   case m of
+    Note d a      | d > r     -> (Rest r, 0%1)
+                  | otherwise -> (Note d a, r - d)
+    Rest d        | d > r     -> (Rest r, 0%1)
+                  | otherwise -> (Rest d, r - d)
+    m1 :+: m2    -> let (rm1,r1) = take r m1
+                        (rm2,r2) = take r1 m2
+                    in if r1 > 0%1 then (rm1 :+: rm2, r2) else (rm1, r1)
+    m1 :=: m2    -> let (rm1,r1) = take r m1
+                        (rm2,r2) = take r m2
+                    in (rm1 :=: rm2, min r1 r2)
+    --Stretch 0 _  -> (Rest 0, 0)
+    Stretch d m' -> let (mu,le) = take (r / d) m' in (Stretch d mu, le)
+  takeline r []     = ([], r)
+  takeline r (u:us) = 
+   if r > 0%1 
+    then let (u',ur) = take r u 
+             (ul,rr) = takeline ur us 
+         in if ur > 0%1 then (u':ul,rr) else ([u'],0%1)
+    else ([], 0%1)
+
+-- | Drops the beginning of 'Notation'. Notes that would be split are replaced by fitted rests.
+dropNotation :: Ratio Int -> Notation a -> Notation a
+dropNotation len mus = either id (const $ Rest (0%1)) $ drop len mus
+ where
+  drop :: Ratio Int -> Notation a -> Either (Notation a) (Ratio Int)
+  drop r m = if r <= 0 % 1 then Left m else
+   case m of
+    Note d a      | d > r     -> Left $ Rest (d - r)
+                  | otherwise -> Right (r - d)
+    Rest d        | d > r     -> Left $ Rest (d - r)
+                  | otherwise -> Right (r - d)
+    m1 :+: m2    -> case drop r m1 of
+                     Left m1' -> Left (m1' :+: m2)
+                     Right r' -> drop r' m2
+    m1 :=: m2    -> case (drop r m1, drop r m2) of
+                     (Left m1', Left m2') -> Left (m1' :=: m2')
+                     (Left m1', _       ) -> Left m1' 
+                     (_'      , Left m2') -> Left m2'
+                     (Right r1, Right r2) -> Right (min r1 r2)
+    Stretch d m' -> either (Left . Stretch d) Right $ drop (r / d) m'
+  dropline r []     = Right r
+  dropline r (u:us) = 
+   if r > 0%1 
+    then case drop r u of
+          Left u'  -> Left (u' : us)
+          Right r' -> dropline r' us
+    else Left (u:us)
+
+-- -- | Composes the notations sequentially.
+--lineNotation :: [Notation a] -> Notation a
+--lineNotation ns = foldr (:+:) (Rest 0) ns
+
+-- -- | Composes the notations in parallel (starting at the same time).
+--chordNotation :: [Notation a] -> Notation a
+--chordNotation ns = foldr (:=:) (Rest 0) ns
+
+-- | Replaces notes where the predicate fails with rests.
+--filterNotation :: (a -> Bool) -> Notation a -> Notation a
+filterNotation :: (Musical (m a), Monad m) => (a -> Bool) -> m a -> m a
+filterNotation p n = n >>= \a -> if p a then return a else rest
+
+filterNotation' :: (Musical (m a), Musical (m b), Monad m) => (a -> Maybe b) -> m a -> m b
+filterNotation' f n = n >>= maybe rest return . f 
+
+-- -- | Composes the notations sequentially and divides the duration by the
+-- --   number of notations in the list.
+--lineNotation' :: [Notation a] -> Notation a
+--lineNotation' ns = stretch (1 % length ns) $ lineNotation ns
+
+-- -- | Composes the notations sequentially and stretches them proportionally.
+--propNotation :: (Int, Int) -> Notation a -> Notation a -> Notation a
+--propNotation (l,r) c1 c2 | l == r    = stretch (1 % 2) (c1 :+: c2)
+--                         | otherwise = let l' = abs l
+--                                           r' = abs r
+--                                       in stretch (l' % (l'+r')) c1
+--                                          :+: stretch (r' % (l'+r')) c2
+
+---------------------------------------------------------------------------------------------------
+-- | A parallel composition of a sequence of values and a Notation
+--   Each value of the sequence has the same given duration.
+--   Every Note is updated by a function that gets the actual value of the sequence. 
+--   NOTE: This function is not tested yet! 
+sequenceNotation :: (a -> b -> c) -> Dur -> [a] -> Notation b -> Notation c
+sequenceNotation f stpsz input mub = let (x,_,_,_) = loop (denominator stpsz % numerator stpsz) (0%1) input mub in x
+ where
+  step x = let i = div (numerator x) (denominator x)
+           in (i, x - (i % 1))
+--        stepsize     error                                    duration   error
+--loop :: Ratio Int -> Ratio Int -> [a] -> Music b -> (Music c, Ratio Int, Ratio Int, [a])
+  loop stepsize off as@(a:_) mu =
+   case mu of
+    Note d b    -> let (i,off') = step (off + stepsize * d)
+                   in (Note d (f a b), d, off', drop i as)
+    Rest d      -> let (i,off') = step (off + stepsize * d)
+                   in (Rest d, d, off', drop i as)
+    m1 :+: m2   -> let (m1', d1, o1, as1) = loop stepsize off as m1 
+                       (m2', d2, o2, as2) = loop stepsize o1 as1 m2
+                   in (m1' :+: m2', d1 + d2, o2, as2)
+                    
+    m1 :=: m2   -> let (m1', d1, o1, as1) = loop stepsize off as1 m1 
+                       (m2', d2, o2, as2) = loop stepsize off as2 m2
+                       (d', o', as') | d1 < d2   = (d2, o2, as2)
+                                     | d1 > d2   = (d1, o1, as1)
+                                     | o1 < o2   = (d2, o2, as2)
+                                     | otherwise = (d1, o1, as1)
+                   in (m1' :=: m2', d', o', as')
+    Stretch r m -> let (m', d', o', as') = loop (stepsize * r) off as m
+                   in (Stretch r m', d', o', as')
+  loop stepsize off [] mu = (Rest (0%1), 0%1, 0%1, [])
+---------------------------------------------------------------------------------------------------
+-- | NOTE: This function is not tested yet! 
+sequenceNotations :: (a -> b -> c) -> Dur -> [a] -> [Notation b] -> [Notation c]
+sequenceNotations f stpsz input mubs = let (x,_,_,_) = aux (denominator stpsz % numerator stpsz) (0%1) input mubs in x
+ where
+  step x = let i = div (numerator x) (denominator x)
+           in (i, x - (i % 1))
+--        stepsize     error                                    duration   error
+--loop :: Ratio Int -> Ratio Int -> [a] -> Music b -> (Music c, Ratio Int, Ratio Int, [a])
+  loop stepsize off as@(a:_) mu =
+   case mu of
+    Note d b    -> let (i,off') = step (off + stepsize * d)
+                   in (Note d (f a b), d, off', drop i as)
+    Rest d      -> let (i,off') = step (off + stepsize * d)
+                   in (Rest d, d, off', drop i as)
+    m1 :+: m2   -> let (m1', d1, o1, as1) = loop stepsize off as m1 
+                       (m2', d2, o2, as2) = loop stepsize o1 as1 m2
+                   in (m1' :+: m2', d1 + d2, o2, as2)
+                    
+    m1 :=: m2   -> let (m1', d1, o1, as1) = loop stepsize off as1 m1 
+                       (m2', d2, o2, as2) = loop stepsize off as2 m2
+                       (d', o', as') | d1 < d2   = (d2, o2, as2)
+                                     | d1 > d2   = (d1, o1, as1)
+                                     | o1 < o2   = (d2, o2, as2)
+                                     | otherwise = (d1, o1, as1)
+                   in (m1' :=: m2', d', o', as')
+    Stretch r m -> let (m', d', o', as') = loop (stepsize * r) off as m
+                   in (Stretch r m', d', o', as')
+  loop stepsize off [] mu = (Rest (0%1), 0%1, 0%1, [])
+  aux stepsize off as@(a:_) ms = 
+                   let fu o as []     = ([] ,0%1,o,as) 
+                       fu o as (m:ms) = let (m' ,d,o',as') = loop stepsize o as m
+                                            (ms',ds,o'',as'') = fu o' as' ms
+                                        in (m':ms', d+ds, o'', as'')
+                       (ms',d,off',as') = fu off as ms 
+                   in (ms', d, off', as')
+
+

+ Sound/Hommage/Osc.hs view
@@ -0,0 +1,195 @@+module Sound.Hommage.Osc
+ (
+ -- * Sound Generators
+   osc
+ , sinus 
+ , cosinus 
+ , rect
+ , saw
+ , tri
+ , randomList
+
+ -- * Functions for Lists
+-- , amplify
+ , sampleAndHold
+ , average 
+ , terminateAt
+ , follow
+
+ -- * Functions for single values
+ -- | These Functions can be used with 'map':
+ , compress
+ , noteToFrequency 
+ , adjustFrequency 
+
+ -- * Other Functions
+ -- | These Functions are not simple (i. e. linear) list transformers:
+ , splitWaves 
+ , crossfade 
+ )
+ where
+
+import Sound.Hommage.Misc
+import System.Random
+
+{- Length Stepsize Freq (Hz) -}
+
+---------------------------------------------------------------------------------------------------
+randomList :: Random a => (a,a) -> [a]
+randomList = toList . return . randomRIO 
+---------------------------------------------------------------------------------------------------
+-- | Play given sound with variable speed resp. frequency. 
+--   (General definition: Usually a frequency of 1.0 means a period of 1024 values).
+--   Use 'scratchSample' or 'scratchSampleSignal' for backward playing.
+osc :: [Double] -- ^ The sound to play. Output will be finite if sound is finite.
+    -> [Double] -- ^ Speed,      1.0 \= normal, 
+                --               0.0 \< X \< 1.0 \= slower resp. lower, 
+                --               1.0 \< X \= faster resp. higher, 
+                --               X \< 0.0 \=\> X \= abs X.
+    -> [Double] -- ^ Output 
+osc = loop 0.0
+ where
+  loop p []  _     = []
+  loop p vs (d:ds) = let v   = interpol p vs
+                         p'  = p + abs d
+                         i   = floor p'
+                     in v : loop (p' - fromIntegral i) (drop (floor p') vs) ds 
+  loop p _      _  = []
+  interpol p ds = if p == 0.0 then head ds else
+                  case ds of
+                   (d1 : d2 : r) -> d1 * (1.0 - p) + d2 * p
+                   [d1]          -> d1 * (1.0 - p) 
+---------------------------------------------------------------------------------------------------
+integrate :: Num a => [a] -> [a]
+integrate [] = []
+integrate (x:xs) = loop x xs
+ where
+  loop v (a:as) = let k = v + a in seq k (v : loop k as)
+--  loop v (a:as) = let k = v + a in v : seq k (loop k as) -- ODER SO?
+  loop v []     = [v]
+
+-- | A sinus wave generator with a period of 1024\/N for frequency N 
+sinus :: [Double] -> [Double]
+sinus = map (sin . (*f)) . integrate  
+ where
+  f = pi / 512.0
+
+-- | A cosinus wave generator
+cosinus :: [Double] -> [Double]
+cosinus = map (cos . (*f)) . integrate 
+ where
+  f = pi / 512.0
+
+-- | A rectangle wave generator
+rect :: [Double] -> [Double]
+rect = map signum . sinus
+
+-- | A sawtooth wave generator
+saw :: [Double] -> [Double]
+saw = loop 1.0
+ where
+  loop _ []     = []
+  loop v (d:dr) | v <= -1.0 = loop 1.0 (d:dr)
+                | otherwise = v : loop (v - abs (d / 512.0)) dr
+
+-- | A triangle wave generator
+tri :: [Double] -> [Double]
+tri = osc (let k = 0.0 : 1.0 : 0.0 : -1.0 : k in k) . map (/256.0)
+---------------------------------------------------------------------------------------------------
+-- | Adjusts the frequency. If given oscillator has period X for frequency of 1.0 and you want it to
+--   produce a wave with Y Hz at frequency of 1.0, use @ map (adjustFrequency X Y) @ to adjust the
+--   input of the oscillator.
+adjustFrequency :: Double   -- ^ Period 
+                -> Double   -- ^ New Frequency (Hz) for old frequency of 1.0
+                -> Double   -- ^ Input Frequency
+                -> Double   -- ^ Output Frequency
+adjustFrequency periode basefreq = let k = periode * basefreq / 44100.0 in (*k)
+
+-- | Transforms a notevalue into a frequency. A Notevalue of 0.0 means a frequency of 1.0. 
+noteToFrequency :: Double  -- ^ Base, 
+                -> Double  -- ^ Notenumber
+                -> Double  -- ^ 2 \^ (Notenumber \/ Base)
+noteToFrequency base note = 2.0 ** (note / base)
+---------------------------------------------------------------------------------------------------
+-- | Splits a wave into parts. they are split when a value equal or less than zero is followed by a
+--   value greater than zero.
+splitWaves :: [Double] -> [[Double]]
+splitWaves = loop
+ where
+  next l (x:xs) | l <= 0.0 && x > 0.0 = ([], x:xs)
+                | otherwise           = let (a,r) = next x xs in (x:a,r)
+  next l []                           = ([],[])
+  loop (x:xs) = let (a,r) = next x xs in ((x:a) : loop r)
+  loop []     = []
+
+---------------------------------------------------------------------------------------------------
+-- | Create a wave with the beginning of w1, the ending of w2 and the length of the longer one of them.
+crossfade :: [Double] -- ^ w1
+          -> [Double] -- ^ w2
+          -> [Double] -- ^ result
+crossfade xs1 xs2 = fun
+ where
+  l1 = length xs1
+  l2 = length xs2
+  fun | l1 < l2 = let (i,r) = splitAt l1 xs2
+                      d = 1.0 / fromIntegral l1
+                  in (zipWith3 (\v x y -> (1.0-v)*x + v*y) (iterate (+d) 0.0) xs1 i) ++ r
+      | l1 > l2 = let (i,r) = splitAt (l1-l2) xs1
+                      d = 1.0 / fromIntegral l2
+                  in i ++ (zipWith3 (\v x y -> (1.0-v)*x + v*y) (iterate (+d) 0.0) r xs2)
+      | otherwise = let d = 1.0 / fromIntegral l1
+                    in (zipWith3 (\v x y -> (1.0-v)*x + v*y) (iterate (+d) 0.0) xs1 xs2)
+---------------------------------------------------------------------------------------------------
+-- | @ compress p x = x \/ (abs p + abs x) @ 
+compress :: Double -> Double -> Double
+compress 0.0 x = signum x
+compress p x   = x / (abs p + abs x)
+
+---------------------------------------------------------------------------------------------------
+-- | Current output value is repeatet until the first list argument value switches from zero or below 
+--   to a non-zero positive value, the actual value of the second list argument is then taken for output.
+sampleAndHold :: (Ord a, Num a) => b -> [a] -> [b] -> [b]
+sampleAndHold y xs ys = loop y 0 xs ys
+ where
+  loop s o (a:as) (b:bs) | o <= 0 && a > 0 = b : loop b a as bs
+                         | otherwise       = s : loop s a as bs
+  loop _ _ _ _ = []
+
+follow :: Double -> [Double] -> [Double] -> [Double] 
+follow p = loop 0.0 
+ where
+  loop pos (f:fs) (x:xs) | pos > x   = pos : loop (pos - p * abs f) fs xs
+                         | otherwise = pos : loop (pos + p * abs f) fs xs
+  loop _ _ _ = []
+
+-- | Maps the values to the average of the last N values (including the actual)
+average :: Fractional a => Int -> [a] -> [a]
+average n as = loop 0 as (replicate n 0 ++ as)
+ where
+  dy = 1.0 / fromIntegral n
+  loop i (x:xs) (y:ys) = (i * dy) : loop (i+x-y) xs ys
+  loop _ _ _ = []
+
+---------------------------------------------------------------------------------------------------
+varydelay :: Int -> [Int] -> [a] -> [a]
+varydelay len (l:ls) (d:ds) | len > l   = d : varydelay (len - 1) ls (tail ds)
+                            | len < l   = d : d : varydelay (len + 1) ls ds
+                            | otherwise = d : varydelay len ls ds
+varydelay _   _      _      = []
+
+
+variableDelay :: Int -> [Double] -> [Double] -> [Double]
+variableDelay initLen pitch inp = outp
+ where
+  len0       = fromIntegral initLen 
+  lengths    = map (floor.(len0/). max 0.001 . abs) pitch
+  outp       = varydelay initLen lengths (replicate initLen 0.0 ++ inp)
+---------------------------------------------------------------------------------------------------
+-- | If predicate holds for N elements, list is cut.
+terminateAt :: Int -> (a -> Bool) -> [a] -> [a]
+terminateAt n test = loop n
+ where
+  loop 0 (x:xs) = if test x then [] else x : loop n xs
+  loop k (x:xs) = if test x then x : loop (k-1) xs else x : loop n xs
+               
+---------------------------------------------------------------------------------------------------

+ Sound/Hommage/Parameter.hs view
@@ -0,0 +1,272 @@+-- | This module contains a datatype 'Field' and sone type classes. It is used
+--   to construct record-like datatypes.
+
+module Sound.Hommage.Parameter
+ ( 
+ -- | Example:
+ --
+ --   To create a \"record\" with the accessors\/modificators first you have to define the type
+ --   of the record, It must be a right-associative list of pairs, just like a LISP list.
+ --   The rightmost element must be @ () @. The following Example defines a record with information
+ --   for music generation. 
+ -- 
+ -- > type DefaultNote = (Int, (Double, (Char, ())))     
+ -- 
+ --   Then a default value should be defined. 
+ -- 
+ -- > defaultNote = (0, (1.0, ('a' , ())))
+ -- > defaultNote :: DefaultNote 
+ -- 
+ --   For each \"datafield\" the 'Field' must be declared.
+ -- 
+ -- > pitch :: Field DefaultNote Int 
+ -- > volume :: Field DefaultNote Double 
+ -- > channel :: Field DefaultNote Char 
+ --  
+ --  Creating the fields is done with 'toField' applied to a value of the \"record\" type.
+ --  
+ -- > pitch :>> volume :>> channel :>> NilM = toFields defaultNote 
+ --  
+ --  Is is recommended to declare all types and match all results of 'toFields' incl. the 'NilM' at
+ --  the end.
+ --
+ --  NOTE:
+ --
+ -- > pitch :>> volume :>> channel :>> NilM = toFields (undefined :: DefaultNote)
+ --
+ --  should work too.
+ --
+ 
+ -- * Field
+   Field (..)
+ , (<>) 
+ , fstField 
+ , sndField 
+ , UpdateField (..)
+ , CheckField (..)
+ , updateField 
+ , checkField 
+ , applyField
+ , withField 
+
+ , Group (..)
+ , leftGroup 
+ , rightGroup 
+ , (><) 
+
+ -- * Hetero List
+ , LM (..)
+ , NilM (..)
+ , PushFields (..)
+ , ToFields (..)
+ , PushGroups (..)
+ , ToGroups (..)
+ )
+ where
+-------------------------------------------------------------------------------
+infixr 5 :>>
+
+data LM a b m = m a :>> b m
+
+
+-- | The correct type is: @ data NilM (m :: * -> *) = NilM @ . 
+--   (But Haddock rejects this definition. GHC will need it)
+--data NilM m = NilM
+data NilM (m :: * -> *) = NilM
+-------------------------------------------------------------------------------
+-- | A @ Field record field @ is an interface to access a type @ field @ which 
+--   is part of a type @ record @.
+--   A 'Field' is used to access and modify subtypes (\"datafields\") of 
+--   a record-like datastructure. In this module, a right-associative pair structure is
+--   taken as record-type with \"datafields\" in the fst parts of the pairs.
+data Field c a = Field
+ { getField :: c -> a
+ , setField :: (a -> a) -> c -> c
+ }
+
+(<>) :: Field a b -> Field c a -> Field c b
+Field g1 f1 <> Field g2 f2 = Field (g1 . g2) (f2 . f1)
+
+fstField :: Field (a,b) a 
+fstField = Field fst (\f (a,b) -> (f a, b))
+
+sndField :: Field (a,b) b 
+sndField = Field snd (\f (a,b) -> (a, f b))
+-------------------------------------------------------------------------------
+data UpdateField c = forall a . Field c a := a
+                     | forall a . Field c a :$ (a -> a)
+                     | If (CheckField c) [UpdateField c] [UpdateField c]
+
+data CheckField c = forall a . Field c a :? (a -> Bool)
+                    | And [CheckField c]
+                    | Or [CheckField c]
+
+updateField :: UpdateField c -> c -> c
+updateField (ctxt := a) = setField ctxt (const a) 
+updateField (ctxt :$ f) = setField ctxt f
+updateField (If ch u e) = \c -> if checkField ch c then applyField u c else applyField e c
+
+checkField :: CheckField c -> c -> Bool
+checkField (ctxt :? p) c = p $ getField ctxt c
+checkField (And cs)    c = and $ map (flip checkField c) cs 
+checkField (Or  cs)    c = or $ map (flip checkField c) cs 
+
+applyField :: [UpdateField c] -> c -> c
+applyField us c = foldl (flip updateField) c us
+
+withField :: [UpdateField a] -> (a -> b) -> a -> b
+withField ucs f = f . applyField ucs
+-------------------------------------------------------------------------------
+class PushFields m where
+ pushFields :: m (Field c) -> m (Field (x, c))
+
+instance PushFields NilM where
+ pushFields NilM = NilM 
+
+instance PushFields b => PushFields (LM a b) where
+ pushFields (ca :>> bc) = (ca <> sndField) :>> pushFields bc
+-------------------------------------------------------------------------------
+class ToFields a r where
+ toFields :: a -> r (Field a)
+
+instance ToFields () NilM where
+ toFields _ = NilM
+
+instance (PushFields b', ToFields b b') => ToFields (a, b) (LM a b') where
+-- toField (a, b) = fstField :>> pushFields (toField b)
+ toFields _ = fstField :>> pushFields (toFields undefined)
+
+--instance (PushFields b', ToField b b') => ToField (L a b) (LM a b') where
+-- toField (a :> b) = fstField :>> pushFields (toField b)
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+data Group c a = Group 
+ { isGroup :: c -> Maybe a
+ , mkGroup :: a -> c
+ }
+
+leftGroup :: Group (Either a b) a
+leftGroup = Group (either Just (const Nothing)) Left
+
+rightGroup :: Group (Either a b) b
+rightGroup = Group (either (const Nothing) Just) Right
+
+(><) :: Group a b -> Group c a -> Group c b
+Group i1 t1 >< Group i2 t2 = Group (\c -> i2 c >>= i1) (t2 . t1)
+-------------------------------------------------------------------------------
+class PushGroups m where
+ pushGroups :: m (Group c) -> m (Group (Either x c))
+
+instance PushGroups NilM where
+ pushGroups NilM = NilM 
+
+instance PushGroups b => PushGroups (LM a b) where
+ pushGroups (ca :>> bc) = (ca >< rightGroup) :>> pushGroups bc
+-------------------------------------------------------------------------------
+class ToGroups a r where
+ toGroups :: a -> r (Group a)
+
+instance ToGroups () NilM where
+ toGroups _ = NilM
+
+instance (ToGroups b b', PushGroups b') => ToGroups (Either a b) (LM a b') where
+ toGroups eab = leftGroup :>> pushGroups (toGroups (either undefined id eab))
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
+type DefaultNote1 = (Int, (Double, (Char, ())))     
+
+defaultNote1 :: DefaultNote1 
+defaultNote1 = (0, (1.0, ('a' , ())))
+
+pitch1 :: Field DefaultNote1 Int 
+volume1 :: Field DefaultNote1 Double 
+channel1 :: Field DefaultNote1 Char 
+
+pitch1 :>> volume1 :>> channel1 :>> NilM = toFields defaultNote1
+-------------------------------------------------------------------------------
+type DefaultNote2 = (Int, (Double, ()))
+
+defaultNote2 :: DefaultNote2
+defaultNote2 = (0, (1.0, ()))
+
+pitch2 :: Field DefaultNote2 Int 
+volume2 :: Field DefaultNote2 Double 
+
+pitch2 :>> volume2 :>> NilM = toFields defaultNote2
+-------------------------------------------------------------------------------
+type MixNote = Either DefaultNote1 (Either DefaultNote2 ())
+
+n1 :: Group MixNote DefaultNote1
+n2 :: Group MixNote DefaultNote2
+
+n1 :>> n2 :>> NilM = toGroups (undefined :: MixNote)
+-------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+--data Prop c = forall a . Field c a := a
+
+--def@[ volume := 2.0, trigger := True ] = definition
+
+-------------------------------------------------------------------------------
+{-
+
+-------------------------------------------------------------------------------
+data Output t a = Output { unOutput :: a -> t }
+-------------------------------------------------------------------------------
+class PushOutputs m where
+ pushOutputs :: m (Output c) -> m (Output (Either x c))
+
+instance PushOutputs NilM where
+ pushOutputs NilM = NilM 
+
+instance PushOutputs b => PushOutputs (LM a b) where
+ pushOutputs (ca :>> bc) = (Output (Right . unOutput ca)) :>> pushOutputs bc
+-------------------------------------------------------------------------------
+class ToOutput a r where
+ toOutput :: a -> r (Output a)
+
+instance ToOutput () NilM where
+ toOutput _ = NilM
+
+instance (ToOutput b b', PushOutputs b') => ToOutput (Either a b) (LM a b') where
+ toOutput _ = Output Left :>> pushOutputs (toOutput undefined)
+-------------------------------------------------------------------------------
+data Filter t a = Filter { unFilter :: t -> Maybe a }
+-------------------------------------------------------------------------------
+class PushFilters m where
+ pushFilters :: m (Filter c) -> m (Filter (Either x c))
+
+instance PushFilters NilM where
+ pushFilters NilM = NilM 
+
+instance PushFilters b => PushFilters (LM a b) where
+ pushFilters (ca :>> bc) = (Filter (\c -> either (const Nothing) Just c >>= unFilter ca)) :>> pushFilters bc
+-------------------------------------------------------------------------------
+class ToFilter a r where
+ toFilter :: a -> r (Filter a)
+
+instance ToFilter () NilM where
+ toFilter _ = NilM
+
+instance (ToFilter b b', PushFilters b') => ToFilter (Either a b) (LM a b') where
+ toFilter _ = Filter (either Just (const Nothing)) :>> pushFilters (toFilter undefined)
+-------------------------------------------------------------------------------
+
+-}
+
+
+

+ Sound/Hommage/Play.hs view
@@ -0,0 +1,301 @@+module Sound.Hommage.Play
+ (
+ -- * Play
+   Play (..)
+ , getDur 
+ , resetDur 
+ , randomPlay 
+ , mix 
+ , mix'
+
+ -- * Interpretation of Notation for Play
+ , notationMono
+ , notationStereo 
+ , notation 
+ , Mixable (..)
+-- , MixableL
+
+ -- * Parallel played and hierarchical defined tracks
+ , Song (..)
+ , runSong
+
+ , Track (..)
+ , playTrack 
+ , track 
+-- , tracks 
+-- , (-/-) 
+-- , (-|-) 
+-- , (-||-) 
+ , Trackable (..)
+-- , notationTracks 
+-- , ToTrack (..)
+
+ -- * Environment
+ , Environment (..)
+ , emptyEnvironment 
+ , nextEnvironment 
+ , insertEnvironment 
+ , lookupEnvironment 
+-- , defineEnvironment 
+
+ -- * Duration
+ , Duration (..)
+ , resetDuration
+ , initDuration 
+
+ )
+
+ where
+
+import Sound.Hommage.Notation
+import Sound.Hommage.Signal
+import Sound.Hommage.Seq
+import Sound.Hommage.Misc
+--import Sound.Hommage.MList
+
+import Data.Ratio
+import Data.Dynamic
+
+import Data.IORef
+import System.IO.Unsafe
+import System.Random
+
+-------------------------------------------------------------------------------
+newtype Environment = Environment ( Int , [(Int, [Dynamic])] )
+
+emptyEnvironment :: Environment
+emptyEnvironment = Environment (0, [])
+
+nextEnvironment :: Environment -> Environment 
+nextEnvironment (Environment (c, b)) = 
+ let b' = loop b in seq b' (Environment (c, b'))
+  where
+   loop []         = []
+   loop ((n,(_:d)):xs) = let xs' = loop xs
+                         in seq d (seq xs' ((n,d):xs'))
+
+insertEnvironment :: [Dynamic] -> Environment -> (Environment -> Dynamic, Environment)
+insertEnvironment d (Environment (c,b)) = 
+ seq c (lookupEnvironment c, Environment (c+1, (c,d):b))
+
+lookupEnvironment :: Int -> Environment -> Dynamic
+lookupEnvironment n (Environment (_,b)) = case lookup n b of Just (d:_) -> d
+-------------------------------------------------------------------------------
+class Typeable a => Trackable a where
+ toNext :: a -> a
+
+instance Typeable Signal where
+ typeOf _ = mkTyConApp (mkTyCon "Signal") []
+
+instance Trackable Signal where
+ toNext s = case s of
+  Mono (x:xs)   -> seq x (Mono xs)
+  Mono []       -> Mono []
+  Stereo (x:xs) -> seq x (Stereo xs)
+  Stereo []     -> Stereo []
+
+instance Typeable a => Trackable [a] where
+ toNext (x:xs) = seq x xs
+ toNext []     = []
+
+instance Typeable Stereo where
+ typeOf _ = mkTyConApp (mkTyCon "Stereo") []
+-------------------------------------------------------------------------------
+defineEnvironment :: Trackable a => (Environment -> a) -> Environment -> (Environment -> a, Environment)
+defineEnvironment f env = (\e -> case fromDynamic $ lkup e of Just a -> a, env')
+ where
+  iter a = seq a (toDyn a : iter (toNext a))
+  (lkup, env') = insertEnvironment (iter $ f env) env
+
+defineEnvironment_ :: Trackable a 
+                   => a -> Environment -> (Environment -> a, Environment)
+defineEnvironment_ a env = (\e -> case fromDynamic $ lkup e of Just a -> a, env')
+ where
+  iter a = seq a (toDyn a : iter (toNext a))
+  (lkup, env') = insertEnvironment (iter a) env
+
+-- (a -> a) -> Environment -> Environment, 
+-------------------------------------------------------------------------------
+data Duration = DURATION
+ { relativeDuration :: Dur
+ , absoluteDuration :: Dur
+ }
+
+instance IsDur Duration where
+ durFrom = relativeDuration 
+ durUpdate f d = d { relativeDuration = f (relativeDuration d) } 
+
+resetDuration :: Duration -> Duration
+resetDuration d = d { relativeDuration = absoluteDuration d } 
+
+initDuration :: Dur -> Duration
+initDuration d = DURATION d d
+-------------------------------------------------------------------------------
+newtype Play a = PLAY { unPlay :: Duration -> Environment -> a }
+
+playToWithDur :: Play a -> WithDur Duration (Environment -> a)
+playToWithDur (PLAY p) = WithDur p
+
+--returnPlay :: a -> Play a
+--returnPlay a = PLAY $ \dur env -> case env of
+-- Environment (0, []) -> a
+-- Environment _       -> a
+
+instance Monad Play where
+ return a = PLAY $ \dur env -> a --returnPlay a
+ PLAY g >>= f = PLAY $ \dur env -> unPlay (f $ g dur env) dur env
+
+instance Functor Play where
+ fmap f (PLAY g) = PLAY $ \dur env -> f (g dur env)
+-- fmap f p = p >>= return . f
+
+instance Stretchable (Play a) where
+ stretch d (PLAY g) = PLAY $ \duration e -> g (durUpdate (*d) duration) e
+
+getDur :: Play Dur
+getDur = PLAY $ \dur _ -> durFrom dur 
+
+resetDur :: Play a -> Play a
+resetDur (PLAY g) = PLAY $ \d e -> g (resetDuration d) e
+
+randomPlay :: Random a => (a,a) -> Play a
+randomPlay v = PLAY $ \_ _ -> unsafePerformIO $ randomRIO v
+-----------------------------------------------------------
+mix :: [Play Signal] -> Play Signal
+mix ps = sequence ps >>= return . mergeSignals
+
+mix' :: Num a => [Play [a]] -> Play [a]
+mix' ps = sequence ps >>= return . mergeSet sum
+-------------------------------------------------------------------------------
+class Mixable a where
+ mixdown :: Seq a -> a
+
+instance Num a => Mixable [a] where
+ mixdown = mixdownNumSeq
+
+notation :: Mixable a => Notation (Play a) -> Play a
+notation n = PLAY $ \dur env -> mixdown $ applySeq nextEnvironment 
+ (unWithDur (runNotation (fmap (noteSeq' . playToWithDur ) n)) dur) env
+
+notationMono :: Notation (Play Signal) -> Play [Mono]
+notationMono n = PLAY $ \dur env -> mixdown $ applySeq nextEnvironment 
+ (unWithDur (runNotation (fmap (noteSeq' . playToWithDur . fmap signalToMono) n)) dur) env
+
+notationStereo :: Notation (Play Signal) -> Play [Stereo]
+notationStereo n = PLAY $ \dur env -> mixdown $ applySeq nextEnvironment 
+ (unWithDur (runNotation (fmap (noteSeq' . playToWithDur . fmap signalToStereo) n)) dur) env
+
+-------------------------------------------------------------------------------
+data Song a = SONG { unSong :: Duration -> Environment -> (a, Environment) }
+
+instance Functor Song where
+ fmap f (SONG g) = SONG $ \d e -> let (a, e') = g d e in (f a, e')
+
+instance Monad Song where
+ return a = SONG $ \_ e -> (a,e)
+ SONG g >>= f = SONG $ \d e -> let (a,e') = g d e in unSong (f a) d e'
+
+runSong :: Double -> Song (Play a) -> a
+runSong bpm (SONG ts) = 
+ let duration = initDuration $ bpmToDur bpm
+     (PLAY p, env) = ts duration emptyEnvironment 
+ in p duration env
+-------------------------------------------------------------------------------
+newtype Track a = TRACK { unTrack :: Environment -> a }
+
+instance Functor Track where
+ fmap f (TRACK g) = TRACK (f . g)
+
+playTrack :: Track a -> Play a
+playTrack (TRACK get) = PLAY $ \d e -> get e
+
+track :: Trackable a => Play a -> Song (Track a)
+track (PLAY p) = SONG $ \dur env -> 
+ let (get, env') = defineEnvironment (p dur) env
+ in seq env' (TRACK get, env')
+-------------------------------------------------------------------------------
+{- Causes too much memory use. Reason: More than one Reference to Environment. 
+
+notationTracks :: (ToFilter a l, MixableL l) => Notation (Play a) -> Song (l Track)
+notationTracks n = SONG $ \dur env -> 
+ let f = toFilter (undefined :: a)
+     (l, env') = mixdownL (applySeq nextEnvironment (runNotation (fmap (noteSeq' . unPlay) n) dur) env) f env
+ in seq env' (l, env')
+
+aux1 :: (ToFilter a l, MixableL l) => Notation (Play a) -> Seq a -> l (Filter a) -> Environment -> (l Track, Environment)
+aux1 _ = mixdownL
+
+-------------------------------------------------------------------------------
+class MixableL l where
+ mixdownL :: Seq a -> l (Filter a) -> Environment -> (l Track, Environment)
+
+instance MixableL NilM where
+ mixdownL sq NilM env = (NilM, env)
+
+instance (Mixable a, Trackable a, MixableL b) => MixableL (LM a b) where
+ mixdownL sq (a :>> b) env = 
+  let (get, env') = defineEnvironment_ (mixdown $ filterSeq (unFilter a) sq) env
+      (b', env'') = mixdownL sq b env'
+  in seq env' (seq env' (TRACK get :>> b', env''))
+-------------------------------------------------------------------------------
+
+
+infixr 5 -|-, -||-
+
+
+(-/-) :: Trackable b => Song a -> Play b -> Song (L a (Track b)) 
+SONG s -/- PLAY p = SONG $ \dur env -> 
+ let ~(a, env') = s dur env
+     ~(get, env'') = defineEnvironment_ (p dur env) env'
+ in seq env' (seq env'' ((a :> TRACK get), env''))
+
+
+(-|-) :: Trackable a => Play a -> Song b -> Song (L (Track a) b) 
+PLAY p -|- SONG s = SONG $ \dur env -> 
+ let ~(b, env') = s dur env
+     ~(get, env'') = defineEnvironment_ (p dur env) env'
+ in seq env' (seq b (seq env''(seq get (TRACK get :> b, env''))))
+
+(-||-) :: Trackable a => Play a -> Song (b Track) -> Song (LM a b Track) 
+PLAY p -||- SONG s = SONG $ \dur env -> 
+ let (b, env') = s dur env
+     (get, env'') = defineEnvironment_ (p dur env) env'
+ in seq env' $ seq env'' ((TRACK get :>> b), env'')  
+
+class ToTrack l where
+-- toTrack :: l Play -> Duration -> Environment -> Environment -> (l Track, Environment)
+ toTrack :: l Play -> Duration -> Environment -> (l Track, Environment)
+
+instance ToTrack NilM where
+-- toTrack NilM _ _ env' = (NilM, env')
+ toTrack NilM _ env = (NilM, env)
+
+--instance (Trackable a, ToTrack b) => ToTrack (LM a b) where
+-- toTrack (PLAY a :>> b) dur env env' = let (get, env'') = defineEnvironment_ (a dur env) env'
+--                                           (b', env''') = toTrack b dur env env''
+--                                       in seq env (seq env' (seq env'' (seq env''' (TRACK get :>> b', env'''))))
+
+instance (Trackable a, ToTrack b) => ToTrack (LM a b) where
+ toTrack (PLAY a :>> b) dur env = case toTrack b dur env of 
+                                   ~(b', env') -> case seq b' (seq env' (defineEnvironment_ (a dur env) env')) of 
+                                    ~(get, env'') -> seq get (seq env'' (TRACK get :>> b', env''))
+
+tracks :: ToTrack l => l Play -> Song (l Track)
+tracks l = SONG $ \dur env -> toTrack l dur env 
+
+-- l Play -> Song (l Track)
+-}
+-------------------------------------------------------------------------------
+
+-- notations :: Notation (Play a) -> Play 
+
+
+
+-- Seq e -> l (Filter e) -> l Identity
+
+
+
+
+
+
+

+ Sound/Hommage/Rand.hs view
@@ -0,0 +1,95 @@+module Sound.Hommage.Rand 
+ ( R (..)
+ , mkR
+ , runR
+ , rif
+ , rselect
+ , RM
+ , ror
+ , rnote
+ , runRM
+ , rplay
+ )
+ where
+
+import Control.Applicative
+import System.Random
+
+import Sound.Hommage.Misc
+import Sound.Hommage.Notation
+import Sound.Hommage.Play
+import Sound.Hommage.Sound
+import Sound.Hommage.Signal
+
+---------------------------------------------------------------------------------------------------
+newtype R a = R { unR :: StdGen -> a }
+
+instance Monad R where
+ return = R . const
+ R g >>= f = R $ \s -> let (s1,s2) = split s in unR (f (g s1)) s2
+ 
+instance Functor R where
+ fmap f (R g) = R (f . g)
+ 
+mkR :: (StdGen -> (a, StdGen)) -> R a
+mkR f = R (fst . f)
+
+ 
+instance Applicative R where
+ R gf <*> R ga = R $ \s -> let (s1,s2) = split s in gf s1 (ga s2)
+ pure = R . const
+ 
+runR :: Int -> R a -> a
+runR i (R g) = g $ mkStdGen i 
+
+rif :: Double -> (a , a) -> R a
+rif p (a1,a2) = R $ \s -> if (fst $ randomR (0, 1::Double) s) > p then a1 else a2
+
+rselect :: [a] -> R a
+rselect [] = error "empty probs"
+rselect xs = let n = fromIntegral $ length xs 
+             in R $ \s -> let k = fst $ randomR (0, 1::Double) s
+                              i = floor (k * n)
+                          in xs !! i
+
+---------------------------------------------------------------------------------------------------
+newtype RM a = RM { unRM :: StdGen -> Notation a }
+ 
+instance Functor RM where
+ fmap f (RM g) = RM ( fmap f . g)
+
+instance Monad RM where
+ return a = RM $ const $ note a
+ RM g >>= f = RM $ \s -> let (s1,s2) = split s in g s1 >>= \a-> unRM (f a) s2
+
+--rRM :: R a -> (a -> RM b) -> RM b
+--rRM (R g) f = RM $ \s -> let (s1,s2) = split s in unRM (f (g s1)) s2
+
+instance Stretchable (RM a) where
+ stretch d (RM g) = RM (stretch d . g)
+ 
+instance Arrangeable (RM a) where
+ parallel (RM a) (RM b) = RM $ \s -> let (s1,s2) = split s in a s1 :=: b s2
+ sequent  (RM a) (RM b) = RM $ \s -> let (s1,s2) = split s in a s1 :+: b s2
+
+instance Musical (RM a) where
+ rest = RM $ const $ Rest 1
+ 
+rnote :: a -> RM a
+rnote = RM . const . Note 1
+
+ror :: [RM a] -> RM a
+ror [] = rest
+ror xs = let n = fromIntegral $ length xs 
+         in RM $ \s -> let (s1, s2) = split s
+                           k = fst $ randomR (0, 1::Double) s1
+                           i = floor (k * n)
+                           m = xs !! i
+                       in unRM m s2
+
+runRM :: RM a -> R (Notation a)
+runRM (RM g) = R g
+
+rplay :: Sound a => a -> RM (Play Signal)
+rplay = rnote . play
+

+ Sound/Hommage/Sample.hs view
@@ -0,0 +1,408 @@+module Sound.Hommage.Sample
+ (
+ -- * Sample Datastructure
+   Sample 
+ , arraySample 
+ , sizeSample  
+ , newSample 
+ , newSampleFromList
+
+ -- * File Operations
+ , openWavSample 
+ , saveWavSampleMono 
+ , saveWavSampleStereo
+
+ -- * Pitching, Playing and Scratching
+ , pitchWavSignal 
+ , scratchWavSignal
+ , playSample
+ , pitchSample 
+ , scratchSample
+ , playCoeffs 
+
+ -- * Transforming Samples
+ , mapSample 
+ , foldlSample 
+ , updateSample 
+ , normaliseSample 
+ , fadeinoutSample 
+ , stretchSample 
+
+ -- * Filter and Fourier Coeffs
+ , Coeffs 
+ , arrayCoeffs     
+ , sizeCoeffs      
+ , wavesizeCoeffs  
+ , syntheseSample   
+ , analyseSample    
+ , filterCoeffs     
+ , mkPlayCoeffs 
+ , readCoeffs 
+ , writeCoeffs 
+
+ -- * Playing a Sample
+ , mkTriggerSample 
+ , mkPlaySample 
+ , mkScratchSample 
+ , mkPitchSample 
+
+ -- * Array functions
+ , interpolArray       
+ , mkLoopArray         
+ , mkPlayArray         
+
+ )
+ where
+
+import Foreign.Storable
+import Data.Array.Storable
+import Data.Array.IO
+import Data.Int
+import Data.IORef
+import Data.Complex
+
+import Sound.Hommage.Misc
+import Sound.Hommage.WavFile
+import Sound.Hommage.DFTFilter
+import Sound.Hommage.Signal
+
+---------------------------------------------------------------------------------------------------
+-- | Open a Wav-File, but play it with variable (positive) speed\/ frequency. 
+pitchWavSignal :: FilePath -> [Double] -> Signal 
+pitchWavSignal fp = either Mono Stereo . inListE'' 
+ (openWavSample fp >>= either (fmap Left . mkPitchSample) (fmap Right . mkPitchSample) )
+
+-- | Open a Wav-File, but play it with variable (positive and\/or negative) speed\/ frequency. 
+--   Backward playing is possible.
+scratchWavSignal :: FilePath -> [Double] -> Signal
+scratchWavSignal fp = either Mono Stereo . inListE' 
+ (openWavSample fp >>= either (fmap Left . mkScratchSample) (fmap Right . mkScratchSample) )
+---------------------------------------------------------------------------------------------------
+-- | Creates a finite list with the content of the Sample.
+playSample :: Sample a -> [a]
+playSample = toList' . mkPlaySample
+
+-- | Creates a list with the content of the Sample, but played with variable speed\/frequency.
+pitchSample :: Fractional a => Sample a -> [Double] -> [a]
+pitchSample s = inList'' $ mkPitchSample s
+
+-- | Creates a list with the content of the Sample, but played with variable speed\/frequency, 
+--   backward playing possible.
+scratchSample :: Fractional a => Sample a -> [Double] -> [a]
+scratchSample s = inList' $ mkScratchSample s
+
+-- | Creates a list with the content of 'Coeffs' (a representation of the fourier coefficients of 
+--   a 'Sample'). 
+playCoeffs :: Coeffs -> [Complex Double]
+playCoeffs = toList' . mkPlayCoeffs
+---------------------------------------------------------------------------------------------------
+
+---------------------------------------------------------------------------------------------------
+--interpolArray :: MArray array Double IO => array Int Double -> Int -> Double -> IO Double
+interpolArray :: (Fractional a, MArray array a IO) => array Int a -> Int -> Double -> IO a
+interpolArray arr size = 
+ let f  = fromRational . toRational
+ in \pos -> do
+  let p0 = floor pos
+      p1 = p0 + 1
+      d :: Double
+      d  = pos - fromIntegral p0
+      d' = 1.0 - d
+  v1 <- readArray arr $ mod p0 size
+  v2 <- readArray arr $ mod p1 size
+  let r = v1 * f d' + v2 * f d
+  return r
+
+mkLoopArray :: (Fractional a, MArray arr a IO) => arr Int a -> Int -> IO (Double -> IO a)
+mkLoopArray arr size = do
+ r <- newIORef 0.0
+ let f  = fromRational . toRational
+ return $ \dp -> 
+  do pos <- readIORef r
+     let p  = floor pos
+         p0 = mod p size
+         p1 = mod (p + 1) size
+         d :: Double
+         d  = pos - fromIntegral p
+         pos' = d + fromIntegral p0
+         d' = 1.0 - d
+     v1 <- readArray arr p0
+     v2 <- readArray arr p1
+     writeIORef r (pos' + dp)
+     return (v1 * f d' + v2 * f d)
+
+mkPlayArray :: (Fractional a, MArray arr a IO) => arr Int a -> Int -> IO (Double -> IO (Maybe a))
+mkPlayArray arr size = do
+ r <- newIORef 0.0
+ let f  = fromRational . toRational
+ return $ \dp -> 
+  do pos <- readIORef r
+     let p0 = floor pos
+         p1 = p0 + 1
+         d :: Double
+         d  = pos - fromIntegral p0
+         d' = 1.0 - d
+     if p1 >= size then return Nothing else do
+      v1 <- readArray arr p0
+      v2 <- readArray arr p1
+      writeIORef r (pos + abs dp)
+      return $ Just (v1 * f d' + v2 * f d)
+
+
+---------------------------------------------------------------------------------------------------
+data Sample a = SAMPLE
+ { arraySample :: !(IOArray Int a)
+ , sizeSample  :: !Int
+ }
+---------------------------------------------------------------------------------------------------
+newSample :: Int -> a -> IO (Sample a)
+newSample n a = newArray (0, n-1) a >>= \arr -> return $ SAMPLE arr n
+
+newSampleFromList :: [a] -> IO (Sample a)
+newSampleFromList xs = do
+ let n = length xs
+ arr <- newListArray (0, n - 1) xs
+ return $ SAMPLE arr n
+
+mapSample :: (a -> b) -> Sample a -> IO (Sample b)
+mapSample f (SAMPLE arr n) = do
+ brr <- newArray_ (0, n - 1)
+ for 0 (<n) (+1) (\i -> readArray arr i >>= writeArray brr i . f)
+ return $ SAMPLE brr n
+---------------------------------------------------------------------------------------------------
+openWavSample :: FilePath -> IO (Either (Sample Mono) (Sample Stereo)) 
+openWavSample filepath = do
+ (close, read, len, stereo) <- openInputWavFile filepath
+ let bsize = 4000
+ buf <- newArray_ (0, bsize-1)
+ if stereo
+  then do let lenh = div len 2
+              hsize = div bsize 2
+          arr <- newArray_ (0, lenh - 1)
+          let step o i = do let i1=i*2                  -- i: maximal 1999
+                            x1 <- readArray buf i1      -- 
+                            x2 <- readArray buf (i1+1) 
+                            writeArray arr (o + i) (wavInt16ToDouble x1 :><: wavInt16ToDouble x2)
+              loop o k | k < bsize = do read buf k 
+                                        for 0 (<(div k 2)) (+1) (step o)
+                                        close
+                                        return $ Right $ SAMPLE arr lenh
+                       | otherwise = do read buf bsize 
+                                        for 0 (<hsize) (+1) (step o)
+                                        loop (o+hsize) (k-bsize)
+          loop 0 len
+  else do arr <- newArray_ (0, len - 1)
+          let loop o k | k < bsize = do read buf k 
+                                        for 0 (<k) (+1) (\i -> readArray buf i >>= writeArray arr (o + i) . wavInt16ToDouble )
+                                        close
+                                        return $ Left $ SAMPLE arr len
+                       | otherwise = do read buf bsize 
+                                        for 0 (<bsize) (+1) (\i -> readArray buf i >>= writeArray arr (o + i) . wavInt16ToDouble )
+                                        loop (o+bsize) (k-bsize)
+          loop 0 len
+---------------------------------------------------------------------------------------------------
+saveWavSampleMono :: FilePath -> Sample Double -> IO ()
+saveWavSampleMono filepath (SAMPLE arr len) = do
+ (close, write) <- openOutputWavFileMono filepath
+ let bsize = 4000
+ buf <- newArray_ (0, bsize-1)
+ let step o i = do x <- readArray arr (o+i)
+                   writeArray buf i (wavDoubleToInt16 x)
+     loop o k | k < bsize = do for 0 (<k) (+1) (step o)
+                               write buf k
+                               close
+              | otherwise = do for 0 (<bsize) (+1) (step o)
+                               write buf bsize
+                               loop (o + bsize) (k - bsize)
+ loop 0 len
+---------------------------------------------------------------------------------------------------
+saveWavSampleStereo :: FilePath -> Sample Stereo -> IO ()
+saveWavSampleStereo filepath (SAMPLE arr len) = do
+ (close, write) <- openOutputWavFileStereo filepath
+ let bsize = 4000
+     hsize = div bsize 2
+ buf <- newArray_ (0, bsize-1)
+ let step o i = do let i1 = i * 2
+                       i2 = i1 + 1
+                   x <- readArray arr (o+i)
+                   writeArray buf i1 (wavDoubleToInt16 $ leftStereo x)
+                   writeArray buf i2 (wavDoubleToInt16 $ rightStereo x)
+     loop o k | k < hsize = do for 0 (<k) (+1) (step o)
+                               write buf (2*k)
+                               close
+              | otherwise = do for 0 (<hsize) (+1) (step o)
+                               write buf bsize
+                               loop (o + hsize) (k - hsize)
+ loop 0 len
+
+--12000    348
+
+
+---------------------------------------------------------------------------------------------------
+mkTriggerSample :: Sample a -> a -> IO (Bool -> IO a)
+mkTriggerSample s a = do
+ rp <- newIORef 0
+ let n = sizeSample s
+     arr = arraySample s
+     fun b = if b 
+              then readIORef rp >>= \p ->
+                   if p < n 
+                    then writeIORef rp (p+1) >>
+                         readArray arr p
+                    else return a
+              else writeIORef rp 0 >>
+                   return a
+ return fun
+
+mkPlaySample :: Sample a -> IO (IO (Maybe a))
+mkPlaySample (SAMPLE arr n) = do
+ rpos <- newIORef 0
+ let read = readIORef rpos >>= \pos ->
+            if pos >= n then return Nothing 
+                        else writeIORef rpos (pos+1) >> readArray arr pos >>= return . Just
+ return read 
+---------------------------------------------------------------------------------------------------
+foldlSample :: Sample a -> (b -> a -> b) -> b -> IO b
+foldlSample (SAMPLE arr n) f x =  
+ for' 0 (<n) (+1) x (\i x -> readArray arr i >>= \y -> return (f x y))
+
+updateSample :: Sample a -> (a -> a) -> IO ()
+updateSample (SAMPLE arr n) f = 
+ for 0 (<n) (+1) (\i -> readArray arr i >>= writeArray arr i . f)
+---------------------------------------------------------------------------------------------------
+normaliseSample :: (Ord a, Fractional a) => Sample a -> IO ()
+normaliseSample s = do
+ m <- foldlSample s (\b a -> max b (abs a)) 0.001 
+ updateSample s ((*)(1.0 / m)) 
+---------------------------------------------------------------------------------------------------
+fadeinoutSample :: Fractional a => (Int, Int) -> Sample a -> IO ()
+fadeinoutSample (li,lo) sa = do
+ let n = sizeSample sa
+     arr = arraySample sa
+     li' = min li n
+     lo' = min lo n
+     ol  = n - lo'
+     si  = 1.0 / fromIntegral li'
+     so  = 1.0 / fromIntegral lo'
+ for' 0 (<li') (+1) 0.0 (\i s -> readArray arr i >>= \v -> writeArray arr i (v * s) >> return (s+si))
+ for' ol (<n) (+1) 1.0 (\i s -> readArray arr i >>= \v -> writeArray arr i (v * s) >> return (s-so))
+ return ()
+
+---------------------------------------------------------------------------------------------------
+stretchSample :: Fractional a => Int -> Sample a -> IO (Sample a)
+stretchSample n sam = do
+ let s   = sizeSample sam
+     arr = arraySample sam
+     d   = fromIntegral s / fromIntegral n
+ ram <- newSample n 0.0
+ for 0 (<n) (+1) (\i -> interpolArray arr s (d * fromIntegral i) >>= writeArray (arraySample ram) i)
+ return ram
+
+mkScratchSample :: Fractional a => Sample a -> IO (Double -> IO a)
+mkScratchSample (SAMPLE arr n) = mkLoopArray arr n
+
+mkPitchSample :: Fractional a => Sample a -> IO (Double -> IO (Maybe a))
+mkPitchSample (SAMPLE arr n) = mkPlayArray arr n
+---------------------------------------------------------------------------------------------------
+data Coeffs = COEFFS
+ { arrayCoeffs    :: IOArray Int CoeffArr
+ , sizeCoeffs     :: Int
+ , wavesizeCoeffs :: Int
+ }
+
+mkPlayCoeffs :: Coeffs -> IO (IO (Maybe (Complex Double)))
+mkPlayCoeffs (COEFFS arr siz wsiz) = do
+ r <- newIORef (0,0)
+ let read = readIORef r >>= \(n,k) ->
+            if n >= siz then return Nothing else 
+            if k >= 512 then writeIORef r (n+1,0) >> read else
+            readArray arr n >>= \cs ->
+            readCoeffArr cs k >>= \c ->
+            writeIORef r (n,k+1) >>
+            return (Just c)
+ return read
+
+analyseSample :: Sample Mono -> IO Coeffs
+analyseSample s = do
+ let arr = arraySample s
+     siz   = sizeSample s
+     n     = div siz 512
+     r     = mod siz 512
+     n'    = if r == 0 then n-1 else n
+     n''   = n' - 1
+     r'    = if r == 0 then 1024 else r+512
+     p'    = n'' * 512
+ dummy <- newArray_ (0,1023)
+ brr <- newArray (0, n'') undefined 
+ for 0 (<n'') (+1) (\i -> do let p = i * 512
+                             for 0 (<1024) (+1) (\i -> readArray arr (i+p) >>= writeArray dummy i)
+                             crr <- newArray_ (0, 1023)
+                             writeArray brr i crr
+                             analyseDFT dummy crr)
+ crr <- newArray_ (0, 1023)
+ writeArray brr n'' crr
+ for 0 (<r') (+1) (\i -> readArray arr (i+p') >>= writeArray dummy i)
+ for r' (<1024) (+1) (\i -> writeArray dummy i 0.0)
+ analyseDFT dummy crr
+ return $ COEFFS brr n' siz
+
+syntheseSample :: Coeffs -> IO (Sample Mono)
+syntheseSample (COEFFS arr n siz) = do
+ so <- newSample siz 0.0
+ let n' = n-1
+ dummy <- newArray (0, 1023) 0.0
+-- sa :: StoraArray Int Double) <- newArray (0, 1023) 0.0
+ for 0 (<n') (+1) (\i -> do crr <- readArray arr i
+                            syntheseDFT crr dummy
+                            kurveDFT dummy
+                            let pl = i * 512
+                            for 0 (<512) (+1) (\j -> let jpl = j + pl 
+                                                         jpr = jpl + 512
+                                                     in
+                                                     readArray (arraySample so) jpl >>= \x ->
+                                                     readArray dummy j >>= \y ->
+                                                     writeArray (arraySample so) jpl (x+y) >>
+                                                     readArray dummy (j+512) >>= \z ->
+                                                     writeArray (arraySample so) jpr z
+                                              )
+                  )
+ crr <- readArray arr n'
+ syntheseDFT crr dummy
+ kurveDFT dummy
+ let pl = n' * 512
+     pm = siz - (pl + 512)
+ for 0 (<512) (+1) (\j -> let jpl = j + pl 
+                          in
+                          readArray (arraySample so) jpl >>= \x ->
+                          readArray dummy j >>= \y ->
+                          writeArray (arraySample so) jpl (x+y) )
+ for 0 (<pm) (+1) (\j -> readArray dummy (j+512) >>= \z ->
+                          writeArray (arraySample so) (j+pl+512) z )
+ return so
+
+filterCoeffs :: IO (CoeffMap ()) -> Coeffs -> IO Coeffs 
+filterCoeffs mkf (COEFFS arrci n siz) = do
+ arrco <- newArray (0, n-1) undefined
+ f   <- mkf
+ for 0 (<n) (+1) (\i -> do ci <- readArray arrci i
+                           co <- newArray_ (0, 1023) 
+                           f ci co                           
+                           writeArray arrco i co)
+ return $ COEFFS arrco n siz
+
+-- | usage: @ readCoeffs obj nrOfCoeffarr nrOfCoefficient @
+readCoeffs :: Coeffs -> Int -> Int -> IO (Complex Double)
+readCoeffs cf a c = readArray (arrayCoeffs cf) a >>= \ca ->
+                    readCoeffArr ca c  
+
+writeCoeffs :: Coeffs -> Int -> Int -> (Complex Double) -> IO ()
+writeCoeffs cf a c v = readArray (arrayCoeffs cf) a >>= \ca ->
+                       writeCoeffArr ca c v
+
+---------------------------------------------------------------------------------------------------
+
+
+
+
+
+

+ Sound/Hommage/Seq.hs view
@@ -0,0 +1,103 @@+module Sound.Hommage.Seq
+ ( runNumNotation 
+ , bpmToDur 
+ , Seq (..)
+ , noteSeq
+ , noteSeq'
+ , mixdownNumSeq
+ , applySeq
+-- , applySeqS
+ , applySeqE
+ , filterSeq 
+ )
+ where
+
+--import Control.Monad.Reader
+--import Control.Monad.State
+import Data.List
+import Data.Ratio
+
+import Sound.Hommage.Misc
+import Sound.Hommage.Notation
+
+-------------------------------------------------------------------------------
+-- | A 'Seq' represents a temporal sequence of \"Moments\". Each moment 
+--   can contain some events of type @a@.
+newtype Seq a = SEQ { unSeq :: [[a]] }
+
+instance Arrangeable (Seq a) where
+ parallel (SEQ xs) (SEQ ys) = SEQ $ merge (++) xs ys
+ sequent  (SEQ xs) (SEQ ys) = SEQ (xs ++ ys)
+
+--instance IsDur d => Musical (d -> Seq a) where
+-- rest = \d -> SEQ ( replicate (fromIntegral $ absDur $ durFrom d) [] )
+
+instance IsDur d => Musical (WithDur d (Seq a)) where
+ rest = WithDur $ \d -> SEQ ( replicate (fromIntegral $ absDur $ durFrom d) [] )
+
+--instance Musical ((Dur, s) -> Seq a) where
+-- rest = \d -> SEQ ( replicate (fromIntegral $ absDur $ fst d) [] )
+
+-- | Creates a 'Seq' with the length that the 'Reader' reads. 
+--   (The length will be in any case at least 1).
+noteSeq :: IsDur d => a -> WithDur d (Seq a)
+noteSeq a = WithDur $ \d -> let l = fromIntegral $ absDur $ durFrom d in -- if l > 0 then 
+                            SEQ ( [a] : replicate (l-1) [] )             -- else emptySeq
+
+noteSeq' :: IsDur d => WithDur d a -> WithDur d (Seq a)
+noteSeq' ra = WithDur $ \d -> unWithDur (noteSeq $ unWithDur ra d) d
+-------------------------------------------------------------------------------
+filterSeq :: (a -> Maybe b) -> Seq a -> Seq b
+filterSeq check (SEQ xs) = SEQ $ map filt xs
+ where
+  filt (a:as) = case check a of
+                 Nothing -> filt as
+                 Just b  -> b : filt as
+  filt []     = []
+
+applySeq :: (s -> s) -> Seq (s -> a) -> s -> (Seq a) 
+applySeq next (SEQ l) = \init -> SEQ (loop init l)
+ where
+  loop state (x:xs) = let state' = next state 
+                      in seq state ((map_ ($ state) x : seq state' (loop state' xs)))
+--                      in seq state (map_ ($ state) x : seq state' (loop state' xs))
+--                      in (map_ ($ state) x : (loop state' xs))
+  loop _     _      = []
+
+
+applySeqE :: (s -> s) -> Seq (Either (s -> a) (s -> s)) -> s -> Seq a
+applySeqE next (SEQ l) = \init -> SEQ (loop init l)
+ where
+  loop state (x:xs) = let (fs, us) = uneitherlist x
+                          state'  = foldl (flip ($)) state us
+                          state'' = next state'
+                      in seq state' ((map ($ state') fs : seq state'' (loop state'' xs)))
+  loop _     _      = []
+
+{-
+applySeqS :: (s -> s) -> Seq (State s a) -> Reader s (Seq a)
+applySeqS next (SEQ l) = Reader $ \init -> SEQ (loop init l)
+ where
+  loop state (x:xs) = let (a, state') = runState (iter x) state 
+                          state'' = next state'
+                      in a : {- seq state'' -} (loop state'' xs)
+  loop _     _      = []
+  iter (f:fs) = f >>= \a -> iter fs >>= \r -> return (a : r)
+  iter []     = return []
+-}
+-------------------------------------------------------------------------------
+mixdownNumSeq :: Num a => Seq [a] -> [a]
+mixdownNumSeq (SEQ s) = loop s
+ where
+  -- loop :: Num a => [[[a]]] -> [a]
+  loop [] = []
+  loop (fs:fl) = case map sum $ transpose fs of
+                  []  -> 0 : loop fl
+                  h:t -> seq h (h : (merge (+) t (loop fl)))
+
+runNumNotation :: (IsDur d, Num a) => Notation (WithDur d [a]) -> d -> [a]
+runNumNotation n = \d -> mixdownNumSeq $ unWithDur (runNotationWith noteSeq' n) d
+
+bpmToDur :: Double -> Dur
+bpmToDur bpm = round (44100 * (240.0 / bpm)) % 1
+-------------------------------------------------------------------------------

+ Sound/Hommage/Signal.hs view
@@ -0,0 +1,183 @@+-- | Dieses Module stellt Datentypen und Funktionen zum Umgang mit Mono- und 
+--   Stereodaten zur Verfügung. Speziell im Falle des Öffnens einer WAV-Datei 
+--   ist erst zur Laufzeit bekannt, ob es sich um eine Mono- oder Stereodatei 
+--   handelt, hier wird der Typ 'Signal' benötigt.
+module Sound.Hommage.Signal
+ ( 
+ -- * Mono and Stereo Values
+   Mono 
+ , Stereo (..)
+ , leftStereo 
+ , rightStereo 
+ , stereoToMono 
+ , monoToStereo 
+ , balance 
+ -- * Signal datatype
+ , Signal (..)
+ , readWavSignal 
+ , openWavSignal 
+ , writeWavMono 
+ , writeWavStereo 
+ , writeWavSignal 
+
+ , writeTracks 
+ 
+ , signalToMono 
+ , signalToStereo 
+ , eitherSignal 
+ , liftSignal 
+ , mergeSignal 
+ , mergeSignals
+ , multSignal  
+ , infiniteSignal 
+ )
+ where
+
+import Sound.Hommage.WavFile
+import Sound.Hommage.Misc
+
+import System.IO.Unsafe
+import Data.List
+-------------------------------------------------------------------------------
+-- | A mono value.
+type Mono = Double
+-------------------------------------------------------------------------------
+-- | A stereo value with left and right part. It is an instance of class Num 
+--   and Fractional. 
+data Stereo = !Double :><: !Double
+ deriving (Eq, Show)
+
+-- | Access to the left part of a 'Stereo' value.
+leftStereo :: Stereo -> Mono
+leftStereo (x :><: _) = x
+
+-- | Access to the right part of a 'Stereo' value.
+rightStereo :: Stereo -> Mono
+rightStereo (_ :><: x) = x
+
+instance Num Stereo where
+ (l1:><:r1) + (l2:><:r2) = (l1+l2) :><: (r1+r2)
+ (l1:><:r1) - (l2:><:r2) = (l1-l2) :><: (r1-r2)
+ (l1:><:r1) * (l2:><:r2) = (l1*l2) :><: (r1*r2)
+ negate (l:><:r) = negate l :><: negate r
+ abs (l:><:r) = abs l :><: abs r
+ signum (l:><:r) = signum l :><: signum r
+ fromInteger i = fromInteger i :><: fromInteger i
+
+instance Fractional Stereo where
+ (l1:><:r1) / (l2:><:r2) = (l1/l2) :><: (r1/r2)
+ fromRational x = fromRational x :><: fromRational x 
+-------------------------------------------------------------------------------
+-- | Converts a Stereo value to a Mono value (Double)
+stereoToMono :: Stereo -> Mono
+stereoToMono (x:><:y) =  (x+y) / 2.0
+
+-- | Converts a Mono value (Double) to a Stereo value
+monoToStereo :: Mono -> Stereo
+monoToStereo x = x :><: x
+
+--panorama :: Double -> Mono -> Stereo
+--panorama p m | p == 0.0 = m :><: m
+--             | p >  0.0 = m :><: ((1.0  - p) * m)
+--             | p <  0.0 = m :><: ((1.0  + p) * m)
+
+-- | The range of the Double value must be between -1 and 1. If it is below 0 
+--   the left channel is turned down, if it is greater than 0 the right channel 
+--   is turned down. NOTE: This function should be replaced by a better one.
+balance :: Double -> Stereo -> Stereo
+balance p (l :><: r) | p == 0.0 = l :><: r
+                     | p >  0.0 = l :><: ((1.0  - p) * r)
+                     | p <  0.0 = ((1.0  + p) * l) :><: r
+-------------------------------------------------------------------------------
+-- | A Signal is either a list of 'Mono' values or a list of 'Stereo' values.
+data Signal = Mono [Mono]
+            | Stereo [Stereo]
+
+eitherSignal :: ([Mono] -> a) -> ([Stereo] -> a) -> Signal -> a
+eitherSignal f g (Mono xs)   = f xs
+eitherSignal f g (Stereo xs) = g xs
+
+-- | Applies the function to the input signal. If it is a stereo signal, the
+--   function is applied to both channels seperately.
+liftSignal :: ([Mono] -> [Mono]) -> Signal -> Signal
+liftSignal f (Mono xs)   = Mono $ f xs
+liftSignal f (Stereo xs) = Stereo $ zipWith (:><:) 
+                           (f $ map leftStereo xs) (f $ map rightStereo xs)
+
+-- mapSignal, liftSignal, 
+-------------------------------------------------------------------------------
+-- | Reads a 'Signal' from a WAV-File.
+readWavSignal :: FilePath -> IO Signal
+readWavSignal fp = readWavFile fp >>= 
+ return . either 
+  (Mono . map wavInt16ToDouble) 
+  (Stereo . map (\(l,r) -> (wavInt16ToDouble l :><: wavInt16ToDouble r)))
+
+-- | Opens a 'Signal' from a WAV-File.
+openWavSignal :: FilePath -> Signal
+openWavSignal fp = unsafePerformIO $ readWavSignal fp
+
+-- | Writes a list of mono values to a WAV-File.
+writeWavMono :: FilePath -> [Mono] -> IO ()
+writeWavMono fp = writeWavFileMono fp . map wavDoubleToInt16 
+
+-- | Writes a list of stereo values to a WAV-File.
+writeWavStereo :: FilePath -> [Stereo] -> IO ()
+writeWavStereo fp = writeWavFileStereo fp . map 
+ (\(l :><: r) -> (wavDoubleToInt16 l, wavDoubleToInt16 r)) 
+
+-- | Writes a 'Signal' to a WAV-File.
+writeWavSignal :: FilePath -> Signal -> IO ()
+writeWavSignal fp (Mono xs)   = writeWavMono fp xs
+writeWavSignal fp (Stereo xs) = writeWavStereo fp xs
+
+writeTracks :: FilePath -> [Signal] -> IO ()
+writeTracks fp s = writeWavFiles fp "" strs
+ where
+  strs = map foo s
+  foo (Mono xs) = Left $ map wavDoubleToInt16 xs
+  foo (Stereo xs) = Right $ map (\(l:><:r)->(wavDoubleToInt16 l, wavDoubleToInt16 r)) xs
+-------------------------------------------------------------------------------
+-- | Transfroms a signal to a list of mono values.
+signalToMono :: Signal -> [Mono]
+signalToMono (Mono xs) = xs
+signalToMono (Stereo xs) = map stereoToMono xs
+
+-- | Transfroms a signal to a list of stereo values.
+signalToStereo :: Signal -> [Stereo]
+signalToStereo (Mono xs) = map monoToStereo xs
+signalToStereo (Stereo xs) = xs
+-------------------------------------------------------------------------------
+-- | The sum of a set of signals. If all signals are mono, the result will be mono. 
+--   Otherwise it will be stereo.
+mergeSignals :: [Signal] -> Signal
+mergeSignals ss = fun
+ where
+  loop (Mono   x : xs) = let (l,r) = loop xs in (x:l,r)
+  loop (Stereo x : xs) = let (l,r) = loop xs in (l,x:r)
+  loop []             = ([],[])
+  fun = case loop ss of
+         ([],[]) -> Mono []
+         (ls,[]) -> Mono $ map sum $ transpose ls
+         ([],rs) -> Stereo $ map sum $ transpose rs
+         (ls,rs) -> Stereo $ map sum $ transpose (map (monoToStereo . sum) (transpose ls) : rs)
+
+-- | The sum of two signals
+mergeSignal :: Signal -> Signal -> Signal
+mergeSignal (Stereo xs) (Stereo ys) = Stereo $ merge (+) xs ys
+mergeSignal (Stereo xs) (Mono ys)   = Stereo $ merge (+) xs (map monoToStereo ys)
+mergeSignal (Mono xs)   (Stereo ys) = Stereo $ merge (+) (map monoToStereo xs) ys
+mergeSignal (Mono xs)   (Mono ys)   = Mono $ merge (+) xs ys
+
+-- | The Double value is added to the input signal (offset). The resulting signal will be infinie 
+--   in any case. 
+infiniteSignal :: Double -> Signal -> Signal
+infiniteSignal d (Mono a)   = Mono (map (+d) a ++ repeat d)
+infiniteSignal d (Stereo a) = Stereo (map (+(d:><:d)) a ++ repeat (d:><:d))
+
+-- | Multiplies two signals.
+multSignal :: Signal -> Signal -> Signal
+multSignal (Mono a)   (Mono b)   = Mono $ zipWith (*) a b
+multSignal (Mono a)   (Stereo b) = Stereo $ zipWith (\x y -> monoToStereo x * y) a b
+multSignal (Stereo a) (Stereo b) = Stereo $ zipWith (*) a b
+multSignal (Stereo a) (Mono b)   = Stereo $ zipWith (\x y -> x * monoToStereo y) a b

+ Sound/Hommage/Sound.hs view
@@ -0,0 +1,362 @@+module Sound.Hommage.Sound
+ ( 
+ -- * Classes
+   (==>) 
+ , (.=>)
+ , Sound (..)
+ , Effect (..)
+ , (<+>)
+ , (<*>)
+
+ -- * Sound Generators and Transformers
+ , WaveForm (..)
+ , playWaveForm 
+ , Oscillator (..)
+ , ToFreq (..)
+ , ToFreqDyn (..)
+ , Noise (..)
+ , PlayWav (..)
+ , OscWav (..)
+ , PitchWav (..)
+ , ScratchWav (..)
+ , Filter (..)
+ , FilterFFT (..)
+ , Lowpass (..)
+ , Highpass (..)
+ , Bandpass (..)
+ , Morphfilter (..)
+ , Stretchfilter (..)
+
+ , Envelope (..)
+ , Amplifier (..)
+ , AddTo (..)
+ , Infinite (..)
+ , Delay (..)
+ , ToMono (..)
+ , Average (..)
+ , SampleAndHold (..)
+ , Compressor (..)
+ , Follow (..)
+ , Panorama (..)
+
+-- , LowpassRect (..)
+
+ )
+ where
+
+import Data.List
+import Data.Ratio
+--import Control.Monad.Reader
+
+import Sound.Hommage.Signal
+import Sound.Hommage.Envelope
+import Sound.Hommage.Notation
+import Sound.Hommage.Play
+import Sound.Hommage.Osc
+import Sound.Hommage.Filter
+import Sound.Hommage.Sample
+import Sound.Hommage.DFTFilter
+import Sound.Hommage.FFT
+
+-----------------------------------------------------------
+(==>) :: (Sound a, Effect b) => a -> b -> Play Signal
+v ==> e = play  v >>= \s -> effect e >>= \f -> return (f s)
+
+(<+>) :: (Sound a, Sound b) => a -> b -> Play Signal
+a <+> b = play a >>= \s1 -> play b >>= \s2 -> return (mergeSignal s1 s2)
+
+(<*>) :: (Sound a, Sound b) => a -> b -> Play Signal
+a <*> b = play a >>= \s1 -> play b >>= \s2 -> return (multSignal s1 s2)
+-----------------------------------------------------------
+-- | Minimal complete definition: 'play'. 
+class Sound a where
+ play :: a -> Play Signal
+ playMono   :: a -> Play [Mono] 
+ playStereo :: a -> Play [Stereo]
+
+ playMono a = play a >>= return . signalToMono 
+ playStereo a = play a >>= return . signalToStereo 
+
+instance Sound () where
+ play = const $ return (Mono [])
+ 
+instance Sound (Play Signal) where
+ play = id
+
+instance Sound (Play [Mono]) where
+ play a = a >>= return . Mono
+
+instance Sound (Play [Stereo]) where
+ play a = a >>= return . Stereo
+
+instance Sound Signal where
+ play = return
+
+instance Sound [Mono] where
+ play = return . Mono
+
+instance Sound [Stereo] where
+ play = return . Stereo
+
+instance Sound Mono where
+ play = return . Mono . repeat
+
+instance Sound Stereo where
+ play = return . Stereo . repeat
+
+--instance Sound FilePath where
+-- play = return . openWavSignal
+
+instance Sound (Track Signal) where
+ play = playTrack
+
+instance Sound (Track [Mono]) where
+ play = fmap Mono . playTrack
+
+instance Sound (Track [Stereo]) where
+ play = fmap Stereo . playTrack
+
+instance Sound Interpolate where
+ play i = getDur >>= \d -> return $ Mono $ toEnv i (absDur d)
+-----------------------------------------------------------
+class Effect a where
+ effect :: a -> Play (Signal -> Signal)
+ effectMono :: a -> Play ([Mono] -> [Mono])
+ effectStereo :: a -> Play ([Stereo] -> [Stereo])
+
+ effectMono a = effect a >>= \f -> return ( signalToMono . f . Mono )
+ effectStereo a = effect a >>= \f -> return ( signalToStereo . f . Stereo )
+
+(.=>) :: (Effect a, Effect b) => a -> b -> Play (Signal -> Signal)
+a .=> b = effect a >>= \fa -> effect b >>= \fb -> return (fb . fa)
+ 
+
+instance Sound a => Effect (Play Signal -> a) where
+ effect f = PLAY $ \d e s -> unPlay (play $ f $ return s) d e
+
+instance Sound a => Effect (Play [Mono] -> a) where
+ effect f = PLAY $ \d e s -> unPlay (play $ f $ return $ signalToMono s) d e
+
+instance Sound a => Effect (Play [Stereo] -> a) where
+ effect f = PLAY $ \d e s -> unPlay (play $ f $ return $ signalToStereo s) d e
+
+instance Effect (Play (Signal -> Signal)) where
+ effect = id
+
+--instance Effect (Play Signal -> Play Signal) where
+-- effect f = PLAY $ \d e s -> unPlay (f (return s)) d e
+
+--instance Sound a => Effect (Signal -> a) where
+-- effect f = PLAY $ \e d s -> unPlay (play $ f s) e d
+
+instance Effect (Signal -> Signal) where
+ effect = return 
+
+instance Effect ([Mono] -> [Mono]) where
+ effect = return . liftSignal
+ effectMono = return
+
+instance Effect ([Stereo] -> [Stereo]) where
+ effectStereo = return
+ effect f = return (Stereo . f . signalToStereo)
+
+--instance Effect ([Mono] -> [Stereo]) where
+-- effect f = return $ eitherSignal (Stereo . f) (Stereo . id) -- ???
+
+--instance Effect ([Stereo] -> [Mono]) where
+-- effect f = return $ eitherSignal (Mono . id) (Mono . f) -- ???
+
+--instance Effect ([Mono] -> Signal) where
+-- effect f = return $ eitherSignal f Stereo  -- ???
+ 
+--instance Effect ([Stereo] -> Signal) where
+-- effect f = return $ eitherSignal Mono f  -- ???
+-----------------------------------------------------------
+newtype PlayWav = PlayWav FilePath
+
+instance Sound PlayWav where
+ play (PlayWav fp) = return $ openWavSignal fp
+-----------------------------------------------------------
+data Filter a = Filter a
+
+instance Sound a => Effect (Filter a) where
+ effect (Filter a) = playMono a >>= \a' -> return $ liftSignal (dftfilter a') 
+
+data FilterFFT a = FilterFFT Int a
+
+instance Sound a => Effect (FilterFFT a) where
+ effect (FilterFFT n a) = playMono a >>= \a' -> return $ liftSignal (ffttv n a') 
+
+-----------------------------------------------------------
+-- | Width and cutoff.
+data Lowpass width cutoff = Lowpass width cutoff
+
+instance (Sound a, Sound b) => Sound (Lowpass a b) where
+ play (Lowpass a b) = playMono a >>= \a -> playMono b >>= \b -> return $ Mono (lowpass a b)
+-----------------------------------------------------------
+-- | Width and cutoff.
+data Highpass width cutoff = Highpass width cutoff
+
+instance (Sound a, Sound b) => Sound (Highpass a b) where
+ play (Highpass a b) = playMono a >>= \a -> playMono b >>= \b -> return $ Mono (highpass a b)
+-----------------------------------------------------------
+data Amplifier volume = Amplifier volume
+
+instance Sound a => Effect (Amplifier a) where
+ effect (Amplifier a) = play a >>= return . multSignal 
+---------------------------------------------------------------------------------------------------
+data Envelope = Envelope EnvMode EnvShape ADSR     
+ deriving (Eq, Read, Show)
+
+instance Sound Envelope where
+ play (Envelope em ec adsr) = getDur >>= return . Mono . playADSR em ec adsr . absDur
+
+instance Sound [(Env, EnvLength)] where
+ play e = getDur >>= \d -> return $ Mono $ runEnv e (absDur d)
+-----------------------------------------------------------
+data AddTo summand = AddTo summand
+
+instance Sound a => Effect (AddTo a) where
+ effect (AddTo a) = play a >>= \s -> return (mergeSignal s)
+-----------------------------------------------------------
+-- | The result will be infinite, with given offset.
+data Infinite = Infinite Double
+
+instance Effect Infinite where
+ effect (Infinite d) = return $ infiniteSignal d
+-----------------------------------------------------------
+data Noise = Noise
+
+instance Sound Noise where
+ play _ = return $ Mono $ randomList (-1.0,1.0)
+ playStereo _ = return $ zipWith (:><:) (randomList (-1.0,1.0)) (randomList (-1.0,1.0))
+-----------------------------------------------------------
+-- | Turns pitch to frequency. 
+data ToFreq = ToFreq Double
+
+instance Effect ToFreq where
+ effect (ToFreq d) = return $ liftSignal (map (noteToFrequency d)) 
+
+
+data ToFreqDyn a = ToFreqDyn a
+ 
+instance Sound a => Effect (ToFreqDyn a) where
+ effect (ToFreqDyn a) = playMono a >>= \s -> return $ liftSignal (zipWith noteToFrequency s) 
+
+ -----------------------------------------------------------
+data WaveForm = Sinus | Cosinus | Rect | Saw | Tri
+ deriving (Eq, Read, Show)
+
+playWaveForm :: WaveForm -> [Double] -> [Double]
+playWaveForm wf =
+ case wf of
+  Sinus   -> sinus
+  Cosinus -> cosinus
+  Rect    -> rect
+  Saw     -> saw
+  Tri     -> tri
+
+instance Effect WaveForm where
+ effect wf =  case wf of
+  Sinus   -> return (liftSignal sinus)
+  Cosinus -> return (liftSignal cosinus)
+  Rect    -> return (liftSignal rect)
+  Saw     -> return (liftSignal saw)
+  Tri     -> return (liftSignal tri)
+-----------------------------------------------------------
+data Oscillator = Oscillator WaveForm Double
+
+instance Effect Oscillator where
+ effect (Oscillator wf d) = return $ 
+  (Mono . playWaveForm wf . map (adjustFrequency 1024 d) . signalToMono)
+-----------------------------------------------------------
+data OscWav = OscWav FilePath Double
+
+instance Effect OscWav where
+ effect (OscWav fp d) = let w = signalToMono $ openWavSignal fp in 
+                            return (Mono . osc (cycle w) . 
+                                     map (adjustFrequency (fromIntegral $ length w) d) . 
+                                    signalToMono)
+-----------------------------------------------------------
+data PitchWav = PitchWav FilePath 
+
+instance Effect PitchWav where
+ effect (PitchWav fp) = return $ pitchWavSignal fp . signalToMono 
+-----------------------------------------------------------
+data ScratchWav = ScratchWav FilePath 
+
+instance Effect ScratchWav where
+ effect (ScratchWav fp) = return $ scratchWavSignal fp . signalToMono 
+-----------------------------------------------------------
+data Delay = AbsDelay Int -- ^ Absolute Delay
+           | RelDelay Dur -- ^ Relative Delay with respect to the current duration
+
+instance Effect Delay where
+ effect (AbsDelay n) = return $ eitherSignal (\x -> Mono (replicate n 0.0 ++ x)) 
+                                             (\x -> Stereo (replicate n (0.0:><:0.0) ++ x))
+
+ effect (RelDelay d) = getDur >>= \dur -> let n = absDur (d * dur) in seq n $ return $ 
+                        eitherSignal (\x -> Mono (replicate n 0.0 ++ x)) 
+                                     (\x -> Stereo (replicate n (0.0:><:0.0) ++ x))
+-----------------------------------------------------------
+data ToMono = ToMono
+ 
+instance Effect ToMono where
+ effect ToMono = return $ Mono . signalToMono 
+-----------------------------------------------------------
+data Average = Average Int
+
+instance Effect Average where
+ effect (Average n) = return $ liftSignal (average n) 
+-----------------------------------------------------------
+data Bandpass width slope cutoff = Bandpass width slope cutoff
+
+instance (Sound a, Sound b, Sound c) => Sound (Bandpass a b c) where
+ play (Bandpass a b c) = do a' <- playMono a
+                            b' <- playMono b
+                            c' <- playMono c
+                            return $ Mono (bandpass a' b' c') 
+-----------------------------------------------------------
+data SampleAndHold trigger = SampleAndHold trigger
+
+instance Sound a => Effect (SampleAndHold a) where
+ effect (SampleAndHold a) = playMono a >>= \a' -> return $ liftSignal (sampleAndHold 0 a') 
+-----------------------------------------------------------
+data Compressor a = Compressor a
+
+instance Sound a => Effect (Compressor a) where
+ effect (Compressor a) = playMono a >>= return . liftSignal . zipWith compress 
+-----------------------------------------------------------
+data Morphfilter cutoff = Morphfilter FilterSpec FilterSpec cutoff
+
+instance Sound a => Sound (Morphfilter a) where
+ play (Morphfilter fs1 fs2 a) = playMono a >>= \a' ->
+                                return $ Mono (morphpass fs1 fs2 a')  
+-----------------------------------------------------------
+data Stretchfilter cutoff = Stretchfilter FilterSpec cutoff
+
+instance Sound a => Sound (Stretchfilter a) where
+ play (Stretchfilter fs a) = playMono a >>= \a' ->
+                             return $ Mono (stretchpass fs a')  
+
+-----------------------------------------------------------
+data Follow a = Follow Double a
+
+instance Sound a => Effect (Follow a) where
+ effect (Follow d a) = playMono a >>= \a' -> 
+                           return $ liftSignal (follow d a') 
+-----------------------------------------------------------
+data Panorama balance = Panorama balance
+
+instance Sound a => Effect (Panorama a) where
+ effect (Panorama a) = playMono a >>= \a' ->
+  return $ eitherSignal (Stereo . zipWith balance a' . map monoToStereo)
+                        (Stereo . zipWith balance a')
+
+-----------------------------------------------------------
+-- | Width and cutoff.
+--data LowpassRect width cutoff = LowpassRect width cutoff
+
+--instance (Sound a, Sound b) => Effect (LowpassRect a b) where
+-- effect (LowpassRect a b) = playMono a >>= \a -> playMono b >>= \b -> return $ liftSignal (lowpassrect a b)
+-----------------------------------------------------------

+ Sound/Hommage/Tools.hs view
@@ -0,0 +1,82 @@+module Sound.Hommage.Tools 
+ ( testSound
+ , testSong
+ , stepSequencer
+ , rhythmize
+ , pitchlist
+ )
+ where
+
+import Sound.Hommage.Misc
+import Sound.Hommage.WavFile
+import Sound.Hommage.DFTFilter
+import Sound.Hommage.Signal
+import Sound.Hommage.Sample
+
+import Sound.Hommage.Midi
+import Sound.Hommage.Notation
+import Sound.Hommage.Seq
+
+import Sound.Hommage.Osc
+import Sound.Hommage.Envelope
+import Sound.Hommage.Filter
+
+import Sound.Hommage.Play
+import Sound.Hommage.Sound
+import Sound.Hommage.FFT
+
+import Data.Time
+
+import Control.Monad
+import Data.Ratio
+import System.Random
+import Control.Applicative
+import System
+
+
+---------------------------------------------------------------------------------------------------
+-- | Usage: @ testSound mb_wavplayer outputfileprefix stereo? bpm sound @
+--
+--   Example: @ testSound (Just \"c:\/Programme\/coolpro\/coolpro.exe\") \"out_\" True 110.0 $ Interpolate Linear (0,1) @
+testSound :: Sound a => (Maybe String) -> String -> Bool -> Double -> a -> IO ()
+testSound wavplayer prefix stereo bpm a =
+    do 
+        --let wavplayer = "c:/Programme/coolpro/coolpro.exe"
+        fp <- newFilePath (\n->prefix ++ show n ++ ".wav")
+        t1 <- getCurrentTime
+        if stereo
+            then writeWavStereo fp $ runSong bpm $ return $ playStereo a
+            else writeWavMono fp $ runSong bpm $ return $ playMono a
+        t2 <- getCurrentTime
+        print $ diffUTCTime t2 t1
+        maybe (return ()) (\wavplayer -> system (wavplayer ++ " " ++ fp) >> return ()) wavplayer
+
+
+testSong :: Sound a => (Maybe String) -> String -> Bool -> Double -> Song a -> IO ()
+testSong wavplayer prefix stereo bpm a =
+    do 
+        --let wavplayer = "c:/Programme/coolpro/coolpro.exe"
+        fp <- newFilePath (\n->prefix ++ show n ++ ".wav")
+        t1 <- getCurrentTime
+        if stereo
+            then writeWavStereo fp $ runSong bpm $ fmap playStereo a
+            else writeWavMono fp $ runSong bpm $ fmap playMono a
+        t2 <- getCurrentTime
+        print $ diffUTCTime t2 t1
+        maybe (return ()) (\wavplayer -> system (wavplayer ++ " " ++ fp) >> return ()) wavplayer
+---------------------------------------------------------------------------------------------------
+stepSequencer :: Eq c => [(c, a)] -> Dur -> [c] -> Notation a
+stepSequencer cs d = line . map (maybe (Rest d) (Note d) . flip lookup cs)
+---------------------------------------------------------------------------------------------------
+rhythmize :: Dur -> [Int] -> [Maybe a] -> Notation a
+rhythmize dur ds as = line $ 
+ zipWith (\d -> maybe (Rest (dur * (d % 1))) (Note (dur * (d % 1)))) ds as
+---------------------------------------------------------------------------------------------------
+pitchlist :: (Num a, Ord a) => Bool -> a -> [a]
+pitchlist major base = takeWhile (<128) $ dropWhile (<0) $ loop $ i base
+ where
+  i base = if base > 0 then i (base - 12) else base
+  d = if major then 4 else 3
+  loop x = x : x+d : x+7 : loop (x+12)
+---------------------------------------------------------------------------------------------------
+

+ Sound/Hommage/WavFile.hs view
@@ -0,0 +1,551 @@+module Sound.Hommage.WavFile
+ (
+ -- * Binary Files
+   writeDataFile 
+ , readDataFile 
+ , openDataFile 
+
+ -- * WAV-Files
+ , writeWavFile 
+ , writeWavFileMono
+ , writeWavFileStereo
+ , readWavFile 
+ , openWavFile 
+
+ , writeWavFiles 
+ 
+ -- * Cast between Int16 and Double representation of WAV-data
+ , wavInt16ToDouble   
+ , wavDoubleToInt16   
+
+ -- * Low-Level implemetation 
+ -- ** Arrays and Files
+ , readArrayFromFile 
+ , writeArrayToFileWithHeader 
+ , writeArrayToFile 
+
+ -- ** Single Stream
+ , openSingleInputFile 
+ , openSingleOutputFile 
+
+ , openSingleInputWavFile 
+ , openSingleOutputWavFileMono 
+ , openSingleOutputWavFileStereo 
+
+ -- ** Buffered Stream
+ , openInputFile 
+ , openOutputFile 
+ , openOutputFileWithHeader 
+ , openInputWavFile 
+ , openOutputWavFileMono 
+ , openOutputWavFileStereo
+
+ -- ** Header Stuff and others
+ , HeaderFun 
+ , HeaderSize
+ , noHeader 
+
+ , wavHeaderFunMono 
+ , wavHeaderFunStereo
+ , wavHeaderSize 
+
+ , initWriteWavHeaderMono 
+ , initWriteWavHeaderStereo 
+ , initReadWavHeader 
+ , closeWriteWavHeader 
+ , encode 
+ , decode 
+ , encodeWavLengt 
+ , initWavHeaderMono 
+ , initWavHeaderStereo 
+ , sizeOfArrayElements 
+ , inferSizeOfArrayElements 
+ , inferSizeOfArrayElements' 
+ )
+ where
+
+import System
+import Control.Monad
+import Control.Monad.Fix
+import Data.Char
+import Data.Int
+import GHC.Handle
+import GHC.IO
+import GHC.IOBase
+import Data.Complex
+
+import Foreign.Storable
+import Data.Array.Storable
+import Data.Array.IArray --(bounds)
+import Data.IORef
+
+import System.IO.Unsafe
+import GHC.Weak
+
+
+---------------------------------------------------------------------------------------------------
+wavInt16ToDouble :: Int16 -> Double
+wavInt16ToDouble i = (fromIntegral i) / 32768.0
+
+wavDoubleToInt16 :: Double -> Int16
+wavDoubleToInt16 d = round (d * 32767.0)
+---------------------------------------------------------------------------------------------------
+readDataFile :: Storable a => FilePath -> IO [a]
+readDataFile fp = init
+ where
+  init = do (c,r,_) <- openSingleInputFile 10000 0 fp
+            mkWeak r () (Just c)
+            loop r
+  loop r = r >>= maybe (return []) (\a -> return (a : unsafePerformIO (loop r)))
+
+openDataFile :: Storable a => FilePath -> [a]
+openDataFile fp = unsafePerformIO $ readDataFile fp
+
+writeDataFile :: Storable a => FilePath -> [a] -> IO ()
+writeDataFile fp xs = do
+ (c,w) <- openSingleOutputFile 4000 fp
+ let loop (x:r) = w x >> loop r
+     loop []    = c
+ loop xs
+
+---------------------------------------------------------------------------------------------------
+readWavFile :: FilePath -> IO (Either [Int16] [(Int16,Int16)])
+readWavFile fp = {- putStrLn ("opening " ++ fp) >> -} init
+ where
+  init = do (c,r,_) <- openSingleInputWavFile 100000 fp
+            either (\rm -> do mkWeak rm () (Just c) 
+                              fmap Left $ loop rm) 
+                   (\rs -> do mkWeak rs () (Just c) 
+                              fmap Right $ loop rs) 
+                   r
+  loop r = r >>= maybe (return []) (\a -> return (a : unsafePerformIO (loop r)))
+
+openWavFile :: FilePath -> Either [Int16] [(Int16,Int16)]
+openWavFile fp = unsafePerformIO $ readWavFile fp
+
+writeWavFile :: FilePath -> Either [Int16] [(Int16, Int16)] -> IO () 
+writeWavFile fp (Left w)  = writeWavFileMono fp w
+writeWavFile fp (Right w) = writeWavFileStereo fp w
+            
+writeWavFileMono :: FilePath -> [Int16] -> IO () 
+writeWavFileMono fp xs = do
+ (c,w) <- openSingleOutputWavFileMono 100000 fp
+ let loop (x:r) = w x >> loop r
+     loop []    = c
+ loop xs
+
+writeWavFileStereo :: FilePath -> [(Int16,Int16)] -> IO () 
+writeWavFileStereo fp xs = do
+ (c,w) <- openSingleOutputWavFileStereo 100000 fp
+ let loop (x:r) = w x >> loop r
+     loop []    = c
+ loop xs
+
+writeWavFiles :: FilePath -> String  -> [Either [Int16] [(Int16, Int16)]] -> IO ()
+writeWavFiles fp fn sns = do
+  let init count (Left x : xs) = do (c,w) <- openSingleOutputWavFileMono 100000 (fp ++ fn ++ "_" ++ show count ++ ".wav")
+                                    r <- init (count+1) xs
+                                    return (Left (c,w,x) : r)
+      init count (Right x : xs) = do (c,w) <- openSingleOutputWavFileStereo 100000 (fp ++ fn ++ "_" ++ show count ++ ".wav")
+                                     r <- init (count+1) xs
+                                     return (Right (c,w,x) : r)
+      init _ _ = return []
+  ss <- init 0 sns
+  let step (Left (c,w,x:xs) : r) = do w x
+                                      r <- step r
+                                      return (Left (c,w,xs) : r)
+      step (Left (c,w,[]) : r)   = c >> step r
+      step (Right (c,w,x:xs) : r) = do w x
+                                       r <- step r
+                                       return (Right (c,w,xs) : r)
+      step (Right (c,w,[]) : r)   = c >> step r
+      step []                     = return []
+      
+      loop [] = return ()
+      loop xs = step xs >>= loop
+  loop ss
+---------------------------------------------------------------------------------------------------
+-- Header
+
+-- | The first Action is applied after opening the file. Then the data
+--   bytes are written. The second Action is then called with the number of
+--   bytes of the data. It must close the handle. 
+type HeaderFun = (Handle -> IO (), Handle -> Int -> IO ())
+type HeaderSize = Int
+
+noHeader :: HeaderFun
+noHeader = (const $ return (), \h _ -> return ())
+
+-------------------------------------------------
+-- WavHeader
+
+-- | The first Action writes the Header of the wav-file.
+--   Then the wav-data is written. The second action moves
+--   the Handle to the positions where the lenght of the wav-file 
+--   are encoded (in the header) and writes the right number, which 
+--   is unknown before all data is written. 
+--   Afterwards it closes the file.
+wavHeaderFunMono :: HeaderFun 
+wavHeaderFunMono = (initWriteWavHeaderMono, closeWriteWavHeader)
+
+wavHeaderFunStereo :: HeaderFun 
+wavHeaderFunStereo = (initWriteWavHeaderStereo, closeWriteWavHeader)
+
+wavHeaderSize :: HeaderSize
+wavHeaderSize = 44
+-------------------------------------------------
+initWriteWavHeaderMono :: Handle -> IO ()
+initWriteWavHeaderMono h = mapM_ (hPutChar h) initWavHeaderMono
+
+initWriteWavHeaderStereo :: Handle -> IO ()
+initWriteWavHeaderStereo h = mapM_ (hPutChar h) initWavHeaderStereo
+
+initReadWavHeader :: Handle -> IO (Maybe (Bool, Int, Int, Int))
+initReadWavHeader handle = 
+ let check [] = return True
+     check (x:xs) = hGetChar handle >>= \y -> if x /= ord y then return False else check xs
+     m >>? n = m >>= \b -> if b then n else return Nothing
+ in hSeek handle AbsoluteSeek 0 >>
+    check [82,73,70,70] >>?
+    (replicateM 4 (hGetChar handle) >>= \l1 ->
+    check [87, 65, 86, 69, 102,109,116,32, 16, 0,  0,  0, 1,  0] >>?
+    (hGetChar handle >>= \s1 ->
+    check [0, 68, 172, 0, 0] >>?
+    (replicateM 4 (hGetChar handle) >>= \x1 ->
+    (hGetChar handle >>= \s2 ->
+    check [0,  16, 0, 100, 97,116,97] >>?
+    (replicateM 4 (hGetChar handle) >>= \l2 ->
+    let b | ord s1 == 1 && ord s2 == 2 = False
+          | ord s1 == 2 && ord s2 == 4 = True
+          | otherwise          = error ("invalid wav file " ++ show s1 ++ ", " ++ show s2)
+    in return $ Just (b, decode l1, decode l2, decode x1) ) ) ) ) )
+
+closeWriteWavHeader :: Handle -> Int -> IO ()
+closeWriteWavHeader h len = do
+ let (sa,sb) = encodeWavLengt len
+ hSeek h AbsoluteSeek 4
+ mapM (hPutChar h) sa
+ hSeek h AbsoluteSeek 40
+ mapM (hPutChar h) sb
+ hClose h
+
+encode :: Int -> String
+encode a = map chr 
+ [ mod a 256
+ , mod (div a 256) 256
+ , mod (div a 65536) 256
+ , mod (div a 16777216) 256
+ ]
+
+decode :: String -> Int
+decode [a0,a1,a2,a3] = sum 
+ [ord a0, 256 * ord a1, 65536 * ord a2, 16777216 * ord a3]
+
+
+encodeWavLengt :: Int -> (String, String)
+encodeWavLengt len = (encode (len + 8), encode len)
+
+initWavHeaderMono :: [Char]
+initWavHeaderMono = 
+ map chr
+ [82,73,70,70,
+  0,0,0,0,
+  87, 65, 86, 69,
+  102,109,116,32,
+  16, 0,  0,  0,
+  1,  0,  1,  0,
+  68, 172,0,  0,
+  136,88, 1,  0,
+  2,  0,  16, 0,
+  100, 97,116,97,
+  0,0,0,0]
+
+initWavHeaderStereo :: [Char]
+initWavHeaderStereo = 
+ map chr
+ [82,73,70,70,
+  0,0,0,0,
+  87, 65, 86, 69,
+  102,109,116,32,
+  16, 0,  0,  0,
+  1,  0,  2,  0,
+  68, 172,0,  0,
+  16,177, 2,  0,
+  4,  0,  16, 0,
+  100, 97,116,97,
+  0,0,0,0]
+
+---------------------------------------------------------------------------------------------------
+sizeOfArrayElements :: Storable a => StorableArray Int a -> Int
+sizeOfArrayElements x = sizeOf (foo x)
+ where
+  foo :: StorableArray Int a -> a
+  foo x = undefined
+
+inferSizeOfArrayElements :: Storable a => (StorableArray Int a -> IO Int) -> StorableArray Int a -> Int
+inferSizeOfArrayElements _ arr = sizeOfArrayElements arr
+     
+inferSizeOfArrayElements' :: Storable a => (StorableArray Int a -> Int -> IO ()) -> StorableArray Int a -> Int
+inferSizeOfArrayElements' _ arr = sizeOfArrayElements arr
+
+inferSizeOfArrayElements'' :: Storable a => (StorableArray Int a -> Int -> IO Int) -> StorableArray Int a -> Int
+inferSizeOfArrayElements'' _ arr = sizeOfArrayElements arr
+
+---------------------------------------------------------------------------------------------------
+-- Array / File
+---------------------------------------------------------------------------------------------------
+readArrayFromFile :: Storable a => HeaderSize -> FilePath -> IO (StorableArray Int a, Int)
+readArrayFromFile offset filepath = do
+ handle <- openBinaryFile filepath ReadMode
+ hSeek handle AbsoluteSeek $ fromIntegral offset
+ bytes <- hFileSize handle
+ let bytesize = fromIntegral bytes - offset
+ arr <- mfix $ \arr -> do let bufsize = div bytesize (sizeOfArrayElements arr)
+                          newArray_ (0, bufsize-1)
+ withStorableArray arr $ \ptr -> hGetBuf handle ptr bytesize
+ hClose handle
+ return (arr, div bytesize (sizeOfArrayElements arr))
+
+writeArrayToFileWithHeader :: (MArray StorableArray a IO, Storable a) => HeaderFun -> FilePath -> StorableArray Int a -> IO ()
+writeArrayToFileWithHeader (initH, closeH) filepath arr = do
+ handle <- openBinaryFile filepath WriteMode
+ initH handle
+ (0, n) <- getBounds arr
+ let elemsize = sizeOfArrayElements arr
+     bytesize = (1+n) * elemsize
+ withStorableArray arr (\ptr -> hPutBuf handle ptr bytesize)
+ closeH handle bytesize
+
+writeArrayToFile :: (MArray StorableArray a IO, Storable a) => FilePath -> StorableArray Int a -> IO ()
+writeArrayToFile filepath arr = do
+ handle <- openBinaryFile filepath WriteMode
+ (0, n) <- getBounds arr
+ let elemsize = sizeOfArrayElements arr
+     bytesize = (1+n) * elemsize
+ withStorableArray arr (\ptr -> hPutBuf handle ptr bytesize)
+ hClose handle
+
+{-
+writeArrayToFileWithHeader :: Storable a => HeaderFun -> FilePath -> StorableArray Int a -> IO ()
+writeArrayToFileWithHeader (initH, closeH) filepath arr = do
+ handle <- openBinaryFile filepath WriteMode
+ initH handle
+ let (0,n) = bounds arr
+     elemsize = sizeOfArrayElements arr
+     bytesize = (1+n) * elemsize
+ withStorableArray arr (\ptr -> hPutBuf handle ptr bytesize)
+ closeH handle bytesize
+
+writeArrayToFile :: Storable a => FilePath -> StorableArray Int a -> IO ()
+writeArrayToFile filepath arr = do
+ handle <- openBinaryFile filepath WriteMode
+ let (0,n) = bounds arr
+     elemsize = sizeOfArrayElements arr
+     bytesize = (1+n) * elemsize
+ withStorableArray arr (\ptr -> hPutBuf handle ptr bytesize)
+ hClose handle
+-}
+---------------------------------------------------------------------------------------------------
+-- Single Wav
+---------------------------------------------------------------------------------------------------
+openSingleInputWavFile :: Int -> FilePath -> IO (IO (), Either (IO (Maybe Int16)) (IO (Maybe (Int16,Int16))), Int)
+openSingleInputWavFile n filepath = do
+ handle <- openBinaryFile filepath ReadMode
+ initReadWavHeader handle >>= maybe (error "unknown wav format") (\(isstereo, len1, len2, x) -> do
+  hSeek handle AbsoluteSeek 44
+  let stereo = do let bufsize = n*2
+                  rpos   <- newIORef bufsize
+                  rmax   <- newIORef bufsize
+                  buf    <- newArray_ (0, bufsize-1)
+                  let elemsize = sizeOfArrayElements buf
+                      bytesize = elemsize * bufsize
+                      next = readIORef rpos >>= \pos ->
+                             readIORef rmax >>= \max ->
+                             if pos >= max
+                              then if max < bufsize
+                                    then return Nothing
+                                    else withStorableArray buf (\ptr -> hGetBuf handle ptr bytesize) >>= \bts ->
+                                         writeIORef rmax (div bts elemsize) >>
+                                         writeIORef rpos 0 >>
+                                         next
+                              else readArray buf pos >>= \v1 ->
+                                   readArray buf (pos+1) >>= \v2 ->
+                                   writeIORef rpos (pos + 2) >>
+                                   return (Just (v1,v2))
+                      close = hClose handle
+                  return (close, Right next,div len2 4)
+      mono   = do let bufsize = n
+                  rpos   <- newIORef bufsize
+                  rmax   <- newIORef bufsize
+                  buf    <- newArray_ (0, bufsize-1) 
+                  let elemsize = sizeOfArrayElements buf
+                      bytesize = elemsize * bufsize
+                      next = readIORef rpos >>= \pos ->
+                             readIORef rmax >>= \max ->
+                             if pos >= max
+                              then if max < bufsize
+                                    then return Nothing
+                                    else withStorableArray buf (\ptr -> hGetBuf handle ptr bytesize) >>= \bts ->
+                                         writeIORef rmax (div bts elemsize) >>
+                                         writeIORef rpos 0 >>
+                                         next
+                              else readArray buf pos >>= \v ->
+                                   writeIORef rpos (pos + 1) >>
+                                   return (Just v)
+                      close = hClose handle
+                  return (close, Left next,div len2 2)
+  if isstereo then stereo else mono )
+---------------------------------------------------------------------------------------------------
+openSingleOutputWavFileMono :: Int -> FilePath -> IO (IO (), Int16 -> IO ())
+openSingleOutputWavFileMono bufsize filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ rpos   <- newIORef 0
+ buf    <- newArray_ (0, bufsize-1)
+ rcnt   <- newIORef 0
+ let elemsize = sizeOfArrayElements buf
+     bytesize = elemsize * bufsize
+     write v = readIORef rpos >>= \pos -> 
+               if pos >= bufsize 
+                then withStorableArray buf (\ptr -> hPutBuf handle ptr bytesize) >>
+                     modifyIORef rcnt (+bytesize) >>
+                     writeIORef rpos 1 >> writeArray buf 0 v 
+                else writeArray buf pos v >> writeIORef rpos (pos+1)
+     close = readIORef rpos >>= \pos -> 
+             withStorableArray buf (\ptr -> hPutBuf handle ptr (pos*elemsize)) >>
+             readIORef rcnt >>= \cnt -> closeWriteWavHeader handle (elemsize*pos+cnt)
+ initWriteWavHeaderMono handle
+ return (close, write)
+---------------------------------------------------------------------------------------------------
+openSingleOutputWavFileStereo :: Int -> FilePath -> IO (IO (), (Int16, Int16) -> IO ())
+openSingleOutputWavFileStereo bufsizearg filepath = do
+ let bufsize | bufsizearg < 2  = 4
+             | even bufsizearg = bufsizearg
+             | otherwise       = bufsizearg + 1
+ handle <- openBinaryFile filepath WriteMode
+ rpos   <- newIORef 0
+ buf    <- newArray_ (0, bufsize-1)
+ rcnt   <- newIORef 0
+ let elemsize = sizeOfArrayElements buf
+     bytesize = elemsize * bufsize
+     write (v1,v2) = readIORef rpos >>= \pos -> 
+                     if pos >= bufsize 
+                      then withStorableArray buf (\ptr -> hPutBuf handle ptr bytesize) >>
+                           modifyIORef rcnt (+bytesize) >>
+                           writeIORef rpos 2 >> writeArray buf 0 v1 >> writeArray buf 1 v2
+                      else writeArray buf pos v1 >> writeArray buf (pos+1) v2 >> writeIORef rpos (pos+2)
+     close = readIORef rpos >>= \pos -> 
+             withStorableArray buf (\ptr -> hPutBuf handle ptr (pos*elemsize)) >>
+             readIORef rcnt >>= \cnt -> closeWriteWavHeader handle (elemsize*pos+cnt)
+ initWriteWavHeaderStereo handle
+ return (close, write)
+---------------------------------------------------------------------------------------------------
+-- Single Storable
+---------------------------------------------------------------------------------------------------
+openSingleInputFile :: Storable a => Int -> HeaderSize -> FilePath -> IO (IO (), IO (Maybe a), Int)
+openSingleInputFile bufsize offset filepath = do
+ handle <- openBinaryFile filepath ReadMode
+ bytes <- hFileSize handle
+ hSeek handle AbsoluteSeek $ fromIntegral offset
+ rpos   <- newIORef bufsize
+ rmax   <- newIORef bufsize
+ buf    <- newArray_ (0, bufsize-1)
+ let elemsize = sizeOfArrayElements buf
+     bytesize = elemsize * bufsize
+     next = readIORef rpos >>= \pos ->
+            readIORef rmax >>= \max ->
+            if pos >= max
+             then if max < bufsize
+                   then return Nothing
+                   else withStorableArray buf (\ptr -> hGetBuf handle ptr bytesize) >>= \bts ->
+                        writeIORef rmax (div bts elemsize) >>
+                        writeIORef rpos 0 >>
+                        next
+             else readArray buf pos >>= \v ->
+                  writeIORef rpos (pos + 1) >>
+                  return (Just v)
+     close = hClose handle
+ return (close, next,div (fromIntegral bytes - offset) elemsize)
+---------------------------------------------------------------------------------------------------
+openSingleOutputFile :: Storable a => Int -> FilePath -> IO (IO (), a -> IO ())
+openSingleOutputFile bufsize filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ rpos   <- newIORef 0
+ buf    <- newArray_ (0, bufsize-1)
+ let elemsize = sizeOfArrayElements buf
+     bytesize = elemsize * bufsize
+     write v = readIORef rpos >>= \pos -> 
+               if pos >= bufsize 
+                then withStorableArray buf (\ptr -> hPutBuf handle ptr bytesize) >>
+                     writeIORef rpos 1 >> writeArray buf 0 v 
+                else writeArray buf pos v >> writeIORef rpos (pos+1)
+     close = readIORef rpos >>= \pos -> 
+             withStorableArray buf (\ptr -> hPutBuf handle ptr (pos*elemsize)) >>
+             hClose handle 
+ return (close, write)
+---------------------------------------------------------------------------------------------------
+-- Buffered Storable
+---------------------------------------------------------------------------------------------------
+openInputFile :: Storable a => HeaderSize -> FilePath -> Int -> IO (IO (), StorableArray Int a -> Int -> IO Int, Int)
+openInputFile offset filepath arrsize = do
+ handle <- openBinaryFile filepath ReadMode
+ hSeek handle AbsoluteSeek $ fromIntegral offset
+ bytes <- hFileSize handle
+ let nr_bytes  = fromIntegral bytes - offset
+     elemsize  = inferSizeOfArrayElements'' read undefined
+     read arr k = withStorableArray arr $ \ptr -> 
+                  hGetBuf handle ptr (k * elemsize) >>= return . flip div elemsize
+     close     = hClose handle 
+ return $ (close, read, div nr_bytes elemsize)
+
+openOutputFile :: Storable a => FilePath -> IO (IO (), StorableArray Int a -> Int -> IO ())
+openOutputFile filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ let elemsize = inferSizeOfArrayElements' write undefined
+     write arr k = withStorableArray arr (\ptr -> hPutBuf handle ptr (k*elemsize))
+     close = hClose handle
+ return $ (close, write)
+
+openOutputFileWithHeader :: Storable a => HeaderFun -> FilePath -> IO (IO (), StorableArray Int a -> Int -> IO ())
+openOutputFileWithHeader (initH, closeH) filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ rlen   <- newIORef 0
+ initH handle
+ let elemsize = inferSizeOfArrayElements' write undefined
+     write arr k = modifyIORef rlen (+k) >> withStorableArray arr (\ptr -> hPutBuf handle ptr (k*elemsize))
+     close =  readIORef rlen >>= \l -> closeH handle (elemsize*l)
+ return $ (close, write)
+---------------------------------------------------------------------------------------------------
+-- Buffered Wav
+---------------------------------------------------------------------------------------------------
+
+openInputWavFile :: FilePath -> IO (IO (), StorableArray Int Int16 -> Int -> IO (), Int, Bool)
+openInputWavFile filepath = do
+ handle <- openBinaryFile filepath ReadMode
+ initReadWavHeader handle >>= maybe (error "unknown wav format") (\(isstereo, len1, len2, x) -> do
+  hSeek handle AbsoluteSeek 44
+  let elemsize  = inferSizeOfArrayElements' read undefined
+      read arr k = withStorableArray arr $ \ptr -> 
+                   hGetBuf handle ptr (k * elemsize) >> return () 
+      close     = hClose handle 
+  return $ (close, read, div len2 2, isstereo) )
+
+openOutputWavFileMono :: FilePath -> IO (IO (), StorableArray Int Int16 -> Int -> IO ())
+openOutputWavFileMono filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ rlen   <- newIORef 0
+ let elemsize = inferSizeOfArrayElements' write undefined
+     write arr k = withStorableArray arr (\ptr -> hPutBuf handle ptr (k*elemsize)) >> modifyIORef rlen (+k)
+     close = readIORef rlen >>= \l -> closeWriteWavHeader handle (elemsize*l)
+ initWriteWavHeaderMono handle
+ return $ (close, write)
+
+openOutputWavFileStereo :: FilePath -> IO (IO (), StorableArray Int Int16 -> Int -> IO ())
+openOutputWavFileStereo filepath = do
+ handle <- openBinaryFile filepath WriteMode
+ rlen   <- newIORef 0
+ let elemsize = inferSizeOfArrayElements' write undefined
+     write arr k = withStorableArray arr (\ptr -> hPutBuf handle ptr (k*elemsize)) >> modifyIORef rlen (+k)
+     close = readIORef rlen >>= \l -> closeWriteWavHeader handle (elemsize*l)
+ initWriteWavHeaderStereo handle
+ return $ (close, write)
+---------------------------------------------------------------------------------------------------

+ Sound/Hommage/dft.c view
@@ -0,0 +1,257 @@+#include <stdio.h>
+/* #include <io.h> */
+#include <fcntl.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+double sinus [1024];
+double cosin [1024];
+double kurve [1024];
+
+int cinit ()
+{
+  int i;
+  double f = 3.1415926 / 512.0;
+  double k = 1.0 / 512.0;
+  for (i=0; i<1024; i++)
+  { double x = f * (double) i;
+    sinus [i] = sin (x);
+    cosin [i] = cos (x);
+  }
+
+  /*
+  for (i=0; i<512; i++)
+  { double x = k * (double) i;
+    kurve [i] = x;
+    kurve [i+512] = 1.0-x;
+  }
+  */
+
+  for (i=0; i<1024; i++)
+  { kurve [i] = 0.5 - (cosin [i] * 0.5);
+  }
+
+  return 0;
+}
+
+double getsinus (int x)
+{ return sinus [x & 1023];
+}
+double getcosin (int x)
+{ return cosin [x & 1023];
+}
+
+void xcanalyse (double * wv, double * cf)
+{ int k, x;
+  for (k=1; k<512; k++)
+  { int kc = k << 1;
+    int ks = kc - 1;
+    cf [kc] = 0.0;
+    cf [ks] = 0.0;
+    for (x=0; x<1024; x++)
+    { int i = (x * k) & 1023;
+      cf [kc] += cosin [i] * wv [x];
+      cf [ks] += sinus [i] * wv [x];
+    }
+    cf [kc] /= 512.0;
+    cf [ks] /= 512.0;
+  }
+  cf [1023] = 0.0;
+  cf [0] = 0.0;
+  for (x=0; x<1024; x++)
+  { if (x % 2 == 0)
+      cf [1023] += wv [x];
+    else
+      cf [1023] -= wv [x];
+    cf [0] += wv [x];
+  }
+  cf [0] /= 512.0;
+  cf [1023] /= 512.0;
+}
+
+void xcsynthese (double * cf, double * wv)
+{ int x,k;
+  double d;
+  for (x=0; x<1024; x++)
+  { d = cf [0] * 0.5;
+    if (x % 2 == 0)
+      d += cf [1023];
+    else
+      d -= cf [1023];
+    for (k=1; k<512; k++)
+    { int kc = k << 1;
+      int ks = kc - 1;
+      int i = (x * k) & 1023;
+      d += cosin [i] * cf [kc];
+      d += sinus [i] * cf [ks];
+    }
+    wv [x] = d; // * st->kurve [x];
+  }
+}
+
+void ckurve (double * arr)
+{ int i;
+  for (i=0; i<1024; i++)
+    arr [i] *= kurve [i];
+}
+
+// Now with FFT ...
+
+void canalyse (double * wv, double * cf)
+{ int group_length;
+  int i,j,d,nr_of_groups,group;
+  int a_ix, b_ix, w_ix;
+
+  int a_r_ix, a_i_ix, b_r_ix, b_i_ix;
+
+  double a_r, a_i, b_r, b_i, w_r, w_i, wb_r, wb_i;
+
+  group_length = 1;
+
+  for (i=0; i<512; i++)
+  { j = 0; //bitreverse (i);
+    int ii = i;
+    for (d=0;d<9;d++)
+    { j<<=1;
+      if (ii % 2)
+      { j++;
+      }
+      ii >>=1;
+    }
+    cf [i*2] = wv [j*2];
+    cf [i*2+1] = wv [j*2+1];
+  }
+
+
+  for (nr_of_groups=512; nr_of_groups>1; nr_of_groups>>=1)
+  { 
+    for (group=0; group<nr_of_groups; group+=2)
+    { 
+      for (i=0; i<group_length; i++) // zipWith3 butterfly ws xs ys
+      { a_ix = group * group_length + i;
+        b_ix = a_ix + group_length;
+
+        w_ix = (i * 512 / group_length);
+
+        //butterfly (w_ix, a_ix, b_ix);
+
+        w_r = cosin [w_ix];
+        w_i = sinus [w_ix];
+
+        a_r_ix = a_ix * 2;
+        a_i_ix = a_r_ix + 1;
+
+        b_r_ix = b_ix * 2;
+        b_i_ix = b_r_ix + 1;
+        
+        a_r = cf [a_r_ix];
+        a_i = cf [a_i_ix];
+
+        b_r = cf [b_r_ix];
+        b_i = cf [b_i_ix];
+
+        wb_r = (w_r * b_r) + (w_i * b_i);
+        wb_i = (w_r * b_i) - (w_i * b_r);
+
+        cf [a_r_ix] = a_r + wb_r;
+        cf [a_i_ix] = a_i + wb_i;
+
+        cf [b_r_ix] = a_r - wb_r;
+        cf [b_i_ix] = a_i - wb_i;
+        
+      }
+    }
+    group_length *= 2;
+  }
+}
+
+void csynthese (double * wv, double * cf)
+{ int group_length;
+  int i,j,d,nr_of_groups,group;
+  int a_ix, b_ix, w_ix;
+  int a_r_ix, a_i_ix, b_r_ix, b_i_ix;
+
+  double a_r, a_i, b_r, b_i, w_r, w_i, wb_r, wb_i;
+
+  group_length = 1;
+
+  for (i=0; i<512; i++)
+  { j = 0; //bitreverse (i);
+    int ii = i;
+    for (d=0;d<9;d++)
+    { j<<=1;
+      if (ii % 2)
+      { j++;
+      }
+      ii >>=1;
+    }
+    cf [i*2] = wv [j*2];
+    cf [i*2+1] = wv [j*2+1];
+  }
+
+  for (nr_of_groups=512; nr_of_groups>1; nr_of_groups>>=1)
+  { 
+    for (group=0; group<nr_of_groups; group+=2)
+    { 
+      for (i=0; i<group_length; i++) // zipWith3 butterfly ws xs ys
+      { a_ix = group * group_length + i;
+        b_ix = a_ix + group_length;
+
+        w_ix = (i * 512 / group_length);
+
+        //butterfly (w_ix, a_ix, b_ix);
+
+        w_r = cosin [w_ix];
+        w_i = sinus [w_ix];
+
+
+        a_r_ix = a_ix * 2;
+        a_i_ix = a_r_ix + 1;
+
+        b_r_ix = b_ix * 2;
+        b_i_ix = b_r_ix + 1;
+        
+        a_r = cf [a_r_ix];
+        a_i = cf [a_i_ix];
+
+        b_r = cf [b_r_ix];
+        b_i = cf [b_i_ix];
+
+        wb_r = (w_r * b_r) - (w_i * b_i);
+        wb_i = (w_r * b_i) + (w_i * b_r);
+
+        cf [a_r_ix] = (a_r + wb_r) * 0.5;
+        cf [a_i_ix] = (a_i + wb_i) * 0.5;
+
+        cf [b_r_ix] = (a_r - wb_r) * 0.5;
+        cf [b_i_ix] = (a_i - wb_i) * 0.5;
+        
+      }
+    }
+    group_length *= 2;
+  }
+}
+
+
+// a + w * b
+
+// (ar,ai) +- (wr,wi) * (br,bi)
+//            (wr*br - wi*bi, wr*bi+br*wi)
+// (ar+wr*br-wi*bi, ai+wr*bi+br*wi)
+// (ar-wr*br+wi*bi, ai-wr*bi+br*wi)
+
+// 1024 i = cosin [i]
+// 512 i = cosin [i*2]   [i * 1024 / grouplength]
+// 2 i = i * 512 
+
+
+
+
+
+
+
+
+
+
+

+ doc/Sound.Hommage.DFTFilter.html view
@@ -0,0 +1,899 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.DFTFilter</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.DFTFilter</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > User-Level Filter Functions</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > CoeffArr</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > CoeffMap</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > IO Wrapper </A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > Interface to C-code</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> This module imports the C-functions for a Fast Fourier Transform and encapsulates them in
+   list-mapping functions. (At first it was a DFT algoritm which I changed, but I didn'd change
+   all the names of the functions, so it is called dft...)
+   The functionality of this module is used for filtering audio data, i. e. for building
+   audio filters.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Adftanalyse"
+		>dftanalyse</A
+		> :: [Double] -&gt; [Complex Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Adftsynthese"
+		>dftsynthese</A
+		> :: [Complex Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Adftfilter"
+		>dftfilter</A
+		> :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AdftfilterBy"
+		>dftfilterBy</A
+		> :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> ()) -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AdftfilterBy'"
+		>dftfilterBy'</A
+		> :: s -&gt; IO (s -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> s) -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3ACoeffArr"
+		>CoeffArr</A
+		> = StorableArray Int Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadCoeffArr"
+		>readCoeffArr</A
+		> :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; Int -&gt; IO (Complex Double)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteCoeffArr"
+		>writeCoeffArr</A
+		> :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; Int -&gt; Complex Double -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AstoreCoeff"
+		>storeCoeff</A
+		> :: IOArray Int (Complex Double) -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AunstoreCoeff"
+		>unstoreCoeff</A
+		> :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; IOArray Int (Complex Double) -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3ACoeffMap"
+		>CoeffMap</A
+		> a = <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		> -&gt; IO a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkCoeffMap"
+		>mkCoeffMap</A
+		> :: [Double] -&gt; IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Acoeffmap"
+		>coeffmap</A
+		> :: StorableArray Int Double -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkAnalyse"
+		>mkAnalyse</A
+		> :: IO (Maybe Double -&gt; IO (Maybe (Complex Double)))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkSynthese"
+		>mkSynthese</A
+		> :: IO (Maybe (Complex Double) -&gt; IO (Maybe Double))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkFilterBuffered"
+		>mkFilterBuffered</A
+		> :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> ()) -&gt; IO (Maybe Double -&gt; IO (Maybe Double))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AanalyseDFT"
+		>analyseDFT</A
+		> :: StorableArray Int Double -&gt; StorableArray Int Double -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsyntheseDFT"
+		>syntheseDFT</A
+		> :: StorableArray Int Double -&gt; StorableArray Int Double -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AkurveDFT"
+		>kurveDFT</A
+		> :: StorableArray Int Double -&gt; IO ()</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > Filtering is done with an FFT algorithm written in C (in the file dft.c). 
+   This module imports the c-functions for fft (<TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AanalyseDFT"
+	      >analyseDFT</A
+	      ></TT
+	    >) and inverse fft (<TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AsyntheseDFT"
+	      >syntheseDFT</A
+	      ></TT
+	    >),
+   which operate on Arrays with 1024 Double values. 
+   The array-operations are embedded in a mechanism that does buffering, overlapping and windowing 
+   and works like a black box that maps one input value to one output value in the IO monad 
+   (<TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkAnalyse"
+	      >mkAnalyse</A
+	      ></TT
+	    >, <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkSynthese"
+	      >mkSynthese</A
+	      ></TT
+	    >, <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkFilterBuffered"
+	      >mkFilterBuffered</A
+	      ></TT
+	    >). 
+   Around these IO's some list mapping functions are wrapped (<TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftanalyse"
+	      >dftanalyse</A
+	      ></TT
+	    >, <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftsynthese"
+	      >dftsynthese</A
+	      ></TT
+	    >, <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftfilter"
+	      >dftfilter</A
+	      ></TT
+	    >,
+   <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AdftfilterBy"
+	      >dftfilterBy</A
+	      ></TT
+	    >) for convenient use in a Haskell programm.</P
+	  ><P
+	  >   Mapping the Fourier coefficients during the filter process means filtering the data. 
+   The result depends on the way the coefficients are mapped resp. modified while mapping.
+   The function to do this has the type of <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	      >CoeffMap</A
+	      ></TT
+	    >.</P
+	  ><P
+	  >   <EM
+	    >Description of the filtering process:</EM
+	    > </P
+	  ><P
+	  >   Filtering is done by mapping the coefficients with <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	      >CoeffMap</A
+	      ></TT
+	    >. 
+   For this the wave data is split into parts of 1024 values, where every part overlaps with the 
+   preceeding and succeeding part by 512 values. Via the fourier-transform (analyse) every part 
+   is mapped  to its frequency spectrum, i. e. its fourier coefficients. </P
+	  ><P
+	  >   The <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	      >CoeffMap</A
+	      ></TT
+	    > action is applied to every frequency spectrum (see <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	      >CoeffArr</A
+	      ></TT
+	    >) in sequence. 
+   It reads the coefficients from the first <TT
+	    ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	      >CoeffArr</A
+	      ></TT
+	    > where the input is stored and writes it 
+   (or some data derived from it) to the second one. This is the point where the 'real' filtering
+   happens. Via the inverse fourier-transform (synthese) the resulting coefficients are mapped 
+   to their real signal values. These signal values are multiplied with a half cosinus curve for 
+   fading in and out (windowing). Then they are mixed in the way their source data was split: 
+   Every part overlaps for 512 values with the last and the next one. </P
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > User-Level Filter Functions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Adftanalyse"
+	  ></A
+	  ><B
+	  >dftanalyse</B
+	  > :: [Double] -&gt; [Complex Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> (Fast) Fourier Transformation. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Adftsynthese"
+	  ></A
+	  ><B
+	  >dftsynthese</B
+	  > :: [Complex Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Inverse (Fast) Fourier Transformation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Adftfilter"
+	  ></A
+	  ><B
+	  >dftfilter</B
+	  > :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> (Fast) Fourier Transformation and Inverse with an additional argument with sublists of
+   factors to weight the coefficients. See <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkCoeffMap"
+	    >mkCoeffMap</A
+	    ></TT
+	  > for a decription of that argument.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AdftfilterBy"
+	  ></A
+	  ><B
+	  >dftfilterBy</B
+	  > :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > ()) -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AdftfilterBy'"
+	  ></A
+	  ><B
+	  >dftfilterBy'</B
+	  > :: s -&gt; IO (s -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > s) -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > CoeffArr</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3ACoeffArr"
+	  ></A
+	  ><B
+	  >CoeffArr</B
+	  > = StorableArray Int Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > Represents a frequency spectrum. 
+   Range is from 0 to 1023 (N=1024).
+   Index 0 is constant value, index 1 is Nyquest frequency (real part of the N/2 frequency). 
+   Index 2 and 3 are the complex value for the basefrequency, index 4 and 5
+   are the complex value for the double basefrequency, 6 and 7 for 3 * basefrequency and so on:</P
+	  ><PRE
+	  > arr [0] = real part of zero frequency (imaginary part is allways 0)
+ arr [1] = real part of Nyquest frequency (N/2) (imaginary part is allways 0)
+ arr [2] = real part of base frequency
+ arr [3] = imag part of base frequency
+ arr [4] = real part of base frequency * 2
+ arr [5] = imag part of base frequency * 2
+ arr [6] = real part of base frequency * 3
+ arr [7] = imag part of base frequency * 3
+ ...
+ arr [N-4] = real part of base frequency * (N/2 - 2)
+ arr [N-3] = imag part of base frequency * (N/2 - 2)
+ arr [N-2] = real part of base frequency * (N/2 - 1)
+ arr [N-1] = imag part of base frequency * (N/2 - 1)</PRE
+	  ><P
+	  > Pseudocode:</P
+	  ><PRE
+	  > c (0)   = (arr [0] :+ 0)
+ c (512) = (arr [1] :+ 0)</PRE
+	  ><P
+	  >  and for all i=[1..511]:</P
+	  ><PRE
+	  > c (i) = (arr [i*2] :+ arr [i*2+1])
+</PRE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadCoeffArr"
+	  ></A
+	  ><B
+	  >readCoeffArr</B
+	  > :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; Int -&gt; IO (Complex Double)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Reads a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteCoeffArr"
+	  ></A
+	  ><B
+	  >writeCoeffArr</B
+	  > :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; Int -&gt; Complex Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Writes a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AstoreCoeff"
+	  ></A
+	  ><B
+	  >storeCoeff</B
+	  > :: IOArray Int (Complex Double) -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AunstoreCoeff"
+	  ></A
+	  ><B
+	  >unstoreCoeff</B
+	  > :: <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; IOArray Int (Complex Double) -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > CoeffMap</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3ACoeffMap"
+	  ></A
+	  ><B
+	  >CoeffMap</B
+	  > a = <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  > -&gt; IO a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> An action that maps the fourier coefficients from the first array to the second.
+   Modifying the data while mapping means filtering. See <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	    >CoeffArr</A
+	    ></TT
+	  > for a description of the arrays.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkCoeffMap"
+	  ></A
+	  ><B
+	  >mkCoeffMap</B
+	  > :: [Double] -&gt; IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Constructs a Coeffmap.
+   The sublists contain the 512 real values with which the basefrequency and the 511 complex fourier coefficients 
+   are multiplied (the Nyquist frequency will be zero). 
+   The first value is the factor for the constant coefficient, the second for the base frequency, the next one 
+   for the double base freq and so on. 
+   If the sublists have more than 512 elements, these elements are thrown away. 
+   If it is shorter, the array will be filled up with zeros.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Acoeffmap"
+	  ></A
+	  ><B
+	  >coeffmap</B
+	  > :: StorableArray Int Double -&gt; <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#v%3Acoeffmap"
+	    >coeffmap</A
+	    ></TT
+	  > takes an Array with 512 values and uses them for a weigted map of the fourier 
+   coefficients. The Nyquist frequency is muliplied with 0.0.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > IO Wrapper </A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkAnalyse"
+	  ></A
+	  ><B
+	  >mkAnalyse</B
+	  > :: IO (Maybe Double -&gt; IO (Maybe (Complex Double)))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Constructs an action that maps wave-data to coefficient-data.
+   Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)
+   512 elemets more than the input.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkSynthese"
+	  ></A
+	  ><B
+	  >mkSynthese</B
+	  > :: IO (Maybe (Complex Double) -&gt; IO (Maybe Double))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Constructs an action that maps coefficient-data to wave-data.
+   Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)
+   512 elemets more than the input.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkFilterBuffered"
+	  ></A
+	  ><B
+	  >mkFilterBuffered</B
+	  > :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > ()) -&gt; IO (Maybe Double -&gt; IO (Maybe Double))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Constructs an action that maps wave-data to wave-data via a Fast Foutrier Transform and inverse,
+   filtered by the given <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	    >CoeffMap</A
+	    ></TT
+	  >.
+   Has a delay of 1024.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > Interface to C-code</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AanalyseDFT"
+	  ></A
+	  ><B
+	  >analyseDFT</B
+	  > :: StorableArray Int Double -&gt; StorableArray Int Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Maps an array with 1024 real values to its frequency spectrum with 512 complex values.
+   The spectrum is stored in the second array with 1024 Doubles which are the real and imaginary
+   parts of the complex values. See <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	    >CoeffArr</A
+	    ></TT
+	  > for a detailed frequency spectrum
+   desription.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsyntheseDFT"
+	  ></A
+	  ><B
+	  >syntheseDFT</B
+	  > :: StorableArray Int Double -&gt; StorableArray Int Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Maps a frequency spectrum to its signal value. Both arrays have a length of 1024; the first one
+   contains the 512 complex values of the spectrum. The real signal value will be stored in
+   the second array. See <TT
+	  ><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	    >CoeffArr</A
+	    ></TT
+	  > for a detailed frequency spectrum
+   desription.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AkurveDFT"
+	  ></A
+	  ><B
+	  >kurveDFT</B
+	  > :: StorableArray Int Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Fades a signal which is stored in an array of length 1024 in and out.
+   The signal is multiplied with a cosinus curve with range 0..pi. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Envelope.html view
@@ -0,0 +1,1220 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Envelope</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Envelope</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Env</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > EnvLength</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > ADSR</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Interpolate</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> This module contains some functions and datatypes for envelopes.
+   An envelope in generall is a kind of controll signal that modulates 
+   (for example) the volume of a sound in a non-periodic way (getting
+   loud at the beginning and fading out at the end...). It is
+   also used to controll the duration of a sound, since (here) envelopes
+   always produce finite signals.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AEnv"
+		>Env</A
+		> = Int -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunEnv"
+		>runEnv</A
+		> :: [(<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		>Env</A
+		>, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		>EnvLength</A
+		>)] -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		>Env</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3C%3F%3E"
+		>(&lt;?&gt;)</A
+		> :: (<A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		>IsEnv</A
+		> a) =&gt; a -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		>EnvLength</A
+		> -&gt; (<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		>Env</A
+		>, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		>EnvLength</A
+		>)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AIsEnv"
+		>IsEnv</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AtoEnv"
+		      >toEnv</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		      >Env</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AcalculateEnvLengths"
+		>calculateEnvLengths</A
+		> :: Int -&gt; [<A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		>EnvLength</A
+		>] -&gt; [Int]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AEnvLength"
+		      >EnvLength</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AAbs"
+			    >Abs</A
+			    > Int</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AAbs_"
+			    >Abs_</A
+			    > Int</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AFlex"
+			    >Flex</A
+			    > Double</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ARel"
+			    >Rel</A
+			    > (Ratio Int)</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ARel_"
+			    >Rel_</A
+			    > (Ratio Int)</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AADSR"
+		>ADSR</A
+		> = (Int, Int, Double, Int)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AEnvShape"
+		      >EnvShape</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3ALinear"
+			    >Linear</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ACosLike"
+			    >CosLike</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AEnvMode"
+		      >EnvMode</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AHoldS"
+			    >HoldS</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AFitS"
+			    >FitS</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AFitADR"
+			    >FitADR</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AplayADSR"
+		>playADSR</A
+		> :: <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		>EnvMode</A
+		> -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		>EnvShape</A
+		> -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+		>ADSR</A
+		> -&gt; Int -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AInterpolate"
+		>Interpolate</A
+		>  = <A HREF = "#v%3AInterpolate"
+		>Interpolate</A
+		> <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		>EnvShape</A
+		> (Double, Double)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AConstant"
+		>Constant</A
+		>  = <A HREF = "#v%3AConstant"
+		>Constant</A
+		> Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ainterpolate"
+		>interpolate</A
+		> :: (Fractional a) =&gt; (a, a) -&gt; Int -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ainterpolate_cos"
+		>interpolate_cos</A
+		> :: (Floating a) =&gt; (a, a) -&gt; Int -&gt; [a]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> An envelope is represented by a function of type <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	    >Env</A
+	    ></TT
+	  >. 
+   Such functions (or instances of class <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+	    >IsEnv</A
+	    ></TT
+	  >) can be combined
+   into a sequence where every <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	    >Env</A
+	    ></TT
+	  > is given a <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	    >EnvLength</A
+	    ></TT
+	  > (using the
+   binary operator <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#v%3A%3C%3F%3E"
+	    >&lt;?&gt;</A
+	    ></TT
+	  >.
+   The whole sequence can be turnde into an <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	    >Env</A
+	    ></TT
+	  > (and be played then)
+   with <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#v%3ArunEnv"
+	    >runEnv</A
+	    ></TT
+	  >.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Env</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AEnv"
+	  ></A
+	  ><B
+	  >Env</B
+	  > = Int -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunEnv"
+	  ></A
+	  ><B
+	  >runEnv</B
+	  > :: [(<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	  >Env</A
+	  >, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	  >EnvLength</A
+	  >)] -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	  >Env</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3C%3F%3E"
+	  ></A
+	  ><B
+	  >(&lt;?&gt;)</B
+	  > :: (<A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+	  >IsEnv</A
+	  > a) =&gt; a -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	  >EnvLength</A
+	  > -&gt; (<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	  >Env</A
+	  >, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	  >EnvLength</A
+	  >)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AIsEnv"
+	  ></A
+	  ><B
+	  >IsEnv</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AtoEnv"
+		      ></A
+		      ><B
+		      >toEnv</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		      >Env</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		      >IsEnv</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		      >Env</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		      >IsEnv</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AInterpolate"
+		      >Interpolate</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		      >IsEnv</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AConstant"
+		      >Constant</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > EnvLength</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AcalculateEnvLengths"
+	  ></A
+	  ><B
+	  >calculateEnvLengths</B
+	  > :: Int -&gt; [<A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	  >EnvLength</A
+	  >] -&gt; [Int]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Takes an absolute total length and a list of EnvLengths. Each <TT
+	  ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	    >EnvLength</A
+	    ></TT
+	  > is mapped
+   to its length with respect to the total length and a resuming length that is
+   the result of <TT
+	  > total length - (all fixed lengths + all relative lengths) </TT
+	  >. 
+   This resuming lengths is distributed to the flexible lengths.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AEnvLength"
+	  ></A
+	  ><B
+	  >EnvLength</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > <TT
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		  >EnvLength</A
+		  ></TT
+		> represents the length of a segment of an Envelope. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAbs"
+		      ></A
+		      ><B
+		      >Abs</B
+		      > Int</TD
+		    ><TD CLASS = "rdoc"
+		    > A fixed length.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAbs_"
+		      ></A
+		      ><B
+		      >Abs_</B
+		      > Int</TD
+		    ><TD CLASS = "rdoc"
+		    > A fixed length that is not subtracted from the total time.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFlex"
+		      ></A
+		      ><B
+		      >Flex</B
+		      > Double</TD
+		    ><TD CLASS = "rdoc"
+		    > A flexible length. Resuming length is distributed to all 
+   flexible lengths proportionally to its value.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ARel"
+		      ></A
+		      ><B
+		      >Rel</B
+		      > (Ratio Int)</TD
+		    ><TD CLASS = "rdoc"
+		    > A length relative to the total length.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ARel_"
+		      ></A
+		      ><B
+		      >Rel_</B
+		      > (Ratio Int)</TD
+		    ><TD CLASS = "rdoc"
+		    > A relative length that is not subtracted from the total time.</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > [(<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		      >Env</A
+		      >, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		      >EnvLength</A
+		      >)]</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > ADSR</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AADSR"
+	  ></A
+	  ><B
+	  >ADSR</B
+	  > = (Int, Int, Double, Int)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > The four components of <TT
+	    ><A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+	      >ADSR</A
+	      ></TT
+	    > are:</P
+	  ><UL
+	  ><LI
+	    > Attack (time to reach value 1.0, starting from 0.0)</LI
+	    ><LI
+	    > Decay (time to reach sustain level)</LI
+	    ><LI
+	    > Sustain (level to hold until note is released, should be a value between 0.0 and 1.0)</LI
+	    ><LI
+	    > Release (time to reach value 0.0 after note is released)</LI
+	    ></UL
+	  ><P
+	  > time is measured in sample points, 44100 is one second.</P
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AEnvShape"
+	  ></A
+	  ><B
+	  >EnvShape</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A linear or a cosinus-like shape</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ALinear"
+		      ></A
+		      ><B
+		      >Linear</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ACosLike"
+		      ></A
+		      ><B
+		      >CosLike</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Eq <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		      >EnvShape</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Read <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		      >EnvShape</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Show <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		      >EnvShape</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AEnvMode"
+	  ></A
+	  ><B
+	  >EnvMode</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AHoldS"
+		      ></A
+		      ><B
+		      >HoldS</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > Sustain value is kept until duration is over, Release part is appended.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFitS"
+		      ></A
+		      ><B
+		      >FitS</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > Envelope has given duration by fitting only duration of constant Sustain level.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFitADR"
+		      ></A
+		      ><B
+		      >FitADR</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > Attack, Decay and Released are together stretched to given duration.</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Eq <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		      >EnvMode</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Read <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		      >EnvMode</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Show <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		      >EnvMode</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AplayADSR"
+	  ></A
+	  ><B
+	  >playADSR</B
+	  > :: <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+	  >EnvMode</A
+	  > -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+	  >EnvShape</A
+	  > -&gt; <A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+	  >ADSR</A
+	  > -&gt; Int -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Playing an ADSR</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > Here is the code of <TT
+	    ><A HREF = "Sound.Hommage.Envelope.html#v%3AplayADSR"
+	      >playADSR</A
+	      ></TT
+	    > to show the use of <TT
+	    ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+	      >Env</A
+	      ></TT
+	    >, <TT
+	    ><A HREF = "Sound.Hommage.Envelope.html#v%3A%3C%3F%3E"
+	      >&lt;?&gt;</A
+	      ></TT
+	    > and <TT
+	    ><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+	      >EnvLength</A
+	      ></TT
+	    >:</P
+	  ><PRE
+	  > playADSR :: EnvMode -&gt; EnvShape -&gt; ADSR -&gt; Int -&gt; [Double]
+ playADSR mode shape (a,d,s,r) = case mode of
+  FitADR -&gt; runEnv
+            [ Interpolate shape (0.0,1.0) &lt;?&gt; Flex (fromIntegral a)
+            , Interpolate shape (1.0, s) &lt;?&gt; Flex (fromIntegral d)
+            , Interpolate shape (s, 0.0) &lt;?&gt; Flex (fromIntegral r)
+            ]
+  FitS   -&gt; runEnv
+            [ Interpolate shape (0.0,1.0) &lt;?&gt; Abs a
+            , Interpolate shape (1.0, s) &lt;?&gt; Abs d
+            , Constant s &lt;?&gt; Flex 1.0
+            , Interpolate shape (s, 0.0) &lt;?&gt; Abs r
+            ]
+  HoldS  -&gt; runEnv
+            [ Interpolate shape (0.0,1.0) &lt;?&gt; Abs a
+            , Interpolate shape (1.0, s) &lt;?&gt; Abs d
+            , Constant s &lt;?&gt; Flex 1.0
+            , Interpolate shape (s, 0.0) &lt;?&gt; Abs_ r
+            ]</PRE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Interpolate</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AInterpolate"
+	  ></A
+	  ><B
+	  >Interpolate</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AInterpolate"
+		      ></A
+		      ><B
+		      >Interpolate</B
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		      >EnvShape</A
+		      > (Double, Double)</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		      >IsEnv</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AInterpolate"
+		      >Interpolate</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AInterpolate"
+		      >Interpolate</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AConstant"
+	  ></A
+	  ><B
+	  >Constant</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AConstant"
+		      ></A
+		      ><B
+		      >Constant</B
+		      > Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		      >IsEnv</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AConstant"
+		      >Constant</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ainterpolate"
+	  ></A
+	  ><B
+	  >interpolate</B
+	  > :: (Fractional a) =&gt; (a, a) -&gt; Int -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> produces a line with given length that starts with fst value and ends with snd value</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ainterpolate_cos"
+	  ></A
+	  ><B
+	  >interpolate_cos</B
+	  > :: (Floating a) =&gt; (a, a) -&gt; Int -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> produces a curve with given length that starts with fst value and ends with snd value. 
+   this curve has the shape of a half cosinus curve (values for 0 to PI).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.FFT.html view
@@ -0,0 +1,801 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.FFT</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.FFT</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > FFT</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > FFT</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> This module implements the Fast Fourier Transformation purely in Haskell.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft"
+		>fft</A
+		> :: Int -&gt; [Double] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft'"
+		>fft'</A
+		> :: Int -&gt; [Complex Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afftt"
+		>fftt</A
+		> :: Int -&gt; ([[Complex Double]] -&gt; [Complex Double]) -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afftc"
+		>fftc</A
+		> :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afftc'"
+		>fftc'</A
+		> :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Affttv"
+		>ffttv</A
+		> :: Int -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afftco"
+		>fftco</A
+		> :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afftco'"
+		>fftco'</A
+		> :: Int -&gt; [Complex Double] -&gt; [Complex Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arect_transform"
+		>rect_transform</A
+		> :: (Floating a) =&gt; Int -&gt; [a] -&gt; [[a]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arect_filter"
+		>rect_filter</A
+		> :: (Floating a) =&gt; Int -&gt; ([[a]] -&gt; [[a]]) -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arect_filter'"
+		>rect_filter'</A
+		> :: (Floating a) =&gt; Int -&gt; [[a]] -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ai"
+		>i</A
+		> :: Complex Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aw"
+		>w</A
+		> :: Int -&gt; Complex Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aws"
+		>ws</A
+		> :: Bool -&gt; Int -&gt; [Complex Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amap2"
+		>map2</A
+		> :: (a -&gt; a -&gt; b) -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Azip2"
+		>zip2</A
+		> :: [a] -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aappendpair"
+		>appendpair</A
+		> :: ([a], [a]) -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Areorder"
+		>reorder</A
+		> :: Int -&gt; [[a]] -&gt; [[a]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Areorder_init'"
+		>reorder_init'</A
+		> :: [a] -&gt; [[a]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abutterfly"
+		>butterfly</A
+		> :: Complex Double -&gt; Complex Double -&gt; Complex Double -&gt; (Complex Double, Complex Double)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abutterfly'"
+		>butterfly'</A
+		> :: Complex Double -&gt; Complex Double -&gt; Complex Double -&gt; (Complex Double, Complex Double)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft_level"
+		>fft_level</A
+		> :: [Complex Double] -&gt; [[Complex Double]] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft_merge"
+		>fft_merge</A
+		> :: [Complex Double] -&gt; [Complex Double] -&gt; [Complex Double] -&gt; ([Complex Double], [Complex Double])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft_level'"
+		>fft_level'</A
+		> :: [Complex Double] -&gt; [[Complex Double]] -&gt; [[Complex Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afft_merge'"
+		>fft_merge'</A
+		> :: [Complex Double] -&gt; [Complex Double] -&gt; [Complex Double] -&gt; ([Complex Double], [Complex Double])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aoverlap_curve"
+		>overlap_curve</A
+		> :: Int -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amix_overlap"
+		>mix_overlap</A
+		> :: Int -&gt; [[Double]] -&gt; [Double]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > FFT</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft"
+	  ></A
+	  ><B
+	  >fft</B
+	  > :: Int -&gt; [Double] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> FFT transformation. Input is grouped into overlapping parts of 2^(N+2) reals and mapped to sublists 
+   with 2^(N+1) complex numbers. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft'"
+	  ></A
+	  ><B
+	  >fft'</B
+	  > :: Int -&gt; [Complex Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Inverse FFT transformation. Complex input is grouped into parts with length 2^(N+1) and mapped to 
+   sublists with 2^(N+2) reals, which are overlapped and mixed.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afftt"
+	  ></A
+	  ><B
+	  >fftt</B
+	  > :: Int -&gt; ([[Complex Double]] -&gt; [Complex Double]) -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> FFT transformation with overlapping and windowing. 
+   Argument function maps the coefficients. Windowsize: 2^(N+2), i. e. 2^(N+1) coefficients</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > FFT</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afftc"
+	  ></A
+	  ><B
+	  >fftc</B
+	  > :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> FFT transformation for complex input (segments of length 2^n). 
+   No overlapping or windowing.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afftc'"
+	  ></A
+	  ><B
+	  >fftc'</B
+	  > :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Inverse FFT transformation for complex input (segments of length 2^n). 
+   No overlapping or windowing.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Affttv"
+	  ></A
+	  ><B
+	  >ffttv</B
+	  > :: Int -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afftco"
+	  ></A
+	  ><B
+	  >fftco</B
+	  > :: Int -&gt; [Complex Double] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> FFT for complex input with overlapping. Segment-size: 2^(n+1)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afftco'"
+	  ></A
+	  ><B
+	  >fftco'</B
+	  > :: Int -&gt; [Complex Double] -&gt; [Complex Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arect_transform"
+	  ></A
+	  ><B
+	  >rect_transform</B
+	  > :: (Floating a) =&gt; Int -&gt; [a] -&gt; [[a]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A self-inverse transformation similar to FFT but with a simple butterfly
+   operation that uses always W=1. Modifying the data between application
+   and inverse is similar to filtering but the result will be built up from
+   rectangle waves instead of sinus waves.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arect_filter"
+	  ></A
+	  ><B
+	  >rect_filter</B
+	  > :: (Floating a) =&gt; Int -&gt; ([[a]] -&gt; [[a]]) -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arect_filter'"
+	  ></A
+	  ><B
+	  >rect_filter'</B
+	  > :: (Floating a) =&gt; Int -&gt; [[a]] -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ai"
+	  ></A
+	  ><B
+	  >i</B
+	  > :: Complex Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The complex value <TT
+	  ><A HREF = "Sound.Hommage.FFT.html#v%3Ai"
+	    >i</A
+	    ></TT
+	  > = <TT
+	  >(0 :+ 1)</TT
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aw"
+	  ></A
+	  ><B
+	  >w</B
+	  > :: Int -&gt; Complex Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The n-th root of 1</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aws"
+	  ></A
+	  ><B
+	  >ws</B
+	  > :: Bool -&gt; Int -&gt; [Complex Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> the 2n-th root with exponents 0, 1, .. n. False=inverse (exponents are negated)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amap2"
+	  ></A
+	  ><B
+	  >map2</B
+	  > :: (a -&gt; a -&gt; b) -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Azip2"
+	  ></A
+	  ><B
+	  >zip2</B
+	  > :: [a] -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aappendpair"
+	  ></A
+	  ><B
+	  >appendpair</B
+	  > :: ([a], [a]) -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Areorder"
+	  ></A
+	  ><B
+	  >reorder</B
+	  > :: Int -&gt; [[a]] -&gt; [[a]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> list is grouped into sublists with length N (must be power of 2) and bitwise reverse order</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Areorder_init'"
+	  ></A
+	  ><B
+	  >reorder_init'</B
+	  > :: [a] -&gt; [[a]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abutterfly"
+	  ></A
+	  ><B
+	  >butterfly</B
+	  > :: Complex Double -&gt; Complex Double -&gt; Complex Double -&gt; (Complex Double, Complex Double)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abutterfly'"
+	  ></A
+	  ><B
+	  >butterfly'</B
+	  > :: Complex Double -&gt; Complex Double -&gt; Complex Double -&gt; (Complex Double, Complex Double)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft_level"
+	  ></A
+	  ><B
+	  >fft_level</B
+	  > :: [Complex Double] -&gt; [[Complex Double]] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft_merge"
+	  ></A
+	  ><B
+	  >fft_merge</B
+	  > :: [Complex Double] -&gt; [Complex Double] -&gt; [Complex Double] -&gt; ([Complex Double], [Complex Double])</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft_level'"
+	  ></A
+	  ><B
+	  >fft_level'</B
+	  > :: [Complex Double] -&gt; [[Complex Double]] -&gt; [[Complex Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afft_merge'"
+	  ></A
+	  ><B
+	  >fft_merge'</B
+	  > :: [Complex Double] -&gt; [Complex Double] -&gt; [Complex Double] -&gt; ([Complex Double], [Complex Double])</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aoverlap_curve"
+	  ></A
+	  ><B
+	  >overlap_curve</B
+	  > :: Int -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a fade with length N</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amix_overlap"
+	  ></A
+	  ><B
+	  >mix_overlap</B
+	  > :: Int -&gt; [[Double]] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Overlaps a sequence of parts of length N (overlaps by N/2).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Filter.html view
@@ -0,0 +1,797 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Filter</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Filter</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Filters</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > FilterSpec</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > FilterSpec and Lists</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Other</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > Filterfunctions</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Alowpass"
+		>lowpass</A
+		> :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ahighpass"
+		>highpass</A
+		> :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abandpass"
+		>bandpass</A
+		> :: [Double] -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Astretchpass"
+		>stretchpass</A
+		> :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amorphpass"
+		>morphpass</A
+		> :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AFilterSpec"
+		>FilterSpec</A
+		> = [(Int, Double)]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AshiftFilterSpec"
+		>shiftFilterSpec</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterSpecToList"
+		>filterSpecToList</A
+		> :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterSpecsToLists"
+		>filterSpecsToLists</A
+		> :: [(Int, <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		>)] -&gt; [[Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinterpolFilterLists"
+		>interpolFilterLists</A
+		> :: [Double] -&gt; [Double] -&gt; Double -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Affreq"
+		>ffreq</A
+		> :: Double -&gt; Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Affreqi"
+		>ffreqi</A
+		> :: Double -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aaverage512"
+		>average512</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AlowpassFS"
+		>lowpassFS</A
+		> :: Double -&gt; Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AhighpassFS"
+		>highpassFS</A
+		> :: Double -&gt; Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AbandpassFS"
+		>bandpassFS</A
+		> :: Double -&gt; Double -&gt; Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Alowp0FS"
+		>lowp0FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Alowp1FS"
+		>lowp1FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abandp0FS"
+		>bandp0FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abandp1FS"
+		>bandp1FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ahighp0FS"
+		>highp0FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ahighp1FS"
+		>highp1FS</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Filters</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Alowpass"
+	  ></A
+	  ><B
+	  >lowpass</B
+	  > :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ahighpass"
+	  ></A
+	  ><B
+	  >highpass</B
+	  > :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abandpass"
+	  ></A
+	  ><B
+	  >bandpass</B
+	  > :: [Double] -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Astretchpass"
+	  ></A
+	  ><B
+	  >stretchpass</B
+	  > :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  > -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amorphpass"
+	  ></A
+	  ><B
+	  >morphpass</B
+	  > :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  > -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  > -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AFilterSpec"
+	  ></A
+	  ><B
+	  >FilterSpec</B
+	  > = [(Int, Double)]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Filtering starts at coeff nr 0 and value 0.0 (constant coeff is always zero). 
+   The elements in FilterSpec define the next value and how many 
+   coeffs it takes to reach this value. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AshiftFilterSpec"
+	  ></A
+	  ><B
+	  >shiftFilterSpec</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  > -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> 0..1: lower, 1..: higher</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > FilterSpec and Lists</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterSpecToList"
+	  ></A
+	  ><B
+	  >filterSpecToList</B
+	  > :: <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  > -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Converting a FilterSpec to a list of 512 Doubles</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterSpecsToLists"
+	  ></A
+	  ><B
+	  >filterSpecsToLists</B
+	  > :: [(Int, <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  >)] -&gt; [[Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Converting and interpolating a sequence of FilterSpecs to a list of lists. The first elemet of the
+ tuple, an Int, describes how many lists it takes to reach the given FilterSpec. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinterpolFilterLists"
+	  ></A
+	  ><B
+	  >interpolFilterLists</B
+	  > :: [Double] -&gt; [Double] -&gt; Double -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Other</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Affreq"
+	  ></A
+	  ><B
+	  >ffreq</B
+	  > :: Double -&gt; Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> for filter coefficient number: (0.0 .. 1.0) -&gt; (1.0 .. 512.0)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Affreqi"
+	  ></A
+	  ><B
+	  >ffreqi</B
+	  > :: Double -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> floor of <TT
+	  ><A HREF = "Sound.Hommage.Filter.html#v%3Affreq"
+	    >ffreq</A
+	    ></TT
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aaverage512"
+	  ></A
+	  ><B
+	  >average512</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> the resulting list is 1 / 512 as long as the input list. 
+   512 elements are read and their average is the next output value.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > Filterfunctions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AlowpassFS"
+	  ></A
+	  ><B
+	  >lowpassFS</B
+	  > :: Double -&gt; Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AhighpassFS"
+	  ></A
+	  ><B
+	  >highpassFS</B
+	  > :: Double -&gt; Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AbandpassFS"
+	  ></A
+	  ><B
+	  >bandpassFS</B
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >:: Double</TD
+	      ><TD CLASS = "rdoc"
+	      > width of freq-window</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		></TD
+	      ><TD CLASS = "rdoc"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "ndoc" COLSPAN = "2"
+	      > range, curve, cutoff</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Alowp0FS"
+	  ></A
+	  ><B
+	  >lowp0FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Alowp1FS"
+	  ></A
+	  ><B
+	  >lowp1FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abandp0FS"
+	  ></A
+	  ><B
+	  >bandp0FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abandp1FS"
+	  ></A
+	  ><B
+	  >bandp1FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ahighp0FS"
+	  ></A
+	  ><B
+	  >highp0FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ahighp1FS"
+	  ></A
+	  ><B
+	  >highp1FS</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+	  >FilterSpec</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Midi.html view
@@ -0,0 +1,1368 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Midi</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Midi</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > MidiFile</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > MidiNote</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > MidiMusic </A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > MidiTrack</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > MidiEvent</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#6"
+		    > Encoding</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AMidiFile"
+		      >MidiFile</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AMidiSync"
+			    >MidiSync</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+			    >Ticks</A
+			    > [<A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+			    >MidiTrack</A
+			    >]</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiSingle"
+			    >MidiSingle</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+			    >Ticks</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+			    >MidiTrack</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiAsync"
+			    >MidiAsync</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+			    >Ticks</A
+			    > [<A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+			    >MidiTrack</A
+			    >]</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteMidiFile"
+		>writeMidiFile</A
+		> :: FilePath -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+		>MidiFile</A
+		> -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3ATicks"
+		>Ticks</A
+		> = Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AMidiNote"
+		      >MidiNote</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AMidiNote"
+			    >MidiNote</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiCtrl"
+			    >MidiCtrl</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AChan"
+		>Chan</A
+		> = Word8</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AMidiValue"
+		>MidiValue</A
+		> = Word8</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AMidiMusic"
+		>MidiMusic</A
+		> = [(<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+		>Delta</A
+		>, Maybe <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+		>MidiEvent</A
+		>)]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnoteMidiMusic"
+		>noteMidiMusic</A
+		> :: Int -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+		>MidiNote</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArestMidiMusic"
+		>restMidiMusic</A
+		> :: Int -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AappendMidiMusic"
+		>appendMidiMusic</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmergeMidiMusic"
+		>mergeMidiMusic</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunMidiMusic"
+		>runMidiMusic</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		> -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		>MidiTrack</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AMidiTrack"
+		>MidiTrack</A
+		> = [(<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+		>Delta</A
+		>, <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+		>MidiEvent</A
+		>)]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3ADelta"
+		>Delta</A
+		> = Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AMidiEvent"
+		      >MidiEvent</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AMidiNoteOff"
+			    >MidiNoteOff</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiNoteOn"
+			    >MidiNoteOn</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiKeyAfter"
+			    >MidiKeyAfter</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiControl"
+			    >MidiControl</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+			    >Chan</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+			    >MidiValue</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AMidiEndOfTrack"
+			    >MidiEndOfTrack</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeMidiFile"
+		>encodeMidiFile</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+		>MidiFile</A
+		> -&gt; [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmidiHeaderSync"
+		>midiHeaderSync</A
+		> :: [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmidiHeaderSingle"
+		>midiHeaderSingle</A
+		> :: [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmidiHeaderAsync"
+		>midiHeaderAsync</A
+		> :: [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeMidiTrack"
+		>encodeMidiTrack</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		>MidiTrack</A
+		> -&gt; [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeDelta"
+		>encodeDelta</A
+		> :: Int -&gt; [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeMidiDeltaEvent"
+		>encodeMidiDeltaEvent</A
+		> :: (<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+		>Delta</A
+		>, <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+		>MidiEvent</A
+		>) -&gt; [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeEvent"
+		>encodeEvent</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+		>MidiEvent</A
+		> -&gt; [Word8]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AlastByte"
+		>lastByte</A
+		> :: Int -&gt; Word8</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnextByte"
+		>nextByte</A
+		> :: Int -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtoBytes"
+		>toBytes</A
+		> :: Int -&gt; Int -&gt; [Word8]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The action <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3AwriteMidiFile"
+	    >writeMidiFile</A
+	    ></TT
+	  > stores the datatype <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+	    >MidiFile</A
+	    ></TT
+	  > in a MIDI-File. 
+   It consists of a field for the <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+	    >Ticks</A
+	    ></TT
+	  > per quarter and a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+	    >MidiTrack</A
+	    ></TT
+	  > (or some). 
+   The function <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3ArunMidiMusic"
+	    >runMidiMusic</A
+	    ></TT
+	  > produces such a track from a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	    >MidiMusic</A
+	    ></TT
+	  >, which can
+   be created using the functions <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3AnoteMidiMusic"
+	    >noteMidiMusic</A
+	    ></TT
+	  >, <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3ArestMidiMusic"
+	    >restMidiMusic</A
+	    ></TT
+	  >, <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3AappendMidiMusic"
+	    >appendMidiMusic</A
+	    ></TT
+	  > and
+   <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#v%3AmergeMidiMusic"
+	    >mergeMidiMusic</A
+	    ></TT
+	  >. 
+   <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+	    >MidiNote</A
+	    ></TT
+	  > is used to create note or controller events; it consists of the Midi-Channel
+   (<TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+	    >Chan</A
+	    ></TT
+	  >) and two fields with a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+	    >MidiValue</A
+	    ></TT
+	  >.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > MidiFile</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AMidiFile"
+	  ></A
+	  ><B
+	  >MidiFile</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiSync"
+		      ></A
+		      ><B
+		      >MidiSync</B
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+		      >Ticks</A
+		      > [<A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		      >MidiTrack</A
+		      >]</TD
+		    ><TD CLASS = "rdoc"
+		    > Some parallel (synchronous) MidiTracks. </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiSingle"
+		      ></A
+		      ><B
+		      >MidiSingle</B
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+		      >Ticks</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		      >MidiTrack</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > A single MidiTrack. (Seems not to work yet)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiAsync"
+		      ></A
+		      ><B
+		      >MidiAsync</B
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+		      >Ticks</A
+		      > [<A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		      >MidiTrack</A
+		      >]</TD
+		    ><TD CLASS = "rdoc"
+		    > Some asynchronous MidiTracks. (Seems not to work yet)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteMidiFile"
+	  ></A
+	  ><B
+	  >writeMidiFile</B
+	  > :: FilePath -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+	  >MidiFile</A
+	  > -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Writes a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+	    >MidiFile</A
+	    ></TT
+	  > to a File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3ATicks"
+	  ></A
+	  ><B
+	  >Ticks</B
+	  > = Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Ticks per Quarter. For some unknown reasons it does not work with any value.
+   96 seems to be ok. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > MidiNote</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AMidiNote"
+	  ></A
+	  ><B
+	  >MidiNote</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiNote"
+		      ></A
+		      ><B
+		      >MidiNote</B
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > A note with pitch and volume</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiCtrl"
+		      ></A
+		      ><B
+		      >MidiCtrl</B
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > Controllernumber and value</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AChan"
+	  ></A
+	  ><B
+	  >Chan</B
+	  > = Word8</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A Midi-Channel (0-15)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AMidiValue"
+	  ></A
+	  ><B
+	  >MidiValue</B
+	  > = Word8</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A Midi-Value (0-127)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > MidiMusic </A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AMidiMusic"
+	  ></A
+	  ><B
+	  >MidiMusic</B
+	  > = [(<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+	  >Delta</A
+	  >, Maybe <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+	  >MidiEvent</A
+	  >)]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A kind of extended MidiTrack type, that allows delta-times without events 
+   (will be summed up by converting to <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+	    >MidiTrack</A
+	    ></TT
+	  >).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnoteMidiMusic"
+	  ></A
+	  ><B
+	  >noteMidiMusic</B
+	  > :: Int -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+	  >MidiNote</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a note or controller event with given length (relative to <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+	    >Ticks</A
+	    ></TT
+	  >). 
+   The length means the delta-time between note-on and note-off resp. the time after
+   the controller event.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArestMidiMusic"
+	  ></A
+	  ><B
+	  >restMidiMusic</B
+	  > :: Int -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A pause with given length.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AappendMidiMusic"
+	  ></A
+	  ><B
+	  >appendMidiMusic</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Sequencial composition of <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	    >MidiMusic</A
+	    ></TT
+	  >.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmergeMidiMusic"
+	  ></A
+	  ><B
+	  >mergeMidiMusic</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Parallel composition of <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	    >MidiMusic</A
+	    ></TT
+	  >.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunMidiMusic"
+	  ></A
+	  ><B
+	  >runMidiMusic</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  > -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+	  >MidiTrack</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Converts a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	    >MidiMusic</A
+	    ></TT
+	  > to a <TT
+	  ><A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+	    >MidiTrack</A
+	    ></TT
+	  >. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > MidiTrack</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AMidiTrack"
+	  ></A
+	  ><B
+	  >MidiTrack</B
+	  > = [(<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+	  >Delta</A
+	  >, <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+	  >MidiEvent</A
+	  >)]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A sequence of MidiEvents with a delta-time which means the number of ticks
+   before the event happens (relative to the last event). </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3ADelta"
+	  ></A
+	  ><B
+	  >Delta</B
+	  > = Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > MidiEvent</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AMidiEvent"
+	  ></A
+	  ><B
+	  >MidiEvent</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiNoteOff"
+		      ></A
+		      ><B
+		      >MidiNoteOff</B
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiNoteOn"
+		      ></A
+		      ><B
+		      >MidiNoteOn</B
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiKeyAfter"
+		      ></A
+		      ><B
+		      >MidiKeyAfter</B
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiControl"
+		      ></A
+		      ><B
+		      >MidiControl</B
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		      >Chan</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      > !<A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		      >MidiValue</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMidiEndOfTrack"
+		      ></A
+		      ><B
+		      >MidiEndOfTrack</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "6"
+	  > Encoding</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeMidiFile"
+	  ></A
+	  ><B
+	  >encodeMidiFile</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+	  >MidiFile</A
+	  > -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmidiHeaderSync"
+	  ></A
+	  ><B
+	  >midiHeaderSync</B
+	  > :: [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmidiHeaderSingle"
+	  ></A
+	  ><B
+	  >midiHeaderSingle</B
+	  > :: [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmidiHeaderAsync"
+	  ></A
+	  ><B
+	  >midiHeaderAsync</B
+	  > :: [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeMidiTrack"
+	  ></A
+	  ><B
+	  >encodeMidiTrack</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+	  >MidiTrack</A
+	  > -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeDelta"
+	  ></A
+	  ><B
+	  >encodeDelta</B
+	  > :: Int -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeMidiDeltaEvent"
+	  ></A
+	  ><B
+	  >encodeMidiDeltaEvent</B
+	  > :: (<A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+	  >Delta</A
+	  >, <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+	  >MidiEvent</A
+	  >) -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeEvent"
+	  ></A
+	  ><B
+	  >encodeEvent</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+	  >MidiEvent</A
+	  > -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AlastByte"
+	  ></A
+	  ><B
+	  >lastByte</B
+	  > :: Int -&gt; Word8</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnextByte"
+	  ></A
+	  ><B
+	  >nextByte</B
+	  > :: Int -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtoBytes"
+	  ></A
+	  ><B
+	  >toBytes</B
+	  > :: Int -&gt; Int -&gt; [Word8]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Misc.html view
@@ -0,0 +1,713 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Misc</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Misc</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Imperative control structure</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Usefull list functions </A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > More usefull functions</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Embedding IO in a list (-map)</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afor"
+		>for</A
+		> :: (Monad m) =&gt; a -&gt; (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; (a -&gt; m b) -&gt; m ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afor'"
+		>for'</A
+		> :: (Monad m) =&gt; a -&gt; (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; b -&gt; (a -&gt; b -&gt; m b) -&gt; m b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amap_"
+		>map_</A
+		> :: (a -&gt; b) -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afoldr_"
+		>foldr_</A
+		> :: (a -&gt; b -&gt; b) -&gt; b -&gt; [a] -&gt; b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amerge"
+		>merge</A
+		> :: (a -&gt; a -&gt; a) -&gt; [a] -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmergeSet"
+		>mergeSet</A
+		> :: ([a] -&gt; b) -&gt; [[a]] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Auneitherlist"
+		>uneitherlist</A
+		> :: [Either a b] -&gt; ([a], [b])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Awalk"
+		>walk</A
+		> :: ([a] -&gt; [b]) -&gt; [a] -&gt; ([a], [b])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aappendmaps"
+		>appendmaps</A
+		> :: [[a] -&gt; [b]] -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aappendmaps'"
+		>appendmaps'</A
+		> :: [[a] -&gt; [b]] -&gt; [a] -&gt; [[b]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aqsort"
+		>qsort</A
+		> :: (a -&gt; a -&gt; Bool) -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AqsortM"
+		>qsortM</A
+		> :: (Monad m) =&gt; (a -&gt; a -&gt; m Bool) -&gt; [a] -&gt; m [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Ahead_opt"
+		>head_opt</A
+		> :: a -&gt; [a] -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnewFilePath"
+		>newFilePath</A
+		> :: (Int -&gt; FilePath) -&gt; IO FilePath</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinList"
+		>inList</A
+		> :: IO (Maybe a -&gt; IO (Maybe b)) -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinList'"
+		>inList'</A
+		> :: IO (a -&gt; IO b) -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinList''"
+		>inList''</A
+		> :: IO (a -&gt; IO (Maybe b)) -&gt; [a] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtoList"
+		>toList</A
+		> :: IO (IO a) -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtoList'"
+		>toList'</A
+		> :: IO (IO (Maybe a)) -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinListE"
+		>inListE</A
+		> :: IO (Either (Maybe a -&gt; IO (Maybe b)) (Maybe a -&gt; IO (Maybe c))) -&gt; [a] -&gt; Either [b] [c]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinListE'"
+		>inListE'</A
+		> :: IO (Either (a -&gt; IO b) (a -&gt; IO c)) -&gt; [a] -&gt; Either [b] [c]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinListE''"
+		>inListE''</A
+		> :: IO (Either (a -&gt; IO (Maybe b)) (a -&gt; IO (Maybe c))) -&gt; [a] -&gt; Either [b] [c]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtoListE"
+		>toListE</A
+		> :: IO (Either (IO a) (IO b)) -&gt; Either [a] [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtoListE'"
+		>toListE'</A
+		> :: IO (Either (IO (Maybe a)) (IO (Maybe b))) -&gt; Either [a] [b]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Imperative control structure</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afor"
+	  ></A
+	  ><B
+	  >for</B
+	  > :: (Monad m) =&gt; a -&gt; (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; (a -&gt; m b) -&gt; m ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afor'"
+	  ></A
+	  ><B
+	  >for'</B
+	  > :: (Monad m) =&gt; a -&gt; (a -&gt; Bool) -&gt; (a -&gt; a) -&gt; b -&gt; (a -&gt; b -&gt; m b) -&gt; m b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Usefull list functions </A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amap_"
+	  ></A
+	  ><B
+	  >map_</B
+	  > :: (a -&gt; b) -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> a pseudo-strict map version. does not touch the elements but reconstructs the whole list 
+   structure before the function is applied to the value</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afoldr_"
+	  ></A
+	  ><B
+	  >foldr_</B
+	  > :: (a -&gt; b -&gt; b) -&gt; b -&gt; [a] -&gt; b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> a pseudo-strict foldr version. does not touch the elements but reconstructs the whole list 
+   structure  before the function is applied to the values. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amerge"
+	  ></A
+	  ><B
+	  >merge</B
+	  > :: (a -&gt; a -&gt; a) -&gt; [a] -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Similar to zipWith, but the result has the length of the longer input list.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmergeSet"
+	  ></A
+	  ><B
+	  >mergeSet</B
+	  > :: ([a] -&gt; b) -&gt; [[a]] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Auneitherlist"
+	  ></A
+	  ><B
+	  >uneitherlist</B
+	  > :: [Either a b] -&gt; ([a], [b])</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Awalk"
+	  ></A
+	  ><B
+	  >walk</B
+	  > :: ([a] -&gt; [b]) -&gt; [a] -&gt; ([a], [b])</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aappendmaps"
+	  ></A
+	  ><B
+	  >appendmaps</B
+	  > :: [[a] -&gt; [b]] -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aappendmaps'"
+	  ></A
+	  ><B
+	  >appendmaps'</B
+	  > :: [[a] -&gt; [b]] -&gt; [a] -&gt; [[b]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aqsort"
+	  ></A
+	  ><B
+	  >qsort</B
+	  > :: (a -&gt; a -&gt; Bool) -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AqsortM"
+	  ></A
+	  ><B
+	  >qsortM</B
+	  > :: (Monad m) =&gt; (a -&gt; a -&gt; m Bool) -&gt; [a] -&gt; m [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > More usefull functions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Ahead_opt"
+	  ></A
+	  ><B
+	  >head_opt</B
+	  > :: a -&gt; [a] -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnewFilePath"
+	  ></A
+	  ><B
+	  >newFilePath</B
+	  > :: (Int -&gt; FilePath) -&gt; IO FilePath</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> the given function must create a filepath using the Int-argument. The filepath must be 
+   different for different arguments. <TT
+	  ><A HREF = "Sound.Hommage.Misc.html#v%3AnewFilePath"
+	    >newFilePath</A
+	    ></TT
+	  > works like Gödels mu-operator and terminates 
+   only if the filepath does not exist.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Embedding IO in a list (-map)</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinList"
+	  ></A
+	  ><B
+	  >inList</B
+	  > :: IO (Maybe a -&gt; IO (Maybe b)) -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinList'"
+	  ></A
+	  ><B
+	  >inList'</B
+	  > :: IO (a -&gt; IO b) -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinList''"
+	  ></A
+	  ><B
+	  >inList''</B
+	  > :: IO (a -&gt; IO (Maybe b)) -&gt; [a] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtoList"
+	  ></A
+	  ><B
+	  >toList</B
+	  > :: IO (IO a) -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtoList'"
+	  ></A
+	  ><B
+	  >toList'</B
+	  > :: IO (IO (Maybe a)) -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinListE"
+	  ></A
+	  ><B
+	  >inListE</B
+	  > :: IO (Either (Maybe a -&gt; IO (Maybe b)) (Maybe a -&gt; IO (Maybe c))) -&gt; [a] -&gt; Either [b] [c]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinListE'"
+	  ></A
+	  ><B
+	  >inListE'</B
+	  > :: IO (Either (a -&gt; IO b) (a -&gt; IO c)) -&gt; [a] -&gt; Either [b] [c]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinListE''"
+	  ></A
+	  ><B
+	  >inListE''</B
+	  > :: IO (Either (a -&gt; IO (Maybe b)) (a -&gt; IO (Maybe c))) -&gt; [a] -&gt; Either [b] [c]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtoListE"
+	  ></A
+	  ><B
+	  >toListE</B
+	  > :: IO (Either (IO a) (IO b)) -&gt; Either [a] [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtoListE'"
+	  ></A
+	  ><B
+	  >toListE'</B
+	  > :: IO (Either (IO (Maybe a)) (IO (Maybe b))) -&gt; Either [a] [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Notation.html view
@@ -0,0 +1,2053 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Notation</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Notation</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Duration</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Music Notation</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > Musical class</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Notation and Midi </A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > More Notation functions</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3ADur"
+		>Dur</A
+		> = Ratio Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AabsDur"
+		>absDur</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AIsDur"
+		>IsDur</A
+		> d  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AdurFrom"
+		      >durFrom</A
+		      > :: d -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AdurUpdate"
+		      >durUpdate</A
+		      > :: (<A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      >) -&gt; d -&gt; d</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3AWithDur"
+		>WithDur</A
+		> d a = <A HREF = "#v%3AWithDur"
+		>WithDur</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AunWithDur"
+		      >unWithDur</A
+		      > :: (d -&gt; a)</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3ANotation"
+		      >Notation</A
+		      > a</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3ANote"
+			    >Note</A
+			    > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    > a</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ARest"
+			    >Rest</A
+			    > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3A%3A%2B%3A"
+			    >(:+:)</A
+			    > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+			    >Notation</A
+			    > a) (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+			    >Notation</A
+			    > a)</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3A%3A%3D%3A"
+			    >(:=:)</A
+			    > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+			    >Notation</A
+			    > a) (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+			    >Notation</A
+			    > a)</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AStretch"
+			    >Stretch</A
+			    > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+			    >Notation</A
+			    > a)</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunNotation"
+		>runNotation</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> m) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> m -&gt; m</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunNotationWith"
+		>runNotationWith</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> m) =&gt; (a -&gt; m) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; m</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AStretchable"
+		>Stretchable</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Astretch"
+		      >stretch</A
+		      > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > -&gt; a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AArrangeable"
+		>Arrangeable</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Aparallel"
+		      >parallel</A
+		      > :: a -&gt; a -&gt; a</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Asequent"
+		      >sequent</A
+		      > :: a -&gt; a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> (<A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		>Stretchable</A
+		> a, <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		>Arrangeable</A
+		> a) =&gt; <A HREF = "#t%3AMusical"
+		>Musical</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Arest"
+		      >rest</A
+		      > :: a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arest0"
+		>rest0</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> a) =&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A-%3D-"
+		>(-=-)</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		>Arrangeable</A
+		> a) =&gt; a -&gt; a -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A-%3E-"
+		>(-&gt;-)</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		>Arrangeable</A
+		> a) =&gt; a -&gt; a -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aline"
+		>line</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> a) =&gt; [a] -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aline'"
+		>line'</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> a) =&gt; [a] -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Achord"
+		>chord</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> a) =&gt; [a] -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aproportional"
+		>proportional</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> a) =&gt; (Int, Int) -&gt; a -&gt; a -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteMidiSyncNotation"
+		>writeMidiSyncNotation</A
+		> :: FilePath -&gt; [<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+		>MidiNote</A
+		>] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amidi"
+		>midi</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		>IsDur</A
+		> d) =&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+		>MidiNote</A
+		> -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amidi'"
+		>midi'</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		>IsDur</A
+		> d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+		>MidiNote</A
+		> -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmidiSyncFile"
+		>midiSyncFile</A
+		> :: <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+		>Ticks</A
+		> -&gt; [<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		>MidiMusic</A
+		>] -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+		>MidiFile</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Anote"
+		>note</A
+		> :: a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmapNotation"
+		>mapNotation</A
+		> :: (a -&gt; b) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AjoinNotation"
+		>joinNotation</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AunmaybeNotation"
+		>unmaybeNotation</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (Maybe a) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AdurationNotation"
+		>durationNotation</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; Ratio Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ApositionNotation"
+		>positionNotation</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		>, a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreverseNotation"
+		>reverseNotation</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtakeNotation"
+		>takeNotation</A
+		> :: Ratio Int -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AdropNotation"
+		>dropNotation</A
+		> :: Ratio Int -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterNotation"
+		>filterNotation</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> (m a), Monad m) =&gt; (a -&gt; Bool) -&gt; m a -&gt; m a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterNotation'"
+		>filterNotation'</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> (m a), <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		>Musical</A
+		> (m b), Monad m) =&gt; (a -&gt; Maybe b) -&gt; m a -&gt; m b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsequenceNotation"
+		>sequenceNotation</A
+		> :: (a -&gt; b -&gt; c) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> -&gt; [a] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> b -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> c</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Duration</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3ADur"
+	  ></A
+	  ><B
+	  >Dur</B
+	  > = Ratio Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The duration (of a note, e. g).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AabsDur"
+	  ></A
+	  ><B
+	  >absDur</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Calculates the absolute duration by dividing the numerator with the denominator. 
+   Because of rounding error this makes only sense if the result is a relative big 
+   number. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AIsDur"
+	  ></A
+	  ><B
+	  >IsDur</B
+	  > d  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AdurFrom"
+		      ></A
+		      ><B
+		      >durFrom</B
+		      > :: d -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AdurUpdate"
+		      ></A
+		      ><B
+		      >durUpdate</B
+		      > :: (<A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      >) -&gt; d -&gt; d</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		      >Duration</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3AWithDur"
+	  ></A
+	  ><B
+	  >WithDur</B
+	  > d a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AWithDur"
+		      ></A
+		      ><B
+		      >WithDur</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunWithDur"
+			    ></A
+			    ><B
+			    >unWithDur</B
+			    > :: (d -&gt; a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d, <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		      >MidiMusic</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Music Notation</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ANotation"
+	  ></A
+	  ><B
+	  >Notation</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A <TT
+		><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		  >Notation</A
+		  ></TT
+		> is a constant, tree-like structure that represents a musical
+   notation. It has a type parameter for flexible usage reasons. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ANote"
+		      ></A
+		      ><B
+		      >Note</B
+		      > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > a</TD
+		    ><TD CLASS = "rdoc"
+		    > A note with given duration and a value of type <TT
+		      >a</TT
+		      >.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ARest"
+		      ></A
+		      ><B
+		      >Rest</B
+		      > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > A rest with given duration.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3A%3A%2B%3A"
+		      ></A
+		      ><B
+		      >(:+:)</B
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a) (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ><TD CLASS = "rdoc"
+		    > Sequential composition of two notations.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3A%3A%3D%3A"
+		      ></A
+		      ><B
+		      >(:=:)</B
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a) (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ><TD CLASS = "rdoc"
+		    > Parallel composition of two notations.</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AStretch"
+		      ></A
+		      ><B
+		      >Stretch</B
+		      > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ><TD CLASS = "rdoc"
+		    > Stretches the duration of the sub-music by given factor.</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Monad <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunNotation"
+	  ></A
+	  ><B
+	  >runNotation</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > m) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > m -&gt; m</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  > can be interpreted if the contained type is an
+   instance of class <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	    >Musical</A
+	    ></TT
+	  >.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunNotationWith"
+	  ></A
+	  ><B
+	  >runNotationWith</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > m) =&gt; (a -&gt; m) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; m</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > Musical class</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AStretchable"
+	  ></A
+	  ><B
+	  >Stretchable</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A type/structure that can be stretched.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Astretch"
+		      ></A
+		      ><B
+		      >stretch</B
+		      > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      > -&gt; a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (s -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AArrangeable"
+	  ></A
+	  ><B
+	  >Arrangeable</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Types/structures that can be composed in two ways, parallel and sequent.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Aparallel"
+		      ></A
+		      ><B
+		      >parallel</B
+		      > :: a -&gt; a -&gt; a</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Asequent"
+		      ></A
+		      ><B
+		      >sequent</B
+		      > :: a -&gt; a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d, <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (s -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		      >MidiMusic</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > (<A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+	  >Stretchable</A
+	  > a, <A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+	  >Arrangeable</A
+	  > a) =&gt; <A NAME = "t%3AMusical"
+	  ></A
+	  ><B
+	  >Musical</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Instances of class <TT
+		><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		  >Musical</A
+		  ></TT
+		> must be <TT
+		><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		  >Stretchable</A
+		  ></TT
+		>, <TT
+		><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		  >Arrangeable</A
+		  ></TT
+		> and
+   they must implement the method <TT
+		><A HREF = "Sound.Hommage.Notation.html#v%3Arest"
+		  >rest</A
+		  ></TT
+		>. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Arest"
+		      ></A
+		      ><B
+		      >rest</B
+		      > :: a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (s -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		      >Notation</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		      >MidiMusic</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arest0"
+	  ></A
+	  ><B
+	  >rest0</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > a) =&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A-%3D-"
+	  ></A
+	  ><B
+	  >(-=-)</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+	  >Arrangeable</A
+	  > a) =&gt; a -&gt; a -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A-%3E-"
+	  ></A
+	  ><B
+	  >(-&gt;-)</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+	  >Arrangeable</A
+	  > a) =&gt; a -&gt; a -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aline"
+	  ></A
+	  ><B
+	  >line</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > a) =&gt; [a] -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A sequence of sounds</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aline'"
+	  ></A
+	  ><B
+	  >line'</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > a) =&gt; [a] -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A sequence of sounds that will be stretched to length=1</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Achord"
+	  ></A
+	  ><B
+	  >chord</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > a) =&gt; [a] -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aproportional"
+	  ></A
+	  ><B
+	  >proportional</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > a) =&gt; (Int, Int) -&gt; a -&gt; a -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Composes the notations sequentially and stretches them proportionally.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Notation and Midi </A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteMidiSyncNotation"
+	  ></A
+	  ><B
+	  >writeMidiSyncNotation</B
+	  > :: FilePath -&gt; [<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+	  >MidiNote</A
+	  >] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A convenient function to write a set of midi notations to a synchronous MIDI-file.
+   NOTE: For unknown reasons not any Ticks value seemes to work. This function uses
+   96 Ticks per quarter. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amidi"
+	  ></A
+	  ><B
+	  >midi</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+	  >IsDur</A
+	  > d) =&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+	  >MidiNote</A
+	  > -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A <TT
+	  > Notation MidiNote </TT
+	  > can be interpreted using <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#v%3ArunNotationWith"
+	    >runNotationWith</A
+	    ></TT
+	  > and <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#v%3Amidi"
+	    >midi</A
+	    ></TT
+	  >. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amidi'"
+	  ></A
+	  ><B
+	  >midi'</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+	  >IsDur</A
+	  > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+	  >MidiNote</A
+	  > -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmidiSyncFile"
+	  ></A
+	  ><B
+	  >midiSyncFile</B
+	  > :: <A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+	  >Ticks</A
+	  > -&gt; [<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > <A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+	  >MidiMusic</A
+	  >] -&gt; <A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+	  >MidiFile</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > More Notation functions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Anote"
+	  ></A
+	  ><B
+	  >note</B
+	  > :: a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a note with length 1. Is a synonym for <TT
+	  >Note (1%1)</TT
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmapNotation"
+	  ></A
+	  ><B
+	  >mapNotation</B
+	  > :: (a -&gt; b) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  > is instance of the class Functor.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AjoinNotation"
+	  ></A
+	  ><B
+	  >joinNotation</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  > is instance of the class Monad. Joining will replace
+    every (outer) Note by its contained (inner) Notation. The inner
+    Notation will be stretched by the duration of the (outer) Note.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AunmaybeNotation"
+	  ></A
+	  ><B
+	  >unmaybeNotation</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (Maybe a) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Replaces any Note that contains Nothing by a rest (with same duration).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AdurationNotation"
+	  ></A
+	  ><B
+	  >durationNotation</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; Ratio Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Calculates the (relative) duration of a <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  > (Must be finite!).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ApositionNotation"
+	  ></A
+	  ><B
+	  >positionNotation</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  >, a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Calculates the offset for each note.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreverseNotation"
+	  ></A
+	  ><B
+	  >reverseNotation</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Reverses a <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  > (Must be finite!).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtakeNotation"
+	  ></A
+	  ><B
+	  >takeNotation</B
+	  > :: Ratio Int -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Takes the beginning of <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  >, result has the given duration if possible or is shorter otherwise.
+   Notes that overlap with the end of duration are not taken but replaced by the (fitted) rests.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AdropNotation"
+	  ></A
+	  ><B
+	  >dropNotation</B
+	  > :: Ratio Int -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Drops the beginning of <TT
+	  ><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	    >Notation</A
+	    ></TT
+	  >. Notes that would be split are replaced by fitted rests.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterNotation"
+	  ></A
+	  ><B
+	  >filterNotation</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > (m a), Monad m) =&gt; (a -&gt; Bool) -&gt; m a -&gt; m a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Replaces notes where the predicate fails with rests.
+filterNotation :: (a -&gt; Bool) -&gt; Notation a -&gt; Notation a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterNotation'"
+	  ></A
+	  ><B
+	  >filterNotation'</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > (m a), <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+	  >Musical</A
+	  > (m b), Monad m) =&gt; (a -&gt; Maybe b) -&gt; m a -&gt; m b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsequenceNotation"
+	  ></A
+	  ><B
+	  >sequenceNotation</B
+	  > :: (a -&gt; b -&gt; c) -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > -&gt; [a] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > b -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > c</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A parallel composition of a sequence of values and a Notation
+   Each value of the sequence has the same given duration.
+   Every Note is updated by a function that gets the actual value of the sequence. 
+   NOTE: This function is not tested yet! </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Osc.html view
@@ -0,0 +1,700 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Osc</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Osc</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Sound Generators</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Functions for Lists</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > Functions for single values</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Other Functions</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aosc"
+		>osc</A
+		> :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Asinus"
+		>sinus</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Acosinus"
+		>cosinus</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arect"
+		>rect</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Asaw"
+		>saw</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Atri"
+		>tri</A
+		> :: [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArandomList"
+		>randomList</A
+		> :: (Random a) =&gt; (a, a) -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsampleAndHold"
+		>sampleAndHold</A
+		> :: (Ord a, Num a) =&gt; b -&gt; [a] -&gt; [b] -&gt; [b]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aaverage"
+		>average</A
+		> :: (Fractional a) =&gt; Int -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AterminateAt"
+		>terminateAt</A
+		> :: Int -&gt; (a -&gt; Bool) -&gt; [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Afollow"
+		>follow</A
+		> :: Double -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Acompress"
+		>compress</A
+		> :: Double -&gt; Double -&gt; Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnoteToFrequency"
+		>noteToFrequency</A
+		> :: Double -&gt; Double -&gt; Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AadjustFrequency"
+		>adjustFrequency</A
+		> :: Double -&gt; Double -&gt; Double -&gt; Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsplitWaves"
+		>splitWaves</A
+		> :: [Double] -&gt; [[Double]]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Acrossfade"
+		>crossfade</A
+		> :: [Double] -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Sound Generators</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aosc"
+	  ></A
+	  ><B
+	  >osc</B
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >:: [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > The sound to play. Output will be finite if sound is finite.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > Speed,      1.0 = normal, 
+               0.0 &lt; X &lt; 1.0 = slower resp. lower, 
+               1.0 &lt; X = faster resp. higher, 
+               X &lt; 0.0 =&gt; X = abs X.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > Output </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "ndoc" COLSPAN = "2"
+	      > Play given sound with variable speed resp. frequency. 
+   (General definition: Usually a frequency of 1.0 means a period of 1024 values).
+   Use scratchSample or scratchSampleSignal for backward playing.</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Asinus"
+	  ></A
+	  ><B
+	  >sinus</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A sinus wave generator with a period of 1024/N for frequency N </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Acosinus"
+	  ></A
+	  ><B
+	  >cosinus</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A cosinus wave generator</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arect"
+	  ></A
+	  ><B
+	  >rect</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A rectangle wave generator</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Asaw"
+	  ></A
+	  ><B
+	  >saw</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A sawtooth wave generator</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Atri"
+	  ></A
+	  ><B
+	  >tri</B
+	  > :: [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A triangle wave generator</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArandomList"
+	  ></A
+	  ><B
+	  >randomList</B
+	  > :: (Random a) =&gt; (a, a) -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Functions for Lists</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsampleAndHold"
+	  ></A
+	  ><B
+	  >sampleAndHold</B
+	  > :: (Ord a, Num a) =&gt; b -&gt; [a] -&gt; [b] -&gt; [b]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Current output value is repeatet until the first list argument value switches from zero or below 
+   to a non-zero positive value, the actual value of the second list argument is then taken for output.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aaverage"
+	  ></A
+	  ><B
+	  >average</B
+	  > :: (Fractional a) =&gt; Int -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Maps the values to the average of the last N values (including the actual)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AterminateAt"
+	  ></A
+	  ><B
+	  >terminateAt</B
+	  > :: Int -&gt; (a -&gt; Bool) -&gt; [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> If predicate holds for N elements, list is cut.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Afollow"
+	  ></A
+	  ><B
+	  >follow</B
+	  > :: Double -&gt; [Double] -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > Functions for single values</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> These Functions can be used with map:</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Acompress"
+	  ></A
+	  ><B
+	  >compress</B
+	  > :: Double -&gt; Double -&gt; Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><PRE
+	  > compress p x = x / (abs p + abs x) </PRE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnoteToFrequency"
+	  ></A
+	  ><B
+	  >noteToFrequency</B
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >:: Double</TD
+	      ><TD CLASS = "rdoc"
+	      > Base, </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > Notenumber</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > 2 ^ (Notenumber / Base)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "ndoc" COLSPAN = "2"
+	      > Transforms a notevalue into a frequency. A Notevalue of 0.0 means a frequency of 1.0. </TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AadjustFrequency"
+	  ></A
+	  ><B
+	  >adjustFrequency</B
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >:: Double</TD
+	      ><TD CLASS = "rdoc"
+	      > Period </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > New Frequency (Hz) for old frequency of 1.0</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > Input Frequency</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; Double</TD
+	      ><TD CLASS = "rdoc"
+	      > Output Frequency</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "ndoc" COLSPAN = "2"
+	      > Adjusts the frequency. If given oscillator has period X for frequency of 1.0 and you want it to
+   produce a wave with Y Hz at frequency of 1.0, use <TT
+		> map (adjustFrequency X Y) </TT
+		> to adjust the
+   input of the oscillator.</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Other Functions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> These Functions are not simple (i. e. linear) list transformers:</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsplitWaves"
+	  ></A
+	  ><B
+	  >splitWaves</B
+	  > :: [Double] -&gt; [[Double]]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Splits a wave into parts. they are split when a value equal or less than zero is followed by a
+   value greater than zero.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Acrossfade"
+	  ></A
+	  ><B
+	  >crossfade</B
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >:: [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > w1</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > w2</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >-&gt; [Double]</TD
+	      ><TD CLASS = "rdoc"
+	      > result</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "ndoc" COLSPAN = "2"
+	      > Create a wave with the beginning of w1, the ending of w2 and the length of the longer one of them.</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Parameter.html view
@@ -0,0 +1,1583 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Parameter</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Parameter</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Field</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Hetero List</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> This module contains a datatype <TT
+	  ><A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	    >Field</A
+	    ></TT
+	  > and sone type classes. It is used
+   to construct record-like datatypes.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AField"
+		>Field</A
+		> c a = <A HREF = "#v%3AField"
+		>Field</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AgetField"
+		      >getField</A
+		      > :: (c -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AsetField"
+		      >setField</A
+		      > :: ((a -&gt; a) -&gt; c -&gt; c)</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3C%3E"
+		>(&lt;&gt;)</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		>Field</A
+		> a b -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		>Field</A
+		> c a -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		>Field</A
+		> c b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfstField"
+		>fstField</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		>Field</A
+		> (a, b) a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsndField"
+		>sndField</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		>Field</A
+		> (a, b) b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AUpdateField"
+		      >UpdateField</A
+		      > c</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <SPAN CLASS = "keyword"
+			    >forall</SPAN
+			    > a . <A HREF = "#v%3A%3A%3D"
+			    >(:=)</A
+			    > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+			    >Field</A
+			    > c a) a</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <SPAN CLASS = "keyword"
+			    >forall</SPAN
+			    > a . <A HREF = "#v%3A%3A%24"
+			    >(:$)</A
+			    > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+			    >Field</A
+			    > c a) (a -&gt; a)</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AIf"
+			    >If</A
+			    > (<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+			    >CheckField</A
+			    > c) [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+			    >UpdateField</A
+			    > c] [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+			    >UpdateField</A
+			    > c]</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3ACheckField"
+		      >CheckField</A
+		      > c</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <SPAN CLASS = "keyword"
+			    >forall</SPAN
+			    > a . <A HREF = "#v%3A%3A%3F"
+			    >(:?)</A
+			    > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+			    >Field</A
+			    > c a) (a -&gt; Bool)</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AAnd"
+			    >And</A
+			    > [<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+			    >CheckField</A
+			    > c]</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AOr"
+			    >Or</A
+			    > [<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+			    >CheckField</A
+			    > c]</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AupdateField"
+		>updateField</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		>UpdateField</A
+		> c -&gt; c -&gt; c</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AcheckField"
+		>checkField</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+		>CheckField</A
+		> c -&gt; c -&gt; Bool</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AapplyField"
+		>applyField</A
+		> :: [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		>UpdateField</A
+		> c] -&gt; c -&gt; c</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwithField"
+		>withField</A
+		> :: [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		>UpdateField</A
+		> a] -&gt; (a -&gt; b) -&gt; a -&gt; b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AGroup"
+		>Group</A
+		> c a = <A HREF = "#v%3AGroup"
+		>Group</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AisGroup"
+		      >isGroup</A
+		      > :: (c -&gt; Maybe a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AmkGroup"
+		      >mkGroup</A
+		      > :: (a -&gt; c)</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AleftGroup"
+		>leftGroup</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		>Group</A
+		> (Either a b) a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArightGroup"
+		>rightGroup</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		>Group</A
+		> (Either a b) b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3E%3C"
+		>(&gt;&lt;)</A
+		> :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		>Group</A
+		> a b -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		>Group</A
+		> c a -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		>Group</A
+		> c b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ALM"
+		>LM</A
+		> a b m = <A HREF = "#v%3A%3A%3E%3E"
+		>(:&gt;&gt;)</A
+		> (m a) (b m)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ANilM"
+		>NilM</A
+		> m = <A HREF = "#v%3ANilM"
+		>NilM</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3APushFields"
+		>PushFields</A
+		> m  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3ApushFields"
+		      >pushFields</A
+		      > :: m (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > c) -&gt; m (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > (x, c))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AToFields"
+		>ToFields</A
+		> a r  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AtoFields"
+		      >toFields</A
+		      > :: a -&gt; r (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3APushGroups"
+		>PushGroups</A
+		> m  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3ApushGroups"
+		      >pushGroups</A
+		      > :: m (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > c) -&gt; m (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > (Either x c))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AToGroups"
+		>ToGroups</A
+		> a r  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AtoGroups"
+		      >toGroups</A
+		      > :: a -&gt; r (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > Example:</P
+	  ><P
+	  >   To create a &quot;record&quot; with the accessors/modificators first you have to define the type
+   of the record, It must be a right-associative list of pairs, just like a LISP list.
+   The rightmost element must be <TT
+	    > () </TT
+	    >. The following Example defines a record with information
+   for music generation. </P
+	  ><PRE
+	  > type DefaultNote = (Int, (Double, (Char, ())))     </PRE
+	  ><P
+	  >   Then a default value should be defined. </P
+	  ><PRE
+	  > defaultNote = (0, (1.0, ('a' , ())))
+ defaultNote :: DefaultNote </PRE
+	  ><P
+	  >   For each &quot;datafield&quot; the <TT
+	    ><A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	      >Field</A
+	      ></TT
+	    > must be declared.</P
+	  ><PRE
+	  > pitch :: Field DefaultNote Int 
+ volume :: Field DefaultNote Double 
+ channel :: Field DefaultNote Char </PRE
+	  ><P
+	  >  Creating the fields is done with toField applied to a value of the &quot;record&quot; type.</P
+	  ><PRE
+	  > pitch :&gt;&gt; volume :&gt;&gt; channel :&gt;&gt; NilM = toFields defaultNote </PRE
+	  ><P
+	  >  Is is recommended to declare all types and match all results of <TT
+	    ><A HREF = "Sound.Hommage.Parameter.html#v%3AtoFields"
+	      >toFields</A
+	      ></TT
+	    > incl. the <TT
+	    ><A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+	      >NilM</A
+	      ></TT
+	    > at
+  the end.</P
+	  ><P
+	  >  NOTE:</P
+	  ><PRE
+	  > pitch :&gt;&gt; volume :&gt;&gt; channel :&gt;&gt; NilM = toFields (undefined :: DefaultNote)</PRE
+	  ><P
+	  >  should work too.
+</P
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Field</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AField"
+	  ></A
+	  ><B
+	  >Field</B
+	  > c a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A <TT
+		> Field record field </TT
+		> is an interface to access a type <TT
+		> field </TT
+		> which 
+   is part of a type <TT
+		> record </TT
+		>.
+   A <TT
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		  >Field</A
+		  ></TT
+		> is used to access and modify subtypes (&quot;datafields&quot;) of 
+   a record-like datastructure. In this module, a right-associative pair structure is
+   taken as record-type with &quot;datafields&quot; in the fst parts of the pairs.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AField"
+		      ></A
+		      ><B
+		      >Field</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AgetField"
+			    ></A
+			    ><B
+			    >getField</B
+			    > :: (c -&gt; a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AsetField"
+			    ></A
+			    ><B
+			    >setField</B
+			    > :: ((a -&gt; a) -&gt; c -&gt; c)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3C%3E"
+	  ></A
+	  ><B
+	  >(&lt;&gt;)</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	  >Field</A
+	  > a b -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	  >Field</A
+	  > c a -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	  >Field</A
+	  > c b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfstField"
+	  ></A
+	  ><B
+	  >fstField</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	  >Field</A
+	  > (a, b) a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsndField"
+	  ></A
+	  ><B
+	  >sndField</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+	  >Field</A
+	  > (a, b) b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AUpdateField"
+	  ></A
+	  ><B
+	  >UpdateField</B
+	  > c</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >forall</SPAN
+		      > a . <A NAME = "v%3A%3A%3D"
+		      ></A
+		      ><B
+		      >(:=)</B
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > c a) a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >forall</SPAN
+		      > a . <A NAME = "v%3A%3A%24"
+		      ></A
+		      ><B
+		      >(:$)</B
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > c a) (a -&gt; a)</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AIf"
+		      ></A
+		      ><B
+		      >If</B
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+		      >CheckField</A
+		      > c) [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		      >UpdateField</A
+		      > c] [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		      >UpdateField</A
+		      > c]</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ACheckField"
+	  ></A
+	  ><B
+	  >CheckField</B
+	  > c</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >forall</SPAN
+		      > a . <A NAME = "v%3A%3A%3F"
+		      ></A
+		      ><B
+		      >(:?)</B
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > c a) (a -&gt; Bool)</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAnd"
+		      ></A
+		      ><B
+		      >And</B
+		      > [<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+		      >CheckField</A
+		      > c]</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AOr"
+		      ></A
+		      ><B
+		      >Or</B
+		      > [<A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+		      >CheckField</A
+		      > c]</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AupdateField"
+	  ></A
+	  ><B
+	  >updateField</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+	  >UpdateField</A
+	  > c -&gt; c -&gt; c</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AcheckField"
+	  ></A
+	  ><B
+	  >checkField</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+	  >CheckField</A
+	  > c -&gt; c -&gt; Bool</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AapplyField"
+	  ></A
+	  ><B
+	  >applyField</B
+	  > :: [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+	  >UpdateField</A
+	  > c] -&gt; c -&gt; c</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwithField"
+	  ></A
+	  ><B
+	  >withField</B
+	  > :: [<A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+	  >UpdateField</A
+	  > a] -&gt; (a -&gt; b) -&gt; a -&gt; b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AGroup"
+	  ></A
+	  ><B
+	  >Group</B
+	  > c a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AGroup"
+		      ></A
+		      ><B
+		      >Group</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AisGroup"
+			    ></A
+			    ><B
+			    >isGroup</B
+			    > :: (c -&gt; Maybe a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AmkGroup"
+			    ></A
+			    ><B
+			    >mkGroup</B
+			    > :: (a -&gt; c)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AleftGroup"
+	  ></A
+	  ><B
+	  >leftGroup</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+	  >Group</A
+	  > (Either a b) a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArightGroup"
+	  ></A
+	  ><B
+	  >rightGroup</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+	  >Group</A
+	  > (Either a b) b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3E%3C"
+	  ></A
+	  ><B
+	  >(&gt;&lt;)</B
+	  > :: <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+	  >Group</A
+	  > a b -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+	  >Group</A
+	  > c a -&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+	  >Group</A
+	  > c b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Hetero List</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ALM"
+	  ></A
+	  ><B
+	  >LM</B
+	  > a b m</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3A%3A%3E%3E"
+		      ></A
+		      ><B
+		      >(:&gt;&gt;)</B
+		      > (m a) (b m)</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > b', <A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > b b') =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > (a, b) (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b')</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > b b', <A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > b') =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > (Either a b) (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b')</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ANilM"
+	  ></A
+	  ><B
+	  >NilM</B
+	  > m</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > The correct type is: <TT
+		> data NilM (m :: * -&gt; *) = NilM </TT
+		> . 
+   (But Haddock rejects this definition. GHC will need it)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ANilM"
+		      ></A
+		      ><B
+		      >NilM</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > () <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > () <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3APushFields"
+	  ></A
+	  ><B
+	  >PushFields</B
+	  > m  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ApushFields"
+		      ></A
+		      ><B
+		      >pushFields</B
+		      > :: m (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > c) -&gt; m (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > (x, c))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AToFields"
+	  ></A
+	  ><B
+	  >ToFields</B
+	  > a r  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AtoFields"
+		      ></A
+		      ><B
+		      >toFields</B
+		      > :: a -&gt; r (<A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		      >Field</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > () <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		      >PushFields</A
+		      > b', <A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > b b') =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		      >ToFields</A
+		      > (a, b) (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b')</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3APushGroups"
+	  ></A
+	  ><B
+	  >PushGroups</B
+	  > m  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ApushGroups"
+		      ></A
+		      ><B
+		      >pushGroups</B
+		      > :: m (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > c) -&gt; m (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > (Either x c))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AToGroups"
+	  ></A
+	  ><B
+	  >ToGroups</B
+	  > a r  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AtoGroups"
+		      ></A
+		      ><B
+		      >toGroups</B
+		      > :: a -&gt; r (<A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		      >Group</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > () <A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		      >NilM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > b b', <A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		      >PushGroups</A
+		      > b') =&gt; <A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		      >ToGroups</A
+		      > (Either a b) (<A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		      >LM</A
+		      > a b')</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Play.html view
@@ -0,0 +1,1525 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Play</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Play</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Play</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Interpretation of Notation for Play</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > Parallel played and hierarchical defined tracks</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Environment</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > Duration</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3APlay"
+		>Play</A
+		> a = <A HREF = "#v%3APLAY"
+		>PLAY</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AunPlay"
+		      >unPlay</A
+		      > :: (<A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		      >Duration</A
+		      > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		      >Environment</A
+		      > -&gt; a)</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AgetDur"
+		>getDur</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AresetDur"
+		>resetDur</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArandomPlay"
+		>randomPlay</A
+		> :: (Random a) =&gt; (a, a) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amix"
+		>mix</A
+		> :: [<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Amix'"
+		>mix'</A
+		> :: (Num a) =&gt; [<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> [a]] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnotationMono"
+		>notationMono</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnotationStereo"
+		>notationStereo</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		>]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Anotation"
+		>notation</A
+		> :: (<A HREF = "Sound.Hommage.Play.html#t%3AMixable"
+		>Mixable</A
+		> a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AMixable"
+		>Mixable</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Amixdown"
+		      >mixdown</A
+		      > :: <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ASong"
+		>Song</A
+		> a = <A HREF = "#v%3ASONG"
+		>SONG</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AunSong"
+		      >unSong</A
+		      > :: (<A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		      >Duration</A
+		      > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		      >Environment</A
+		      > -&gt; (a, <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		      >Environment</A
+		      >))</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunSong"
+		>runSong</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		>Song</A
+		> (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a) -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3ATrack"
+		>Track</A
+		> a = <A HREF = "#v%3ATRACK"
+		>TRACK</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AunTrack"
+		      >unTrack</A
+		      > :: (<A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		      >Environment</A
+		      > -&gt; a)</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AplayTrack"
+		>playTrack</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		>Track</A
+		> a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Atrack"
+		>track</A
+		> :: (<A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+		>Trackable</A
+		> a) =&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		>Song</A
+		> (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		>Track</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> (Typeable a) =&gt; <A HREF = "#t%3ATrackable"
+		>Trackable</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AtoNext"
+		      >toNext</A
+		      > :: a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3AEnvironment"
+		>Environment</A
+		>  = <A HREF = "#v%3AEnvironment"
+		>Environment</A
+		> (Int, [(Int, [Dynamic])])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AemptyEnvironment"
+		>emptyEnvironment</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnextEnvironment"
+		>nextEnvironment</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		> -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinsertEnvironment"
+		>insertEnvironment</A
+		> :: [Dynamic] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		> -&gt; (<A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		> -&gt; Dynamic, <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		>)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AlookupEnvironment"
+		>lookupEnvironment</A
+		> :: Int -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		>Environment</A
+		> -&gt; Dynamic</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ADuration"
+		>Duration</A
+		>  = <A HREF = "#v%3ADURATION"
+		>DURATION</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3ArelativeDuration"
+		      >relativeDuration</A
+		      > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AabsoluteDuration"
+		      >absoluteDuration</A
+		      > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AresetDuration"
+		>resetDuration</A
+		> :: <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		>Duration</A
+		> -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		>Duration</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitDuration"
+		>initDuration</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		>Duration</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Play</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3APlay"
+	  ></A
+	  ><B
+	  >Play</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3APLAY"
+		      ></A
+		      ><B
+		      >PLAY</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunPlay"
+			    ></A
+			    ><B
+			    >unPlay</B
+			    > :: (<A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+			    >Duration</A
+			    > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+			    >Environment</A
+			    > -&gt; a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Monad <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >] -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AgetDur"
+	  ></A
+	  ><B
+	  >getDur</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AresetDur"
+	  ></A
+	  ><B
+	  >resetDur</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArandomPlay"
+	  ></A
+	  ><B
+	  >randomPlay</B
+	  > :: (Random a) =&gt; (a, a) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amix"
+	  ></A
+	  ><B
+	  >mix</B
+	  > :: [<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Amix'"
+	  ></A
+	  ><B
+	  >mix'</B
+	  > :: (Num a) =&gt; [<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > [a]] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Interpretation of Notation for Play</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnotationMono"
+	  ></A
+	  ><B
+	  >notationMono</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnotationStereo"
+	  ></A
+	  ><B
+	  >notationStereo</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  >]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Anotation"
+	  ></A
+	  ><B
+	  >notation</B
+	  > :: (<A HREF = "Sound.Hommage.Play.html#t%3AMixable"
+	  >Mixable</A
+	  > a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a) -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AMixable"
+	  ></A
+	  ><B
+	  >Mixable</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Amixdown"
+		      ></A
+		      ><B
+		      >mixdown</B
+		      > :: <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(Num a) =&gt; <A HREF = "Sound.Hommage.Play.html#t%3AMixable"
+		      >Mixable</A
+		      > [a]</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > Parallel played and hierarchical defined tracks</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ASong"
+	  ></A
+	  ><B
+	  >Song</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ASONG"
+		      ></A
+		      ><B
+		      >SONG</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunSong"
+			    ></A
+			    ><B
+			    >unSong</B
+			    > :: (<A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+			    >Duration</A
+			    > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+			    >Environment</A
+			    > -&gt; (a, <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+			    >Environment</A
+			    >))</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		      >Song</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Monad <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		      >Song</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunSong"
+	  ></A
+	  ><B
+	  >runSong</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+	  >Song</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a) -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3ATrack"
+	  ></A
+	  ><B
+	  >Track</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ATRACK"
+		      ></A
+		      ><B
+		      >TRACK</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunTrack"
+			    ></A
+			    ><B
+			    >unTrack</B
+			    > :: (<A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+			    >Environment</A
+			    > -&gt; a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AplayTrack"
+	  ></A
+	  ><B
+	  >playTrack</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+	  >Track</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Atrack"
+	  ></A
+	  ><B
+	  >track</B
+	  > :: (<A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+	  >Trackable</A
+	  > a) =&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+	  >Song</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+	  >Track</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > (Typeable a) =&gt; <A NAME = "t%3ATrackable"
+	  ></A
+	  ><B
+	  >Trackable</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AtoNext"
+		      ></A
+		      ><B
+		      >toNext</B
+		      > :: a -&gt; a</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+		      >Trackable</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(Typeable a) =&gt; <A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+		      >Trackable</A
+		      > [a]</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Environment</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3AEnvironment"
+	  ></A
+	  ><B
+	  >Environment</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AEnvironment"
+		      ></A
+		      ><B
+		      >Environment</B
+		      > (Int, [(Int, [Dynamic])])</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AemptyEnvironment"
+	  ></A
+	  ><B
+	  >emptyEnvironment</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnextEnvironment"
+	  ></A
+	  ><B
+	  >nextEnvironment</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinsertEnvironment"
+	  ></A
+	  ><B
+	  >insertEnvironment</B
+	  > :: [Dynamic] -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  > -&gt; (<A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  > -&gt; Dynamic, <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  >)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AlookupEnvironment"
+	  ></A
+	  ><B
+	  >lookupEnvironment</B
+	  > :: Int -&gt; <A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+	  >Environment</A
+	  > -&gt; Dynamic</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > Duration</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ADuration"
+	  ></A
+	  ><B
+	  >Duration</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ADURATION"
+		      ></A
+		      ><B
+		      >DURATION</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3ArelativeDuration"
+			    ></A
+			    ><B
+			    >relativeDuration</B
+			    > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    ></TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AabsoluteDuration"
+			    ></A
+			    ><B
+			    >absoluteDuration</B
+			    > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    ></TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		      >Duration</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AresetDuration"
+	  ></A
+	  ><B
+	  >resetDuration</B
+	  > :: <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+	  >Duration</A
+	  > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+	  >Duration</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitDuration"
+	  ></A
+	  ><B
+	  >initDuration</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+	  >Duration</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Rand.html view
@@ -0,0 +1,357 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Rand</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Rand</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3AR"
+	  ></A
+	  ><B
+	  >R</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AR"
+		      ></A
+		      ><B
+		      >R</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunR"
+			    ></A
+			    ><B
+			    >unR</B
+			    > :: (StdGen -&gt; a)</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Monad <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+		      >R</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+		      >R</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Applicative <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+		      >R</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkR"
+	  ></A
+	  ><B
+	  >mkR</B
+	  > :: (StdGen -&gt; (a, StdGen)) -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+	  >R</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunR"
+	  ></A
+	  ><B
+	  >runR</B
+	  > :: Int -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+	  >R</A
+	  > a -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arif"
+	  ></A
+	  ><B
+	  >rif</B
+	  > :: Double -&gt; (a, a) -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+	  >R</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arselect"
+	  ></A
+	  ><B
+	  >rselect</B
+	  > :: [a] -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+	  >R</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ARM"
+	  ></A
+	  ><B
+	  >RM</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Functor <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Monad <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		      >Stretchable</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		      >RM</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aror"
+	  ></A
+	  ><B
+	  >ror</B
+	  > :: [<A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+	  >RM</A
+	  > a] -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+	  >RM</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arnote"
+	  ></A
+	  ><B
+	  >rnote</B
+	  > :: a -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+	  >RM</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunRM"
+	  ></A
+	  ><B
+	  >runRM</B
+	  > :: <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+	  >RM</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3AR"
+	  >R</A
+	  > (<A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arplay"
+	  ></A
+	  ><B
+	  >rplay</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a) =&gt; a -&gt; <A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+	  >RM</A
+	  > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Sample.html view
@@ -0,0 +1,1258 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Sample</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Sample</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Sample Datastructure</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > File Operations</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > Pitching, Playing and Scratching</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Transforming Samples</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#5"
+		    > Filter and Fourier Coeffs</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#6"
+		    > Playing a Sample</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#7"
+		    > Array functions</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ASample"
+		>Sample</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AarraySample"
+		>arraySample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IOArray Int a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsizeSample"
+		>sizeSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnewSample"
+		>newSample</A
+		> :: Int -&gt; a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnewSampleFromList"
+		>newSampleFromList</A
+		> :: [a] -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenWavSample"
+		>openWavSample</A
+		> :: FilePath -&gt; IO (Either (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>) (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		>))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsaveWavSampleMono"
+		>saveWavSampleMono</A
+		> :: FilePath -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> Double -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsaveWavSampleStereo"
+		>saveWavSampleStereo</A
+		> :: FilePath -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		> -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ApitchWavSignal"
+		>pitchWavSignal</A
+		> :: FilePath -&gt; [Double] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AscratchWavSignal"
+		>scratchWavSignal</A
+		> :: FilePath -&gt; [Double] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AplaySample"
+		>playSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ApitchSample"
+		>pitchSample</A
+		> :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; [Double] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AscratchSample"
+		>scratchSample</A
+		> :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; [Double] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AplayCoeffs"
+		>playCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; [Complex Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmapSample"
+		>mapSample</A
+		> :: (a -&gt; b) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> b)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfoldlSample"
+		>foldlSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; (b -&gt; a -&gt; b) -&gt; b -&gt; IO b</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AupdateSample"
+		>updateSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; (a -&gt; a) -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnormaliseSample"
+		>normaliseSample</A
+		> :: (Ord a, Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfadeinoutSample"
+		>fadeinoutSample</A
+		> :: (Fractional a) =&gt; (Int, Int) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AstretchSample"
+		>stretchSample</A
+		> :: (Fractional a) =&gt; Int -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ACoeffs"
+		>Coeffs</A
+		> </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AarrayCoeffs"
+		>arrayCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; IOArray Int <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		>CoeffArr</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsizeCoeffs"
+		>sizeCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavesizeCoeffs"
+		>wavesizeCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsyntheseSample"
+		>syntheseSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AanalyseSample"
+		>analyseSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		> -&gt; IO <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterCoeffs"
+		>filterCoeffs</A
+		> :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		>CoeffMap</A
+		> ()) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; IO <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkPlayCoeffs"
+		>mkPlayCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; IO (IO (Maybe (Complex Double)))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadCoeffs"
+		>readCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; Int -&gt; Int -&gt; IO (Complex Double)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteCoeffs"
+		>writeCoeffs</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		>Coeffs</A
+		> -&gt; Int -&gt; Int -&gt; Complex Double -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkTriggerSample"
+		>mkTriggerSample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; a -&gt; IO (Bool -&gt; IO a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkPlaySample"
+		>mkPlaySample</A
+		> :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO (IO (Maybe a))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkScratchSample"
+		>mkScratchSample</A
+		> :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO (Double -&gt; IO a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkPitchSample"
+		>mkPitchSample</A
+		> :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		>Sample</A
+		> a -&gt; IO (Double -&gt; IO (Maybe a))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinterpolArray"
+		>interpolArray</A
+		> :: (Fractional a, MArray array a IO) =&gt; array Int a -&gt; Int -&gt; Double -&gt; IO a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkLoopArray"
+		>mkLoopArray</A
+		> :: (Fractional a, MArray arr a IO) =&gt; arr Int a -&gt; Int -&gt; IO (Double -&gt; IO a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmkPlayArray"
+		>mkPlayArray</A
+		> :: (Fractional a, MArray arr a IO) =&gt; arr Int a -&gt; Int -&gt; IO (Double -&gt; IO (Maybe a))</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Sample Datastructure</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ASample"
+	  ></A
+	  ><B
+	  >Sample</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AarraySample"
+	  ></A
+	  ><B
+	  >arraySample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IOArray Int a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsizeSample"
+	  ></A
+	  ><B
+	  >sizeSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnewSample"
+	  ></A
+	  ><B
+	  >newSample</B
+	  > :: Int -&gt; a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnewSampleFromList"
+	  ></A
+	  ><B
+	  >newSampleFromList</B
+	  > :: [a] -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > File Operations</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenWavSample"
+	  ></A
+	  ><B
+	  >openWavSample</B
+	  > :: FilePath -&gt; IO (Either (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >) (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  >))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsaveWavSampleMono"
+	  ></A
+	  ><B
+	  >saveWavSampleMono</B
+	  > :: FilePath -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsaveWavSampleStereo"
+	  ></A
+	  ><B
+	  >saveWavSampleStereo</B
+	  > :: FilePath -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  > -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > Pitching, Playing and Scratching</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ApitchWavSignal"
+	  ></A
+	  ><B
+	  >pitchWavSignal</B
+	  > :: FilePath -&gt; [Double] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Open a Wav-File, but play it with variable (positive) speed/ frequency. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AscratchWavSignal"
+	  ></A
+	  ><B
+	  >scratchWavSignal</B
+	  > :: FilePath -&gt; [Double] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Open a Wav-File, but play it with variable (positive and/or negative) speed/ frequency. 
+   Backward playing is possible.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AplaySample"
+	  ></A
+	  ><B
+	  >playSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a finite list with the content of the Sample.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ApitchSample"
+	  ></A
+	  ><B
+	  >pitchSample</B
+	  > :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; [Double] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a list with the content of the Sample, but played with variable speed/frequency.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AscratchSample"
+	  ></A
+	  ><B
+	  >scratchSample</B
+	  > :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; [Double] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a list with the content of the Sample, but played with variable speed/frequency, 
+   backward playing possible.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AplayCoeffs"
+	  ></A
+	  ><B
+	  >playCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; [Complex Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a list with the content of <TT
+	  ><A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	    >Coeffs</A
+	    ></TT
+	  > (a representation of the fourier coefficients of 
+   a <TT
+	  ><A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	    >Sample</A
+	    ></TT
+	  >). </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Transforming Samples</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmapSample"
+	  ></A
+	  ><B
+	  >mapSample</B
+	  > :: (a -&gt; b) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > b)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfoldlSample"
+	  ></A
+	  ><B
+	  >foldlSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; (b -&gt; a -&gt; b) -&gt; b -&gt; IO b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AupdateSample"
+	  ></A
+	  ><B
+	  >updateSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; (a -&gt; a) -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnormaliseSample"
+	  ></A
+	  ><B
+	  >normaliseSample</B
+	  > :: (Ord a, Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfadeinoutSample"
+	  ></A
+	  ><B
+	  >fadeinoutSample</B
+	  > :: (Fractional a) =&gt; (Int, Int) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AstretchSample"
+	  ></A
+	  ><B
+	  >stretchSample</B
+	  > :: (Fractional a) =&gt; Int -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "5"
+	  > Filter and Fourier Coeffs</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ACoeffs"
+	  ></A
+	  ><B
+	  >Coeffs</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AarrayCoeffs"
+	  ></A
+	  ><B
+	  >arrayCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; IOArray Int <A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+	  >CoeffArr</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsizeCoeffs"
+	  ></A
+	  ><B
+	  >sizeCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavesizeCoeffs"
+	  ></A
+	  ><B
+	  >wavesizeCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsyntheseSample"
+	  ></A
+	  ><B
+	  >syntheseSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; IO (<A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AanalyseSample"
+	  ></A
+	  ><B
+	  >analyseSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  > -&gt; IO <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterCoeffs"
+	  ></A
+	  ><B
+	  >filterCoeffs</B
+	  > :: IO (<A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+	  >CoeffMap</A
+	  > ()) -&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; IO <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkPlayCoeffs"
+	  ></A
+	  ><B
+	  >mkPlayCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; IO (IO (Maybe (Complex Double)))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadCoeffs"
+	  ></A
+	  ><B
+	  >readCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; Int -&gt; Int -&gt; IO (Complex Double)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> usage: <TT
+	  > readCoeffs obj nrOfCoeffarr nrOfCoefficient </TT
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteCoeffs"
+	  ></A
+	  ><B
+	  >writeCoeffs</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+	  >Coeffs</A
+	  > -&gt; Int -&gt; Int -&gt; Complex Double -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "6"
+	  > Playing a Sample</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkTriggerSample"
+	  ></A
+	  ><B
+	  >mkTriggerSample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; a -&gt; IO (Bool -&gt; IO a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkPlaySample"
+	  ></A
+	  ><B
+	  >mkPlaySample</B
+	  > :: <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO (IO (Maybe a))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkScratchSample"
+	  ></A
+	  ><B
+	  >mkScratchSample</B
+	  > :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO (Double -&gt; IO a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkPitchSample"
+	  ></A
+	  ><B
+	  >mkPitchSample</B
+	  > :: (Fractional a) =&gt; <A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+	  >Sample</A
+	  > a -&gt; IO (Double -&gt; IO (Maybe a))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "7"
+	  > Array functions</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinterpolArray"
+	  ></A
+	  ><B
+	  >interpolArray</B
+	  > :: (Fractional a, MArray array a IO) =&gt; array Int a -&gt; Int -&gt; Double -&gt; IO a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkLoopArray"
+	  ></A
+	  ><B
+	  >mkLoopArray</B
+	  > :: (Fractional a, MArray arr a IO) =&gt; arr Int a -&gt; Int -&gt; IO (Double -&gt; IO a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmkPlayArray"
+	  ></A
+	  ><B
+	  >mkPlayArray</B
+	  > :: (Fractional a, MArray arr a IO) =&gt; arr Int a -&gt; Int -&gt; IO (Double -&gt; IO (Maybe a))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Seq.html view
@@ -0,0 +1,473 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Seq</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Seq</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArunNumNotation"
+		>runNumNotation</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		>IsDur</A
+		> d, Num a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d [a]) -&gt; d -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AbpmToDur"
+		>bpmToDur</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3ASeq"
+		>Seq</A
+		> a = <A HREF = "#v%3ASEQ"
+		>SEQ</A
+		> {<TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "recfield"
+		    ><A HREF = "#v%3AunSeq"
+		      >unSeq</A
+		      > :: [[a]]</TD
+		    ></TR
+		  ></TABLE
+		>}</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnoteSeq"
+		>noteSeq</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		>IsDur</A
+		> d) =&gt; a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnoteSeq'"
+		>noteSeq'</A
+		> :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		>IsDur</A
+		> d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		>WithDur</A
+		> d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> a)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmixdownNumSeq"
+		>mixdownNumSeq</A
+		> :: (Num a) =&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> [a] -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AapplySeq"
+		>applySeq</A
+		> :: (s -&gt; s) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> (s -&gt; a) -&gt; s -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AapplySeqE"
+		>applySeqE</A
+		> :: (s -&gt; s) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> (Either (s -&gt; a) (s -&gt; s)) -&gt; s -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AfilterSeq"
+		>filterSeq</A
+		> :: (a -&gt; Maybe b) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> a -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		>Seq</A
+		> b</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArunNumNotation"
+	  ></A
+	  ><B
+	  >runNumNotation</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+	  >IsDur</A
+	  > d, Num a) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d [a]) -&gt; d -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AbpmToDur"
+	  ></A
+	  ><B
+	  >bpmToDur</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3ASeq"
+	  ></A
+	  ><B
+	  >Seq</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A <TT
+		><A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		  >Seq</A
+		  ></TT
+		> represents a temporal sequence of &quot;Moments&quot;. Each moment 
+   can contain some events of type <TT
+		>a</TT
+		>.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "5" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ASEQ"
+		      ></A
+		      ><B
+		      >SEQ</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body" COLSPAN = "2"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  ><A NAME = "v%3AunSeq"
+			    ></A
+			    ><B
+			    >unSeq</B
+			    > :: [[a]]</TD
+			  ><TD CLASS = "rdoc"
+			  ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		      >Arrangeable</A
+		      > (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		      >IsDur</A
+		      > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		      >Musical</A
+		      > (<A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		      >WithDur</A
+		      > d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		      >Seq</A
+		      > a))</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnoteSeq"
+	  ></A
+	  ><B
+	  >noteSeq</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+	  >IsDur</A
+	  > d) =&gt; a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creates a <TT
+	  ><A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	    >Seq</A
+	    ></TT
+	  > with the length that the Reader reads. 
+   (The length will be in any case at least 1).</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnoteSeq'"
+	  ></A
+	  ><B
+	  >noteSeq'</B
+	  > :: (<A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+	  >IsDur</A
+	  > d) =&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d a -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+	  >WithDur</A
+	  > d (<A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > a)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmixdownNumSeq"
+	  ></A
+	  ><B
+	  >mixdownNumSeq</B
+	  > :: (Num a) =&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > [a] -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AapplySeq"
+	  ></A
+	  ><B
+	  >applySeq</B
+	  > :: (s -&gt; s) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > (s -&gt; a) -&gt; s -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AapplySeqE"
+	  ></A
+	  ><B
+	  >applySeqE</B
+	  > :: (s -&gt; s) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > (Either (s -&gt; a) (s -&gt; s)) -&gt; s -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AfilterSeq"
+	  ></A
+	  ><B
+	  >filterSeq</B
+	  > :: (a -&gt; Maybe b) -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > a -&gt; <A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+	  >Seq</A
+	  > b</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Signal.html view
@@ -0,0 +1,1218 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Signal</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Signal</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Mono and Stereo Values</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Signal datatype</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Dieses Module stellt Datentypen und Funktionen zum Umgang mit Mono- und 
+   Stereodaten zur Verfügung. Speziell im Falle des Öffnens einer WAV-Datei 
+   ist erst zur Laufzeit bekannt, ob es sich um eine Mono- oder Stereodatei 
+   handelt, hier wird der Typ <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	    >Signal</A
+	    ></TT
+	  > benötigt.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AMono"
+		>Mono</A
+		> = Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AStereo"
+		>Stereo</A
+		>  = <A HREF = "#v%3A%3A%3E%3C%3A"
+		>(:&gt;&lt;:)</A
+		> !Double !Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AleftStereo"
+		>leftStereo</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3ArightStereo"
+		>rightStereo</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AstereoToMono"
+		>stereoToMono</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmonoToStereo"
+		>monoToStereo</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Abalance"
+		>balance</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3ASignal"
+		      >Signal</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AMono"
+			    >Mono</A
+			    > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+			    >Mono</A
+			    >]</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3AStereo"
+			    >Stereo</A
+			    > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+			    >Stereo</A
+			    >]</TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadWavSignal"
+		>readWavSignal</A
+		> :: FilePath -&gt; IO <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenWavSignal"
+		>openWavSignal</A
+		> :: FilePath -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavMono"
+		>writeWavMono</A
+		> :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavStereo"
+		>writeWavStereo</A
+		> :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		>] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavSignal"
+		>writeWavSignal</A
+		> :: FilePath -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteTracks"
+		>writeTracks</A
+		> :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsignalToMono"
+		>signalToMono</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsignalToStereo"
+		>signalToStereo</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		>]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AeitherSignal"
+		>eitherSignal</A
+		> :: ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>] -&gt; a) -&gt; ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		>Stereo</A
+		>] -&gt; a) -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AliftSignal"
+		>liftSignal</A
+		> :: ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		>Mono</A
+		>]) -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmergeSignal"
+		>mergeSignal</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmergeSignals"
+		>mergeSignals</A
+		> :: [<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AmultSignal"
+		>multSignal</A
+		> :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinfiniteSignal"
+		>infiniteSignal</A
+		> :: Double -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Mono and Stereo Values</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AMono"
+	  ></A
+	  ><B
+	  >Mono</B
+	  > = Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A mono value.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AStereo"
+	  ></A
+	  ><B
+	  >Stereo</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A stereo value with left and right part. It is an instance of class Num 
+   and Fractional. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3A%3A%3E%3C%3A"
+		      ></A
+		      ><B
+		      >(:&gt;&lt;:)</B
+		      > !Double !Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Typeable <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Num <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Fractional <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Eq <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Show <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AleftStereo"
+	  ></A
+	  ><B
+	  >leftStereo</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Access to the left part of a <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	    >Stereo</A
+	    ></TT
+	  > value.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3ArightStereo"
+	  ></A
+	  ><B
+	  >rightStereo</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Access to the right part of a <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	    >Stereo</A
+	    ></TT
+	  > value.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AstereoToMono"
+	  ></A
+	  ><B
+	  >stereoToMono</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Converts a Stereo value to a Mono value (Double)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmonoToStereo"
+	  ></A
+	  ><B
+	  >monoToStereo</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Converts a Mono value (Double) to a Stereo value</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Abalance"
+	  ></A
+	  ><B
+	  >balance</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The range of the Double value must be between -1 and 1. If it is below 0 
+   the left channel is turned down, if it is greater than 0 the right channel 
+   is turned down. NOTE: This function should be replaced by a better one.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Signal datatype</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ASignal"
+	  ></A
+	  ><B
+	  >Signal</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > A Signal is either a list of <TT
+		><A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		  >Mono</A
+		  ></TT
+		> values or a list of <TT
+		><A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		  >Stereo</A
+		  ></TT
+		> values.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMono"
+		      ></A
+		      ><B
+		      >Mono</B
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >]</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AStereo"
+		      ></A
+		      ><B
+		      >Stereo</B
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >]</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >Typeable <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+		      >Trackable</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >))</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >))</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadWavSignal"
+	  ></A
+	  ><B
+	  >readWavSignal</B
+	  > :: FilePath -&gt; IO <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Reads a <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	    >Signal</A
+	    ></TT
+	  > from a WAV-File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenWavSignal"
+	  ></A
+	  ><B
+	  >openWavSignal</B
+	  > :: FilePath -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Opens a <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	    >Signal</A
+	    ></TT
+	  > from a WAV-File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavMono"
+	  ></A
+	  ><B
+	  >writeWavMono</B
+	  > :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Writes a list of mono values to a WAV-File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavStereo"
+	  ></A
+	  ><B
+	  >writeWavStereo</B
+	  > :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  >] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Writes a list of stereo values to a WAV-File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavSignal"
+	  ></A
+	  ><B
+	  >writeWavSignal</B
+	  > :: FilePath -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Writes a <TT
+	  ><A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	    >Signal</A
+	    ></TT
+	  > to a WAV-File.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteTracks"
+	  ></A
+	  ><B
+	  >writeTracks</B
+	  > :: FilePath -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsignalToMono"
+	  ></A
+	  ><B
+	  >signalToMono</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Transfroms a signal to a list of mono values.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsignalToStereo"
+	  ></A
+	  ><B
+	  >signalToStereo</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  >]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Transfroms a signal to a list of stereo values.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AeitherSignal"
+	  ></A
+	  ><B
+	  >eitherSignal</B
+	  > :: ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >] -&gt; a) -&gt; ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+	  >Stereo</A
+	  >] -&gt; a) -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AliftSignal"
+	  ></A
+	  ><B
+	  >liftSignal</B
+	  > :: ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+	  >Mono</A
+	  >]) -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Applies the function to the input signal. If it is a stereo signal, the
+   function is applied to both channels seperately.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmergeSignal"
+	  ></A
+	  ><B
+	  >mergeSignal</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The sum of two signals</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmergeSignals"
+	  ></A
+	  ><B
+	  >mergeSignals</B
+	  > :: [<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >] -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The sum of a set of signals. If all signals are mono, the result will be mono. 
+   Otherwise it will be stereo.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AmultSignal"
+	  ></A
+	  ><B
+	  >multSignal</B
+	  > :: <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Multiplies two signals.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinfiniteSignal"
+	  ></A
+	  ><B
+	  >infiniteSignal</B
+	  > :: Double -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The Double value is added to the input signal (offset). The resulting signal will be infinie 
+   in any case. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Sound.html view
@@ -0,0 +1,3253 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Sound</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Sound</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Classes</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Sound Generators and Transformers</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3D%3D%3E"
+		>(==&gt;)</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> a, <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		>Effect</A
+		> b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A.%3D%3E"
+		>(.=&gt;)</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		>Effect</A
+		> a, <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		>Effect</A
+		> b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		> -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		>)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3ASound"
+		>Sound</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Aplay"
+		      >play</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AplayMono"
+		      >playMono</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AplayStereo"
+		      >playStereo</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >]</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>class</SPAN
+		> <A HREF = "#t%3AEffect"
+		>Effect</A
+		> a  <SPAN CLASS = "keyword"
+		>where</SPAN
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3Aeffect"
+		      >effect</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AeffectMono"
+		      >effectMono</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "#v%3AeffectStereo"
+		      >effectStereo</A
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3C%2B%3E"
+		>(&lt;+&gt;)</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3A%3C*%3E"
+		>(&lt;*&gt;)</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		>Play</A
+		> <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		>Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3AWaveForm"
+		      >WaveForm</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3ASinus"
+			    >Sinus</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ACosinus"
+			    >Cosinus</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ARect"
+			    >Rect</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ASaw"
+			    >Saw</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ATri"
+			    >Tri</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AplayWaveForm"
+		>playWaveForm</A
+		> :: <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		>WaveForm</A
+		> -&gt; [Double] -&gt; [Double]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AOscillator"
+		>Oscillator</A
+		>  = <A HREF = "#v%3AOscillator"
+		>Oscillator</A
+		> <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		>WaveForm</A
+		> Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AToFreq"
+		>ToFreq</A
+		>  = <A HREF = "#v%3AToFreq"
+		>ToFreq</A
+		> Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AToFreqDyn"
+		>ToFreqDyn</A
+		> a = <A HREF = "#v%3AToFreqDyn"
+		>ToFreqDyn</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ANoise"
+		>Noise</A
+		>  = <A HREF = "#v%3ANoise"
+		>Noise</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>newtype</SPAN
+		> <A HREF = "#t%3APlayWav"
+		>PlayWav</A
+		>  = <A HREF = "#v%3APlayWav"
+		>PlayWav</A
+		> FilePath</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AOscWav"
+		>OscWav</A
+		>  = <A HREF = "#v%3AOscWav"
+		>OscWav</A
+		> FilePath Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3APitchWav"
+		>PitchWav</A
+		>  = <A HREF = "#v%3APitchWav"
+		>PitchWav</A
+		> FilePath</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AScratchWav"
+		>ScratchWav</A
+		>  = <A HREF = "#v%3AScratchWav"
+		>ScratchWav</A
+		> FilePath</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AFilter"
+		>Filter</A
+		> a = <A HREF = "#v%3AFilter"
+		>Filter</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AFilterFFT"
+		>FilterFFT</A
+		> a = <A HREF = "#v%3AFilterFFT"
+		>FilterFFT</A
+		> Int a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ALowpass"
+		>Lowpass</A
+		> width cutoff = <A HREF = "#v%3ALowpass"
+		>Lowpass</A
+		> width cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AHighpass"
+		>Highpass</A
+		> width cutoff = <A HREF = "#v%3AHighpass"
+		>Highpass</A
+		> width cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ABandpass"
+		>Bandpass</A
+		> width slope cutoff = <A HREF = "#v%3ABandpass"
+		>Bandpass</A
+		> width slope cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AMorphfilter"
+		>Morphfilter</A
+		> cutoff = <A HREF = "#v%3AMorphfilter"
+		>Morphfilter</A
+		> <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AStretchfilter"
+		>Stretchfilter</A
+		> cutoff = <A HREF = "#v%3AStretchfilter"
+		>Stretchfilter</A
+		> <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		>FilterSpec</A
+		> cutoff</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AEnvelope"
+		>Envelope</A
+		>  = <A HREF = "#v%3AEnvelope"
+		>Envelope</A
+		> <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		>EnvMode</A
+		> <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		>EnvShape</A
+		> <A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+		>ADSR</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AAmplifier"
+		>Amplifier</A
+		> volume = <A HREF = "#v%3AAmplifier"
+		>Amplifier</A
+		> volume</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AAddTo"
+		>AddTo</A
+		> summand = <A HREF = "#v%3AAddTo"
+		>AddTo</A
+		> summand</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AInfinite"
+		>Infinite</A
+		>  = <A HREF = "#v%3AInfinite"
+		>Infinite</A
+		> Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><SPAN CLASS = "keyword"
+		      >data</SPAN
+		      > <A HREF = "#t%3ADelay"
+		      >Delay</A
+		      > </TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "body"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD CLASS = "decl"
+			  >= <A HREF = "#v%3AAbsDelay"
+			    >AbsDelay</A
+			    > Int</TD
+			  ></TR
+			><TR
+			><TD CLASS = "decl"
+			  >| <A HREF = "#v%3ARelDelay"
+			    >RelDelay</A
+			    > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+			    >Dur</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AToMono"
+		>ToMono</A
+		>  = <A HREF = "#v%3AToMono"
+		>ToMono</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AAverage"
+		>Average</A
+		>  = <A HREF = "#v%3AAverage"
+		>Average</A
+		> Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ASampleAndHold"
+		>SampleAndHold</A
+		> trigger = <A HREF = "#v%3ASampleAndHold"
+		>SampleAndHold</A
+		> trigger</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3ACompressor"
+		>Compressor</A
+		> a = <A HREF = "#v%3ACompressor"
+		>Compressor</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3AFollow"
+		>Follow</A
+		> a = <A HREF = "#v%3AFollow"
+		>Follow</A
+		> Double a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>data</SPAN
+		> <A HREF = "#t%3APanorama"
+		>Panorama</A
+		> balance = <A HREF = "#v%3APanorama"
+		>Panorama</A
+		> balance</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Classes</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3D%3D%3E"
+	  ></A
+	  ><B
+	  >(==&gt;)</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a, <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+	  >Effect</A
+	  > b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A.%3D%3E"
+	  ></A
+	  ><B
+	  >(.=&gt;)</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+	  >Effect</A
+	  > a, <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+	  >Effect</A
+	  > b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  >)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3ASound"
+	  ></A
+	  ><B
+	  >Sound</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Minimal complete definition: <TT
+		><A HREF = "Sound.Hommage.Sound.html#v%3Aplay"
+		  >play</A
+		  ></TT
+		>. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Aplay"
+		      ></A
+		      ><B
+		      >play</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AplayMono"
+		      ></A
+		      ><B
+		      >playMono</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AplayStereo"
+		      ></A
+		      ><B
+		      >playStereo</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >]</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > ()</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		      >Track</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AInterpolate"
+		      >Interpolate</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3APlayWav"
+		      >PlayWav</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ALowpass"
+		      >Lowpass</A
+		      > a b)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AHighpass"
+		      >Highpass</A
+		      > a b)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		      >Envelope</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > [(<A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		      >Env</A
+		      >, <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		      >EnvLength</A
+		      >)]</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3ANoise"
+		      >Noise</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > c) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ABandpass"
+		      >Bandpass</A
+		      > a b c)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AMorphfilter"
+		      >Morphfilter</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AStretchfilter"
+		      >Stretchfilter</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >class</SPAN
+	  > <A NAME = "t%3AEffect"
+	  ></A
+	  ><B
+	  >Effect</B
+	  > a  <SPAN CLASS = "keyword"
+	  >where</SPAN
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Methods</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3Aeffect"
+		      ></A
+		      ><B
+		      >effect</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AeffectMono"
+		      ></A
+		      ><B
+		      >effectMono</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "s8"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AeffectStereo"
+		      ></A
+		      ><B
+		      >effectStereo</B
+		      > :: a -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >] -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		      >Play</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >))</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      > -&gt; <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		      >Signal</A
+		      >)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		      >Mono</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > ([<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >] -&gt; [<A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		      >Stereo</A
+		      >])</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFilter"
+		      >Filter</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFilterFFT"
+		      >FilterFFT</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AAmplifier"
+		      >Amplifier</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AAddTo"
+		      >AddTo</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AInfinite"
+		      >Infinite</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AToFreq"
+		      >ToFreq</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AToFreqDyn"
+		      >ToFreqDyn</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AOscillator"
+		      >Oscillator</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AOscWav"
+		      >OscWav</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3APitchWav"
+		      >PitchWav</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AScratchWav"
+		      >ScratchWav</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3ADelay"
+		      >Delay</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AToMono"
+		      >ToMono</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AAverage"
+		      >Average</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ASampleAndHold"
+		      >SampleAndHold</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ACompressor"
+		      >Compressor</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFollow"
+		      >Follow</A
+		      > a)</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3APanorama"
+		      >Panorama</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3C%2B%3E"
+	  ></A
+	  ><B
+	  >(&lt;+&gt;)</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3A%3C*%3E"
+	  ></A
+	  ><B
+	  >(&lt;*&gt;)</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > b) =&gt; a -&gt; b -&gt; <A HREF = "Sound.Hommage.Play.html#t%3APlay"
+	  >Play</A
+	  > <A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+	  >Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Sound Generators and Transformers</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AWaveForm"
+	  ></A
+	  ><B
+	  >WaveForm</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ASinus"
+		      ></A
+		      ><B
+		      >Sinus</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ACosinus"
+		      ></A
+		      ><B
+		      >Cosinus</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ARect"
+		      ></A
+		      ><B
+		      >Rect</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ASaw"
+		      ></A
+		      ><B
+		      >Saw</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ATri"
+		      ></A
+		      ><B
+		      >Tri</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Eq <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Read <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Show <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AplayWaveForm"
+	  ></A
+	  ><B
+	  >playWaveForm</B
+	  > :: <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+	  >WaveForm</A
+	  > -&gt; [Double] -&gt; [Double]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AOscillator"
+	  ></A
+	  ><B
+	  >Oscillator</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AOscillator"
+		      ></A
+		      ><B
+		      >Oscillator</B
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		      >WaveForm</A
+		      > Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AOscillator"
+		      >Oscillator</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AToFreq"
+	  ></A
+	  ><B
+	  >ToFreq</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Turns pitch to frequency. </TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AToFreq"
+		      ></A
+		      ><B
+		      >ToFreq</B
+		      > Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AToFreq"
+		      >ToFreq</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AToFreqDyn"
+	  ></A
+	  ><B
+	  >ToFreqDyn</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AToFreqDyn"
+		      ></A
+		      ><B
+		      >ToFreqDyn</B
+		      > a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AToFreqDyn"
+		      >ToFreqDyn</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ANoise"
+	  ></A
+	  ><B
+	  >Noise</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ANoise"
+		      ></A
+		      ><B
+		      >Noise</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3ANoise"
+		      >Noise</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >newtype</SPAN
+	  > <A NAME = "t%3APlayWav"
+	  ></A
+	  ><B
+	  >PlayWav</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3APlayWav"
+		      ></A
+		      ><B
+		      >PlayWav</B
+		      > FilePath</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3APlayWav"
+		      >PlayWav</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AOscWav"
+	  ></A
+	  ><B
+	  >OscWav</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AOscWav"
+		      ></A
+		      ><B
+		      >OscWav</B
+		      > FilePath Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AOscWav"
+		      >OscWav</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3APitchWav"
+	  ></A
+	  ><B
+	  >PitchWav</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3APitchWav"
+		      ></A
+		      ><B
+		      >PitchWav</B
+		      > FilePath</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3APitchWav"
+		      >PitchWav</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AScratchWav"
+	  ></A
+	  ><B
+	  >ScratchWav</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AScratchWav"
+		      ></A
+		      ><B
+		      >ScratchWav</B
+		      > FilePath</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AScratchWav"
+		      >ScratchWav</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AFilter"
+	  ></A
+	  ><B
+	  >Filter</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFilter"
+		      ></A
+		      ><B
+		      >Filter</B
+		      > a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFilter"
+		      >Filter</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AFilterFFT"
+	  ></A
+	  ><B
+	  >FilterFFT</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFilterFFT"
+		      ></A
+		      ><B
+		      >FilterFFT</B
+		      > Int a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFilterFFT"
+		      >FilterFFT</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ALowpass"
+	  ></A
+	  ><B
+	  >Lowpass</B
+	  > width cutoff</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Width and cutoff.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ALowpass"
+		      ></A
+		      ><B
+		      >Lowpass</B
+		      > width cutoff</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ALowpass"
+		      >Lowpass</A
+		      > a b)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AHighpass"
+	  ></A
+	  ><B
+	  >Highpass</B
+	  > width cutoff</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > Width and cutoff.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AHighpass"
+		      ></A
+		      ><B
+		      >Highpass</B
+		      > width cutoff</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AHighpass"
+		      >Highpass</A
+		      > a b)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ABandpass"
+	  ></A
+	  ><B
+	  >Bandpass</B
+	  > width slope cutoff</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ABandpass"
+		      ></A
+		      ><B
+		      >Bandpass</B
+		      > width slope cutoff</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > b, <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > c) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ABandpass"
+		      >Bandpass</A
+		      > a b c)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AMorphfilter"
+	  ></A
+	  ><B
+	  >Morphfilter</B
+	  > cutoff</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AMorphfilter"
+		      ></A
+		      ><B
+		      >Morphfilter</B
+		      > <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		      >FilterSpec</A
+		      > <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		      >FilterSpec</A
+		      > cutoff</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AMorphfilter"
+		      >Morphfilter</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AStretchfilter"
+	  ></A
+	  ><B
+	  >Stretchfilter</B
+	  > cutoff</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AStretchfilter"
+		      ></A
+		      ><B
+		      >Stretchfilter</B
+		      > <A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		      >FilterSpec</A
+		      > cutoff</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AStretchfilter"
+		      >Stretchfilter</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AEnvelope"
+	  ></A
+	  ><B
+	  >Envelope</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AEnvelope"
+		      ></A
+		      ><B
+		      >Envelope</B
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		      >EnvMode</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		      >EnvShape</A
+		      > <A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+		      >ADSR</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		      >Envelope</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Eq <A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		      >Envelope</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Read <A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		      >Envelope</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    >Show <A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		      >Envelope</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AAmplifier"
+	  ></A
+	  ><B
+	  >Amplifier</B
+	  > volume</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAmplifier"
+		      ></A
+		      ><B
+		      >Amplifier</B
+		      > volume</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AAmplifier"
+		      >Amplifier</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AAddTo"
+	  ></A
+	  ><B
+	  >AddTo</B
+	  > summand</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAddTo"
+		      ></A
+		      ><B
+		      >AddTo</B
+		      > summand</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AAddTo"
+		      >AddTo</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AInfinite"
+	  ></A
+	  ><B
+	  >Infinite</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "ndoc"
+	      > The result will be infinite, with given offset.</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AInfinite"
+		      ></A
+		      ><B
+		      >Infinite</B
+		      > Double</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AInfinite"
+		      >Infinite</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ADelay"
+	  ></A
+	  ><B
+	  >Delay</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAbsDelay"
+		      ></A
+		      ><B
+		      >AbsDelay</B
+		      > Int</TD
+		    ><TD CLASS = "rdoc"
+		    > Absolute Delay</TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ARelDelay"
+		      ></A
+		      ><B
+		      >RelDelay</B
+		      > <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		      >Dur</A
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    > Relative Delay with respect to the current duration</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3ADelay"
+		      >Delay</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AToMono"
+	  ></A
+	  ><B
+	  >ToMono</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AToMono"
+		      ></A
+		      ><B
+		      >ToMono</B
+		      ></TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AToMono"
+		      >ToMono</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AAverage"
+	  ></A
+	  ><B
+	  >Average</B
+	  > </TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AAverage"
+		      ></A
+		      ><B
+		      >Average</B
+		      > Int</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > <A HREF = "Sound.Hommage.Sound.html#t%3AAverage"
+		      >Average</A
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ASampleAndHold"
+	  ></A
+	  ><B
+	  >SampleAndHold</B
+	  > trigger</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ASampleAndHold"
+		      ></A
+		      ><B
+		      >SampleAndHold</B
+		      > trigger</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ASampleAndHold"
+		      >SampleAndHold</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3ACompressor"
+	  ></A
+	  ><B
+	  >Compressor</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3ACompressor"
+		      ></A
+		      ><B
+		      >Compressor</B
+		      > a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3ACompressor"
+		      >Compressor</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3AFollow"
+	  ></A
+	  ><B
+	  >Follow</B
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3AFollow"
+		      ></A
+		      ><B
+		      >Follow</B
+		      > Double a</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3AFollow"
+		      >Follow</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >data</SPAN
+	  > <A NAME = "t%3APanorama"
+	  ></A
+	  ><B
+	  >Panorama</B
+	  > balance</TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      >Constructors</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    ><A NAME = "v%3APanorama"
+		      ></A
+		      ><B
+		      >Panorama</B
+		      > balance</TD
+		    ><TD CLASS = "rdoc"
+		    ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "section4"
+	      >Instances</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "body"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "1" CELLPADDING = "0"
+		><TR
+		  ><TD CLASS = "decl"
+		    >(<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		      >Sound</A
+		      > a) =&gt; <A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		      >Effect</A
+		      > (<A HREF = "Sound.Hommage.Sound.html#t%3APanorama"
+		      >Panorama</A
+		      > a)</TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.Tools.html view
@@ -0,0 +1,247 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.Tools</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.Tools</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtestSound"
+		>testSound</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> a) =&gt; Maybe String -&gt; String -&gt; Bool -&gt; Double -&gt; a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AtestSong"
+		>testSong</A
+		> :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		>Sound</A
+		> a) =&gt; Maybe String -&gt; String -&gt; Bool -&gt; Double -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		>Song</A
+		> a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AstepSequencer"
+		>stepSequencer</A
+		> :: (Eq c) =&gt; [(c, a)] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> -&gt; [c] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Arhythmize"
+		>rhythmize</A
+		> :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		>Dur</A
+		> -&gt; [Int] -&gt; [Maybe a] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		>Notation</A
+		> a</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Apitchlist"
+		>pitchlist</A
+		> :: (Num a, Ord a) =&gt; Bool -&gt; a -&gt; [a]</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Documentation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtestSound"
+	  ></A
+	  ><B
+	  >testSound</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a) =&gt; Maybe String -&gt; String -&gt; Bool -&gt; Double -&gt; a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > Usage: <TT
+	    > testSound mb_wavplayer outputfileprefix stereo? bpm sound </TT
+	    ></P
+	  ><P
+	  >   Example: <TT
+	    > testSound (Just &quot;c:/Programme/coolpro/coolpro.exe&quot;) &quot;out_&quot; True 110.0 $ Interpolate Linear (0,1) </TT
+	    ></P
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AtestSong"
+	  ></A
+	  ><B
+	  >testSong</B
+	  > :: (<A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+	  >Sound</A
+	  > a) =&gt; Maybe String -&gt; String -&gt; Bool -&gt; Double -&gt; <A HREF = "Sound.Hommage.Play.html#t%3ASong"
+	  >Song</A
+	  > a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AstepSequencer"
+	  ></A
+	  ><B
+	  >stepSequencer</B
+	  > :: (Eq c) =&gt; [(c, a)] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > -&gt; [c] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Arhythmize"
+	  ></A
+	  ><B
+	  >rhythmize</B
+	  > :: <A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+	  >Dur</A
+	  > -&gt; [Int] -&gt; [Maybe a] -&gt; <A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+	  >Notation</A
+	  > a</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Apitchlist"
+	  ></A
+	  ><B
+	  >pitchlist</B
+	  > :: (Num a, Ord a) =&gt; Bool -&gt; a -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.WavFile.html view
@@ -0,0 +1,1226 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage.WavFile</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.Hommage.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage.WavFile</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Binary Files</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > WAV-Files</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > Cast between Int16 and Double representation of WAV-data</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Low-Level implemetation </A
+		    ></DT
+		  ><DD
+		  ><DL
+		    ><DT
+		      ><A HREF = "#5"
+			> Arrays and Files</A
+			></DT
+		      ><DT
+		      ><A HREF = "#6"
+			> Single Stream</A
+			></DT
+		      ><DT
+		      ><A HREF = "#7"
+			> Buffered Stream</A
+			></DT
+		      ><DT
+		      ><A HREF = "#8"
+			> Header Stuff and others</A
+			></DT
+		      ></DL
+		    ></DD
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteDataFile"
+		>writeDataFile</A
+		> :: (Storable a) =&gt; FilePath -&gt; [a] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadDataFile"
+		>readDataFile</A
+		> :: (Storable a) =&gt; FilePath -&gt; IO [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenDataFile"
+		>openDataFile</A
+		> :: (Storable a) =&gt; FilePath -&gt; [a]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavFile"
+		>writeWavFile</A
+		> :: FilePath -&gt; Either [Int16] [(Int16, Int16)] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavFileMono"
+		>writeWavFileMono</A
+		> :: FilePath -&gt; [Int16] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavFileStereo"
+		>writeWavFileStereo</A
+		> :: FilePath -&gt; [(Int16, Int16)] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadWavFile"
+		>readWavFile</A
+		> :: FilePath -&gt; IO (Either [Int16] [(Int16, Int16)])</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenWavFile"
+		>openWavFile</A
+		> :: FilePath -&gt; Either [Int16] [(Int16, Int16)]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteWavFiles"
+		>writeWavFiles</A
+		> :: FilePath -&gt; String -&gt; [Either [Int16] [(Int16, Int16)]] -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavInt16ToDouble"
+		>wavInt16ToDouble</A
+		> :: Int16 -&gt; Double</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavDoubleToInt16"
+		>wavDoubleToInt16</A
+		> :: Double -&gt; Int16</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AreadArrayFromFile"
+		>readArrayFromFile</A
+		> :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+		>HeaderSize</A
+		> -&gt; FilePath -&gt; IO (StorableArray Int a, Int)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteArrayToFileWithHeader"
+		>writeArrayToFileWithHeader</A
+		> :: (MArray StorableArray a IO, Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		>HeaderFun</A
+		> -&gt; FilePath -&gt; StorableArray Int a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwriteArrayToFile"
+		>writeArrayToFile</A
+		> :: (MArray StorableArray a IO, Storable a) =&gt; FilePath -&gt; StorableArray Int a -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenSingleInputFile"
+		>openSingleInputFile</A
+		> :: (Storable a) =&gt; Int -&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+		>HeaderSize</A
+		> -&gt; FilePath -&gt; IO (IO (), IO (Maybe a), Int)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenSingleOutputFile"
+		>openSingleOutputFile</A
+		> :: (Storable a) =&gt; Int -&gt; FilePath -&gt; IO (IO (), a -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenSingleInputWavFile"
+		>openSingleInputWavFile</A
+		> :: Int -&gt; FilePath -&gt; IO (IO (), Either (IO (Maybe Int16)) (IO (Maybe (Int16, Int16))), Int)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenSingleOutputWavFileMono"
+		>openSingleOutputWavFileMono</A
+		> :: Int -&gt; FilePath -&gt; IO (IO (), Int16 -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenSingleOutputWavFileStereo"
+		>openSingleOutputWavFileStereo</A
+		> :: Int -&gt; FilePath -&gt; IO (IO (), (Int16, Int16) -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenInputFile"
+		>openInputFile</A
+		> :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+		>HeaderSize</A
+		> -&gt; FilePath -&gt; Int -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO Int, Int)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenOutputFile"
+		>openOutputFile</A
+		> :: (Storable a) =&gt; FilePath -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenOutputFileWithHeader"
+		>openOutputFileWithHeader</A
+		> :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		>HeaderFun</A
+		> -&gt; FilePath -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenInputWavFile"
+		>openInputWavFile</A
+		> :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO (), Int, Bool)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenOutputWavFileMono"
+		>openOutputWavFileMono</A
+		> :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AopenOutputWavFileStereo"
+		>openOutputWavFileStereo</A
+		> :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AHeaderFun"
+		>HeaderFun</A
+		> = (Handle -&gt; IO (), Handle -&gt; Int -&gt; IO ())</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><SPAN CLASS = "keyword"
+		>type</SPAN
+		> <A HREF = "#t%3AHeaderSize"
+		>HeaderSize</A
+		> = Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AnoHeader"
+		>noHeader</A
+		> :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		>HeaderFun</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavHeaderFunMono"
+		>wavHeaderFunMono</A
+		> :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		>HeaderFun</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavHeaderFunStereo"
+		>wavHeaderFunStereo</A
+		> :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		>HeaderFun</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AwavHeaderSize"
+		>wavHeaderSize</A
+		> :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+		>HeaderSize</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitWriteWavHeaderMono"
+		>initWriteWavHeaderMono</A
+		> :: Handle -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitWriteWavHeaderStereo"
+		>initWriteWavHeaderStereo</A
+		> :: Handle -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitReadWavHeader"
+		>initReadWavHeader</A
+		> :: Handle -&gt; IO (Maybe (Bool, Int, Int, Int))</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AcloseWriteWavHeader"
+		>closeWriteWavHeader</A
+		> :: Handle -&gt; Int -&gt; IO ()</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Aencode"
+		>encode</A
+		> :: Int -&gt; String</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3Adecode"
+		>decode</A
+		> :: String -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AencodeWavLengt"
+		>encodeWavLengt</A
+		> :: Int -&gt; (String, String)</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitWavHeaderMono"
+		>initWavHeaderMono</A
+		> :: [Char]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinitWavHeaderStereo"
+		>initWavHeaderStereo</A
+		> :: [Char]</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AsizeOfArrayElements"
+		>sizeOfArrayElements</A
+		> :: (Storable a) =&gt; StorableArray Int a -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinferSizeOfArrayElements"
+		>inferSizeOfArrayElements</A
+		> :: (Storable a) =&gt; (StorableArray Int a -&gt; IO Int) -&gt; StorableArray Int a -&gt; Int</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      ><A HREF = "#v%3AinferSizeOfArrayElements'"
+		>inferSizeOfArrayElements'</A
+		> :: (Storable a) =&gt; (StorableArray Int a -&gt; Int -&gt; IO ()) -&gt; StorableArray Int a -&gt; Int</TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Binary Files</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteDataFile"
+	  ></A
+	  ><B
+	  >writeDataFile</B
+	  > :: (Storable a) =&gt; FilePath -&gt; [a] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadDataFile"
+	  ></A
+	  ><B
+	  >readDataFile</B
+	  > :: (Storable a) =&gt; FilePath -&gt; IO [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenDataFile"
+	  ></A
+	  ><B
+	  >openDataFile</B
+	  > :: (Storable a) =&gt; FilePath -&gt; [a]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > WAV-Files</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavFile"
+	  ></A
+	  ><B
+	  >writeWavFile</B
+	  > :: FilePath -&gt; Either [Int16] [(Int16, Int16)] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavFileMono"
+	  ></A
+	  ><B
+	  >writeWavFileMono</B
+	  > :: FilePath -&gt; [Int16] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavFileStereo"
+	  ></A
+	  ><B
+	  >writeWavFileStereo</B
+	  > :: FilePath -&gt; [(Int16, Int16)] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadWavFile"
+	  ></A
+	  ><B
+	  >readWavFile</B
+	  > :: FilePath -&gt; IO (Either [Int16] [(Int16, Int16)])</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenWavFile"
+	  ></A
+	  ><B
+	  >openWavFile</B
+	  > :: FilePath -&gt; Either [Int16] [(Int16, Int16)]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteWavFiles"
+	  ></A
+	  ><B
+	  >writeWavFiles</B
+	  > :: FilePath -&gt; String -&gt; [Either [Int16] [(Int16, Int16)]] -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > Cast between Int16 and Double representation of WAV-data</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavInt16ToDouble"
+	  ></A
+	  ><B
+	  >wavInt16ToDouble</B
+	  > :: Int16 -&gt; Double</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavDoubleToInt16"
+	  ></A
+	  ><B
+	  >wavDoubleToInt16</B
+	  > :: Double -&gt; Int16</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Low-Level implemetation </A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section2"
+	><A NAME = "5"
+	  > Arrays and Files</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AreadArrayFromFile"
+	  ></A
+	  ><B
+	  >readArrayFromFile</B
+	  > :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+	  >HeaderSize</A
+	  > -&gt; FilePath -&gt; IO (StorableArray Int a, Int)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteArrayToFileWithHeader"
+	  ></A
+	  ><B
+	  >writeArrayToFileWithHeader</B
+	  > :: (MArray StorableArray a IO, Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+	  >HeaderFun</A
+	  > -&gt; FilePath -&gt; StorableArray Int a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwriteArrayToFile"
+	  ></A
+	  ><B
+	  >writeArrayToFile</B
+	  > :: (MArray StorableArray a IO, Storable a) =&gt; FilePath -&gt; StorableArray Int a -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section2"
+	><A NAME = "6"
+	  > Single Stream</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenSingleInputFile"
+	  ></A
+	  ><B
+	  >openSingleInputFile</B
+	  > :: (Storable a) =&gt; Int -&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+	  >HeaderSize</A
+	  > -&gt; FilePath -&gt; IO (IO (), IO (Maybe a), Int)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenSingleOutputFile"
+	  ></A
+	  ><B
+	  >openSingleOutputFile</B
+	  > :: (Storable a) =&gt; Int -&gt; FilePath -&gt; IO (IO (), a -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenSingleInputWavFile"
+	  ></A
+	  ><B
+	  >openSingleInputWavFile</B
+	  > :: Int -&gt; FilePath -&gt; IO (IO (), Either (IO (Maybe Int16)) (IO (Maybe (Int16, Int16))), Int)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenSingleOutputWavFileMono"
+	  ></A
+	  ><B
+	  >openSingleOutputWavFileMono</B
+	  > :: Int -&gt; FilePath -&gt; IO (IO (), Int16 -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenSingleOutputWavFileStereo"
+	  ></A
+	  ><B
+	  >openSingleOutputWavFileStereo</B
+	  > :: Int -&gt; FilePath -&gt; IO (IO (), (Int16, Int16) -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section2"
+	><A NAME = "7"
+	  > Buffered Stream</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenInputFile"
+	  ></A
+	  ><B
+	  >openInputFile</B
+	  > :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+	  >HeaderSize</A
+	  > -&gt; FilePath -&gt; Int -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO Int, Int)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenOutputFile"
+	  ></A
+	  ><B
+	  >openOutputFile</B
+	  > :: (Storable a) =&gt; FilePath -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenOutputFileWithHeader"
+	  ></A
+	  ><B
+	  >openOutputFileWithHeader</B
+	  > :: (Storable a) =&gt; <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+	  >HeaderFun</A
+	  > -&gt; FilePath -&gt; IO (IO (), StorableArray Int a -&gt; Int -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenInputWavFile"
+	  ></A
+	  ><B
+	  >openInputWavFile</B
+	  > :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO (), Int, Bool)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenOutputWavFileMono"
+	  ></A
+	  ><B
+	  >openOutputWavFileMono</B
+	  > :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AopenOutputWavFileStereo"
+	  ></A
+	  ><B
+	  >openOutputWavFileStereo</B
+	  > :: FilePath -&gt; IO (IO (), StorableArray Int Int16 -&gt; Int -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section2"
+	><A NAME = "8"
+	  > Header Stuff and others</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AHeaderFun"
+	  ></A
+	  ><B
+	  >HeaderFun</B
+	  > = (Handle -&gt; IO (), Handle -&gt; Int -&gt; IO ())</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The first Action is applied after opening the file. Then the data
+   bytes are written. The second Action is then called with the number of
+   bytes of the data. It must close the handle. </TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><SPAN CLASS = "keyword"
+	  >type</SPAN
+	  > <A NAME = "t%3AHeaderSize"
+	  ></A
+	  ><B
+	  >HeaderSize</B
+	  > = Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AnoHeader"
+	  ></A
+	  ><B
+	  >noHeader</B
+	  > :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+	  >HeaderFun</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavHeaderFunMono"
+	  ></A
+	  ><B
+	  >wavHeaderFunMono</B
+	  > :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+	  >HeaderFun</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The first Action writes the Header of the wav-file.
+   Then the wav-data is written. The second action moves
+   the Handle to the positions where the lenght of the wav-file 
+   are encoded (in the header) and writes the right number, which 
+   is unknown before all data is written. 
+   Afterwards it closes the file.</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavHeaderFunStereo"
+	  ></A
+	  ><B
+	  >wavHeaderFunStereo</B
+	  > :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+	  >HeaderFun</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AwavHeaderSize"
+	  ></A
+	  ><B
+	  >wavHeaderSize</B
+	  > :: <A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+	  >HeaderSize</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitWriteWavHeaderMono"
+	  ></A
+	  ><B
+	  >initWriteWavHeaderMono</B
+	  > :: Handle -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitWriteWavHeaderStereo"
+	  ></A
+	  ><B
+	  >initWriteWavHeaderStereo</B
+	  > :: Handle -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitReadWavHeader"
+	  ></A
+	  ><B
+	  >initReadWavHeader</B
+	  > :: Handle -&gt; IO (Maybe (Bool, Int, Int, Int))</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AcloseWriteWavHeader"
+	  ></A
+	  ><B
+	  >closeWriteWavHeader</B
+	  > :: Handle -&gt; Int -&gt; IO ()</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Aencode"
+	  ></A
+	  ><B
+	  >encode</B
+	  > :: Int -&gt; String</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3Adecode"
+	  ></A
+	  ><B
+	  >decode</B
+	  > :: String -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AencodeWavLengt"
+	  ></A
+	  ><B
+	  >encodeWavLengt</B
+	  > :: Int -&gt; (String, String)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitWavHeaderMono"
+	  ></A
+	  ><B
+	  >initWavHeaderMono</B
+	  > :: [Char]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinitWavHeaderStereo"
+	  ></A
+	  ><B
+	  >initWavHeaderStereo</B
+	  > :: [Char]</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AsizeOfArrayElements"
+	  ></A
+	  ><B
+	  >sizeOfArrayElements</B
+	  > :: (Storable a) =&gt; StorableArray Int a -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinferSizeOfArrayElements"
+	  ></A
+	  ><B
+	  >inferSizeOfArrayElements</B
+	  > :: (Storable a) =&gt; (StorableArray Int a -&gt; IO Int) -&gt; StorableArray Int a -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	><A NAME = "v%3AinferSizeOfArrayElements'"
+	  ></A
+	  ><B
+	  >inferSizeOfArrayElements'</B
+	  > :: (Storable a) =&gt; (StorableArray Int a -&gt; Int -&gt; IO ()) -&gt; StorableArray Int a -&gt; Int</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/Sound.Hommage.html view
@@ -0,0 +1,643 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    >Sound.Hommage</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "Sound.html"
+		>Parent</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "modulebar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><FONT SIZE = "6"
+		>Sound.Hommage</FONT
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "section4"
+	      ><B
+		>Contents</B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      ><DL
+		><DT
+		  ><A HREF = "#1"
+		    > Basic sound stuff</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#2"
+		    > Musical Notation and Sythesizers</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#3"
+		    > More usable stuff</A
+		    ></DT
+		  ><DT
+		  ><A HREF = "#4"
+		    > Internals</A
+		    ></DT
+		  ></DL
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Description</TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	><P
+	  > HOMMAGE - Haskell Offline Music Manipulation And Generation EDSL</P
+	  ><P
+	  >   Daniel van den Eijkel  <A HREF = "mailto:dvde@gmx.net"
+	    >mailto:dvde@gmx.net</A
+	    ></P
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Synopsis</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "body"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Signal.html"
+		>Sound.Hommage.Signal</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Osc.html"
+		>Sound.Hommage.Osc</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Envelope.html"
+		>Sound.Hommage.Envelope</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Filter.html"
+		>Sound.Hommage.Filter</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Notation.html"
+		>Sound.Hommage.Notation</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Play.html"
+		>Sound.Hommage.Play</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Sound.html"
+		>Sound.Hommage.Sound</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Sample.html"
+		>Sound.Hommage.Sample</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Midi.html"
+		>Sound.Hommage.Midi</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Parameter.html"
+		>Sound.Hommage.Parameter</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.FFT.html"
+		>Sound.Hommage.FFT</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Rand.html"
+		>Sound.Hommage.Rand</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Tools.html"
+		>Sound.Hommage.Tools</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.WavFile.html"
+		>Sound.Hommage.WavFile</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.DFTFilter.html"
+		>Sound.Hommage.DFTFilter</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Seq.html"
+		>Sound.Hommage.Seq</A
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "s8"
+	      ></TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "decl"
+	      >module <A HREF = "Sound.Hommage.Misc.html"
+		>Sound.Hommage.Misc</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "1"
+	  > Basic sound stuff</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Mono and stereo signals:</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Signal.html"
+	  >Sound.Hommage.Signal</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Oscillators</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Osc.html"
+	  >Sound.Hommage.Osc</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Envelopes</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Envelope.html"
+	  >Sound.Hommage.Envelope</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Filter</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Filter.html"
+	  >Sound.Hommage.Filter</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "2"
+	  > Musical Notation and Sythesizers</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A datatype for representing musical structures (idea stolen from Haskore)</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Notation.html"
+	  >Sound.Hommage.Notation</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The Play Monad</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Play.html"
+	  >Sound.Hommage.Play</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> The Sound and Effect classes</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Sound.html"
+	  >Sound.Hommage.Sound</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "3"
+	  > More usable stuff</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> A datatype for buffered audio data</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Sample.html"
+	  >Sound.Hommage.Sample</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Creating MIDI files</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Midi.html"
+	  >Sound.Hommage.Midi</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Experimental: A kind of record datatype</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Parameter.html"
+	  >Sound.Hommage.Parameter</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Pure Haskell FFT Filter</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.FFT.html"
+	  >Sound.Hommage.FFT</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Random Notation</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Rand.html"
+	  >Sound.Hommage.Rand</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Tools.html"
+	  >Sound.Hommage.Tools</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	><A NAME = "4"
+	  > Internals</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> File Input/Output for binary files and WAV files:</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.WavFile.html"
+	  >Sound.Hommage.WavFile</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Basic module for DFT transforming (depends on a C-code file):</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.DFTFilter.html"
+	  >Sound.Hommage.DFTFilter</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Audio rendering</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Seq.html"
+	  >Sound.Hommage.Seq</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "doc"
+	> Miscelaneous convenient functions, collected in an independent module:</TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "decl"
+	>module <A HREF = "Sound.Hommage.Misc.html"
+	  >Sound.Hommage.Misc</A
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tA.html view
@@ -0,0 +1,105 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (A)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >ADSR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AADSR"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >AddTo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AAddTo"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Amplifier</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AAmplifier"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Arrangeable</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3AArrangeable"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Average</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AAverage"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tB.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (B)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Bandpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ABandpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tC.html view
@@ -0,0 +1,129 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (C)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Chan</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AChan"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >CheckField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3ACheckField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >CoeffArr</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffArr"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >CoeffMap</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#t%3ACoeffMap"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Coeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#t%3ACoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Compressor</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ACompressor"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Constant</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AConstant"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tD.html view
@@ -0,0 +1,93 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (D)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Delay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ADelay"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Delta</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3ADelta"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Dur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3ADur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Duration</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3ADuration"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tE.html view
@@ -0,0 +1,129 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (E)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Effect</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AEffect"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Env</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AEnv"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >EnvLength</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvLength"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >EnvMode</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvMode"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >EnvShape</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AEnvShape"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Envelope</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AEnvelope"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Environment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3AEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tF.html view
@@ -0,0 +1,105 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (F)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Field</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Filter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AFilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >FilterFFT</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AFilterFFT"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >FilterSpec</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#t%3AFilterSpec"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Follow</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AFollow"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tG.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (G)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Group</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tH.html view
@@ -0,0 +1,81 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (H)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >HeaderFun</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderFun"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >HeaderSize</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#t%3AHeaderSize"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Highpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AHighpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tI.html view
@@ -0,0 +1,93 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (I)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Infinite</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AInfinite"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Interpolate</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AInterpolate"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >IsDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3AIsDur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >IsEnv</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#t%3AIsEnv"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tL.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (L)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >LM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3ALM"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Lowpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ALowpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tM.html view
@@ -0,0 +1,165 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (M)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >MidiEvent</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiEvent"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiFile"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiNote</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiNote"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiTrack</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiTrack"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiValue</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3AMidiValue"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Mixable</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3AMixable"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Mono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#t%3AMono"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Morphfilter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AMorphfilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Musical</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3AMusical"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tN.html view
@@ -0,0 +1,81 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (N)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >NilM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3ANilM"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Noise</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ANoise"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Notation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3ANotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tO.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (O)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >OscWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AOscWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Oscillator</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AOscillator"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tP.html view
@@ -0,0 +1,117 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (P)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Panorama</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3APanorama"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PitchWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3APitchWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Play</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3APlay"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PlayWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3APlayWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PushFields</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3APushFields"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PushGroups</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3APushGroups"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tR.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (R)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >R</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#t%3AR"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >RM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#t%3ARM"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tS.html view
@@ -0,0 +1,165 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (S)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Sample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#t%3ASample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >SampleAndHold</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ASampleAndHold"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ScratchWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AScratchWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Seq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#t%3ASeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Signal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#t%3ASignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Song</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3ASong"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Sound</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3ASound"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#t%3AStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stretchable</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3AStretchable"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stretchfilter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AStretchfilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tT.html view
@@ -0,0 +1,141 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (T)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Ticks</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#t%3ATicks"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToFields</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AToFields"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToFreq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AToFreq"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToFreqDyn</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AToFreqDyn"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToGroups</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AToGroups"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AToMono"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Track</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3ATrack"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Trackable</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#t%3ATrackable"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tU.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (U)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >UpdateField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#t%3AUpdateField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-tW.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Type/ClassIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index (W)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >WaveForm</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#t%3AWaveForm"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >WithDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#t%3AWithDur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v45.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (-)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >-=-</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3A-%3D-"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >-&gt;-</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3A-%3E-"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v46.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (.)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >.=&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3A.%3D%3E"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v58.html view
@@ -0,0 +1,129 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (:)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >:$</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3A%24"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:+:</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3A%3A%2B%3A"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:=</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3A%3D"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:=:</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3A%3A%3D%3A"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:&gt;&lt;:</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3A%3A%3E%3C%3A"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:&gt;&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3A%3E%3E"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >:?</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3A%3F"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v60.html view
@@ -0,0 +1,93 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (&lt;)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >&lt;*&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3A%3C*%3E"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >&lt;+&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3A%3C%2B%3E"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >&lt;&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3C%3E"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >&lt;?&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3A%3C%3F%3E"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v61.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (=)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >==&gt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3A%3D%3D%3E"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-v62.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (&gt;)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >&gt;&lt;</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3A%3E%3C"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vA.html view
@@ -0,0 +1,321 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (A)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Abs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AAbs"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >AbsDelay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AAbsDelay"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Abs_</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AAbs_"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >AddTo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AAddTo"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Amplifier</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AAmplifier"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >And</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AAnd"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Average</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AAverage"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >absDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AabsDur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >absoluteDuration</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AabsoluteDuration"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >adjustFrequency</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3AadjustFrequency"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >analyseDFT</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AanalyseDFT"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >analyseSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AanalyseSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >appendMidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AappendMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >appendmaps</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Aappendmaps"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >appendmaps'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Aappendmaps'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >appendpair</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Aappendpair"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >applyField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AapplyField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >applySeq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AapplySeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >applySeqE</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AapplySeqE"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >arrayCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AarrayCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >arraySample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AarraySample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >average</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Aaverage"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >average512</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Aaverage512"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vB.html view
@@ -0,0 +1,153 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (B)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Bandpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ABandpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >balance</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3Abalance"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >bandp0FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Abandp0FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >bandp1FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Abandp1FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >bandpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Abandpass"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >bandpassFS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AbandpassFS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >bpmToDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AbpmToDur"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >butterfly</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Abutterfly"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >butterfly'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Abutterfly'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vC.html view
@@ -0,0 +1,189 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (C)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Compressor</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ACompressor"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Constant</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AConstant"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >CosLike</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3ACosLike"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Cosinus</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ACosinus"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >calculateEnvLengths</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AcalculateEnvLengths"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >checkField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AcheckField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >chord</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Achord"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >closeWriteWavHeader</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AcloseWriteWavHeader"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >coeffmap</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3Acoeffmap"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >compress</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Acompress"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >cosinus</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Acosinus"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >crossfade</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Acrossfade"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vD.html view
@@ -0,0 +1,177 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (D)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >DURATION</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ADURATION"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >decode</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3Adecode"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dftanalyse</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftanalyse"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dftfilter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftfilter"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dftfilterBy</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AdftfilterBy"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dftfilterBy'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AdftfilterBy'"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dftsynthese</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3Adftsynthese"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >dropNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AdropNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >durFrom</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AdurFrom"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >durUpdate</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AdurUpdate"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >durationNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AdurationNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vE.html view
@@ -0,0 +1,213 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (E)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Envelope</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AEnvelope"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Environment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >effect</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3Aeffect"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >effectMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AeffectMono"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >effectStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AeffectStereo"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >eitherSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AeitherSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >emptyEnvironment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AemptyEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encode</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3Aencode"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeDelta</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AencodeDelta"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeEvent</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AencodeEvent"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeMidiDeltaEvent</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AencodeMidiDeltaEvent"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeMidiFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AencodeMidiFile"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeMidiTrack</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AencodeMidiTrack"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >encodeWavLengt</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AencodeWavLengt"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vF.html view
@@ -0,0 +1,453 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (F)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Field</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Filter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AFilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >FilterFFT</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AFilterFFT"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >FitADR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AFitADR"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >FitS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AFitS"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Flex</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AFlex"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Follow</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AFollow"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fadeinoutSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AfadeinoutSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ffreq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Affreq"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ffreqi</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Affreqi"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft_level</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft_level"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft_level'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft_level'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft_merge</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft_merge"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fft_merge'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afft_merge'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fftc</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afftc"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fftc'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afftc'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fftco</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afftco"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fftco'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afftco'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fftt</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Afftt"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ffttv</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Affttv"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AfilterCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AfilterNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterNotation'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AfilterNotation'"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterSeq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AfilterSeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterSpecToList</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AfilterSpecToList"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >filterSpecsToLists</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AfilterSpecsToLists"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >foldlSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AfoldlSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >foldr_</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Afoldr_"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >follow</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Afollow"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >for</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Afor"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >for'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Afor'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >fstField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AfstField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vG.html view
@@ -0,0 +1,81 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (G)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Group</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >getDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AgetDur"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >getField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AgetField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vH.html view
@@ -0,0 +1,129 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (H)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Highpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AHighpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >HoldS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AHoldS"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >head_opt</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Ahead_opt"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >highp0FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Ahighp0FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >highp1FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Ahighp1FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >highpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Ahighpass"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >highpassFS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AhighpassFS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vI.html view
@@ -0,0 +1,345 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (I)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >If</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AIf"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Infinite</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AInfinite"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Interpolate</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AInterpolate"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >i</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Ai"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inList</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinList"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inList'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinList'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inList''</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinList''"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inListE</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinListE"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inListE'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinListE'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inListE''</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AinListE''"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inferSizeOfArrayElements</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinferSizeOfArrayElements"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >inferSizeOfArrayElements'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinferSizeOfArrayElements'"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >infiniteSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AinfiniteSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initDuration</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AinitDuration"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initReadWavHeader</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinitReadWavHeader"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initWavHeaderMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinitWavHeaderMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initWavHeaderStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinitWavHeaderStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initWriteWavHeaderMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinitWriteWavHeaderMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >initWriteWavHeaderStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AinitWriteWavHeaderStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >insertEnvironment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AinsertEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >interpolArray</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AinterpolArray"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >interpolFilterLists</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AinterpolFilterLists"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >interpolate</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3Ainterpolate"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >interpolate_cos</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3Ainterpolate_cos"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >isGroup</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AisGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vJ.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (J)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >joinNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AjoinNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vK.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (K)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >kurveDFT</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AkurveDFT"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vL.html view
@@ -0,0 +1,201 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (L)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Linear</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3ALinear"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Lowpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ALowpass"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lastByte</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AlastByte"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >leftGroup</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AleftGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >leftStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AleftStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >liftSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AliftSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >line</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Aline"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >line'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Aline'"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lookupEnvironment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AlookupEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lowp0FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Alowp0FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lowp1FS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Alowp1FS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lowpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Alowpass"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >lowpassFS</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AlowpassFS"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vM.html view
@@ -0,0 +1,621 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (M)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >MidiAsync</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiAsync"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiControl</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiControl"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiCtrl</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiCtrl"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiEndOfTrack</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiEndOfTrack"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiKeyAfter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiKeyAfter"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiNote</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiNote"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiNoteOff</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiNoteOff"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiNoteOn</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiNoteOn"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiSingle</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiSingle"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >MidiSync</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AMidiSync"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Mono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AMono"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Morphfilter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AMorphfilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >map2</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Amap2"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mapNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AmapNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mapSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmapSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >map_</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Amap_"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >merge</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Amerge"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mergeMidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AmergeMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mergeSet</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AmergeSet"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mergeSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AmergeSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mergeSignals</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AmergeSignals"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midi</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Amidi"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midi'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Amidi'"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midiHeaderAsync</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AmidiHeaderAsync"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midiHeaderSingle</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AmidiHeaderSingle"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midiHeaderSync</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AmidiHeaderSync"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >midiSyncFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AmidiSyncFile"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mix</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3Amix"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mix'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3Amix'"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mix_overlap</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Amix_overlap"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mixdown</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3Amixdown"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mixdownNumSeq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AmixdownNumSeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkAnalyse</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkAnalyse"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkCoeffMap</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkCoeffMap"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkFilterBuffered</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkFilterBuffered"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkGroup</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AmkGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkLoopArray</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkLoopArray"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkPitchSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkPitchSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkPlayArray</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkPlayArray"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkPlayCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkPlayCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkPlaySample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkPlaySample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3AmkR"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkScratchSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkScratchSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkSynthese</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AmkSynthese"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >mkTriggerSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AmkTriggerSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >monoToStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AmonoToStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >morphpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Amorphpass"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >multSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AmultSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vN.html view
@@ -0,0 +1,261 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (N)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >NilM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3ANilM"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Noise</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ANoise"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Note</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3ANote"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >newFilePath</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AnewFilePath"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >newSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AnewSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >newSampleFromList</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AnewSampleFromList"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >nextByte</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AnextByte"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >nextEnvironment</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AnextEnvironment"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >noHeader</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AnoHeader"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >normaliseSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AnormaliseSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >notation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3Anotation"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >notationMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AnotationMono"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >notationStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AnotationStereo"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >note</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Anote"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >noteMidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AnoteMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >noteSeq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AnoteSeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >noteSeq'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AnoteSeq'"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >noteToFrequency</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3AnoteToFrequency"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vO.html view
@@ -0,0 +1,285 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (O)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >Or</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AOr"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >OscWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AOscWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Oscillator</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AOscillator"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openDataFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenDataFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openInputFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenInputFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openInputWavFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenInputWavFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openOutputFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenOutputFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openOutputFileWithHeader</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenOutputFileWithHeader"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openOutputWavFileMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenOutputWavFileMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openOutputWavFileStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenOutputWavFileStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openSingleInputFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenSingleInputFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openSingleInputWavFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenSingleInputWavFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openSingleOutputFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenSingleOutputFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openSingleOutputWavFileMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenSingleOutputWavFileMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openSingleOutputWavFileStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenSingleOutputWavFileStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openWavFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AopenWavFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openWavSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AopenWavSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >openWavSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AopenWavSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >osc</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Aosc"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >overlap_curve</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Aoverlap_curve"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vP.html view
@@ -0,0 +1,285 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (P)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >PLAY</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3APLAY"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Panorama</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3APanorama"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PitchWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3APitchWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >PlayWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3APlayWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >parallel</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Aparallel"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >pitchSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3ApitchSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >pitchWavSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3ApitchWavSignal"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >pitchlist</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Tools.html#v%3Apitchlist"
+		  >Sound.Hommage.Tools</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >play</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3Aplay"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playADSR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AplayADSR"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AplayCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AplayMono"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AplaySample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AplayStereo"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playTrack</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AplayTrack"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >playWaveForm</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AplayWaveForm"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >positionNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3ApositionNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >proportional</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Aproportional"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >pushFields</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3ApushFields"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >pushGroups</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3ApushGroups"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vQ.html view
@@ -0,0 +1,69 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (Q)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >qsort</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Aqsort"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >qsortM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AqsortM"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vR.html view
@@ -0,0 +1,561 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (R)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >R</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3AR"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Rect</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ARect"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Rel</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3ARel"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >RelDelay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ARelDelay"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Rel_</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3ARel_"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Rest</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3ARest"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >randomList</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3ArandomList"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >randomPlay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ArandomPlay"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readArrayFromFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AreadArrayFromFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readCoeffArr</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AreadCoeffArr"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AreadCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readDataFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AreadDataFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readWavFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AreadWavFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >readWavSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AreadWavSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rect</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Arect"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rect_filter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Arect_filter"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rect_filter'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Arect_filter'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rect_transform</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Arect_transform"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >relativeDuration</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ArelativeDuration"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >reorder</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Areorder"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >reorder_init'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Areorder_init'"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >resetDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AresetDur"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >resetDuration</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AresetDuration"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rest</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Arest"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rest0</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Arest0"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >restMidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3ArestMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >reverseNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AreverseNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rhythmize</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Tools.html#v%3Arhythmize"
+		  >Sound.Hommage.Tools</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rif</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3Arif"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rightGroup</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3ArightGroup"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rightStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3ArightStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rnote</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3Arnote"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ror</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3Aror"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rplay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3Arplay"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >rselect</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3Arselect"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runEnv</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3ArunEnv"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runMidiMusic</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3ArunMidiMusic"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3ArunNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runNotationWith</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3ArunNotationWith"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runNumNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3ArunNumNotation"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3ArunR"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runRM</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3ArunRM"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >runSong</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ArunSong"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vS.html view
@@ -0,0 +1,465 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (S)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >SEQ</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3ASEQ"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >SONG</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ASONG"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >SampleAndHold</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ASampleAndHold"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Saw</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ASaw"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ScratchWav</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AScratchWav"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Sinus</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ASinus"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stretch</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AStretch"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Stretchfilter</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AStretchfilter"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sampleAndHold</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3AsampleAndHold"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >saveWavSampleMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AsaveWavSampleMono"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >saveWavSampleStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AsaveWavSampleStereo"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >saw</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Asaw"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >scratchSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AscratchSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >scratchWavSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AscratchWavSignal"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sequenceNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AsequenceNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sequent</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Asequent"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >setField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AsetField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >shiftFilterSpec</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3AshiftFilterSpec"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >signalToMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AsignalToMono"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >signalToStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AsignalToStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sinus</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Asinus"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sizeCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AsizeCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sizeOfArrayElements</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AsizeOfArrayElements"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sizeSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AsizeSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >sndField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AsndField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >splitWaves</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3AsplitWaves"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >stepSequencer</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Tools.html#v%3AstepSequencer"
+		  >Sound.Hommage.Tools</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >stereoToMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AstereoToMono"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >storeCoeff</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AstoreCoeff"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >stretch</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3Astretch"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >stretchSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AstretchSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >stretchpass</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Filter.html#v%3Astretchpass"
+		  >Sound.Hommage.Filter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >syntheseDFT</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AsyntheseDFT"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >syntheseSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AsyntheseSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vT.html view
@@ -0,0 +1,285 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (T)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >TRACK</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3ATRACK"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToFreq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AToFreq"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToFreqDyn</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AToFreqDyn"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ToMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3AToMono"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >Tri</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sound.html#v%3ATri"
+		  >Sound.Hommage.Sound</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >takeNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AtakeNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >terminateAt</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3AterminateAt"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >testSong</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Tools.html#v%3AtestSong"
+		  >Sound.Hommage.Tools</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >testSound</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Tools.html#v%3AtestSound"
+		  >Sound.Hommage.Tools</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toBytes</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AtoBytes"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toEnv</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Envelope.html#v%3AtoEnv"
+		  >Sound.Hommage.Envelope</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toFields</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AtoFields"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toGroups</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AtoGroups"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toList</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AtoList"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toList'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AtoList'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toListE</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AtoListE"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toListE'</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3AtoListE'"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >toNext</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AtoNext"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >track</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3Atrack"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >tri</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Osc.html#v%3Atri"
+		  >Sound.Hommage.Osc</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vU.html view
@@ -0,0 +1,177 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (U)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >unPlay</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AunPlay"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unR</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Rand.html#v%3AunR"
+		  >Sound.Hommage.Rand</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unSeq</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Seq.html#v%3AunSeq"
+		  >Sound.Hommage.Seq</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unSong</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AunSong"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unTrack</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Play.html#v%3AunTrack"
+		  >Sound.Hommage.Play</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unWithDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AunWithDur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >uneitherlist</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Auneitherlist"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unmaybeNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AunmaybeNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >unstoreCoeff</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AunstoreCoeff"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >updateField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AupdateField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >updateSample</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AupdateSample"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vW.html view
@@ -0,0 +1,357 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (W)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >WithDur</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AWithDur"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >w</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Aw"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >walk</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Misc.html#v%3Awalk"
+		  >Sound.Hommage.Misc</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavDoubleToInt16</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwavDoubleToInt16"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavHeaderFunMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwavHeaderFunMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavHeaderFunStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwavHeaderFunStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavHeaderSize</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwavHeaderSize"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavInt16ToDouble</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwavInt16ToDouble"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >wavesizeCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AwavesizeCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >withField</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Parameter.html#v%3AwithField"
+		  >Sound.Hommage.Parameter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeArrayToFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteArrayToFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeArrayToFileWithHeader</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteArrayToFileWithHeader"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeCoeffArr</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.DFTFilter.html#v%3AwriteCoeffArr"
+		  >Sound.Hommage.DFTFilter</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeCoeffs</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Sample.html#v%3AwriteCoeffs"
+		  >Sound.Hommage.Sample</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeDataFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteDataFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeMidiFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Midi.html#v%3AwriteMidiFile"
+		  >Sound.Hommage.Midi</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeMidiSyncNotation</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Notation.html#v%3AwriteMidiSyncNotation"
+		  >Sound.Hommage.Notation</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeTracks</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AwriteTracks"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavFile</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteWavFile"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavFileMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteWavFileMono"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavFileStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteWavFileStereo"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavFiles</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.WavFile.html#v%3AwriteWavFiles"
+		  >Sound.Hommage.WavFile</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavMono</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AwriteWavMono"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavSignal</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AwriteWavSignal"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >writeWavStereo</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.Signal.html#v%3AwriteWavStereo"
+		  >Sound.Hommage.Signal</A
+		  ></B
+		></TD
+	      ></TR
+	    ><TR
+	    ><TD
+	      >ws</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Aws"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index-vZ.html view
@@ -0,0 +1,57 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Function/ConstructorIndex)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index (Z)</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      >zip2</TD
+	      ><TD
+	      ><A HREF = "Sound.Hommage.html"
+		>Sound.Hommage</A
+		> <B
+		><A HREF = "Sound.Hommage.FFT.html#v%3Azip2"
+		  >Sound.Hommage.FFT</A
+		  ></B
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/doc-index.html view
@@ -0,0 +1,251 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    > (Index)</TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Type/Class Index</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      ><A HREF = "doc-index-tA.html"
+		>A</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tB.html"
+		>B</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tC.html"
+		>C</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tD.html"
+		>D</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tE.html"
+		>E</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tF.html"
+		>F</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tG.html"
+		>G</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tH.html"
+		>H</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tI.html"
+		>I</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tL.html"
+		>L</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tM.html"
+		>M</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tN.html"
+		>N</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tO.html"
+		>O</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tP.html"
+		>P</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tR.html"
+		>R</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tS.html"
+		>S</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tT.html"
+		>T</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tU.html"
+		>U</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-tW.html"
+		>W</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Function/Constructor Index</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "5"
+	  ><TR
+	    ><TD
+	      ><A HREF = "doc-index-vA.html"
+		>A</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vB.html"
+		>B</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vC.html"
+		>C</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vD.html"
+		>D</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vE.html"
+		>E</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vF.html"
+		>F</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vG.html"
+		>G</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vH.html"
+		>H</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vI.html"
+		>I</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vJ.html"
+		>J</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vK.html"
+		>K</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vL.html"
+		>L</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vM.html"
+		>M</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vN.html"
+		>N</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vO.html"
+		>O</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vP.html"
+		>P</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vQ.html"
+		>Q</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vR.html"
+		>R</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vS.html"
+		>S</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vT.html"
+		>T</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vU.html"
+		>U</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vW.html"
+		>W</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-vZ.html"
+		>Z</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v58.html"
+		>:</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v46.html"
+		>.</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v60.html"
+		>&lt;</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v61.html"
+		>=</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v62.html"
+		>&gt;</A
+		></TD
+	      ><TD
+	      ><A HREF = "doc-index-v45.html"
+		>-</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ doc/haddock.css view
@@ -0,0 +1,180 @@+/* -------- Global things --------- */
+
+BODY { 
+  background-color: #ffffff;
+  color: #000000;
+  font-family: sans-serif;
+  } 
+
+A:link    { color: #0000e0; text-decoration: none }
+A:visited { color: #0000a0; text-decoration: none }
+A:hover   { background-color: #e0e0ff; text-decoration: none }
+
+TABLE.vanilla {
+  width: 100%;
+  border-width: 0px;
+  /* I can't seem to specify cellspacing or cellpadding properly using CSS... */
+}
+
+/* <TT> font is a little too small in MSIE */
+TT  { font-size: 100%; }
+PRE { font-size: 100%; }
+
+LI P { margin: 0pt } 
+
+TD {
+  border-width: 0px;
+}
+
+TABLE.narrow {
+  border-width: 0px;
+}
+
+TD.s8  {  height: 8px;  }
+TD.s15 {  height: 15px; }
+
+SPAN.keyword { text-decoration: underline; }
+
+/* --------- Documentation elements ---------- */
+
+TD.children {
+  padding-left: 25px;
+  }
+
+TD.synopsis {
+  padding: 2px;
+  background-color: #f0f0f0;
+  font-family: monospace
+ }
+
+TD.decl { 
+  padding: 2px;
+  background-color: #f0f0f0; 
+  font-family: monospace;
+  white-space: nowrap;
+  vertical-align: top;
+  }
+
+TD.recfield { padding-left: 20px }
+
+TD.doc  { 
+  padding-top: 2px;
+  padding-left: 10px;
+  }
+
+TD.ndoc  { 
+  padding: 2px;
+  }
+
+TD.rdoc  { 
+  padding: 2px;
+  padding-left: 10px;
+  width: 100%;
+  }
+
+TD.body  { 
+  padding-left: 10px
+  }
+
+/* ------- Section Headings ------- */
+
+TD.section1 {
+  padding-top: 15px;
+  font-weight: bold;
+  font-size: 150%
+  }
+
+TD.section2 {
+  padding-top: 10px;
+  font-weight: bold;
+  font-size: 130%
+  }
+
+TD.section3 {
+  padding-top: 5px;
+  font-weight: bold;
+  font-size: 110%
+  }
+
+TD.section4 {
+  font-weight: bold;
+  font-size: 100%
+  }
+
+/* -------------- The title bar at the top of the page */
+
+TD.infohead {
+  color: #ffffff;
+  font-weight: bold;
+  padding-right: 10px;
+  text-align: left;
+}
+
+TD.infoval {
+  color: #ffffff;
+  padding-right: 10px;
+  text-align: left;
+}
+
+TD.topbar {
+  background-color: #000099;
+  padding: 5px;
+}
+
+TD.title {
+  color: #ffffff;
+  padding-left: 10px;
+  width: 100%
+  }
+
+TD.topbut {
+  padding-left: 5px;
+  padding-right: 5px;
+  border-left-width: 1px;
+  border-left-color: #ffffff;
+  border-left-style: solid;
+  white-space: nowrap;
+  }
+
+TD.topbut A:link {
+  color: #ffffff
+  }
+
+TD.topbut A:visited {
+  color: #ffff00
+  }
+
+TD.topbut A:hover {
+  background-color: #6060ff;
+  }
+
+TD.topbut:hover {
+  background-color: #6060ff
+  }
+
+TD.modulebar { 
+  background-color: #0077dd;
+  padding: 5px;
+  border-top-width: 1px;
+  border-top-color: #ffffff;
+  border-top-style: solid;
+  }
+
+/* --------- The page footer --------- */
+
+TD.botbar {
+  background-color: #000099;
+  color: #ffffff;
+  padding: 5px
+  }
+TD.botbar A:link {
+  color: #ffffff;
+  text-decoration: underline
+  }
+TD.botbar A:visited {
+  color: #ffff00
+  }
+TD.botbar A:hover {
+  background-color: #6060ff
+  }
+

+ doc/haskell_icon.gif view
binary file changed (absent → 911 bytes)
+ doc/index.html view
@@ -0,0 +1,179 @@+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--Rendered using the Haskell Html Library v0.2-->
+<HTML
+><HEAD
+  ><TITLE
+    ></TITLE
+    ><LINK HREF = "haddock.css" REL = "stylesheet" TYPE = "text/css"
+    ></HEAD
+  ><BODY
+  ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+    ><TR
+      ><TD CLASS = "topbar"
+	><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+	  ><TR
+	    ><TD
+	      ><IMG SRC = "haskell_icon.gif" WIDTH = "16" HEIGHT = "16" ALT = " "
+		></TD
+	      ><TD CLASS = "title"
+	      ></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "index.html"
+		>Contents</A
+		></TD
+	      ><TD CLASS = "topbut"
+	      ><A HREF = "doc-index.html"
+		>Index</A
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "section1"
+	>Modules</TD
+	></TR
+      ><TR
+      ><TD
+	><TABLE CELLPADDING = "0" CELLSPACING = "2"
+	  ><TR
+	    ><TD
+	      >Sound</TD
+	      ></TR
+	    ><TR
+	    ><TD CLASS = "children"
+	      ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		><TR
+		  ><TD
+		    ><A HREF = "Sound.Hommage.html"
+		      >Hommage</A
+		      ></TD
+		    ></TR
+		  ><TR
+		  ><TD CLASS = "children"
+		    ><TABLE CLASS = "vanilla" CELLSPACING = "0" CELLPADDING = "0"
+		      ><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.DFTFilter.html"
+			    >DFTFilter</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Envelope.html"
+			    >Envelope</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.FFT.html"
+			    >FFT</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Filter.html"
+			    >Filter</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Midi.html"
+			    >Midi</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Misc.html"
+			    >Misc</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Notation.html"
+			    >Notation</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Osc.html"
+			    >Osc</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Parameter.html"
+			    >Parameter</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Play.html"
+			    >Play</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Rand.html"
+			    >Rand</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Sample.html"
+			    >Sample</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Seq.html"
+			    >Seq</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Signal.html"
+			    >Signal</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Sound.html"
+			    >Sound</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.Tools.html"
+			    >Tools</A
+			    ></TD
+			  ></TR
+			><TR
+			><TD
+			  ><A HREF = "Sound.Hommage.WavFile.html"
+			    >WavFile</A
+			    ></TD
+			  ></TR
+			></TABLE
+		      ></TD
+		    ></TR
+		  ></TABLE
+		></TD
+	      ></TR
+	    ></TABLE
+	  ></TD
+	></TR
+      ><TR
+      ><TD CLASS = "s15"
+	></TD
+	></TR
+      ><TR
+      ><TD CLASS = "botbar"
+	>Produced by <A HREF = "http://www.haskell.org/haddock/"
+	  >Haddock</A
+	  > version HADDOCK_VERSION</TD
+	></TR
+      ></TABLE
+    ></BODY
+  ></HTML
+>

+ hommage.cabal view
@@ -0,0 +1,36 @@+Name:               hommage+Version:            0.0.5+License-file:       LICENSE+Author:			    Daniel van den Eijkel <dvde@gmx.net>+Category:           Sound+Synopsis:           Haskell Offline Music Manipulation And Generation EDSL+Description:        HOMMAGE is the successor of the Haskell Sound Lib.+                    <http://substitut-fuer-feinmotorik.net/projects/haskellommage/introduction>+Cabal-Version:      >=1.2+Build-Type:         Simple+GHC-Options:        -O2 -fglasgow-exts+License:            BSD3+Maintainer:         <None>++c-sources:          Sound/Hommage/dft.c  ++build-depends:      base, directory, array, haskell98, random, time++Exposed-modules:    Sound.Hommage, +                    Sound.Hommage.Misc, +                    Sound.Hommage.WavFile, +                    Sound.Hommage.DFTFilter, +                    Sound.Hommage.Signal, +                    Sound.Hommage.Sample, +                    Sound.Hommage.Midi, +                    Sound.Hommage.Notation, +                    Sound.Hommage.Seq, +                    Sound.Hommage.Osc, +                    Sound.Hommage.Envelope, +                    Sound.Hommage.Filter, +                    Sound.Hommage.Play, +                    Sound.Hommage.Sound, +                    Sound.Hommage.Parameter, +                    Sound.Hommage.FFT+                    Sound.Hommage.Rand+                    Sound.Hommage.Tools