packages feed

musicxml 0.1.1 → 0.1.2

raw patch · 23 files changed

+692/−906 lines, 23 filesdep ~HaXmldep ~basedep ~containersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: HaXml, base, containers, directory, old-time, pretty

API changes (from Hackage documentation)

- Text.XML.MusicXML.Note: read_Notations_aux1 :: (Eq i) => STM Result [Content i] (Editorial, Notations_)
- Text.XML.MusicXML.Note: show_Notations_aux1 :: (Editorial, Notations_) -> [Content ()]
- Text.XML.MusicXML.Util: ST :: (s -> (s, a)) -> ST s a
- Text.XML.MusicXML.Util: STM :: (s -> m (s, a)) -> STM m s a
- Text.XML.MusicXML.Util: instance (Monad m) => Functor (STM m s)
- Text.XML.MusicXML.Util: instance (Monad m) => Monad (STM m s)
- Text.XML.MusicXML.Util: instance (MonadPlus m) => MonadPlus (STM m s)
- Text.XML.MusicXML.Util: instance Functor (ST s)
- Text.XML.MusicXML.Util: instance Monad (ST s)
- Text.XML.MusicXML.Util: liftST :: (s -> a) -> ST s a
- Text.XML.MusicXML.Util: liftSTM :: (Monad m) => ST s (m a) -> STM m s a
- Text.XML.MusicXML.Util: newtype ST s a
- Text.XML.MusicXML.Util: newtype STM m s a
- Text.XML.MusicXML.Util: returnSTM :: (Monad m) => m a -> STM m s a
- Text.XML.MusicXML.Util: stateM :: STM m s a -> s -> m (s, a)
+ Text.XML.MusicXML.Util: State :: (s -> (s, a)) -> State s a
+ Text.XML.MusicXML.Util: StateT :: (s -> m (s, a)) -> StateT m s a
+ Text.XML.MusicXML.Util: instance (Monad m) => Functor (StateT m s)
+ Text.XML.MusicXML.Util: instance (Monad m) => Monad (StateT m s)
+ Text.XML.MusicXML.Util: instance (MonadPlus m) => MonadPlus (StateT m s)
+ Text.XML.MusicXML.Util: instance Functor (State s)
+ Text.XML.MusicXML.Util: instance Monad (State s)
+ Text.XML.MusicXML.Util: liftState :: (s -> a) -> State s a
+ Text.XML.MusicXML.Util: liftStateT :: (Monad m) => State s (m a) -> StateT m s a
+ Text.XML.MusicXML.Util: newtype State s a
+ Text.XML.MusicXML.Util: newtype StateT m s a
+ Text.XML.MusicXML.Util: returnStateT :: (Monad m) => m a -> StateT m s a
+ Text.XML.MusicXML.Util: stateT :: StateT m s a -> s -> m (s, a)
- Text.XML.MusicXML: read_DOCUMENT :: STM Result [Content Posn] a -> Document Posn -> Result a
+ Text.XML.MusicXML: read_DOCUMENT :: StateT Result [Content Posn] a -> Document Posn -> Result a
- Text.XML.MusicXML.Attributes: read_Attributes :: (Eq i) => STM Result [Content i] Attributes
+ Text.XML.MusicXML.Attributes: read_Attributes :: (Eq i) => StateT Result [Content i] Attributes
- Text.XML.MusicXML.Attributes: read_Beat_Repeat :: (Eq i) => STM Result [Content i] Beat_Repeat
+ Text.XML.MusicXML.Attributes: read_Beat_Repeat :: (Eq i) => StateT Result [Content i] Beat_Repeat
- Text.XML.MusicXML.Attributes: read_Beat_Repeat_aux1 :: (Eq i) => STM Result [Content i] (Slash_Type, [Slash_Dot])
+ Text.XML.MusicXML.Attributes: read_Beat_Repeat_aux1 :: (Eq i) => StateT Result [Content i] (Slash_Type, [Slash_Dot])
- Text.XML.MusicXML.Attributes: read_Beat_Type :: STM Result [Content i] Beat_Type
+ Text.XML.MusicXML.Attributes: read_Beat_Type :: StateT Result [Content i] Beat_Type
- Text.XML.MusicXML.Attributes: read_Beats :: STM Result [Content i] Beats
+ Text.XML.MusicXML.Attributes: read_Beats :: StateT Result [Content i] Beats
- Text.XML.MusicXML.Attributes: read_Cancel :: STM Result [Content i] Cancel
+ Text.XML.MusicXML.Attributes: read_Cancel :: StateT Result [Content i] Cancel
- Text.XML.MusicXML.Attributes: read_Capo :: STM Result [Content i] Capo
+ Text.XML.MusicXML.Attributes: read_Capo :: StateT Result [Content i] Capo
- Text.XML.MusicXML.Attributes: read_Chromatic :: STM Result [Content i] Chromatic
+ Text.XML.MusicXML.Attributes: read_Chromatic :: StateT Result [Content i] Chromatic
- Text.XML.MusicXML.Attributes: read_Clef :: (Eq i) => STM Result [Content i] Clef
+ Text.XML.MusicXML.Attributes: read_Clef :: (Eq i) => StateT Result [Content i] Clef
- Text.XML.MusicXML.Attributes: read_Clef_Octave_Change :: STM Result [Content i] Clef_Octave_Change
+ Text.XML.MusicXML.Attributes: read_Clef_Octave_Change :: StateT Result [Content i] Clef_Octave_Change
- Text.XML.MusicXML.Attributes: read_Diatonic :: STM Result [Content i] Diatonic
+ Text.XML.MusicXML.Attributes: read_Diatonic :: StateT Result [Content i] Diatonic
- Text.XML.MusicXML.Attributes: read_Directive :: STM Result [Content i] Directive
+ Text.XML.MusicXML.Attributes: read_Directive :: StateT Result [Content i] Directive
- Text.XML.MusicXML.Attributes: read_Divisions :: STM Result [Content i] Divisions
+ Text.XML.MusicXML.Attributes: read_Divisions :: StateT Result [Content i] Divisions
- Text.XML.MusicXML.Attributes: read_Double :: STM Result [Content i] Double
+ Text.XML.MusicXML.Attributes: read_Double :: StateT Result [Content i] Double
- Text.XML.MusicXML.Attributes: read_Fifths :: STM Result [Content i] Fifths
+ Text.XML.MusicXML.Attributes: read_Fifths :: StateT Result [Content i] Fifths
- Text.XML.MusicXML.Attributes: read_Instruments :: STM Result [Content i] Instruments
+ Text.XML.MusicXML.Attributes: read_Instruments :: StateT Result [Content i] Instruments
- Text.XML.MusicXML.Attributes: read_Key :: (Eq i) => STM Result [Content i] Key
+ Text.XML.MusicXML.Attributes: read_Key :: (Eq i) => StateT Result [Content i] Key
- Text.XML.MusicXML.Attributes: read_Key_ :: (Eq i) => STM Result [Content i] Key_
+ Text.XML.MusicXML.Attributes: read_Key_ :: (Eq i) => StateT Result [Content i] Key_
- Text.XML.MusicXML.Attributes: read_Key_Alter :: STM Result [Content i] Key_Alter
+ Text.XML.MusicXML.Attributes: read_Key_Alter :: StateT Result [Content i] Key_Alter
- Text.XML.MusicXML.Attributes: read_Key_Octave :: STM Result [Content i] Key_Octave
+ Text.XML.MusicXML.Attributes: read_Key_Octave :: StateT Result [Content i] Key_Octave
- Text.XML.MusicXML.Attributes: read_Key_Step :: STM Result [Content i] Key_Step
+ Text.XML.MusicXML.Attributes: read_Key_Step :: StateT Result [Content i] Key_Step
- Text.XML.MusicXML.Attributes: read_Key_aux1 :: (Eq i) => STM Result [Content i] (Maybe Cancel, Fifths, Maybe Mode)
+ Text.XML.MusicXML.Attributes: read_Key_aux1 :: (Eq i) => StateT Result [Content i] (Maybe Cancel, Fifths, Maybe Mode)
- Text.XML.MusicXML.Attributes: read_Key_aux2 :: (Eq i) => STM Result [Content i] (Key_Step, Key_Alter)
+ Text.XML.MusicXML.Attributes: read_Key_aux2 :: (Eq i) => StateT Result [Content i] (Key_Step, Key_Alter)
- Text.XML.MusicXML.Attributes: read_Line :: STM Result [Content i] Line
+ Text.XML.MusicXML.Attributes: read_Line :: StateT Result [Content i] Line
- Text.XML.MusicXML.Attributes: read_Measure_Repeat :: STM Result [Content i] Measure_Repeat
+ Text.XML.MusicXML.Attributes: read_Measure_Repeat :: StateT Result [Content i] Measure_Repeat
- Text.XML.MusicXML.Attributes: read_Measure_Style :: (Eq i) => STM Result [Content i] Measure_Style
+ Text.XML.MusicXML.Attributes: read_Measure_Style :: (Eq i) => StateT Result [Content i] Measure_Style
- Text.XML.MusicXML.Attributes: read_Measure_Style_ :: (Eq i) => STM Result [Content i] Measure_Style_
+ Text.XML.MusicXML.Attributes: read_Measure_Style_ :: (Eq i) => StateT Result [Content i] Measure_Style_
- Text.XML.MusicXML.Attributes: read_Mode :: STM Result [Content i] Mode
+ Text.XML.MusicXML.Attributes: read_Mode :: StateT Result [Content i] Mode
- Text.XML.MusicXML.Attributes: read_Multiple_Rest :: STM Result [Content i] Multiple_Rest
+ Text.XML.MusicXML.Attributes: read_Multiple_Rest :: StateT Result [Content i] Multiple_Rest
- Text.XML.MusicXML.Attributes: read_Octave_Change :: STM Result [Content i] Octave_Change
+ Text.XML.MusicXML.Attributes: read_Octave_Change :: StateT Result [Content i] Octave_Change
- Text.XML.MusicXML.Attributes: read_Part_Symbol :: STM Result [Content i] Part_Symbol
+ Text.XML.MusicXML.Attributes: read_Part_Symbol :: StateT Result [Content i] Part_Symbol
- Text.XML.MusicXML.Attributes: read_Senza_Misura :: STM Result [Content i] Senza_Misura
+ Text.XML.MusicXML.Attributes: read_Senza_Misura :: StateT Result [Content i] Senza_Misura
- Text.XML.MusicXML.Attributes: read_Sign :: STM Result [Content i] Sign
+ Text.XML.MusicXML.Attributes: read_Sign :: StateT Result [Content i] Sign
- Text.XML.MusicXML.Attributes: read_Slash :: (Eq i) => STM Result [Content i] Slash
+ Text.XML.MusicXML.Attributes: read_Slash :: (Eq i) => StateT Result [Content i] Slash
- Text.XML.MusicXML.Attributes: read_Slash_Dot :: STM Result [Content i] Slash_Dot
+ Text.XML.MusicXML.Attributes: read_Slash_Dot :: StateT Result [Content i] Slash_Dot
- Text.XML.MusicXML.Attributes: read_Slash_Type :: STM Result [Content i] Slash_Type
+ Text.XML.MusicXML.Attributes: read_Slash_Type :: StateT Result [Content i] Slash_Type
- Text.XML.MusicXML.Attributes: read_Slash_aux1 :: (Eq i) => STM Result [Content i] (Slash_Type, [Slash_Dot])
+ Text.XML.MusicXML.Attributes: read_Slash_aux1 :: (Eq i) => StateT Result [Content i] (Slash_Type, [Slash_Dot])
- Text.XML.MusicXML.Attributes: read_Staff_Details :: (Eq i) => STM Result [Content i] Staff_Details
+ Text.XML.MusicXML.Attributes: read_Staff_Details :: (Eq i) => StateT Result [Content i] Staff_Details
- Text.XML.MusicXML.Attributes: read_Staff_Lines :: STM Result [Content i] Staff_Lines
+ Text.XML.MusicXML.Attributes: read_Staff_Lines :: StateT Result [Content i] Staff_Lines
- Text.XML.MusicXML.Attributes: read_Staff_Size :: STM Result [Content i] Staff_Size
+ Text.XML.MusicXML.Attributes: read_Staff_Size :: StateT Result [Content i] Staff_Size
- Text.XML.MusicXML.Attributes: read_Staff_Tuning :: (Eq i) => STM Result [Content i] Staff_Tuning
+ Text.XML.MusicXML.Attributes: read_Staff_Tuning :: (Eq i) => StateT Result [Content i] Staff_Tuning
- Text.XML.MusicXML.Attributes: read_Staff_Type :: STM Result [Content i] Staff_Type
+ Text.XML.MusicXML.Attributes: read_Staff_Type :: StateT Result [Content i] Staff_Type
- Text.XML.MusicXML.Attributes: read_Staves :: STM Result [Content i] Staves
+ Text.XML.MusicXML.Attributes: read_Staves :: StateT Result [Content i] Staves
- Text.XML.MusicXML.Attributes: read_Time :: (Eq i) => STM Result [Content i] Time
+ Text.XML.MusicXML.Attributes: read_Time :: (Eq i) => StateT Result [Content i] Time
- Text.XML.MusicXML.Attributes: read_Time_B :: (Eq i) => STM Result [Content i] Time_B
+ Text.XML.MusicXML.Attributes: read_Time_B :: (Eq i) => StateT Result [Content i] Time_B
- Text.XML.MusicXML.Attributes: read_Time_B_aux1 :: STM Result [Content i] (Beats, Beat_Type)
+ Text.XML.MusicXML.Attributes: read_Time_B_aux1 :: StateT Result [Content i] (Beats, Beat_Type)
- Text.XML.MusicXML.Attributes: read_Transpose :: (Eq i) => STM Result [Content i] Transpose
+ Text.XML.MusicXML.Attributes: read_Transpose :: (Eq i) => StateT Result [Content i] Transpose
- Text.XML.MusicXML.Barline: read_Bar_Style :: STM Result [Content i] Bar_Style
+ Text.XML.MusicXML.Barline: read_Bar_Style :: StateT Result [Content i] Bar_Style
- Text.XML.MusicXML.Barline: read_Barline :: (Eq i) => STM Result [Content i] Barline
+ Text.XML.MusicXML.Barline: read_Barline :: (Eq i) => StateT Result [Content i] Barline
- Text.XML.MusicXML.Barline: read_Barline_aux1 :: STM Result [Content i] (Fermata, Maybe Fermata)
+ Text.XML.MusicXML.Barline: read_Barline_aux1 :: StateT Result [Content i] (Fermata, Maybe Fermata)
- Text.XML.MusicXML.Barline: read_Ending :: (Eq i) => STM Result [Content i] Ending
+ Text.XML.MusicXML.Barline: read_Ending :: (Eq i) => StateT Result [Content i] Ending
- Text.XML.MusicXML.Barline: read_Repeat :: STM Result [Content i] Repeat
+ Text.XML.MusicXML.Barline: read_Repeat :: StateT Result [Content i] Repeat
- Text.XML.MusicXML.Common: read_Accidental_Text :: STM Result [Content i] Accidental_Text
+ Text.XML.MusicXML.Common: read_Accidental_Text :: StateT Result [Content i] Accidental_Text
- Text.XML.MusicXML.Common: read_Actual_Notes :: STM Result [Content i] Actual_Notes
+ Text.XML.MusicXML.Common: read_Actual_Notes :: StateT Result [Content i] Actual_Notes
- Text.XML.MusicXML.Common: read_Bend_Sound :: STM Result [Attribute] Bend_Sound
+ Text.XML.MusicXML.Common: read_Bend_Sound :: StateT Result [Attribute] Bend_Sound
- Text.XML.MusicXML.Common: read_Bezier :: STM Result [Attribute] Bezier
+ Text.XML.MusicXML.Common: read_Bezier :: StateT Result [Attribute] Bezier
- Text.XML.MusicXML.Common: read_Coda :: STM Result [Content i] Coda
+ Text.XML.MusicXML.Common: read_Coda :: StateT Result [Content i] Coda
- Text.XML.MusicXML.Common: read_Color :: STM Result [Attribute] Color
+ Text.XML.MusicXML.Common: read_Color :: StateT Result [Attribute] Color
- Text.XML.MusicXML.Common: read_Directive :: STM Result [Attribute] Directive
+ Text.XML.MusicXML.Common: read_Directive :: StateT Result [Attribute] Directive
- Text.XML.MusicXML.Common: read_Display_Text :: STM Result [Content i] Display_Text
+ Text.XML.MusicXML.Common: read_Display_Text :: StateT Result [Content i] Display_Text
- Text.XML.MusicXML.Common: read_Document_Attributes :: STM Result [Attribute] Document_Attributes
+ Text.XML.MusicXML.Common: read_Document_Attributes :: StateT Result [Attribute] Document_Attributes
- Text.XML.MusicXML.Common: read_Dynamics :: (Eq i) => STM Result [Content i] Dynamics
+ Text.XML.MusicXML.Common: read_Dynamics :: (Eq i) => StateT Result [Content i] Dynamics
- Text.XML.MusicXML.Common: read_Dynamics_ :: STM Result [Content i] Dynamics_
+ Text.XML.MusicXML.Common: read_Dynamics_ :: StateT Result [Content i] Dynamics_
- Text.XML.MusicXML.Common: read_Editorial :: STM Result [Content i] (Editorial)
+ Text.XML.MusicXML.Common: read_Editorial :: StateT Result [Content i] (Editorial)
- Text.XML.MusicXML.Common: read_Editorial_Voice :: STM Result [Content i] Editorial_Voice
+ Text.XML.MusicXML.Common: read_Editorial_Voice :: StateT Result [Content i] Editorial_Voice
- Text.XML.MusicXML.Common: read_Elevation :: STM Result [Content i] Elevation
+ Text.XML.MusicXML.Common: read_Elevation :: StateT Result [Content i] Elevation
- Text.XML.MusicXML.Common: read_F :: STM Result [Content i] F
+ Text.XML.MusicXML.Common: read_F :: StateT Result [Content i] F
- Text.XML.MusicXML.Common: read_FF :: STM Result [Content i] FF
+ Text.XML.MusicXML.Common: read_FF :: StateT Result [Content i] FF
- Text.XML.MusicXML.Common: read_FFF :: STM Result [Content i] FFF
+ Text.XML.MusicXML.Common: read_FFF :: StateT Result [Content i] FFF
- Text.XML.MusicXML.Common: read_FFFF :: STM Result [Content i] FFFF
+ Text.XML.MusicXML.Common: read_FFFF :: StateT Result [Content i] FFFF
- Text.XML.MusicXML.Common: read_FFFFF :: STM Result [Content i] FFFFF
+ Text.XML.MusicXML.Common: read_FFFFF :: StateT Result [Content i] FFFFF
- Text.XML.MusicXML.Common: read_FFFFFF :: STM Result [Content i] FFFFFF
+ Text.XML.MusicXML.Common: read_FFFFFF :: StateT Result [Content i] FFFFFF
- Text.XML.MusicXML.Common: read_FP :: STM Result [Content i] FP
+ Text.XML.MusicXML.Common: read_FP :: StateT Result [Content i] FP
- Text.XML.MusicXML.Common: read_FZ :: STM Result [Content i] FZ
+ Text.XML.MusicXML.Common: read_FZ :: StateT Result [Content i] FZ
- Text.XML.MusicXML.Common: read_Fermata :: STM Result [Content i] Fermata
+ Text.XML.MusicXML.Common: read_Fermata :: StateT Result [Content i] Fermata
- Text.XML.MusicXML.Common: read_Fingering :: STM Result [Content i] Fingering
+ Text.XML.MusicXML.Common: read_Fingering :: StateT Result [Content i] Fingering
- Text.XML.MusicXML.Common: read_Font :: STM Result [Attribute] Font
+ Text.XML.MusicXML.Common: read_Font :: StateT Result [Attribute] Font
- Text.XML.MusicXML.Common: read_Footnote :: STM Result [Content i] Footnote
+ Text.XML.MusicXML.Common: read_Footnote :: StateT Result [Content i] Footnote
- Text.XML.MusicXML.Common: read_Fret :: STM Result [Content i] Fret
+ Text.XML.MusicXML.Common: read_Fret :: StateT Result [Content i] Fret
- Text.XML.MusicXML.Common: read_Halign :: STM Result [Attribute] Halign
+ Text.XML.MusicXML.Common: read_Halign :: StateT Result [Attribute] Halign
- Text.XML.MusicXML.Common: read_Justify :: STM Result [Attribute] Justify
+ Text.XML.MusicXML.Common: read_Justify :: StateT Result [Attribute] Justify
- Text.XML.MusicXML.Common: read_Layout_Tenths :: STM Result [Content i] Layout_Tenths
+ Text.XML.MusicXML.Common: read_Layout_Tenths :: StateT Result [Content i] Layout_Tenths
- Text.XML.MusicXML.Common: read_Letter_Spacing :: STM Result [Attribute] Letter_Spacing
+ Text.XML.MusicXML.Common: read_Letter_Spacing :: StateT Result [Attribute] Letter_Spacing
- Text.XML.MusicXML.Common: read_Level :: STM Result [Content i] Level
+ Text.XML.MusicXML.Common: read_Level :: StateT Result [Content i] Level
- Text.XML.MusicXML.Common: read_Level_Display :: STM Result [Attribute] Level_Display
+ Text.XML.MusicXML.Common: read_Level_Display :: StateT Result [Attribute] Level_Display
- Text.XML.MusicXML.Common: read_Line_Height :: STM Result [Attribute] Line_Height
+ Text.XML.MusicXML.Common: read_Line_Height :: StateT Result [Attribute] Line_Height
- Text.XML.MusicXML.Common: read_Line_Shape :: STM Result [Attribute] Line_Shape
+ Text.XML.MusicXML.Common: read_Line_Shape :: StateT Result [Attribute] Line_Shape
- Text.XML.MusicXML.Common: read_Line_Type :: STM Result [Attribute] Line_Type
+ Text.XML.MusicXML.Common: read_Line_Type :: StateT Result [Attribute] Line_Type
- Text.XML.MusicXML.Common: read_MF :: STM Result [Content i] MF
+ Text.XML.MusicXML.Common: read_MF :: StateT Result [Content i] MF
- Text.XML.MusicXML.Common: read_MP :: STM Result [Content i] MP
+ Text.XML.MusicXML.Common: read_MP :: StateT Result [Content i] MP
- Text.XML.MusicXML.Common: read_Midi_Bank :: STM Result [Content i] Midi_Bank
+ Text.XML.MusicXML.Common: read_Midi_Bank :: StateT Result [Content i] Midi_Bank
- Text.XML.MusicXML.Common: read_Midi_Channel :: STM Result [Content i] Midi_Channel
+ Text.XML.MusicXML.Common: read_Midi_Channel :: StateT Result [Content i] Midi_Channel
- Text.XML.MusicXML.Common: read_Midi_Instrument :: STM Result [Content i] Midi_Instrument
+ Text.XML.MusicXML.Common: read_Midi_Instrument :: StateT Result [Content i] Midi_Instrument
- Text.XML.MusicXML.Common: read_Midi_Name :: STM Result [Content i] Midi_Name
+ Text.XML.MusicXML.Common: read_Midi_Name :: StateT Result [Content i] Midi_Name
- Text.XML.MusicXML.Common: read_Midi_Program :: STM Result [Content i] Midi_Program
+ Text.XML.MusicXML.Common: read_Midi_Program :: StateT Result [Content i] Midi_Program
- Text.XML.MusicXML.Common: read_Midi_Unpitched :: STM Result [Content i] Midi_Unpitched
+ Text.XML.MusicXML.Common: read_Midi_Unpitched :: StateT Result [Content i] Midi_Unpitched
- Text.XML.MusicXML.Common: read_Normal_Dot :: STM Result [Content i] Normal_Dot
+ Text.XML.MusicXML.Common: read_Normal_Dot :: StateT Result [Content i] Normal_Dot
- Text.XML.MusicXML.Common: read_Normal_Notes :: STM Result [Content i] Normal_Notes
+ Text.XML.MusicXML.Common: read_Normal_Notes :: StateT Result [Content i] Normal_Notes
- Text.XML.MusicXML.Common: read_Normal_Type :: STM Result [Content i] Normal_Type
+ Text.XML.MusicXML.Common: read_Normal_Type :: StateT Result [Content i] Normal_Type
- Text.XML.MusicXML.Common: read_Orientation :: STM Result [Attribute] Orientation
+ Text.XML.MusicXML.Common: read_Orientation :: StateT Result [Attribute] Orientation
- Text.XML.MusicXML.Common: read_Other_Dynamics :: STM Result [Content i] Other_Dynamics
+ Text.XML.MusicXML.Common: read_Other_Dynamics :: StateT Result [Content i] Other_Dynamics
- Text.XML.MusicXML.Common: read_P :: STM Result [Content i] P
+ Text.XML.MusicXML.Common: read_P :: StateT Result [Content i] P
- Text.XML.MusicXML.Common: read_PP :: STM Result [Content i] PP
+ Text.XML.MusicXML.Common: read_PP :: StateT Result [Content i] PP
- Text.XML.MusicXML.Common: read_PPP :: STM Result [Content i] PPP
+ Text.XML.MusicXML.Common: read_PPP :: StateT Result [Content i] PPP
- Text.XML.MusicXML.Common: read_PPPP :: STM Result [Content i] PPPP
+ Text.XML.MusicXML.Common: read_PPPP :: StateT Result [Content i] PPPP
- Text.XML.MusicXML.Common: read_PPPPP :: STM Result [Content i] PPPPP
+ Text.XML.MusicXML.Common: read_PPPPP :: StateT Result [Content i] PPPPP
- Text.XML.MusicXML.Common: read_PPPPPP :: STM Result [Content i] PPPPPP
+ Text.XML.MusicXML.Common: read_PPPPPP :: StateT Result [Content i] PPPPPP
- Text.XML.MusicXML.Common: read_Pan :: STM Result [Content i] Pan
+ Text.XML.MusicXML.Common: read_Pan :: StateT Result [Content i] Pan
- Text.XML.MusicXML.Common: read_Part_Abbreviation_Display :: (Eq i) => STM Result [Content i] Part_Abbreviation_Display
+ Text.XML.MusicXML.Common: read_Part_Abbreviation_Display :: (Eq i) => StateT Result [Content i] Part_Abbreviation_Display
- Text.XML.MusicXML.Common: read_Part_Abbreviation_Display_ :: STM Result [Content i] Part_Abbreviation_Display_
+ Text.XML.MusicXML.Common: read_Part_Abbreviation_Display_ :: StateT Result [Content i] Part_Abbreviation_Display_
- Text.XML.MusicXML.Common: read_Part_Name_Display :: (Eq i) => STM Result [Content i] Part_Name_Display
+ Text.XML.MusicXML.Common: read_Part_Name_Display :: (Eq i) => StateT Result [Content i] Part_Name_Display
- Text.XML.MusicXML.Common: read_Part_Name_Display_ :: STM Result [Content i] Part_Name_Display_
+ Text.XML.MusicXML.Common: read_Part_Name_Display_ :: StateT Result [Content i] Part_Name_Display_
- Text.XML.MusicXML.Common: read_Placement :: STM Result [Attribute] Placement
+ Text.XML.MusicXML.Common: read_Placement :: StateT Result [Attribute] Placement
- Text.XML.MusicXML.Common: read_Position :: STM Result [Attribute] Position
+ Text.XML.MusicXML.Common: read_Position :: StateT Result [Attribute] Position
- Text.XML.MusicXML.Common: read_Print_Object :: STM Result [Attribute] Print_Object
+ Text.XML.MusicXML.Common: read_Print_Object :: StateT Result [Attribute] Print_Object
- Text.XML.MusicXML.Common: read_Print_Spacing :: STM Result [Attribute] Print_Spacing
+ Text.XML.MusicXML.Common: read_Print_Spacing :: StateT Result [Attribute] Print_Spacing
- Text.XML.MusicXML.Common: read_Print_Style :: STM Result [Attribute] Print_Style
+ Text.XML.MusicXML.Common: read_Print_Style :: StateT Result [Attribute] Print_Style
- Text.XML.MusicXML.Common: read_Printout :: STM Result [Attribute] Printout
+ Text.XML.MusicXML.Common: read_Printout :: StateT Result [Attribute] Printout
- Text.XML.MusicXML.Common: read_RF :: STM Result [Content i] RF
+ Text.XML.MusicXML.Common: read_RF :: StateT Result [Content i] RF
- Text.XML.MusicXML.Common: read_RFZ :: STM Result [Content i] RFZ
+ Text.XML.MusicXML.Common: read_RFZ :: StateT Result [Content i] RFZ
- Text.XML.MusicXML.Common: read_SF :: STM Result [Content i] SF
+ Text.XML.MusicXML.Common: read_SF :: StateT Result [Content i] SF
- Text.XML.MusicXML.Common: read_SFFZ :: STM Result [Content i] SFFZ
+ Text.XML.MusicXML.Common: read_SFFZ :: StateT Result [Content i] SFFZ
- Text.XML.MusicXML.Common: read_SFP :: STM Result [Content i] SFP
+ Text.XML.MusicXML.Common: read_SFP :: StateT Result [Content i] SFP
- Text.XML.MusicXML.Common: read_SFPP :: STM Result [Content i] SFPP
+ Text.XML.MusicXML.Common: read_SFPP :: StateT Result [Content i] SFPP
- Text.XML.MusicXML.Common: read_SFZ :: STM Result [Content i] SFZ
+ Text.XML.MusicXML.Common: read_SFZ :: StateT Result [Content i] SFZ
- Text.XML.MusicXML.Common: read_Segno :: STM Result [Content i] Segno
+ Text.XML.MusicXML.Common: read_Segno :: StateT Result [Content i] Segno
- Text.XML.MusicXML.Common: read_Staff :: STM Result [Content i] Staff
+ Text.XML.MusicXML.Common: read_Staff :: StateT Result [Content i] Staff
- Text.XML.MusicXML.Common: read_String :: STM Result [Content i] String
+ Text.XML.MusicXML.Common: read_String :: StateT Result [Content i] String
- Text.XML.MusicXML.Common: read_Text_Decoration :: STM Result [Attribute] Text_Decoration
+ Text.XML.MusicXML.Common: read_Text_Decoration :: StateT Result [Attribute] Text_Decoration
- Text.XML.MusicXML.Common: read_Text_Direction :: STM Result [Attribute] Text_Direction
+ Text.XML.MusicXML.Common: read_Text_Direction :: StateT Result [Attribute] Text_Direction
- Text.XML.MusicXML.Common: read_Text_Formatting :: STM Result [Attribute] Text_Formatting
+ Text.XML.MusicXML.Common: read_Text_Formatting :: StateT Result [Attribute] Text_Formatting
- Text.XML.MusicXML.Common: read_Text_Rotation :: STM Result [Attribute] Text_Rotation
+ Text.XML.MusicXML.Common: read_Text_Rotation :: StateT Result [Attribute] Text_Rotation
- Text.XML.MusicXML.Common: read_Trill_Sound :: STM Result [Attribute] Trill_Sound
+ Text.XML.MusicXML.Common: read_Trill_Sound :: StateT Result [Attribute] Trill_Sound
- Text.XML.MusicXML.Common: read_Tuning_Alter :: STM Result [Content i] Tuning_Alter
+ Text.XML.MusicXML.Common: read_Tuning_Alter :: StateT Result [Content i] Tuning_Alter
- Text.XML.MusicXML.Common: read_Tuning_Octave :: STM Result [Content i] Tuning_Octave
+ Text.XML.MusicXML.Common: read_Tuning_Octave :: StateT Result [Content i] Tuning_Octave
- Text.XML.MusicXML.Common: read_Tuning_Step :: STM Result [Content i] Tuning_Step
+ Text.XML.MusicXML.Common: read_Tuning_Step :: StateT Result [Content i] Tuning_Step
- Text.XML.MusicXML.Common: read_Valign :: STM Result [Attribute] Valign
+ Text.XML.MusicXML.Common: read_Valign :: StateT Result [Attribute] Valign
- Text.XML.MusicXML.Common: read_Valign_Image :: STM Result [Attribute] Valign_Image
+ Text.XML.MusicXML.Common: read_Valign_Image :: StateT Result [Attribute] Valign_Image
- Text.XML.MusicXML.Common: read_Voice :: STM Result [Content i] Voice
+ Text.XML.MusicXML.Common: read_Voice :: StateT Result [Content i] Voice
- Text.XML.MusicXML.Common: read_Volume :: STM Result [Content i] Volume
+ Text.XML.MusicXML.Common: read_Volume :: StateT Result [Content i] Volume
- Text.XML.MusicXML.Common: read_Wavy_Line :: STM Result [Content i] Wavy_Line
+ Text.XML.MusicXML.Common: read_Wavy_Line :: StateT Result [Content i] Wavy_Line
- Text.XML.MusicXML.Common: read_YYYY_MM_DD :: STM Result [Content i] YYYY_MM_DD
+ Text.XML.MusicXML.Common: read_YYYY_MM_DD :: StateT Result [Content i] YYYY_MM_DD
- Text.XML.MusicXML.Container: read_Container :: (Eq i) => STM Result [Content i] Container
+ Text.XML.MusicXML.Container: read_Container :: (Eq i) => StateT Result [Content i] Container
- Text.XML.MusicXML.Container: read_Rootfile :: (Eq i) => STM Result [Content i] Rootfile
+ Text.XML.MusicXML.Container: read_Rootfile :: (Eq i) => StateT Result [Content i] Rootfile
- Text.XML.MusicXML.Container: read_Rootfiles :: (Eq i) => STM Result [Content i] Rootfiles
+ Text.XML.MusicXML.Container: read_Rootfiles :: (Eq i) => StateT Result [Content i] Rootfiles
- Text.XML.MusicXML.Direction: read_Accord :: STM Result [Content i] Accord
+ Text.XML.MusicXML.Direction: read_Accord :: StateT Result [Content i] Accord
- Text.XML.MusicXML.Direction: read_Accordion_High :: STM Result [Content i] Accordion_High
+ Text.XML.MusicXML.Direction: read_Accordion_High :: StateT Result [Content i] Accordion_High
- Text.XML.MusicXML.Direction: read_Accordion_Low :: STM Result [Content i] Accordion_Low
+ Text.XML.MusicXML.Direction: read_Accordion_Low :: StateT Result [Content i] Accordion_Low
- Text.XML.MusicXML.Direction: read_Accordion_Middle :: STM Result [Content i] Accordion_Middle
+ Text.XML.MusicXML.Direction: read_Accordion_Middle :: StateT Result [Content i] Accordion_Middle
- Text.XML.MusicXML.Direction: read_Accordion_Registration :: STM Result [Content i] Accordion_Registration
+ Text.XML.MusicXML.Direction: read_Accordion_Registration :: StateT Result [Content i] Accordion_Registration
- Text.XML.MusicXML.Direction: read_Barre :: STM Result [Content i] Barre
+ Text.XML.MusicXML.Direction: read_Barre :: StateT Result [Content i] Barre
- Text.XML.MusicXML.Direction: read_Bass :: STM Result [Content i] Bass
+ Text.XML.MusicXML.Direction: read_Bass :: StateT Result [Content i] Bass
- Text.XML.MusicXML.Direction: read_Bass_Alter :: STM Result [Content i] Bass_Alter
+ Text.XML.MusicXML.Direction: read_Bass_Alter :: StateT Result [Content i] Bass_Alter
- Text.XML.MusicXML.Direction: read_Bass_Step :: STM Result [Content i] Bass_Step
+ Text.XML.MusicXML.Direction: read_Bass_Step :: StateT Result [Content i] Bass_Step
- Text.XML.MusicXML.Direction: read_Beat_Unit :: STM Result [Content i] Beat_Unit
+ Text.XML.MusicXML.Direction: read_Beat_Unit :: StateT Result [Content i] Beat_Unit
- Text.XML.MusicXML.Direction: read_Beat_Unit_Dot :: STM Result [Content i] Beat_Unit_Dot
+ Text.XML.MusicXML.Direction: read_Beat_Unit_Dot :: StateT Result [Content i] Beat_Unit_Dot
- Text.XML.MusicXML.Direction: read_Bracket :: STM Result [Content i] Bracket
+ Text.XML.MusicXML.Direction: read_Bracket :: StateT Result [Content i] Bracket
- Text.XML.MusicXML.Direction: read_Damp :: STM Result [Content i] Damp
+ Text.XML.MusicXML.Direction: read_Damp :: StateT Result [Content i] Damp
- Text.XML.MusicXML.Direction: read_Damp_All :: STM Result [Content i] Damp_All
+ Text.XML.MusicXML.Direction: read_Damp_All :: StateT Result [Content i] Damp_All
- Text.XML.MusicXML.Direction: read_Dashes :: STM Result [Content i] Dashes
+ Text.XML.MusicXML.Direction: read_Dashes :: StateT Result [Content i] Dashes
- Text.XML.MusicXML.Direction: read_Degree :: STM Result [Content i] Degree
+ Text.XML.MusicXML.Direction: read_Degree :: StateT Result [Content i] Degree
- Text.XML.MusicXML.Direction: read_Degree_Alter :: STM Result [Content i] Degree_Alter
+ Text.XML.MusicXML.Direction: read_Degree_Alter :: StateT Result [Content i] Degree_Alter
- Text.XML.MusicXML.Direction: read_Degree_Type :: STM Result [Content i] Degree_Type
+ Text.XML.MusicXML.Direction: read_Degree_Type :: StateT Result [Content i] Degree_Type
- Text.XML.MusicXML.Direction: read_Degree_Value :: STM Result [Content i] Degree_Value
+ Text.XML.MusicXML.Direction: read_Degree_Value :: StateT Result [Content i] Degree_Value
- Text.XML.MusicXML.Direction: read_Direction :: (Eq i) => STM Result [Content i] Direction
+ Text.XML.MusicXML.Direction: read_Direction :: (Eq i) => StateT Result [Content i] Direction
- Text.XML.MusicXML.Direction: read_Direction_Type :: (Eq i) => STM Result [Content i] Direction_Type
+ Text.XML.MusicXML.Direction: read_Direction_Type :: (Eq i) => StateT Result [Content i] Direction_Type
- Text.XML.MusicXML.Direction: read_Direction_Type_ :: (Eq i) => STM Result [Content i] Direction_Type_
+ Text.XML.MusicXML.Direction: read_Direction_Type_ :: (Eq i) => StateT Result [Content i] Direction_Type_
- Text.XML.MusicXML.Direction: read_Eyeglasses :: STM Result [Content i] Eyeglasses
+ Text.XML.MusicXML.Direction: read_Eyeglasses :: StateT Result [Content i] Eyeglasses
- Text.XML.MusicXML.Direction: read_Feature :: STM Result [Content i] Feature
+ Text.XML.MusicXML.Direction: read_Feature :: StateT Result [Content i] Feature
- Text.XML.MusicXML.Direction: read_First_Fret :: STM Result [Content i] First_Fret
+ Text.XML.MusicXML.Direction: read_First_Fret :: StateT Result [Content i] First_Fret
- Text.XML.MusicXML.Direction: read_Frame :: (Eq i) => STM Result [Content i] Frame
+ Text.XML.MusicXML.Direction: read_Frame :: (Eq i) => StateT Result [Content i] Frame
- Text.XML.MusicXML.Direction: read_Frame_Frets :: STM Result [Content i] Frame_Frets
+ Text.XML.MusicXML.Direction: read_Frame_Frets :: StateT Result [Content i] Frame_Frets
- Text.XML.MusicXML.Direction: read_Frame_Note :: STM Result [Content i] Frame_Note
+ Text.XML.MusicXML.Direction: read_Frame_Note :: StateT Result [Content i] Frame_Note
- Text.XML.MusicXML.Direction: read_Frame_Strings :: STM Result [Content i] Frame_Strings
+ Text.XML.MusicXML.Direction: read_Frame_Strings :: StateT Result [Content i] Frame_Strings
- Text.XML.MusicXML.Direction: read_Function :: STM Result [Content i] Function
+ Text.XML.MusicXML.Direction: read_Function :: StateT Result [Content i] Function
- Text.XML.MusicXML.Direction: read_Grouping :: (Eq i) => STM Result [Content i] Grouping
+ Text.XML.MusicXML.Direction: read_Grouping :: (Eq i) => StateT Result [Content i] Grouping
- Text.XML.MusicXML.Direction: read_Harmony :: (Eq i) => STM Result [Content i] Harmony
+ Text.XML.MusicXML.Direction: read_Harmony :: (Eq i) => StateT Result [Content i] Harmony
- Text.XML.MusicXML.Direction: read_Harmony_Chord :: (Eq i) => STM Result [Content i] Harmony_Chord
+ Text.XML.MusicXML.Direction: read_Harmony_Chord :: (Eq i) => StateT Result [Content i] Harmony_Chord
- Text.XML.MusicXML.Direction: read_Harmony_Chord_ :: STM Result [Content i] Harmony_Chord_
+ Text.XML.MusicXML.Direction: read_Harmony_Chord_ :: StateT Result [Content i] Harmony_Chord_
- Text.XML.MusicXML.Direction: read_Harp_Pedals :: (Eq i) => STM Result [Content i] Harp_Pedals
+ Text.XML.MusicXML.Direction: read_Harp_Pedals :: (Eq i) => StateT Result [Content i] Harp_Pedals
- Text.XML.MusicXML.Direction: read_Image :: STM Result [Content i] Image
+ Text.XML.MusicXML.Direction: read_Image :: StateT Result [Content i] Image
- Text.XML.MusicXML.Direction: read_Inversion :: STM Result [Content i] Inversion
+ Text.XML.MusicXML.Direction: read_Inversion :: StateT Result [Content i] Inversion
- Text.XML.MusicXML.Direction: read_Kind :: STM Result [Content i] Kind
+ Text.XML.MusicXML.Direction: read_Kind :: StateT Result [Content i] Kind
- Text.XML.MusicXML.Direction: read_Measure_Numbering :: (Eq i) => STM Result [Content i] Measure_Numbering
+ Text.XML.MusicXML.Direction: read_Measure_Numbering :: (Eq i) => StateT Result [Content i] Measure_Numbering
- Text.XML.MusicXML.Direction: read_Metronome :: (Eq i) => STM Result [Content i] Metronome
+ Text.XML.MusicXML.Direction: read_Metronome :: (Eq i) => StateT Result [Content i] Metronome
- Text.XML.MusicXML.Direction: read_Metronome_A :: (Eq i) => STM Result [Content i] Metronome_A
+ Text.XML.MusicXML.Direction: read_Metronome_A :: (Eq i) => StateT Result [Content i] Metronome_A
- Text.XML.MusicXML.Direction: read_Metronome_A_aux1 :: (Eq i) => STM Result [Content i] (Beat_Unit, [Beat_Unit_Dot], Metronome_B)
+ Text.XML.MusicXML.Direction: read_Metronome_A_aux1 :: (Eq i) => StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot], Metronome_B)
- Text.XML.MusicXML.Direction: read_Metronome_A_aux2 :: (Eq i) => STM Result [Content i] ([Metronome_Note], Maybe (Metronome_Relation, [Metronome_Note]))
+ Text.XML.MusicXML.Direction: read_Metronome_A_aux2 :: (Eq i) => StateT Result [Content i] ([Metronome_Note], Maybe (Metronome_Relation, [Metronome_Note]))
- Text.XML.MusicXML.Direction: read_Metronome_A_aux3 :: (Eq i) => STM Result [Content i] (Metronome_Relation, [Metronome_Note])
+ Text.XML.MusicXML.Direction: read_Metronome_A_aux3 :: (Eq i) => StateT Result [Content i] (Metronome_Relation, [Metronome_Note])
- Text.XML.MusicXML.Direction: read_Metronome_B :: (Eq i) => STM Result [Content i] Metronome_B
+ Text.XML.MusicXML.Direction: read_Metronome_B :: (Eq i) => StateT Result [Content i] Metronome_B
- Text.XML.MusicXML.Direction: read_Metronome_B_aux1 :: (Eq i) => STM Result [Content i] (Beat_Unit, [Beat_Unit_Dot])
+ Text.XML.MusicXML.Direction: read_Metronome_B_aux1 :: (Eq i) => StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot])
- Text.XML.MusicXML.Direction: read_Metronome_Beam :: STM Result [Content i] Metronome_Beam
+ Text.XML.MusicXML.Direction: read_Metronome_Beam :: StateT Result [Content i] Metronome_Beam
- Text.XML.MusicXML.Direction: read_Metronome_Dot :: STM Result [Content i] Metronome_Dot
+ Text.XML.MusicXML.Direction: read_Metronome_Dot :: StateT Result [Content i] Metronome_Dot
- Text.XML.MusicXML.Direction: read_Metronome_Note :: (Eq i) => STM Result [Content i] Metronome_Note
+ Text.XML.MusicXML.Direction: read_Metronome_Note :: (Eq i) => StateT Result [Content i] Metronome_Note
- Text.XML.MusicXML.Direction: read_Metronome_Relation :: STM Result [Content i] Metronome_Relation
+ Text.XML.MusicXML.Direction: read_Metronome_Relation :: StateT Result [Content i] Metronome_Relation
- Text.XML.MusicXML.Direction: read_Metronome_Tuplet :: (Eq i) => STM Result [Content i] Metronome_Tuplet
+ Text.XML.MusicXML.Direction: read_Metronome_Tuplet :: (Eq i) => StateT Result [Content i] Metronome_Tuplet
- Text.XML.MusicXML.Direction: read_Metronome_Tuplet_aux1 :: (Eq i) => STM Result [Content i] (Normal_Type, [Normal_Dot])
+ Text.XML.MusicXML.Direction: read_Metronome_Tuplet_aux1 :: (Eq i) => StateT Result [Content i] (Normal_Type, [Normal_Dot])
- Text.XML.MusicXML.Direction: read_Metronome_Type :: STM Result [Content i] Metronome_Type
+ Text.XML.MusicXML.Direction: read_Metronome_Type :: StateT Result [Content i] Metronome_Type
- Text.XML.MusicXML.Direction: read_Octave_Shift :: STM Result [Content i] Octave_Shift
+ Text.XML.MusicXML.Direction: read_Octave_Shift :: StateT Result [Content i] Octave_Shift
- Text.XML.MusicXML.Direction: read_Offset :: STM Result [Content i] Offset
+ Text.XML.MusicXML.Direction: read_Offset :: StateT Result [Content i] Offset
- Text.XML.MusicXML.Direction: read_Other_Direction :: STM Result [Content i] Other_Direction
+ Text.XML.MusicXML.Direction: read_Other_Direction :: StateT Result [Content i] Other_Direction
- Text.XML.MusicXML.Direction: read_Pedal :: STM Result [Content i] Pedal
+ Text.XML.MusicXML.Direction: read_Pedal :: StateT Result [Content i] Pedal
- Text.XML.MusicXML.Direction: read_Pedal_Alter :: STM Result [Content i] Pedal_Alter
+ Text.XML.MusicXML.Direction: read_Pedal_Alter :: StateT Result [Content i] Pedal_Alter
- Text.XML.MusicXML.Direction: read_Pedal_Step :: STM Result [Content i] Pedal_Step
+ Text.XML.MusicXML.Direction: read_Pedal_Step :: StateT Result [Content i] Pedal_Step
- Text.XML.MusicXML.Direction: read_Pedal_Tuning :: STM Result [Content i] Pedal_Tuning
+ Text.XML.MusicXML.Direction: read_Pedal_Tuning :: StateT Result [Content i] Pedal_Tuning
- Text.XML.MusicXML.Direction: read_Per_Minute :: STM Result [Content i] Per_Minute
+ Text.XML.MusicXML.Direction: read_Per_Minute :: StateT Result [Content i] Per_Minute
- Text.XML.MusicXML.Direction: read_Print :: (Eq i) => STM Result [Content i] Print
+ Text.XML.MusicXML.Direction: read_Print :: (Eq i) => StateT Result [Content i] Print
- Text.XML.MusicXML.Direction: read_Rehearsal :: STM Result [Content i] Rehearsal
+ Text.XML.MusicXML.Direction: read_Rehearsal :: StateT Result [Content i] Rehearsal
- Text.XML.MusicXML.Direction: read_Root :: STM Result [Content i] Root
+ Text.XML.MusicXML.Direction: read_Root :: StateT Result [Content i] Root
- Text.XML.MusicXML.Direction: read_Root_Alter :: STM Result [Content i] Root_Alter
+ Text.XML.MusicXML.Direction: read_Root_Alter :: StateT Result [Content i] Root_Alter
- Text.XML.MusicXML.Direction: read_Root_Step :: STM Result [Content i] Root_Step
+ Text.XML.MusicXML.Direction: read_Root_Step :: StateT Result [Content i] Root_Step
- Text.XML.MusicXML.Direction: read_Scordatura :: (Eq i) => STM Result [Content i] Scordatura
+ Text.XML.MusicXML.Direction: read_Scordatura :: (Eq i) => StateT Result [Content i] Scordatura
- Text.XML.MusicXML.Direction: read_Sound :: (Eq i) => STM Result [Content i] Sound
+ Text.XML.MusicXML.Direction: read_Sound :: (Eq i) => StateT Result [Content i] Sound
- Text.XML.MusicXML.Direction: read_Wedge :: STM Result [Content i] Wedge
+ Text.XML.MusicXML.Direction: read_Wedge :: StateT Result [Content i] Wedge
- Text.XML.MusicXML.Direction: read_Words :: STM Result [Content i] Words
+ Text.XML.MusicXML.Direction: read_Words :: StateT Result [Content i] Words
- Text.XML.MusicXML.Identity: read_Creator :: (Eq i) => STM Result [Content i] Creator
+ Text.XML.MusicXML.Identity: read_Creator :: (Eq i) => StateT Result [Content i] Creator
- Text.XML.MusicXML.Identity: read_Encoder :: (Eq i) => STM Result [Content i] Encoder
+ Text.XML.MusicXML.Identity: read_Encoder :: (Eq i) => StateT Result [Content i] Encoder
- Text.XML.MusicXML.Identity: read_Encoding :: (Eq i) => STM Result [Content i] Encoding
+ Text.XML.MusicXML.Identity: read_Encoding :: (Eq i) => StateT Result [Content i] Encoding
- Text.XML.MusicXML.Identity: read_Encoding_ :: (Eq i) => STM Result [Content i] Encoding_
+ Text.XML.MusicXML.Identity: read_Encoding_ :: (Eq i) => StateT Result [Content i] Encoding_
- Text.XML.MusicXML.Identity: read_Encoding_Date :: (Eq i) => STM Result [Content i] Encoding_Date
+ Text.XML.MusicXML.Identity: read_Encoding_Date :: (Eq i) => StateT Result [Content i] Encoding_Date
- Text.XML.MusicXML.Identity: read_Encoding_Description :: STM Result [Content i] Encoding_Description
+ Text.XML.MusicXML.Identity: read_Encoding_Description :: StateT Result [Content i] Encoding_Description
- Text.XML.MusicXML.Identity: read_Identification :: (Eq i) => STM Result [Content i] Identification
+ Text.XML.MusicXML.Identity: read_Identification :: (Eq i) => StateT Result [Content i] Identification
- Text.XML.MusicXML.Identity: read_Miscellaneous :: (Eq i) => STM Result [Content i] Miscellaneous
+ Text.XML.MusicXML.Identity: read_Miscellaneous :: (Eq i) => StateT Result [Content i] Miscellaneous
- Text.XML.MusicXML.Identity: read_Miscellaneous_Field :: STM Result [Content i] Miscellaneous_Field
+ Text.XML.MusicXML.Identity: read_Miscellaneous_Field :: StateT Result [Content i] Miscellaneous_Field
- Text.XML.MusicXML.Identity: read_Relation :: STM Result [Content i] Relation
+ Text.XML.MusicXML.Identity: read_Relation :: StateT Result [Content i] Relation
- Text.XML.MusicXML.Identity: read_Rights :: (Eq i) => STM Result [Content i] Rights
+ Text.XML.MusicXML.Identity: read_Rights :: (Eq i) => StateT Result [Content i] Rights
- Text.XML.MusicXML.Identity: read_Software :: (Eq i) => STM Result [Content i] Software
+ Text.XML.MusicXML.Identity: read_Software :: (Eq i) => StateT Result [Content i] Software
- Text.XML.MusicXML.Identity: read_Source :: STM Result [Content i] Source
+ Text.XML.MusicXML.Identity: read_Source :: StateT Result [Content i] Source
- Text.XML.MusicXML.Identity: read_Supports :: (Eq i) => STM Result [Content i] Supports
+ Text.XML.MusicXML.Identity: read_Supports :: (Eq i) => StateT Result [Content i] Supports
- Text.XML.MusicXML.Layout: read_Appearance :: (Eq i) => STM Result [Content i] Appearance
+ Text.XML.MusicXML.Layout: read_Appearance :: (Eq i) => StateT Result [Content i] Appearance
- Text.XML.MusicXML.Layout: read_Bottom_Margin :: STM Result [Content i] Bottom_Margin
+ Text.XML.MusicXML.Layout: read_Bottom_Margin :: StateT Result [Content i] Bottom_Margin
- Text.XML.MusicXML.Layout: read_Left_Margin :: STM Result [Content i] Left_Margin
+ Text.XML.MusicXML.Layout: read_Left_Margin :: StateT Result [Content i] Left_Margin
- Text.XML.MusicXML.Layout: read_Line_Width :: STM Result [Content i] Line_Width
+ Text.XML.MusicXML.Layout: read_Line_Width :: StateT Result [Content i] Line_Width
- Text.XML.MusicXML.Layout: read_Measure_Distance :: (Eq i) => STM Result [Content i] Measure_Distance
+ Text.XML.MusicXML.Layout: read_Measure_Distance :: (Eq i) => StateT Result [Content i] Measure_Distance
- Text.XML.MusicXML.Layout: read_Measure_Layout :: (Eq i) => STM Result [Content i] Measure_Layout
+ Text.XML.MusicXML.Layout: read_Measure_Layout :: (Eq i) => StateT Result [Content i] Measure_Layout
- Text.XML.MusicXML.Layout: read_Millimeters :: (Eq i) => STM Result [Content i] Millimeters
+ Text.XML.MusicXML.Layout: read_Millimeters :: (Eq i) => StateT Result [Content i] Millimeters
- Text.XML.MusicXML.Layout: read_Note_Size :: STM Result [Content i] Note_Size
+ Text.XML.MusicXML.Layout: read_Note_Size :: StateT Result [Content i] Note_Size
- Text.XML.MusicXML.Layout: read_Other_Appearance :: STM Result [Content i] Other_Appearance
+ Text.XML.MusicXML.Layout: read_Other_Appearance :: StateT Result [Content i] Other_Appearance
- Text.XML.MusicXML.Layout: read_Page_Height :: (Eq i) => STM Result [Content i] Page_Height
+ Text.XML.MusicXML.Layout: read_Page_Height :: (Eq i) => StateT Result [Content i] Page_Height
- Text.XML.MusicXML.Layout: read_Page_Layout :: (Eq i) => STM Result [Content i] Page_Layout
+ Text.XML.MusicXML.Layout: read_Page_Layout :: (Eq i) => StateT Result [Content i] Page_Layout
- Text.XML.MusicXML.Layout: read_Page_Layout_aux1 :: (Eq i) => STM Result [Content i] (Page_Height, Page_Width)
+ Text.XML.MusicXML.Layout: read_Page_Layout_aux1 :: (Eq i) => StateT Result [Content i] (Page_Height, Page_Width)
- Text.XML.MusicXML.Layout: read_Page_Layout_aux2 :: (Eq i) => STM Result [Content i] (Page_Margins, Maybe Page_Margins)
+ Text.XML.MusicXML.Layout: read_Page_Layout_aux2 :: (Eq i) => StateT Result [Content i] (Page_Margins, Maybe Page_Margins)
- Text.XML.MusicXML.Layout: read_Page_Margins :: (Eq i) => STM Result [Content i] Page_Margins
+ Text.XML.MusicXML.Layout: read_Page_Margins :: (Eq i) => StateT Result [Content i] Page_Margins
- Text.XML.MusicXML.Layout: read_Page_Width :: (Eq i) => STM Result [Content i] Page_Width
+ Text.XML.MusicXML.Layout: read_Page_Width :: (Eq i) => StateT Result [Content i] Page_Width
- Text.XML.MusicXML.Layout: read_Right_Margin :: STM Result [Content i] Right_Margin
+ Text.XML.MusicXML.Layout: read_Right_Margin :: StateT Result [Content i] Right_Margin
- Text.XML.MusicXML.Layout: read_Scaling :: (Eq i) => STM Result [Content i] Scaling
+ Text.XML.MusicXML.Layout: read_Scaling :: (Eq i) => StateT Result [Content i] Scaling
- Text.XML.MusicXML.Layout: read_Staff_Distance :: STM Result [Content i] Staff_Distance
+ Text.XML.MusicXML.Layout: read_Staff_Distance :: StateT Result [Content i] Staff_Distance
- Text.XML.MusicXML.Layout: read_Staff_Layout :: STM Result [Content i] Staff_Layout
+ Text.XML.MusicXML.Layout: read_Staff_Layout :: StateT Result [Content i] Staff_Layout
- Text.XML.MusicXML.Layout: read_System_Distance :: STM Result [Content i] System_Distance
+ Text.XML.MusicXML.Layout: read_System_Distance :: StateT Result [Content i] System_Distance
- Text.XML.MusicXML.Layout: read_System_Layout :: STM Result [Content i] System_Layout
+ Text.XML.MusicXML.Layout: read_System_Layout :: StateT Result [Content i] System_Layout
- Text.XML.MusicXML.Layout: read_System_Margins :: STM Result [Content i] System_Margins
+ Text.XML.MusicXML.Layout: read_System_Margins :: StateT Result [Content i] System_Margins
- Text.XML.MusicXML.Layout: read_Tenths :: (Eq i) => STM Result [Content i] Tenths
+ Text.XML.MusicXML.Layout: read_Tenths :: (Eq i) => StateT Result [Content i] Tenths
- Text.XML.MusicXML.Layout: read_Top_Margin :: STM Result [Content i] Top_Margin
+ Text.XML.MusicXML.Layout: read_Top_Margin :: StateT Result [Content i] Top_Margin
- Text.XML.MusicXML.Layout: read_Top_System_Distance :: STM Result [Content i] Top_System_Distance
+ Text.XML.MusicXML.Layout: read_Top_System_Distance :: StateT Result [Content i] Top_System_Distance
- Text.XML.MusicXML.Link: read_Bookmark :: (Eq i) => STM Result [Content i] Bookmark
+ Text.XML.MusicXML.Link: read_Bookmark :: (Eq i) => StateT Result [Content i] Bookmark
- Text.XML.MusicXML.Link: read_Link :: (Eq i) => STM Result [Content i] Link
+ Text.XML.MusicXML.Link: read_Link :: (Eq i) => StateT Result [Content i] Link
- Text.XML.MusicXML.Link: read_Link_Attributes :: STM Result [Attribute] Link_Attributes
+ Text.XML.MusicXML.Link: read_Link_Attributes :: StateT Result [Attribute] Link_Attributes
- Text.XML.MusicXML.Note: read_Accent :: STM Result [Content i] Accent
+ Text.XML.MusicXML.Note: read_Accent :: StateT Result [Content i] Accent
- Text.XML.MusicXML.Note: read_Accidental :: STM Result [Content i] Accidental
+ Text.XML.MusicXML.Note: read_Accidental :: StateT Result [Content i] Accidental
- Text.XML.MusicXML.Note: read_Accidental_Mark :: STM Result [Content i] Accidental_Mark
+ Text.XML.MusicXML.Note: read_Accidental_Mark :: StateT Result [Content i] Accidental_Mark
- Text.XML.MusicXML.Note: read_Alter :: STM Result [Content i] Alter
+ Text.XML.MusicXML.Note: read_Alter :: StateT Result [Content i] Alter
- Text.XML.MusicXML.Note: read_Arpeggiate :: STM Result [Content i] Arpeggiate
+ Text.XML.MusicXML.Note: read_Arpeggiate :: StateT Result [Content i] Arpeggiate
- Text.XML.MusicXML.Note: read_Articulations :: (Eq i) => STM Result [Content i] Articulations
+ Text.XML.MusicXML.Note: read_Articulations :: (Eq i) => StateT Result [Content i] Articulations
- Text.XML.MusicXML.Note: read_Articulations_ :: STM Result [Content i] Articulations_
+ Text.XML.MusicXML.Note: read_Articulations_ :: StateT Result [Content i] Articulations_
- Text.XML.MusicXML.Note: read_Artificial :: STM Result [Content i] Artificial
+ Text.XML.MusicXML.Note: read_Artificial :: StateT Result [Content i] Artificial
- Text.XML.MusicXML.Note: read_Backup :: STM Result [Content i] Backup
+ Text.XML.MusicXML.Note: read_Backup :: StateT Result [Content i] Backup
- Text.XML.MusicXML.Note: read_Base_Pitch :: STM Result [Content i] Base_Pitch
+ Text.XML.MusicXML.Note: read_Base_Pitch :: StateT Result [Content i] Base_Pitch
- Text.XML.MusicXML.Note: read_Beam :: STM Result [Content i] Beam
+ Text.XML.MusicXML.Note: read_Beam :: StateT Result [Content i] Beam
- Text.XML.MusicXML.Note: read_Bend :: STM Result [Content i] Bend
+ Text.XML.MusicXML.Note: read_Bend :: StateT Result [Content i] Bend
- Text.XML.MusicXML.Note: read_Bend_ :: STM Result [Content i] Bend_
+ Text.XML.MusicXML.Note: read_Bend_ :: StateT Result [Content i] Bend_
- Text.XML.MusicXML.Note: read_Bend_Alter :: STM Result [Content i] Bend_Alter
+ Text.XML.MusicXML.Note: read_Bend_Alter :: StateT Result [Content i] Bend_Alter
- Text.XML.MusicXML.Note: read_Breath_Mark :: STM Result [Content i] Breath_Mark
+ Text.XML.MusicXML.Note: read_Breath_Mark :: StateT Result [Content i] Breath_Mark
- Text.XML.MusicXML.Note: read_Caesura :: STM Result [Content i] Caesura
+ Text.XML.MusicXML.Note: read_Caesura :: StateT Result [Content i] Caesura
- Text.XML.MusicXML.Note: read_Chord :: STM Result [Content i] Chord
+ Text.XML.MusicXML.Note: read_Chord :: StateT Result [Content i] Chord
- Text.XML.MusicXML.Note: read_Cue :: STM Result [Content i] Cue
+ Text.XML.MusicXML.Note: read_Cue :: StateT Result [Content i] Cue
- Text.XML.MusicXML.Note: read_Delayed_Turn :: STM Result [Content i] Delayed_Turn
+ Text.XML.MusicXML.Note: read_Delayed_Turn :: StateT Result [Content i] Delayed_Turn
- Text.XML.MusicXML.Note: read_Detached_Legato :: STM Result [Content i] Detached_Legato
+ Text.XML.MusicXML.Note: read_Detached_Legato :: StateT Result [Content i] Detached_Legato
- Text.XML.MusicXML.Note: read_Display_Octave :: STM Result [Content i] Display_Octave
+ Text.XML.MusicXML.Note: read_Display_Octave :: StateT Result [Content i] Display_Octave
- Text.XML.MusicXML.Note: read_Display_Step :: STM Result [Content i] Display_Step
+ Text.XML.MusicXML.Note: read_Display_Step :: StateT Result [Content i] Display_Step
- Text.XML.MusicXML.Note: read_Doit :: STM Result [Content i] Doit
+ Text.XML.MusicXML.Note: read_Doit :: StateT Result [Content i] Doit
- Text.XML.MusicXML.Note: read_Dot :: STM Result [Content i] Dot
+ Text.XML.MusicXML.Note: read_Dot :: StateT Result [Content i] Dot
- Text.XML.MusicXML.Note: read_Double_Tongue :: STM Result [Content i] Double_Tongue
+ Text.XML.MusicXML.Note: read_Double_Tongue :: StateT Result [Content i] Double_Tongue
- Text.XML.MusicXML.Note: read_Down_Bow :: STM Result [Content i] Down_Bow
+ Text.XML.MusicXML.Note: read_Down_Bow :: StateT Result [Content i] Down_Bow
- Text.XML.MusicXML.Note: read_Duration :: STM Result [Content i] Duration
+ Text.XML.MusicXML.Note: read_Duration :: StateT Result [Content i] Duration
- Text.XML.MusicXML.Note: read_Elision :: STM Result [Content i] Elision
+ Text.XML.MusicXML.Note: read_Elision :: StateT Result [Content i] Elision
- Text.XML.MusicXML.Note: read_End_Line :: STM Result [Content i] End_Line
+ Text.XML.MusicXML.Note: read_End_Line :: StateT Result [Content i] End_Line
- Text.XML.MusicXML.Note: read_End_Paragraph :: STM Result [Content i] End_Paragraph
+ Text.XML.MusicXML.Note: read_End_Paragraph :: StateT Result [Content i] End_Paragraph
- Text.XML.MusicXML.Note: read_Extend :: STM Result [Content i] Extend
+ Text.XML.MusicXML.Note: read_Extend :: StateT Result [Content i] Extend
- Text.XML.MusicXML.Note: read_Falloff :: STM Result [Content i] Falloff
+ Text.XML.MusicXML.Note: read_Falloff :: StateT Result [Content i] Falloff
- Text.XML.MusicXML.Note: read_Figure :: STM Result [Content i] Figure
+ Text.XML.MusicXML.Note: read_Figure :: StateT Result [Content i] Figure
- Text.XML.MusicXML.Note: read_Figure_Number :: STM Result [Content i] Figure_Number
+ Text.XML.MusicXML.Note: read_Figure_Number :: StateT Result [Content i] Figure_Number
- Text.XML.MusicXML.Note: read_Figured_Bass :: (Eq i) => STM Result [Content i] Figured_Bass
+ Text.XML.MusicXML.Note: read_Figured_Bass :: (Eq i) => StateT Result [Content i] Figured_Bass
- Text.XML.MusicXML.Note: read_Fingernails :: STM Result [Content i] Fingernails
+ Text.XML.MusicXML.Note: read_Fingernails :: StateT Result [Content i] Fingernails
- Text.XML.MusicXML.Note: read_Forward :: STM Result [Content i] Forward
+ Text.XML.MusicXML.Note: read_Forward :: StateT Result [Content i] Forward
- Text.XML.MusicXML.Note: read_Full_Note :: STM Result [Content i] Full_Note
+ Text.XML.MusicXML.Note: read_Full_Note :: StateT Result [Content i] Full_Note
- Text.XML.MusicXML.Note: read_Full_Note_ :: STM Result [Content i] Full_Note_
+ Text.XML.MusicXML.Note: read_Full_Note_ :: StateT Result [Content i] Full_Note_
- Text.XML.MusicXML.Note: read_Glissando :: STM Result [Content i] Glissando
+ Text.XML.MusicXML.Note: read_Glissando :: StateT Result [Content i] Glissando
- Text.XML.MusicXML.Note: read_Grace :: STM Result [Content i] Grace
+ Text.XML.MusicXML.Note: read_Grace :: StateT Result [Content i] Grace
- Text.XML.MusicXML.Note: read_Hammer_On :: STM Result [Content i] Hammer_On
+ Text.XML.MusicXML.Note: read_Hammer_On :: StateT Result [Content i] Hammer_On
- Text.XML.MusicXML.Note: read_Harmonic :: STM Result [Content i] Harmonic
+ Text.XML.MusicXML.Note: read_Harmonic :: StateT Result [Content i] Harmonic
- Text.XML.MusicXML.Note: read_Harmonic_A :: STM Result [Content i] Harmonic_A
+ Text.XML.MusicXML.Note: read_Harmonic_A :: StateT Result [Content i] Harmonic_A
- Text.XML.MusicXML.Note: read_Harmonic_B :: STM Result [Content i] Harmonic_B
+ Text.XML.MusicXML.Note: read_Harmonic_B :: StateT Result [Content i] Harmonic_B
- Text.XML.MusicXML.Note: read_Heel :: STM Result [Content i] Heel
+ Text.XML.MusicXML.Note: read_Heel :: StateT Result [Content i] Heel
- Text.XML.MusicXML.Note: read_Humming :: STM Result [Content i] Humming
+ Text.XML.MusicXML.Note: read_Humming :: StateT Result [Content i] Humming
- Text.XML.MusicXML.Note: read_Instrument :: STM Result [Content i] Instrument
+ Text.XML.MusicXML.Note: read_Instrument :: StateT Result [Content i] Instrument
- Text.XML.MusicXML.Note: read_Inverted_Mordent :: STM Result [Content i] Inverted_Mordent
+ Text.XML.MusicXML.Note: read_Inverted_Mordent :: StateT Result [Content i] Inverted_Mordent
- Text.XML.MusicXML.Note: read_Inverted_Turn :: STM Result [Content i] Inverted_Turn
+ Text.XML.MusicXML.Note: read_Inverted_Turn :: StateT Result [Content i] Inverted_Turn
- Text.XML.MusicXML.Note: read_Laughing :: STM Result [Content i] Laughing
+ Text.XML.MusicXML.Note: read_Laughing :: StateT Result [Content i] Laughing
- Text.XML.MusicXML.Note: read_Lyric :: (Eq i) => STM Result [Content i] Lyric
+ Text.XML.MusicXML.Note: read_Lyric :: (Eq i) => StateT Result [Content i] Lyric
- Text.XML.MusicXML.Note: read_Lyric_ :: (Eq i) => STM Result [Content i] Lyric_
+ Text.XML.MusicXML.Note: read_Lyric_ :: (Eq i) => StateT Result [Content i] Lyric_
- Text.XML.MusicXML.Note: read_Lyric_aux1 :: (Eq i) => STM Result [Content i] ((Maybe Syllabic, Text), [(Maybe Elision, Maybe Syllabic, Text)], Maybe Extend)
+ Text.XML.MusicXML.Note: read_Lyric_aux1 :: (Eq i) => StateT Result [Content i] ((Maybe Syllabic, Text), [(Maybe Elision, Maybe Syllabic, Text)], Maybe Extend)
- Text.XML.MusicXML.Note: read_Lyric_aux2 :: STM Result [Content i] (Maybe Elision, Maybe Syllabic, Text)
+ Text.XML.MusicXML.Note: read_Lyric_aux2 :: StateT Result [Content i] (Maybe Elision, Maybe Syllabic, Text)
- Text.XML.MusicXML.Note: read_Mordent :: STM Result [Content i] Mordent
+ Text.XML.MusicXML.Note: read_Mordent :: StateT Result [Content i] Mordent
- Text.XML.MusicXML.Note: read_Natural :: STM Result [Content i] Natural
+ Text.XML.MusicXML.Note: read_Natural :: StateT Result [Content i] Natural
- Text.XML.MusicXML.Note: read_Non_Arpeggiate :: STM Result [Content i] Non_Arpeggiate
+ Text.XML.MusicXML.Note: read_Non_Arpeggiate :: StateT Result [Content i] Non_Arpeggiate
- Text.XML.MusicXML.Note: read_Notations :: (Eq i) => STM Result [Content i] Notations
+ Text.XML.MusicXML.Note: read_Notations :: (Eq i) => StateT Result [Content i] Notations
- Text.XML.MusicXML.Note: read_Notations_ :: (Eq i) => STM Result [Content i] Notations_
+ Text.XML.MusicXML.Note: read_Notations_ :: (Eq i) => StateT Result [Content i] Notations_
- Text.XML.MusicXML.Note: read_Note :: (Eq i) => STM Result [Content i] Note
+ Text.XML.MusicXML.Note: read_Note :: (Eq i) => StateT Result [Content i] Note
- Text.XML.MusicXML.Note: read_Note_ :: STM Result [Content i] Note_
+ Text.XML.MusicXML.Note: read_Note_ :: StateT Result [Content i] Note_
- Text.XML.MusicXML.Note: read_Note_aux1 :: STM Result [Content i] (Grace, Full_Note, Maybe (Tie, Maybe Tie))
+ Text.XML.MusicXML.Note: read_Note_aux1 :: StateT Result [Content i] (Grace, Full_Note, Maybe (Tie, Maybe Tie))
- Text.XML.MusicXML.Note: read_Note_aux2 :: STM Result [Content i] (Cue, Full_Note, Duration)
+ Text.XML.MusicXML.Note: read_Note_aux2 :: StateT Result [Content i] (Cue, Full_Note, Duration)
- Text.XML.MusicXML.Note: read_Note_aux3 :: STM Result [Content i] (Full_Note, Duration, Maybe (Tie, Maybe Tie))
+ Text.XML.MusicXML.Note: read_Note_aux3 :: StateT Result [Content i] (Full_Note, Duration, Maybe (Tie, Maybe Tie))
- Text.XML.MusicXML.Note: read_Note_aux4 :: STM Result [Content i] (Tie, Maybe Tie)
+ Text.XML.MusicXML.Note: read_Note_aux4 :: StateT Result [Content i] (Tie, Maybe Tie)
- Text.XML.MusicXML.Note: read_Notehead :: STM Result [Content i] Notehead
+ Text.XML.MusicXML.Note: read_Notehead :: StateT Result [Content i] Notehead
- Text.XML.MusicXML.Note: read_Octave :: STM Result [Content i] Octave
+ Text.XML.MusicXML.Note: read_Octave :: StateT Result [Content i] Octave
- Text.XML.MusicXML.Note: read_Open_String :: STM Result [Content i] Open_String
+ Text.XML.MusicXML.Note: read_Open_String :: StateT Result [Content i] Open_String
- Text.XML.MusicXML.Note: read_Ornaments :: (Eq i) => STM Result [Content i] Ornaments
+ Text.XML.MusicXML.Note: read_Ornaments :: (Eq i) => StateT Result [Content i] Ornaments
- Text.XML.MusicXML.Note: read_Ornaments_ :: STM Result [Content i] Ornaments_
+ Text.XML.MusicXML.Note: read_Ornaments_ :: StateT Result [Content i] Ornaments_
- Text.XML.MusicXML.Note: read_Ornaments_aux1 :: (Eq i) => STM Result [Content i] (Ornaments_, [Accidental_Mark])
+ Text.XML.MusicXML.Note: read_Ornaments_aux1 :: (Eq i) => StateT Result [Content i] (Ornaments_, [Accidental_Mark])
- Text.XML.MusicXML.Note: read_Other_Articulation :: STM Result [Content i] Other_Articulation
+ Text.XML.MusicXML.Note: read_Other_Articulation :: StateT Result [Content i] Other_Articulation
- Text.XML.MusicXML.Note: read_Other_Notation :: STM Result [Content i] Other_Notation
+ Text.XML.MusicXML.Note: read_Other_Notation :: StateT Result [Content i] Other_Notation
- Text.XML.MusicXML.Note: read_Other_Ornament :: STM Result [Content i] Other_Ornament
+ Text.XML.MusicXML.Note: read_Other_Ornament :: StateT Result [Content i] Other_Ornament
- Text.XML.MusicXML.Note: read_Other_Technical :: STM Result [Content i] Other_Technical
+ Text.XML.MusicXML.Note: read_Other_Technical :: StateT Result [Content i] Other_Technical
- Text.XML.MusicXML.Note: read_Pitch :: STM Result [Content i] Pitch
+ Text.XML.MusicXML.Note: read_Pitch :: StateT Result [Content i] Pitch
- Text.XML.MusicXML.Note: read_Plop :: STM Result [Content i] Plop
+ Text.XML.MusicXML.Note: read_Plop :: StateT Result [Content i] Plop
- Text.XML.MusicXML.Note: read_Pluck :: STM Result [Content i] Pluck
+ Text.XML.MusicXML.Note: read_Pluck :: StateT Result [Content i] Pluck
- Text.XML.MusicXML.Note: read_Pre_Bend :: STM Result [Content i] Pre_Bend
+ Text.XML.MusicXML.Note: read_Pre_Bend :: StateT Result [Content i] Pre_Bend
- Text.XML.MusicXML.Note: read_Prefix :: STM Result [Content i] Prefix
+ Text.XML.MusicXML.Note: read_Prefix :: StateT Result [Content i] Prefix
- Text.XML.MusicXML.Note: read_Pull_Off :: STM Result [Content i] Pull_Off
+ Text.XML.MusicXML.Note: read_Pull_Off :: StateT Result [Content i] Pull_Off
- Text.XML.MusicXML.Note: read_Release :: STM Result [Content i] Release
+ Text.XML.MusicXML.Note: read_Release :: StateT Result [Content i] Release
- Text.XML.MusicXML.Note: read_Rest :: STM Result [Content i] Rest
+ Text.XML.MusicXML.Note: read_Rest :: StateT Result [Content i] Rest
- Text.XML.MusicXML.Note: read_Rest_aux1 :: STM Result [Content i] (Display_Step, Display_Octave)
+ Text.XML.MusicXML.Note: read_Rest_aux1 :: StateT Result [Content i] (Display_Step, Display_Octave)
- Text.XML.MusicXML.Note: read_Schleifer :: STM Result [Content i] Schleifer
+ Text.XML.MusicXML.Note: read_Schleifer :: StateT Result [Content i] Schleifer
- Text.XML.MusicXML.Note: read_Scoop :: STM Result [Content i] Scoop
+ Text.XML.MusicXML.Note: read_Scoop :: StateT Result [Content i] Scoop
- Text.XML.MusicXML.Note: read_Shake :: STM Result [Content i] Shake
+ Text.XML.MusicXML.Note: read_Shake :: StateT Result [Content i] Shake
- Text.XML.MusicXML.Note: read_Slide :: STM Result [Content i] Slide
+ Text.XML.MusicXML.Note: read_Slide :: StateT Result [Content i] Slide
- Text.XML.MusicXML.Note: read_Slur :: STM Result [Content i] Slur
+ Text.XML.MusicXML.Note: read_Slur :: StateT Result [Content i] Slur
- Text.XML.MusicXML.Note: read_Snap_Pizzicato :: STM Result [Content i] Snap_Pizzicato
+ Text.XML.MusicXML.Note: read_Snap_Pizzicato :: StateT Result [Content i] Snap_Pizzicato
- Text.XML.MusicXML.Note: read_Sounding_Pitch :: STM Result [Content i] Sounding_Pitch
+ Text.XML.MusicXML.Note: read_Sounding_Pitch :: StateT Result [Content i] Sounding_Pitch
- Text.XML.MusicXML.Note: read_Spiccato :: STM Result [Content i] Spiccato
+ Text.XML.MusicXML.Note: read_Spiccato :: StateT Result [Content i] Spiccato
- Text.XML.MusicXML.Note: read_Staccatissimo :: STM Result [Content i] Staccato
+ Text.XML.MusicXML.Note: read_Staccatissimo :: StateT Result [Content i] Staccato
- Text.XML.MusicXML.Note: read_Staccato :: STM Result [Content i] Staccato
+ Text.XML.MusicXML.Note: read_Staccato :: StateT Result [Content i] Staccato
- Text.XML.MusicXML.Note: read_Stem :: STM Result [Content i] Stem
+ Text.XML.MusicXML.Note: read_Stem :: StateT Result [Content i] Stem
- Text.XML.MusicXML.Note: read_Step :: STM Result [Content i] Step
+ Text.XML.MusicXML.Note: read_Step :: StateT Result [Content i] Step
- Text.XML.MusicXML.Note: read_Stopped :: STM Result [Content i] Stopped
+ Text.XML.MusicXML.Note: read_Stopped :: StateT Result [Content i] Stopped
- Text.XML.MusicXML.Note: read_Stress :: STM Result [Content i] Stress
+ Text.XML.MusicXML.Note: read_Stress :: StateT Result [Content i] Stress
- Text.XML.MusicXML.Note: read_Strong_Accent :: STM Result [Content i] Strong_Accent
+ Text.XML.MusicXML.Note: read_Strong_Accent :: StateT Result [Content i] Strong_Accent
- Text.XML.MusicXML.Note: read_Suffix :: STM Result [Content i] Suffix
+ Text.XML.MusicXML.Note: read_Suffix :: StateT Result [Content i] Suffix
- Text.XML.MusicXML.Note: read_Syllabic :: STM Result [Content i] Syllabic
+ Text.XML.MusicXML.Note: read_Syllabic :: StateT Result [Content i] Syllabic
- Text.XML.MusicXML.Note: read_Tap :: STM Result [Content i] Tap
+ Text.XML.MusicXML.Note: read_Tap :: StateT Result [Content i] Tap
- Text.XML.MusicXML.Note: read_Technical :: (Eq i) => STM Result [Content i] Technical
+ Text.XML.MusicXML.Note: read_Technical :: (Eq i) => StateT Result [Content i] Technical
- Text.XML.MusicXML.Note: read_Technical_ :: STM Result [Content i] Technical_
+ Text.XML.MusicXML.Note: read_Technical_ :: StateT Result [Content i] Technical_
- Text.XML.MusicXML.Note: read_Tenuto :: STM Result [Content i] Tenuto
+ Text.XML.MusicXML.Note: read_Tenuto :: StateT Result [Content i] Tenuto
- Text.XML.MusicXML.Note: read_Text :: STM Result [Content i] Text
+ Text.XML.MusicXML.Note: read_Text :: StateT Result [Content i] Text
- Text.XML.MusicXML.Note: read_Thumb_Position :: STM Result [Content i] Thumb_Position
+ Text.XML.MusicXML.Note: read_Thumb_Position :: StateT Result [Content i] Thumb_Position
- Text.XML.MusicXML.Note: read_Tie :: STM Result [Content i] Tie
+ Text.XML.MusicXML.Note: read_Tie :: StateT Result [Content i] Tie
- Text.XML.MusicXML.Note: read_Tied :: STM Result [Content i] Tied
+ Text.XML.MusicXML.Note: read_Tied :: StateT Result [Content i] Tied
- Text.XML.MusicXML.Note: read_Time_Modification :: (Eq i) => STM Result [Content i] Time_Modification
+ Text.XML.MusicXML.Note: read_Time_Modification :: (Eq i) => StateT Result [Content i] Time_Modification
- Text.XML.MusicXML.Note: read_Time_Modification_aux1 :: (Eq i) => STM Result [Content i] (Normal_Type, [Normal_Dot])
+ Text.XML.MusicXML.Note: read_Time_Modification_aux1 :: (Eq i) => StateT Result [Content i] (Normal_Type, [Normal_Dot])
- Text.XML.MusicXML.Note: read_Toe :: STM Result [Content i] Toe
+ Text.XML.MusicXML.Note: read_Toe :: StateT Result [Content i] Toe
- Text.XML.MusicXML.Note: read_Touching_Pitch :: STM Result [Content i] Touching_Pitch
+ Text.XML.MusicXML.Note: read_Touching_Pitch :: StateT Result [Content i] Touching_Pitch
- Text.XML.MusicXML.Note: read_Tremolo :: STM Result [Content i] Tremolo
+ Text.XML.MusicXML.Note: read_Tremolo :: StateT Result [Content i] Tremolo
- Text.XML.MusicXML.Note: read_Trill_Mark :: STM Result [Content i] Trill_Mark
+ Text.XML.MusicXML.Note: read_Trill_Mark :: StateT Result [Content i] Trill_Mark
- Text.XML.MusicXML.Note: read_Triple_Tongue :: STM Result [Content i] Triple_Tongue
+ Text.XML.MusicXML.Note: read_Triple_Tongue :: StateT Result [Content i] Triple_Tongue
- Text.XML.MusicXML.Note: read_Tuplet :: (Eq i) => STM Result [Content i] Tuplet
+ Text.XML.MusicXML.Note: read_Tuplet :: (Eq i) => StateT Result [Content i] Tuplet
- Text.XML.MusicXML.Note: read_Tuplet_Actual :: (Eq i) => STM Result [Content i] Tuplet_Actual
+ Text.XML.MusicXML.Note: read_Tuplet_Actual :: (Eq i) => StateT Result [Content i] Tuplet_Actual
- Text.XML.MusicXML.Note: read_Tuplet_Dot :: STM Result [Content i] Tuplet_Dot
+ Text.XML.MusicXML.Note: read_Tuplet_Dot :: StateT Result [Content i] Tuplet_Dot
- Text.XML.MusicXML.Note: read_Tuplet_Normal :: (Eq i) => STM Result [Content i] Tuplet_Normal
+ Text.XML.MusicXML.Note: read_Tuplet_Normal :: (Eq i) => StateT Result [Content i] Tuplet_Normal
- Text.XML.MusicXML.Note: read_Tuplet_Number :: STM Result [Content i] Tuplet_Number
+ Text.XML.MusicXML.Note: read_Tuplet_Number :: StateT Result [Content i] Tuplet_Number
- Text.XML.MusicXML.Note: read_Tuplet_Type :: STM Result [Content i] Tuplet_Type
+ Text.XML.MusicXML.Note: read_Tuplet_Type :: StateT Result [Content i] Tuplet_Type
- Text.XML.MusicXML.Note: read_Turn :: STM Result [Content i] Turn
+ Text.XML.MusicXML.Note: read_Turn :: StateT Result [Content i] Turn
- Text.XML.MusicXML.Note: read_Type :: STM Result [Content i] Type
+ Text.XML.MusicXML.Note: read_Type :: StateT Result [Content i] Type
- Text.XML.MusicXML.Note: read_Unpitched :: STM Result [Content i] Unpitched
+ Text.XML.MusicXML.Note: read_Unpitched :: StateT Result [Content i] Unpitched
- Text.XML.MusicXML.Note: read_Unpitched_aux1 :: STM Result [Content i] (Display_Step, Display_Octave)
+ Text.XML.MusicXML.Note: read_Unpitched_aux1 :: StateT Result [Content i] (Display_Step, Display_Octave)
- Text.XML.MusicXML.Note: read_Unstress :: STM Result [Content i] Unstress
+ Text.XML.MusicXML.Note: read_Unstress :: StateT Result [Content i] Unstress
- Text.XML.MusicXML.Note: read_Up_Bow :: STM Result [Content i] Up_Bow
+ Text.XML.MusicXML.Note: read_Up_Bow :: StateT Result [Content i] Up_Bow
- Text.XML.MusicXML.Note: read_With_Bar :: STM Result [Content i] With_Bar
+ Text.XML.MusicXML.Note: read_With_Bar :: StateT Result [Content i] With_Bar
- Text.XML.MusicXML.Note: type Glissando = ((Start_Stop, Number_Level, Line_Type, Print_Style), Text)
+ Text.XML.MusicXML.Note: type Glissando = ((Start_Stop, Number_Level, Line_Type, Print_Style), PCDATA)
- Text.XML.MusicXML.Note: type Notations = [(Editorial, Notations_)]
+ Text.XML.MusicXML.Note: type Notations = (Editorial, [Notations_])
- Text.XML.MusicXML.Note: type Slide = ((Start_Stop, Number_Level, Line_Type, Print_Style, Bend_Sound), Text)
+ Text.XML.MusicXML.Note: type Slide = ((Start_Stop, Number_Level, Line_Type, Print_Style, Bend_Sound), PCDATA)
- Text.XML.MusicXML.Opus: read_Opus :: (Eq i) => STM Result [Content i] Opus
+ Text.XML.MusicXML.Opus: read_Opus :: (Eq i) => StateT Result [Content i] Opus
- Text.XML.MusicXML.Opus: read_Opus_ :: (Eq i) => STM Result [Content i] Opus_
+ Text.XML.MusicXML.Opus: read_Opus_ :: (Eq i) => StateT Result [Content i] Opus_
- Text.XML.MusicXML.Opus: read_Opus_Link :: STM Result [Content i] Opus_Link
+ Text.XML.MusicXML.Opus: read_Opus_Link :: StateT Result [Content i] Opus_Link
- Text.XML.MusicXML.Opus: read_Score :: STM Result [Content i] Score
+ Text.XML.MusicXML.Opus: read_Score :: StateT Result [Content i] Score
- Text.XML.MusicXML.Opus: read_Title :: STM Result [Content i] Title
+ Text.XML.MusicXML.Opus: read_Title :: StateT Result [Content i] Title
- Text.XML.MusicXML.Partwise: read_Measure :: (Eq i) => STM Result [Content i] Measure
+ Text.XML.MusicXML.Partwise: read_Measure :: (Eq i) => StateT Result [Content i] Measure
- Text.XML.MusicXML.Partwise: read_Part :: (Eq i) => STM Result [Content i] Part
+ Text.XML.MusicXML.Partwise: read_Part :: (Eq i) => StateT Result [Content i] Part
- Text.XML.MusicXML.Partwise: read_Score_Partwise :: (Eq i) => STM Result [Content i] Score_Partwise
+ Text.XML.MusicXML.Partwise: read_Score_Partwise :: (Eq i) => StateT Result [Content i] Score_Partwise
- Text.XML.MusicXML.Score: read_Credit :: (Eq i) => STM Result [Content i] Credit
+ Text.XML.MusicXML.Score: read_Credit :: (Eq i) => StateT Result [Content i] Credit
- Text.XML.MusicXML.Score: read_Credit_ :: (Eq i) => STM Result [Content i] Credit_
+ Text.XML.MusicXML.Score: read_Credit_ :: (Eq i) => StateT Result [Content i] Credit_
- Text.XML.MusicXML.Score: read_Credit_Image :: STM Result [Content i] Credit_Image
+ Text.XML.MusicXML.Score: read_Credit_Image :: StateT Result [Content i] Credit_Image
- Text.XML.MusicXML.Score: read_Credit_Words :: STM Result [Content i] Credit_Words
+ Text.XML.MusicXML.Score: read_Credit_Words :: StateT Result [Content i] Credit_Words
- Text.XML.MusicXML.Score: read_Credit_aux1 :: (Eq i) => STM Result [Content i] (Credit_Words, [([Link], [Bookmark], Credit_Words)])
+ Text.XML.MusicXML.Score: read_Credit_aux1 :: (Eq i) => StateT Result [Content i] (Credit_Words, [([Link], [Bookmark], Credit_Words)])
- Text.XML.MusicXML.Score: read_Credit_aux2 :: (Eq i) => STM Result [Content i] ([Link], [Bookmark], Credit_Words)
+ Text.XML.MusicXML.Score: read_Credit_aux2 :: (Eq i) => StateT Result [Content i] ([Link], [Bookmark], Credit_Words)
- Text.XML.MusicXML.Score: read_Defaults :: (Eq i) => STM Result [Content i] Defaults
+ Text.XML.MusicXML.Score: read_Defaults :: (Eq i) => StateT Result [Content i] Defaults
- Text.XML.MusicXML.Score: read_Ensemble :: STM Result [Content i] Ensemble
+ Text.XML.MusicXML.Score: read_Ensemble :: StateT Result [Content i] Ensemble
- Text.XML.MusicXML.Score: read_Group :: STM Result [Content i] Group
+ Text.XML.MusicXML.Score: read_Group :: StateT Result [Content i] Group
- Text.XML.MusicXML.Score: read_Group_Abbreviation :: STM Result [Content i] Group_Abbreviation
+ Text.XML.MusicXML.Score: read_Group_Abbreviation :: StateT Result [Content i] Group_Abbreviation
- Text.XML.MusicXML.Score: read_Group_Abbreviation_Display :: (Eq i) => STM Result [Content i] Group_Abbreviation_Display
+ Text.XML.MusicXML.Score: read_Group_Abbreviation_Display :: (Eq i) => StateT Result [Content i] Group_Abbreviation_Display
- Text.XML.MusicXML.Score: read_Group_Abbreviation_Display_ :: STM Result [Content i] Group_Abbreviation_Display_
+ Text.XML.MusicXML.Score: read_Group_Abbreviation_Display_ :: StateT Result [Content i] Group_Abbreviation_Display_
- Text.XML.MusicXML.Score: read_Group_Barline :: STM Result [Content i] Group_Barline
+ Text.XML.MusicXML.Score: read_Group_Barline :: StateT Result [Content i] Group_Barline
- Text.XML.MusicXML.Score: read_Group_Name :: STM Result [Content i] Group_Name
+ Text.XML.MusicXML.Score: read_Group_Name :: StateT Result [Content i] Group_Name
- Text.XML.MusicXML.Score: read_Group_Name_Display :: (Eq i) => STM Result [Content i] Group_Name_Display
+ Text.XML.MusicXML.Score: read_Group_Name_Display :: (Eq i) => StateT Result [Content i] Group_Name_Display
- Text.XML.MusicXML.Score: read_Group_Name_Display_ :: STM Result [Content i] Group_Name_Display_
+ Text.XML.MusicXML.Score: read_Group_Name_Display_ :: StateT Result [Content i] Group_Name_Display_
- Text.XML.MusicXML.Score: read_Group_Symbol :: STM Result [Content i] Group_Symbol
+ Text.XML.MusicXML.Score: read_Group_Symbol :: StateT Result [Content i] Group_Symbol
- Text.XML.MusicXML.Score: read_Group_Time :: STM Result [Content i] Group_Time
+ Text.XML.MusicXML.Score: read_Group_Time :: StateT Result [Content i] Group_Time
- Text.XML.MusicXML.Score: read_Instrument_Abbreviation :: STM Result [Content i] Instrument_Abbreviation
+ Text.XML.MusicXML.Score: read_Instrument_Abbreviation :: StateT Result [Content i] Instrument_Abbreviation
- Text.XML.MusicXML.Score: read_Instrument_Name :: STM Result [Content i] Instrument_Name
+ Text.XML.MusicXML.Score: read_Instrument_Name :: StateT Result [Content i] Instrument_Name
- Text.XML.MusicXML.Score: read_Lyric_Font :: (Eq i) => STM Result [Content i] Lyric_Font
+ Text.XML.MusicXML.Score: read_Lyric_Font :: (Eq i) => StateT Result [Content i] Lyric_Font
- Text.XML.MusicXML.Score: read_Lyric_Language :: (Eq i) => STM Result [Content i] Lyric_Language
+ Text.XML.MusicXML.Score: read_Lyric_Language :: (Eq i) => StateT Result [Content i] Lyric_Language
- Text.XML.MusicXML.Score: read_Midi_Device :: STM Result [Content i] Midi_Device
+ Text.XML.MusicXML.Score: read_Midi_Device :: StateT Result [Content i] Midi_Device
- Text.XML.MusicXML.Score: read_Movement_Number :: STM Result [Content i] Movement_Number
+ Text.XML.MusicXML.Score: read_Movement_Number :: StateT Result [Content i] Movement_Number
- Text.XML.MusicXML.Score: read_Movement_Title :: STM Result [Content i] Movement_Title
+ Text.XML.MusicXML.Score: read_Movement_Title :: StateT Result [Content i] Movement_Title
- Text.XML.MusicXML.Score: read_Music_Data :: (Eq i) => STM Result [Content i] Music_Data
+ Text.XML.MusicXML.Score: read_Music_Data :: (Eq i) => StateT Result [Content i] Music_Data
- Text.XML.MusicXML.Score: read_Music_Data_ :: (Eq i) => STM Result [Content i] Music_Data_
+ Text.XML.MusicXML.Score: read_Music_Data_ :: (Eq i) => StateT Result [Content i] Music_Data_
- Text.XML.MusicXML.Score: read_Music_Font :: (Eq i) => STM Result [Content i] Music_Font
+ Text.XML.MusicXML.Score: read_Music_Font :: (Eq i) => StateT Result [Content i] Music_Font
- Text.XML.MusicXML.Score: read_Opus :: STM Result [Content i] Opus
+ Text.XML.MusicXML.Score: read_Opus :: StateT Result [Content i] Opus
- Text.XML.MusicXML.Score: read_Part_Abbreviation :: STM Result [Content i] Part_Abbreviation
+ Text.XML.MusicXML.Score: read_Part_Abbreviation :: StateT Result [Content i] Part_Abbreviation
- Text.XML.MusicXML.Score: read_Part_Group :: (Eq i) => STM Result [Content i] Part_Group
+ Text.XML.MusicXML.Score: read_Part_Group :: (Eq i) => StateT Result [Content i] Part_Group
- Text.XML.MusicXML.Score: read_Part_List :: (Eq i) => STM Result [Content i] Part_List
+ Text.XML.MusicXML.Score: read_Part_List :: (Eq i) => StateT Result [Content i] Part_List
- Text.XML.MusicXML.Score: read_Part_List_ :: (Eq i) => STM Result [Content i] Part_List_
+ Text.XML.MusicXML.Score: read_Part_List_ :: (Eq i) => StateT Result [Content i] Part_List_
- Text.XML.MusicXML.Score: read_Part_Name :: STM Result [Content i] Part_Name
+ Text.XML.MusicXML.Score: read_Part_Name :: StateT Result [Content i] Part_Name
- Text.XML.MusicXML.Score: read_Score_Header :: (Eq i) => STM Result [Content i] Score_Header
+ Text.XML.MusicXML.Score: read_Score_Header :: (Eq i) => StateT Result [Content i] Score_Header
- Text.XML.MusicXML.Score: read_Score_Instrument :: STM Result [Content i] Score_Instrument
+ Text.XML.MusicXML.Score: read_Score_Instrument :: StateT Result [Content i] Score_Instrument
- Text.XML.MusicXML.Score: read_Score_Instrument_ :: STM Result [Content i] Score_Instrument_
+ Text.XML.MusicXML.Score: read_Score_Instrument_ :: StateT Result [Content i] Score_Instrument_
- Text.XML.MusicXML.Score: read_Score_Part :: (Eq i) => STM Result [Content i] Score_Part
+ Text.XML.MusicXML.Score: read_Score_Part :: (Eq i) => StateT Result [Content i] Score_Part
- Text.XML.MusicXML.Score: read_Solo :: STM Result [Content i] Solo
+ Text.XML.MusicXML.Score: read_Solo :: StateT Result [Content i] Solo
- Text.XML.MusicXML.Score: read_Word_Font :: (Eq i) => STM Result [Content i] Word_Font
+ Text.XML.MusicXML.Score: read_Word_Font :: (Eq i) => StateT Result [Content i] Word_Font
- Text.XML.MusicXML.Score: read_Work :: STM Result [Content i] Work
+ Text.XML.MusicXML.Score: read_Work :: StateT Result [Content i] Work
- Text.XML.MusicXML.Score: read_Work_Number :: STM Result [Content i] Work_Number
+ Text.XML.MusicXML.Score: read_Work_Number :: StateT Result [Content i] Work_Number
- Text.XML.MusicXML.Score: read_Work_Title :: STM Result [Content i] Work_Title
+ Text.XML.MusicXML.Score: read_Work_Title :: StateT Result [Content i] Work_Title
- Text.XML.MusicXML.Timewise: read_Measure :: (Eq i) => STM Result [Content i] Measure
+ Text.XML.MusicXML.Timewise: read_Measure :: (Eq i) => StateT Result [Content i] Measure
- Text.XML.MusicXML.Timewise: read_Part :: (Eq i) => STM Result [Content i] Part
+ Text.XML.MusicXML.Timewise: read_Part :: (Eq i) => StateT Result [Content i] Part
- Text.XML.MusicXML.Timewise: read_Score_Timewise :: (Eq i) => STM Result [Content i] Score_Timewise
+ Text.XML.MusicXML.Timewise: read_Score_Timewise :: (Eq i) => StateT Result [Content i] Score_Timewise
- Text.XML.MusicXML.Util: read_1 :: (Monad m) => STM m s a -> s -> STM m s' a
+ Text.XML.MusicXML.Util: read_1 :: (Monad m) => StateT m s a -> s -> StateT m s' a
- Text.XML.MusicXML.Util: read_10 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> STM m s j -> s -> STM m s' (a, b, c, d, e, f, g, h, i, j)
+ Text.XML.MusicXML.Util: read_10 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> StateT m s j -> s -> StateT m s' (a, b, c, d, e, f, g, h, i, j)
- Text.XML.MusicXML.Util: read_11 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> STM m s j -> STM m s k -> s -> STM m s' (a, b, c, d, e, f, g, h, i, j, k)
+ Text.XML.MusicXML.Util: read_11 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> s -> StateT m s' (a, b, c, d, e, f, g, h, i, j, k)
- Text.XML.MusicXML.Util: read_12 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> STM m s j -> STM m s k -> STM m s l -> s -> STM m s' (a, b, c, d, e, f, g, h, i, j, k, l)
+ Text.XML.MusicXML.Util: read_12 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> StateT m s l -> s -> StateT m s' (a, b, c, d, e, f, g, h, i, j, k, l)
- Text.XML.MusicXML.Util: read_13 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> STM m s j -> STM m s k -> STM m s l -> STM m s n -> s -> STM m s' (a, b, c, d, e, f, g, h, i, j, k, l, n)
+ Text.XML.MusicXML.Util: read_13 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> StateT m s l -> StateT m s n -> s -> StateT m s' (a, b, c, d, e, f, g, h, i, j, k, l, n)
- Text.XML.MusicXML.Util: read_17 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> STM m s j -> STM m s k -> STM m s l -> STM m s n -> STM m s o -> STM m s p -> STM m s q -> STM m s r -> s -> STM m s' (a, b, c, d, e, f, g, h, i, j, k, l, n, o, p, q, r)
+ Text.XML.MusicXML.Util: read_17 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> StateT m s l -> StateT m s n -> StateT m s o -> StateT m s p -> StateT m s q -> StateT m s r -> s -> StateT m s' (a, b, c, d, e, f, g, h, i, j, k, l, n, o, p, q, r)
- Text.XML.MusicXML.Util: read_2 :: (Monad m) => STM m s a -> STM m s b -> s -> STM m s' (a, b)
+ Text.XML.MusicXML.Util: read_2 :: (Monad m) => StateT m s a -> StateT m s b -> s -> StateT m s' (a, b)
- Text.XML.MusicXML.Util: read_3 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> s -> STM m s' (a, b, c)
+ Text.XML.MusicXML.Util: read_3 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> s -> StateT m s' (a, b, c)
- Text.XML.MusicXML.Util: read_4 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> s -> STM m s' (a, b, c, d)
+ Text.XML.MusicXML.Util: read_4 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> s -> StateT m s' (a, b, c, d)
- Text.XML.MusicXML.Util: read_5 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> s -> STM m s' (a, b, c, d, e)
+ Text.XML.MusicXML.Util: read_5 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> s -> StateT m s' (a, b, c, d, e)
- Text.XML.MusicXML.Util: read_6 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> s -> STM m s' (a, b, c, d, e, f)
+ Text.XML.MusicXML.Util: read_6 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> s -> StateT m s' (a, b, c, d, e, f)
- Text.XML.MusicXML.Util: read_7 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> s -> STM m s' (a, b, c, d, e, f, g)
+ Text.XML.MusicXML.Util: read_7 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> s -> StateT m s' (a, b, c, d, e, f, g)
- Text.XML.MusicXML.Util: read_8 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> s -> STM m s' (a, b, c, d, e, f, g, h)
+ Text.XML.MusicXML.Util: read_8 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> s -> StateT m s' (a, b, c, d, e, f, g, h)
- Text.XML.MusicXML.Util: read_9 :: (Monad m) => STM m s a -> STM m s b -> STM m s c -> STM m s d -> STM m s e -> STM m s f -> STM m s g -> STM m s h -> STM m s i -> s -> STM m s' (a, b, c, d, e, f, g, h, i)
+ Text.XML.MusicXML.Util: read_9 :: (Monad m) => StateT m s a -> StateT m s b -> StateT m s c -> StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> StateT m s h -> StateT m s i -> s -> StateT m s' (a, b, c, d, e, f, g, h, i)
- Text.XML.MusicXML.Util: read_DEFAULT :: (Monad m) => String -> (String -> Result a) -> a -> STM m [Attribute] a
+ Text.XML.MusicXML.Util: read_DEFAULT :: (Monad m) => String -> (String -> Result a) -> a -> StateT m [Attribute] a
- Text.XML.MusicXML.Util: read_ELEMENT :: String -> STM Result [Content i] (Element i)
+ Text.XML.MusicXML.Util: read_ELEMENT :: String -> StateT Result [Content i] (Element i)
- Text.XML.MusicXML.Util: read_FIXED :: (Monad m) => String -> (String -> Result a) -> a -> STM m [Attribute] a
+ Text.XML.MusicXML.Util: read_FIXED :: (Monad m) => String -> (String -> Result a) -> a -> StateT m [Attribute] a
- Text.XML.MusicXML.Util: read_IMPLIED :: (Monad m) => String -> (String -> Result a) -> STM m [Attribute] (Maybe a)
+ Text.XML.MusicXML.Util: read_IMPLIED :: (Monad m) => String -> (String -> Result a) -> StateT m [Attribute] (Maybe a)
- Text.XML.MusicXML.Util: read_LIST :: (Eq i) => STM Result [Content i] a -> STM Result [Content i] [a]
+ Text.XML.MusicXML.Util: read_LIST :: (Eq i) => StateT Result [Content i] a -> StateT Result [Content i] [a]
- Text.XML.MusicXML.Util: read_LIST1 :: (Eq i) => STM Result [Content i] a -> STM Result [Content i] [a]
+ Text.XML.MusicXML.Util: read_LIST1 :: (Eq i) => StateT Result [Content i] a -> StateT Result [Content i] [a]
- Text.XML.MusicXML.Util: read_MAYBE :: STM Result [Content i] a -> STM Result [Content i] (Maybe a)
+ Text.XML.MusicXML.Util: read_MAYBE :: StateT Result [Content i] a -> StateT Result [Content i] (Maybe a)
- Text.XML.MusicXML.Util: read_PCDATA :: STM Result [Content i] PCDATA
+ Text.XML.MusicXML.Util: read_PCDATA :: StateT Result [Content i] PCDATA
- Text.XML.MusicXML.Util: read_REQUIRED :: (Monad m) => String -> (String -> Result a) -> STM m [Attribute] a
+ Text.XML.MusicXML.Util: read_REQUIRED :: (Monad m) => String -> (String -> Result a) -> StateT m [Attribute] a
- Text.XML.MusicXML.Util: state :: ST s a -> s -> (s, a)
+ Text.XML.MusicXML.Util: state :: State s a -> s -> (s, a)

Files

CHANGELOG view
@@ -3,38 +3,20 @@ =====================================================================
 
 =====================================================================
-Build 626
-2008-06-26 Samuel Silva <silva.samuel@alumni.uminho.pt>
-	* begin development
-
-=====================================================================
-Build 729
-2008-07-29 Samuel Silva <silva.samuel@alumni.uminho.pt>
-	* beta stage
-
-=====================================================================
-Build 826
-2008-08-26 Samuel Silva <silva.samuel@alumni.uminho.pt>
-	* add Opus and Container modules
-
-=====================================================================
-Build 927
-2008-09-27 Samuel Silva <silva.samuel@alumni.uminho.pt>
-	* new API
-
-=====================================================================
 Version 0.1
 2008-11-04 Samuel Silva <silva.samuel@alumni.uminho.pt>
 	* publish musicxml on hackage
 
 =====================================================================
-Build 101
-2009-01-01 Samuel Silva <silva.samuel@alumni.uminho.pt>
-	* fix bug on Util.lhs: "throw . ErrorCall" => error
-
-=====================================================================
 Version 0.1.1
 2009-01-09 Samuel Silva <silva.samuel@alumni.uminho.pt>
+	* fix bug on Util.lhs: "throw . ErrorCall" => error
 	* add examples
 	* publish musicxml on hackage
 
+=====================================================================
+Version 0.1.2
+2009-06-06 Samuel Silva <silva.samuel@alumni.uminho.pt>
+	* Change ST and STM to State and StateM
+	* Fix bugs on implementation
+		- Text -> PCDATA @ Glissando and Slide definitions
+ THANKS view
@@ -0,0 +1,7 @@+I would thanks for valuable guidance at design of this package to:
+    José João Dias de Almeida           <jj@di.uminho.pt>
+    José Nuno Oliveira                  <jno@di.uminho.pt>
+    Alberto Manuel Brandão Simões       <ambs@di.uminho.pt>
+
+I would thanks for comments and suggestions to:
+    Randy Polen                         <randy@kanonika.com>
− doc/Tutorial-musicxml.lt.pdf

binary file changed (927981 → absent bytes)

musicxml.cabal view
@@ -1,25 +1,22 @@ name:           musicxml
-version:        0.1.1
+version:        0.1.2
 author:         Samuel Silva <silva.samuel@alumni.uminho.pt>
 maintainer:     Samuel Silva <silva.samuel@alumni.uminho.pt>
-copyright:      Copyright (c) 2008 Samuel Silva
+copyright:      Copyright (c) 2008-2009 Samuel Silva
 stability:      experimental
-synopsis:       Library to parse musicxml and write musicxml. 
-description:    This library translates DTD specification of MusicXML 2.0 into
-                specific type. 
-                
-                Library's purpose is to be interface between
-                MusicXML format and its application, allowing reading and
-                writting of musicxml documents.
-                
-                This library supports MusicXML at 2.0 version, not only partwise
-                and timewise specification but also opus and container
-                specification.
+synopsis:       MusicXML format encoded as Haskell type and functions of reading
+                and writting.  
+description:    This package presents MusicXML format typed at Haskell language
+                to be interface between MusicXML format and MusicXML
+                applications developed using Haskell. This package allows read
+                and write MusicXML documents at least 2.0 version as partwise or
+                timewise format besides opus and container specification.
+
 homepage:       https://troglodita.di.uminho.pt/svn/musica/work/MusicXML
 license:        BSD3
 license-file:   LICENSE
 category:       Text, XML, Music
-tested-with:    GHC ==6.8.2, GHC ==6.8.3
+tested-with:    GHC ==6.8.2
 build-type:     Simple
 cabal-version:  >= 1.2
 extra-source-files:
@@ -27,23 +24,20 @@     CHANGELOG
     README
     TODO
-    src/Makefile
-    doc/Tutorial-musicxml.lt.pdf
+    THANKS
     examples/Update.lhs
     examples/ReadPartwise.lhs
     examples/Read.lhs
     examples/ReadWrite.lhs
-    script/haskellpp.pl
-    script/id.xsl
 flag splitBase
     default: True
     description: base >= 3
 
 library
     if flag(splitBase)
-        build-depends: base >=3, directory, old-time, containers
+        build-depends: base >= 3 && < 4, directory, old-time, containers
     else 
-        build-depends: base <3
+        build-depends: base < 3
     build-depends: pretty, HaXml >=1.19.4
 
     ghc-options: -Wall 
@@ -64,11 +58,4 @@         Text.XML.MusicXML.Score
         Text.XML.MusicXML.Timewise
         Text.XML.MusicXML.Util
-
-executable test-musicxml
-    ghc-options: -Wall 
-    hs-source-dirs: src, tests
-    main-is: Test/MusicXML.lhs
-    buildable: True
-
 
− script/haskellpp.pl
@@ -1,47 +0,0 @@-#####################################################################
-# This scripts process Literate Haskell Script itself to be process 
-#   by lhs2TeX with haddock comments. 
-#
-
-use strict;
-use warnings;
-
-my @tag=();
-
-while (<>) {
-    if ($_ =~ /\\begin{(.*)}/) {push @tag => $1;}
-    
-    if ( elem("code",@tag) and /(.*)--(.*)/) {
-        print $1 => '--' => 
-#            "\\begin{verbatim}" => $2 => "\\end{verbatim}" => "\n";
-            process($2) => "\n";
-    }
-    elsif (elem("nocode",@tag)) {;}
-    else {
-        print;
-    }
-    if ($_ =~ /\\end{(.*)}/ and $1 eq $tag[@tag-1]) {pop @tag;}
-}
-
-#####################################################################
-
-#######################################
-sub process{
-    my ($input) = @_;
-    $input =~ s/\\/\$\\backslash\$/g;
-    $input =~ s/\|/\|\|/g;
-    $input =~ s/\@/\@\@/g;
-    $input =~ s/\^//g;
-    $input =~ s/\"/\'/g;
-    $input =~ s/_/\\_/g;
-    return $input;
-}
-
-#######################################
-sub elem {
-    my ($x,@xs) = @_;
-    my $res = 0;
-    for (@xs) {$res=1 if $x eq $_}
-    return $res;
-}
-
− script/id.xsl
@@ -1,7 +0,0 @@-<?xml version="1.0"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-    <xsl:output method="xml" encoding="utf-8" indent="yes"/>
-    <xsl:template match="/">
-        <xsl:copy-of select="."/>
-    </xsl:template>
-</xsl:stylesheet>
− src/Makefile
@@ -1,32 +0,0 @@-init: 
-###############################################################################	
-build: Text/XML/MusicXML.lhs Text/XML/MusicXML/Attributes.lhs \
-	Text/XML/MusicXML/Barline.lhs Text/XML/MusicXML/Container.lhs \
-	Text/XML/MusicXML/Common.lhs Text/XML/MusicXML/Identity.lhs \
-	Text/XML/MusicXML/Layout.lhs Text/XML/MusicXML/Note.lhs \
-	Text/XML/MusicXML/Opus.lhs Text/XML/MusicXML/Score.lhs \
-	Text/XML/MusicXML/Link.lhs Text/XML/MusicXML/Partwise.lhs \
-	Text/XML/MusicXML/Timewise.lhs Text/XML/MusicXML/Util.lhs \
-	Text/XML/MusicXML/Direction.lhs
-	ghc -package=HaXml -Wall -O2 -c --make $^
-
-###############################################################################
-clean:
-	rm -vf Text/XML/MusicXML.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Attributes.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Barline.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Common.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Container.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Opus.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Layout.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Link.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Identity.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Note.{o,hi,lhs~,lhs.lt}\
-	  	Text/XML/MusicXML/Score.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Partwise.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Timewise.{o,hi,lhs~,lhs.lt} \
-		Text/XML/MusicXML/Util.{o,hi,lhs~,lhs.lt} \
-	  	Text/XML/MusicXML/Direction.{o,hi,lhs~,lhs.lt}
-
-###############################################################################
-
src/Text/XML/MusicXML.lhs view
@@ -79,8 +79,8 @@ \end{code}
 \begin{code}
 -- |
-read_DOCUMENT :: STM Result [Content Posn] a -> Document Posn -> Result a
-read_DOCUMENT r (Document _ _ x _) = stateM r [CElem x noPos] >>= (return.snd)
+read_DOCUMENT :: StateT Result [Content Posn] a -> Document Posn -> Result a
+read_DOCUMENT r (Document _ _ x _) = stateT r [CElem x noPos] >>= (return.snd)
 -- |
 read_MusicXML_Partwise :: Document Posn -> Result Score_Partwise
 read_MusicXML_Partwise = read_DOCUMENT read_Score_Partwise
src/Text/XML/MusicXML/Attributes.lhs view
@@ -26,7 +26,7 @@     Maybe Staves, Maybe Part_Symbol, Maybe Instruments, [Clef], [Staff_Details],
     Maybe Transpose, [Directive], [Measure_Style])
 -- | 
-read_Attributes :: Eq i => STM Result [Content i] Attributes
+read_Attributes :: Eq i => StateT Result [Content i] Attributes
 read_Attributes = do
     y <- read_ELEMENT "attributes"
     read_12 read_Editorial (read_MAYBE read_Divisions)
@@ -96,7 +96,7 @@ type Key = ((Maybe CDATA, Print_Style, Print_Object), 
     (Key_, [Key_Octave]))
 -- |
-read_Key :: Eq i => STM Result [Content i] Key
+read_Key :: Eq i => StateT Result [Content i] Key
 read_Key = do
     y <- read_ELEMENT "key"
     y1 <- read_3 (read_IMPLIED "number" read_CDATA)
@@ -114,7 +114,7 @@           | Key_2 [(Key_Step, Key_Alter)]
             deriving (Eq, Show)
 -- |
-read_Key_ :: Eq i => STM Result [Content i] Key_
+read_Key_ :: Eq i => StateT Result [Content i] Key_
 read_Key_ = 
     (read_Key_aux1 >>= return . Key_1) `mplus`
     (read_LIST read_Key_aux2 >>= return . Key_2) 
@@ -124,13 +124,13 @@                             show_MAYBE show_Mode c
 show_Key_ (Key_2 a) = show_LIST show_Key_aux1 a
 -- |
-read_Key_aux1 :: Eq i => STM Result [Content i] (Maybe Cancel, Fifths, Maybe Mode)
+read_Key_aux1 :: Eq i => StateT Result [Content i] (Maybe Cancel, Fifths, Maybe Mode)
 read_Key_aux1 = do
     y1 <- read_MAYBE read_Cancel
     y2 <- read_Fifths
     y3 <- read_MAYBE read_Mode
     return (y1,y2,y3)
-read_Key_aux2 :: Eq i => STM Result [Content i] (Key_Step, Key_Alter)
+read_Key_aux2 :: Eq i => StateT Result [Content i] (Key_Step, Key_Alter)
 read_Key_aux2 = do
     y1 <- read_Key_Step
     y2 <- read_Key_Alter
@@ -141,7 +141,7 @@ -- |
 type Cancel = (Maybe Left_Right, PCDATA)
 -- |
-read_Cancel :: STM Result [Content i] Cancel
+read_Cancel :: StateT Result [Content i] Cancel
 read_Cancel = do
     y <- read_ELEMENT "cancel"
     y1 <- read_1 (read_IMPLIED "location" read_Left_Right) (attributes y)
@@ -155,7 +155,7 @@ -- |
 type Fifths = PCDATA
 -- |
-read_Fifths :: STM Result [Content i] Fifths
+read_Fifths :: StateT Result [Content i] Fifths
 read_Fifths = do
     y <- read_ELEMENT "fifths"
     read_1 read_PCDATA (childs y)
@@ -165,7 +165,7 @@ -- |
 type Mode = PCDATA
 -- |
-read_Mode :: STM Result [Content i] Mode
+read_Mode :: StateT Result [Content i] Mode
 read_Mode = do
     y <- read_ELEMENT "mode"
     read_1 read_PCDATA (childs y)
@@ -175,7 +175,7 @@ -- |
 type Key_Step = PCDATA
 -- |
-read_Key_Step :: STM Result [Content i] Key_Step
+read_Key_Step :: StateT Result [Content i] Key_Step
 read_Key_Step = do
     y <- read_ELEMENT "key-step"
     read_1 read_PCDATA (childs y)
@@ -185,7 +185,7 @@ -- |
 type Key_Alter = PCDATA
 -- |
-read_Key_Alter :: STM Result [Content i] Key_Alter
+read_Key_Alter :: StateT Result [Content i] Key_Alter
 read_Key_Alter = do
     y <- read_ELEMENT "key-alter"
     read_1 read_PCDATA (childs y)
@@ -195,7 +195,7 @@ -- |
 type Key_Octave = ((CDATA, Maybe Yes_No), PCDATA)
 -- |
-read_Key_Octave :: STM Result [Content i] Key_Octave
+read_Key_Octave :: StateT Result [Content i] Key_Octave
 read_Key_Octave = do
     y <- read_ELEMENT "key-octave"
     y1 <- read_2 (read_REQUIRED "number" read_CDATA)
@@ -229,7 +229,7 @@ -- |
 type Divisions = PCDATA
 -- |
-read_Divisions :: STM Result [Content i] Divisions
+read_Divisions :: StateT Result [Content i] Divisions
 read_Divisions = do
     y <- read_ELEMENT "divisions"
     read_1 read_PCDATA (childs y)
@@ -267,7 +267,7 @@ -- |
 type Time = ((Maybe CDATA, Maybe Time_A, Print_Style, Print_Object), Time_B)
 -- |
-read_Time :: Eq i => STM Result [Content i] Time
+read_Time :: Eq i => StateT Result [Content i] Time
 read_Time = do
     y <- read_ELEMENT "time"
     y1 <- read_4 (read_IMPLIED "number" read_CDATA) 
@@ -303,7 +303,7 @@             | Time_6 Senza_Misura
               deriving (Eq, Show)
 -- |
-read_Time_B :: Eq i => STM Result [Content i] Time_B
+read_Time_B :: Eq i => StateT Result [Content i] Time_B
 read_Time_B = 
     (read_LIST1 read_Time_B_aux1 >>= return . Time_5) `mplus`
     (read_Senza_Misura >>= return . Time_6)
@@ -312,7 +312,7 @@ show_Time_B (Time_5 a) = show_LIST show_Time_B_aux1 a
 show_Time_B (Time_6 a) = show_Senza_Misura a
 -- |
-read_Time_B_aux1 :: STM Result [Content i] (Beats, Beat_Type)
+read_Time_B_aux1 :: StateT Result [Content i] (Beats, Beat_Type)
 read_Time_B_aux1 = do
     y1 <- read_Beats
     y2 <- read_Beat_Type
@@ -323,7 +323,7 @@ -- |
 type Beats = PCDATA
 -- |
-read_Beats :: STM Result [Content i] Beats
+read_Beats :: StateT Result [Content i] Beats
 read_Beats = do
     y <- read_ELEMENT "beats" 
     read_1 read_PCDATA (childs y)
@@ -333,7 +333,7 @@ -- |
 type Beat_Type = PCDATA
 -- |
-read_Beat_Type :: STM Result [Content i] Beat_Type
+read_Beat_Type :: StateT Result [Content i] Beat_Type
 read_Beat_Type = do
     y <- read_ELEMENT "beat-type" 
     read_1 read_PCDATA (childs y)
@@ -343,7 +343,7 @@ -- |
 type Senza_Misura = ()
 -- |
-read_Senza_Misura :: STM Result [Content i] Senza_Misura
+read_Senza_Misura :: StateT Result [Content i] Senza_Misura
 read_Senza_Misura = do
     read_ELEMENT "senza-misura" >> return ()
 -- |
@@ -363,7 +363,7 @@ -- |
 type Staves = PCDATA
 -- |
-read_Staves :: STM Result [Content i] Staves
+read_Staves :: StateT Result [Content i] Staves
 read_Staves = do
     y <- read_ELEMENT "staves"
     read_1 read_PCDATA (childs y)
@@ -389,7 +389,7 @@ -- |
 type Part_Symbol = ((Maybe CDATA, Maybe CDATA, Position, Color), PCDATA)
 -- |
-read_Part_Symbol :: STM Result [Content i] Part_Symbol
+read_Part_Symbol :: StateT Result [Content i] Part_Symbol
 read_Part_Symbol = do
     y <- read_ELEMENT "part-symbol"
     y1 <- read_4 (read_IMPLIED "top-staff" read_CDATA) 
@@ -418,7 +418,7 @@ -- |
 type Instruments = PCDATA
 -- |
-read_Instruments :: STM Result [Content i] Instruments
+read_Instruments :: StateT Result [Content i] Instruments
 read_Instruments = do
     y <- read_ELEMENT "instruments"
     read_1 read_PCDATA (childs y)
@@ -457,7 +457,7 @@         Print_Style, Print_Object), 
     (Sign, Maybe Line, Maybe Clef_Octave_Change))
 -- |
-read_Clef :: Eq i => STM Result [Content i] Clef
+read_Clef :: Eq i => StateT Result [Content i] Clef
 read_Clef = do
     y <- read_ELEMENT "clef"
     y1 <- read_5 (read_IMPLIED "number" read_CDATA)
@@ -479,7 +479,7 @@ -- |
 type Sign = PCDATA
 -- |
-read_Sign :: STM Result [Content i] Sign
+read_Sign :: StateT Result [Content i] Sign
 read_Sign = do
     y <- read_ELEMENT "sign"
     read_1 read_PCDATA (childs y)
@@ -489,7 +489,7 @@ -- |
 type Line = PCDATA
 -- |
-read_Line :: STM Result [Content i] Line
+read_Line :: StateT Result [Content i] Line
 read_Line = do
     y <- read_ELEMENT "line"
     read_1 read_PCDATA (childs y)
@@ -499,7 +499,7 @@ -- |
 type Clef_Octave_Change = PCDATA
 -- |
-read_Clef_Octave_Change :: STM Result [Content i] Clef_Octave_Change
+read_Clef_Octave_Change :: StateT Result [Content i] Clef_Octave_Change
 read_Clef_Octave_Change = do
     y <- read_ELEMENT "clef-octave-change"
     read_1 read_PCDATA (childs y)
@@ -539,7 +539,7 @@     (Maybe Staff_Type, Maybe Staff_Lines, [Staff_Tuning], 
      Maybe Capo, Maybe Staff_Size))
 -- |
-read_Staff_Details :: Eq i => STM Result [Content i] Staff_Details
+read_Staff_Details :: Eq i => StateT Result [Content i] Staff_Details
 read_Staff_Details = do
     y <- read_ELEMENT "staff-details"
     y1 <- read_4 (read_IMPLIED "number" read_CDATA)
@@ -575,7 +575,7 @@ -- |
 type Staff_Type = PCDATA
 -- |
-read_Staff_Type :: STM Result [Content i] Staff_Type
+read_Staff_Type :: StateT Result [Content i] Staff_Type
 read_Staff_Type = do
     y <- read_ELEMENT "staff-type"
     read_1 read_PCDATA (childs y)
@@ -585,7 +585,7 @@ -- |
 type Staff_Lines = PCDATA
 -- |
-read_Staff_Lines :: STM Result [Content i] Staff_Lines
+read_Staff_Lines :: StateT Result [Content i] Staff_Lines
 read_Staff_Lines = do
     y <- read_ELEMENT "staff-lines"
     read_1 read_PCDATA (childs y)
@@ -604,7 +604,7 @@ -- |
 type Staff_Tuning = (CDATA, (Tuning_Step, Maybe Tuning_Alter, Tuning_Octave))
 -- |
-read_Staff_Tuning :: Eq i => STM Result [Content i] Staff_Tuning
+read_Staff_Tuning :: Eq i => StateT Result [Content i] Staff_Tuning
 read_Staff_Tuning = do
     y <- read_ELEMENT "staff-tuning"
     y1 <- read_1 (read_REQUIRED "line" read_CDATA) (attributes y)
@@ -630,7 +630,7 @@ -- |
 type Capo = PCDATA
 -- |
-read_Capo :: STM Result [Content i] Capo
+read_Capo :: StateT Result [Content i] Capo
 read_Capo = do
     y <- read_ELEMENT "capo"
     read_1 read_PCDATA (childs y)
@@ -656,7 +656,7 @@ -- |
 type Staff_Size = PCDATA
 -- |
-read_Staff_Size :: STM Result [Content i] Staff_Size
+read_Staff_Size :: StateT Result [Content i] Staff_Size
 read_Staff_Size = do
     y <- read_ELEMENT "staff-size"
     read_1 read_PCDATA (childs y)
@@ -687,7 +687,7 @@ type Transpose = (Maybe Diatonic, Chromatic, Maybe Octave_Change, 
     Maybe Double)    
 -- |
-read_Transpose :: Eq i => STM Result [Content i] Transpose
+read_Transpose :: Eq i => StateT Result [Content i] Transpose
 read_Transpose = do 
     y <- read_ELEMENT "transpose"
     read_4 (read_MAYBE read_Diatonic) read_Chromatic
@@ -703,7 +703,7 @@ -- |
 type Diatonic = PCDATA
 -- |
-read_Diatonic :: STM Result [Content i] Diatonic
+read_Diatonic :: StateT Result [Content i] Diatonic
 read_Diatonic = do
     y <- read_ELEMENT "diatonic"
     read_1 read_PCDATA (childs y)
@@ -713,7 +713,7 @@ -- |
 type Chromatic = PCDATA
 -- |
-read_Chromatic :: STM Result [Content i] Chromatic
+read_Chromatic :: StateT Result [Content i] Chromatic
 read_Chromatic = do
     y <- read_ELEMENT "chromatic"
     read_1 read_PCDATA (childs y)
@@ -723,7 +723,7 @@ -- |
 type Octave_Change = PCDATA
 -- |
-read_Octave_Change :: STM Result [Content i] Octave_Change
+read_Octave_Change :: StateT Result [Content i] Octave_Change
 read_Octave_Change = do
     y <- read_ELEMENT "octave-change"
     read_1 read_PCDATA (childs y)
@@ -733,7 +733,7 @@ -- |
 type Double = ()
 -- |
-read_Double :: STM Result [Content i] Double
+read_Double :: StateT Result [Content i] Double
 read_Double = read_ELEMENT "double" >> return ()
 -- |
 show_Double :: Double -> [Content ()]
@@ -755,7 +755,7 @@ -- |
 type Directive = ((Print_Style, Maybe CDATA), CDATA)
 -- |
-read_Directive :: STM Result [Content i] Directive
+read_Directive :: StateT Result [Content i] Directive
 read_Directive = do
     y <- read_ELEMENT "directive"
     y1 <- read_2 read_Print_Style 
@@ -790,7 +790,7 @@ -- |
 type Measure_Style = ((Maybe CDATA, Font, Color), Measure_Style_)
 -- |
-read_Measure_Style :: Eq i => STM Result [Content i] Measure_Style
+read_Measure_Style :: Eq i => StateT Result [Content i] Measure_Style
 read_Measure_Style = do
     y <- read_ELEMENT "measure-style"
     y1 <- read_3 (read_IMPLIED "number" read_CDATA)
@@ -810,7 +810,7 @@                     | Measure_Style_4 Slash
                       deriving (Eq, Show)
 -- |
-read_Measure_Style_ :: Eq i => STM Result [Content i] Measure_Style_
+read_Measure_Style_ :: Eq i => StateT Result [Content i] Measure_Style_
 read_Measure_Style_ = 
     (read_Multiple_Rest >>= return . Measure_Style_1) `mplus`
     (read_Measure_Repeat >>= return . Measure_Style_2) `mplus`
@@ -836,7 +836,7 @@ -- |
 type Slash_Type = PCDATA
 -- |
-read_Slash_Type :: STM Result [Content i] Slash_Type
+read_Slash_Type :: StateT Result [Content i] Slash_Type
 read_Slash_Type = do
     y <- read_ELEMENT "slash-type"
     read_1 read_PCDATA (childs y)
@@ -846,7 +846,7 @@ -- |
 type Slash_Dot = ()
 -- |
-read_Slash_Dot :: STM Result [Content i] Slash_Dot
+read_Slash_Dot :: StateT Result [Content i] Slash_Dot
 read_Slash_Dot = read_ELEMENT "slash-dot" >> return ()
 -- |
 show_Slash_Dot :: Slash_Dot -> [Content ()]
@@ -865,7 +865,7 @@ -- |
 type Multiple_Rest = (Maybe Yes_No, PCDATA)
 -- |
-read_Multiple_Rest :: STM Result [Content i] Multiple_Rest
+read_Multiple_Rest :: StateT Result [Content i] Multiple_Rest
 read_Multiple_Rest = do
     y <- read_ELEMENT "multiple-rest"
     y1 <- read_1 (read_IMPLIED "use-symbols" read_Yes_No) (attributes y)
@@ -897,7 +897,7 @@ -- |
 type Measure_Repeat = ((Start_Stop, Maybe CDATA), PCDATA)
 -- |
-read_Measure_Repeat :: STM Result [Content i] Measure_Repeat
+read_Measure_Repeat :: StateT Result [Content i] Measure_Repeat
 read_Measure_Repeat = do
     y <- read_ELEMENT "measure-repeat"
     y1 <- read_2 (read_REQUIRED "type" read_Start_Stop)
@@ -930,7 +930,7 @@ type Beat_Repeat = ((Start_Stop, Maybe CDATA, Maybe Yes_No), 
     Maybe (Slash_Type, [Slash_Dot]))
 -- |
-read_Beat_Repeat :: Eq i => STM Result [Content i] Beat_Repeat
+read_Beat_Repeat :: Eq i => StateT Result [Content i] Beat_Repeat
 read_Beat_Repeat = do
     y <- read_ELEMENT "beat-repeat"
     y1 <- read_3 (read_REQUIRED "type" read_Start_Stop)
@@ -947,7 +947,7 @@                                 show_IMPLIED "use-dots" show_Yes_No c) 
                                (show_MAYBE show_Beat_Repeat_aux1 d)
 -- |
-read_Beat_Repeat_aux1 :: Eq i => STM Result [Content i] (Slash_Type, [Slash_Dot])
+read_Beat_Repeat_aux1 :: Eq i => StateT Result [Content i] (Slash_Type, [Slash_Dot])
 read_Beat_Repeat_aux1 = do
     y1 <- read_Slash_Type
     y2 <- read_LIST read_Slash_Dot
@@ -973,7 +973,7 @@ type Slash = ((Start_Stop, Maybe Yes_No, Maybe Yes_No), 
     Maybe (Slash_Type, [Slash_Dot]))
 -- |
-read_Slash :: Eq i => STM Result [Content i] Slash
+read_Slash :: Eq i => StateT Result [Content i] Slash
 read_Slash = do
     y <- read_ELEMENT "slash"
     y1 <- read_3 (read_REQUIRED "type" read_Start_Stop)
@@ -990,7 +990,7 @@                           show_IMPLIED "use-stems" show_Yes_No c) 
                          (show_MAYBE show_Slash_aux1 d)
 -- |
-read_Slash_aux1 :: Eq i => STM Result [Content i] (Slash_Type, [Slash_Dot])
+read_Slash_aux1 :: Eq i => StateT Result [Content i] (Slash_Type, [Slash_Dot])
 read_Slash_aux1 = do
     y1 <- read_Slash_Type
     y2 <- read_LIST read_Slash_Dot
src/Text/XML/MusicXML/Barline.lhs view
@@ -47,7 +47,7 @@     Maybe Segno, Maybe Coda, Maybe (Fermata, Maybe Fermata), 
     Maybe Ending, Maybe Repeat))
 -- |
-read_Barline :: Eq i => STM Result [Content i] Barline
+read_Barline :: Eq i => StateT Result [Content i] Barline
 read_Barline = do
     y <- read_ELEMENT "barline"
     y1 <- read_4 (read_DEFAULT "location" read_Barline_ Barline_1)
@@ -73,7 +73,7 @@                             show_MAYBE show_Barline_aux1 j ++
                             show_MAYBE show_Ending k ++ show_MAYBE show_Repeat l)
 -- |
-read_Barline_aux1 :: STM Result [Content i] (Fermata, Maybe Fermata)
+read_Barline_aux1 :: StateT Result [Content i] (Fermata, Maybe Fermata)
 read_Barline_aux1 = do
     y1 <- read_Fermata
     y2 <- read_MAYBE read_Fermata
@@ -110,7 +110,7 @@ -- |
 type Bar_Style = (Color, PCDATA)
 -- |
-read_Bar_Style :: STM Result [Content i] Bar_Style
+read_Bar_Style :: StateT Result [Content i] Bar_Style
 read_Bar_Style = do
     y <- read_ELEMENT "bar-style"
     y1 <- read_1 read_Color (attributes y)
@@ -157,7 +157,7 @@ type Ending = ((CDATA, Ending_, Print_Object, Print_Style,
         Maybe Tenths, Maybe Tenths, Maybe Tenths), PCDATA)
 -- |
-read_Ending :: Eq i => STM Result [Content i] Ending
+read_Ending :: Eq i => StateT Result [Content i] Ending
 read_Ending = do
     y <- read_ELEMENT "ending"
     y1 <- read_7 (read_REQUIRED "number" read_CDATA)
@@ -208,7 +208,7 @@ -- |
 type Repeat = ((Repeat_, Maybe CDATA), ())
 -- |
-read_Repeat :: STM Result [Content i] Repeat
+read_Repeat :: StateT Result [Content i] Repeat
 read_Repeat = do
     y <- read_ELEMENT "repeat"
     y1 <- read_2 (read_REQUIRED "direction" read_Repeat_)
src/Text/XML/MusicXML/Common.lhs view
@@ -42,7 +42,7 @@ -- |
 type YYYY_MM_DD = PCDATA
 -- |
-read_YYYY_MM_DD :: STM Result [Content i] YYYY_MM_DD
+read_YYYY_MM_DD :: StateT Result [Content i] YYYY_MM_DD
 read_YYYY_MM_DD = read_PCDATA
 -- |
 show_YYYY_MM_DD :: YYYY_MM_DD -> [Content ()]
@@ -70,7 +70,7 @@ -- |
 type Layout_Tenths = PCDATA
 -- |
-read_Layout_Tenths :: STM Result [Content i] Layout_Tenths
+read_Layout_Tenths :: StateT Result [Content i] Layout_Tenths
 read_Layout_Tenths = read_PCDATA
 -- |
 show_Layout_Tenths :: Layout_Tenths -> [Content ()]
@@ -435,7 +435,7 @@ -- |
 type Position = (Maybe Tenths, Maybe Tenths, Maybe Tenths, Maybe Tenths)
 -- |
-read_Position :: STM Result [Attribute] Position
+read_Position :: StateT Result [Attribute] Position
 read_Position = do
     y1 <- read_IMPLIED "default-x" read_Tenths 
     y2 <- read_IMPLIED "default-y" read_Tenths 
@@ -461,7 +461,7 @@ -- |
 type Placement = Maybe Placement_
 -- |
-read_Placement :: STM Result [Attribute] Placement
+read_Placement :: StateT Result [Attribute] Placement
 read_Placement = read_IMPLIED "placement" read_Placement_ 
 -- |
 show_Placement :: Placement -> [Attribute]
@@ -492,7 +492,7 @@ -- |
 type Orientation = Maybe Orientation_
 -- |
-read_Orientation :: STM Result [Attribute] Orientation
+read_Orientation :: StateT Result [Attribute] Orientation
 read_Orientation = read_IMPLIED "orientation" read_Orientation_
 -- |
 show_Orientation :: Orientation -> [Attribute]
@@ -525,7 +525,7 @@ -- |
 type Directive = Maybe Yes_No
 -- |
-read_Directive :: STM Result [Attribute] Directive
+read_Directive :: StateT Result [Attribute] Directive
 read_Directive =  read_IMPLIED "directive" read_Yes_No
 -- |
 show_Directive :: Directive -> [Attribute]
@@ -565,7 +565,7 @@ type Bezier = (Maybe CDATA, Maybe CDATA,
         Maybe Tenths, Maybe Tenths, Maybe Tenths, Maybe Tenths)
 -- |
-read_Bezier :: STM Result [Attribute] Bezier
+read_Bezier :: StateT Result [Attribute] Bezier
 read_Bezier = do
     y1 <- read_IMPLIED "bezier-offset" read_CDATA 
     y2 <- read_IMPLIED "bezier-offset2" read_CDATA
@@ -609,7 +609,7 @@ -- |
 type Font = (Maybe CDATA, Maybe CDATA, Maybe CDATA, Maybe CDATA)
 -- |
-read_Font :: STM Result [Attribute] Font
+read_Font :: StateT Result [Attribute] Font
 read_Font  = do
     y1 <- read_IMPLIED "font-family" read_CDATA 
     y2 <- read_IMPLIED "font-style" read_CDATA 
@@ -645,7 +645,7 @@ -- |
 type Color = Maybe CDATA
 -- |
-read_Color :: STM Result [Attribute] Color
+read_Color :: StateT Result [Attribute] Color
 read_Color = read_IMPLIED "color" read_CDATA
 -- |
 show_Color :: Color -> [Attribute]
@@ -666,7 +666,7 @@         Maybe Number_Of_Lines,
         Maybe Number_Of_Lines)
 -- |
-read_Text_Decoration :: STM Result [Attribute] Text_Decoration
+read_Text_Decoration :: StateT Result [Attribute] Text_Decoration
 read_Text_Decoration  = do
     y1 <- read_IMPLIED "underline" read_Number_Of_Lines 
     y2 <- read_IMPLIED "overline" read_Number_Of_Lines 
@@ -690,7 +690,7 @@ -- |
 type Justify = Maybe Justify_
 -- |
-read_Justify :: STM Result [Attribute] Justify
+read_Justify :: StateT Result [Attribute] Justify
 read_Justify = read_IMPLIED "justify" read_Justify_
 -- |
 show_Justify :: Justify -> [Attribute]
@@ -733,7 +733,7 @@ -- |
 type Halign = Maybe Halign_
 -- |
-read_Halign :: STM Result [Attribute] Halign
+read_Halign :: StateT Result [Attribute] Halign
 read_Halign = read_IMPLIED "halign" read_Halign_
 -- |
 show_Halign :: Halign -> [Attribute]
@@ -765,7 +765,7 @@ -- |
 type Valign = Maybe Valign_
 -- |
-read_Valign :: STM Result [Attribute] Valign
+read_Valign :: StateT Result [Attribute] Valign
 read_Valign = read_IMPLIED "valign" read_Valign_
 -- |
 show_Valign :: Valign -> [Attribute]
@@ -798,7 +798,7 @@ -- |
 type Valign_Image = Maybe Valign_Image_
 -- |
-read_Valign_Image :: STM Result [Attribute] Valign_Image
+read_Valign_Image :: StateT Result [Attribute] Valign_Image
 read_Valign_Image = read_IMPLIED "valign-image" read_Valign_Image_
 -- |
 show_Valign_Image :: Valign_Image -> [Attribute]
@@ -833,7 +833,7 @@ -- |
 type Letter_Spacing = Maybe CDATA
 -- |
-read_Letter_Spacing :: STM Result [Attribute] Letter_Spacing
+read_Letter_Spacing :: StateT Result [Attribute] Letter_Spacing
 read_Letter_Spacing = read_IMPLIED "letter-spacing" read_CDATA
 -- |
 show_Letter_Spacing :: Letter_Spacing -> [Attribute]
@@ -852,7 +852,7 @@ -- |
 type Line_Height = Maybe CDATA
 -- |
-read_Line_Height :: STM Result [Attribute] Line_Height
+read_Line_Height :: StateT Result [Attribute] Line_Height
 read_Line_Height = read_IMPLIED "line-height" read_CDATA
 -- |
 show_Line_Height :: Line_Height -> [Attribute]
@@ -877,7 +877,7 @@ -- |
 type Text_Direction = Maybe Text_Direction_
 -- |
-read_Text_Direction :: STM Result [Attribute] Text_Direction
+read_Text_Direction :: StateT Result [Attribute] Text_Direction
 read_Text_Direction = read_IMPLIED "dir" read_Text_Direction_
 -- |
 show_Text_Direction :: Text_Direction -> [Attribute]
@@ -916,7 +916,7 @@ -- |
 type Text_Rotation = Maybe CDATA
 -- |
-read_Text_Rotation :: STM Result [Attribute] Text_Rotation
+read_Text_Rotation :: StateT Result [Attribute] Text_Rotation
 read_Text_Rotation = read_IMPLIED "text-rotation" read_CDATA
 -- |
 show_Text_Rotation :: Text_Rotation -> [Attribute]
@@ -933,7 +933,7 @@ -- |
 type Print_Style = (Position, Font, Color)
 -- |
-read_Print_Style :: STM Result [Attribute] Print_Style
+read_Print_Style :: StateT Result [Attribute] Print_Style
 read_Print_Style = do
     y1 <- read_Position 
     y2 <- read_Font 
@@ -955,7 +955,7 @@ \begin{code}
 type Line_Shape = Maybe Line_Shape_
 -- |
-read_Line_Shape :: STM Result [Attribute] Line_Shape
+read_Line_Shape :: StateT Result [Attribute] Line_Shape
 read_Line_Shape = read_IMPLIED "line-shape" read_Line_Shape_
 -- |
 show_Line_Shape :: Line_Shape -> [Attribute]
@@ -976,7 +976,7 @@ -- |
 type Line_Type = Maybe Line_Type_
 -- |
-read_Line_Type :: STM Result [Attribute] Line_Type
+read_Line_Type :: StateT Result [Attribute] Line_Type
 read_Line_Type = read_IMPLIED "line-type" read_Line_Type_
 -- |
 show_Line_Type :: Line_Type -> [Attribute]
@@ -1020,7 +1020,7 @@ -- |
 type Print_Object = Maybe Yes_No
 -- |
-read_Print_Object :: STM Result [Attribute] Print_Object
+read_Print_Object :: StateT Result [Attribute] Print_Object
 read_Print_Object = read_IMPLIED "print-object" read_Yes_No
 -- |
 show_Print_Object :: Print_Object -> [Attribute]
@@ -1028,7 +1028,7 @@ -- |
 type Print_Spacing = Maybe Yes_No
 -- |
-read_Print_Spacing :: STM Result [Attribute] Print_Spacing
+read_Print_Spacing :: StateT Result [Attribute] Print_Spacing
 read_Print_Spacing = read_IMPLIED "print-spacing" read_Yes_No
 -- |
 show_Print_Spacing :: Print_Spacing -> [Attribute]
@@ -1036,7 +1036,7 @@ -- |
 type Printout = (Print_Object, Maybe Yes_No, Print_Spacing, Maybe Yes_No)
 -- |
-read_Printout :: STM Result [Attribute] Printout 
+read_Printout :: StateT Result [Attribute] Printout 
 read_Printout = do
     y1 <- read_Print_Object 
     y2 <- read_IMPLIED "print-dot" read_Yes_No 
@@ -1063,7 +1063,7 @@         Print_Style, Text_Decoration, Text_Rotation, Letter_Spacing,
         Line_Height, Maybe CDATA, Text_Direction, Maybe Text_Formatting_)
 -- |
-read_Text_Formatting :: STM Result [Attribute] Text_Formatting
+read_Text_Formatting :: StateT Result [Attribute] Text_Formatting
 read_Text_Formatting = do
     y1 <- read_Justify 
     y2 <- read_Halign 
@@ -1123,7 +1123,7 @@ -- |
 type Level_Display = (Maybe Yes_No, Maybe Yes_No, Maybe Symbol_Size)
 -- |
-read_Level_Display :: STM Result [Attribute] Level_Display
+read_Level_Display :: StateT Result [Attribute] Level_Display
 read_Level_Display = do -- return (
     y1 <- read_IMPLIED "parentheses" read_Yes_No 
     y2 <- read_IMPLIED "braket" read_Yes_No 
@@ -1171,7 +1171,7 @@         Maybe Trill_Sound_A, Maybe Trill_Sound_B, Maybe Trill_Sound_C,
         Maybe Bool, Maybe CDATA, Maybe CDATA, Maybe CDATA)
 -- |
-read_Trill_Sound :: STM Result [Attribute] Trill_Sound
+read_Trill_Sound :: StateT Result [Attribute] Trill_Sound
 read_Trill_Sound = do
     y1 <- read_IMPLIED "start-note" read_Trill_Sound_A 
     y2 <- read_IMPLIED "trill-step" read_Trill_Sound_B 
@@ -1256,7 +1256,7 @@ -- |
 type Bend_Sound = (Maybe Yes_No, Maybe CDATA, Maybe CDATA, Maybe CDATA)
 -- |
-read_Bend_Sound :: STM Result [Attribute] Bend_Sound
+read_Bend_Sound :: StateT Result [Attribute] Bend_Sound
 read_Bend_Sound = do
     y1 <- read_IMPLIED "accelerate" read_Yes_No 
     y2 <- read_IMPLIED "beats" read_CDATA 
@@ -1293,7 +1293,7 @@ -- |
 type Document_Attributes = CDATA
 -- |
-read_Document_Attributes :: STM Result [Attribute] Document_Attributes
+read_Document_Attributes :: StateT Result [Attribute] Document_Attributes
 read_Document_Attributes = read_DEFAULT "version" read_CDATA "1.0"
 -- |
 show_Document_Attributes :: Document_Attributes -> [Attribute]
@@ -1313,7 +1313,7 @@ -- |
 type Editorial = (Maybe Footnote, Maybe Level)
 -- | 
-read_Editorial :: STM Result [Content i] (Editorial)
+read_Editorial :: StateT Result [Content i] (Editorial)
 read_Editorial = do
     y1 <- read_MAYBE read_Footnote
     y2 <- read_MAYBE read_Level
@@ -1326,7 +1326,7 @@ -- |
 type Editorial_Voice = (Maybe Footnote, Maybe Level, Maybe Voice)
 -- | 
-read_Editorial_Voice :: STM Result [Content i] Editorial_Voice
+read_Editorial_Voice :: StateT Result [Content i] Editorial_Voice
 read_Editorial_Voice = do
     y1 <- read_MAYBE read_Footnote 
     y2 <- read_MAYBE read_Level 
@@ -1358,7 +1358,7 @@ -- |
 type Footnote = (Text_Formatting, PCDATA)
 -- |
-read_Footnote :: STM Result [Content i] Footnote
+read_Footnote :: StateT Result [Content i] Footnote
 read_Footnote = do
     y <- read_ELEMENT "footnote" 
     y1 <- read_1 read_Text_Formatting (attributes y)
@@ -1373,7 +1373,7 @@ -- |
 type Level = ((Maybe Yes_No, Level_Display), PCDATA)
 -- | 
-read_Level :: STM Result [Content i] Level
+read_Level :: StateT Result [Content i] Level
 read_Level = do
     y <- read_ELEMENT "level" 
     y1 <- read_2 (read_IMPLIED "reference" read_Yes_No) 
@@ -1390,7 +1390,7 @@ -- |
 type Voice = PCDATA
 -- | 
-read_Voice :: STM Result [Content i] Voice
+read_Voice :: StateT Result [Content i] Voice
 read_Voice = do
     y <- read_ELEMENT "voice" 
     read_1 read_PCDATA (childs y)
@@ -1426,7 +1426,7 @@ show_Fermata_ Fermata_1 = "upright"
 show_Fermata_ Fermata_2 = "inverted"
 -- |
-read_Fermata :: STM Result [Content i] Fermata
+read_Fermata :: StateT Result [Content i] Fermata
 read_Fermata = do
     y <- read_ELEMENT "fermata"
     y1 <- read_2 (read_IMPLIED "type" read_Fermata_) 
@@ -1444,7 +1444,7 @@ type Wavy_Line = ((Start_Stop_Continue, Maybe Number_Level,
         Position, Placement, Color, Trill_Sound),())
 -- |
-read_Wavy_Line :: STM Result [Content i] Wavy_Line
+read_Wavy_Line :: StateT Result [Content i] Wavy_Line
 read_Wavy_Line = do
     y <- read_ELEMENT "wavy-line" 
     y1 <- read_6 (read_REQUIRED "type" read_Start_Stop_Continue) 
@@ -1477,7 +1477,7 @@ -- |
 type Staff = PCDATA
 -- | 
-read_Staff :: STM Result [Content i] Staff
+read_Staff :: StateT Result [Content i] Staff
 read_Staff = do
     y <- read_ELEMENT "staff" 
     read_1 read_PCDATA (childs y)
@@ -1497,7 +1497,7 @@ -- |
 type Segno = (Print_Style, ())
 -- |
-read_Segno :: STM Result [Content i] Segno
+read_Segno :: StateT Result [Content i] Segno
 read_Segno = do
     y <- read_ELEMENT "segno"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -1508,7 +1508,7 @@ -- |
 type Coda = (Print_Style, ())
 -- |
-read_Coda :: STM Result [Content i] Coda
+read_Coda :: StateT Result [Content i] Coda
 read_Coda = do
     y <- read_ELEMENT "coda"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -1532,7 +1532,7 @@ -- |
 type Actual_Notes = PCDATA
 -- | 
-read_Actual_Notes :: STM Result [Content i] Actual_Notes
+read_Actual_Notes :: StateT Result [Content i] Actual_Notes
 read_Actual_Notes = do
     y <- read_ELEMENT "actual-notes" 
     read_1 read_PCDATA (childs y)
@@ -1542,7 +1542,7 @@ -- |
 type Normal_Notes = PCDATA
 -- | 
-read_Normal_Notes :: STM Result [Content i] Normal_Notes
+read_Normal_Notes :: StateT Result [Content i] Normal_Notes
 read_Normal_Notes = do
     y <- read_ELEMENT "normal-notes" 
     read_1 read_PCDATA (childs y)
@@ -1552,7 +1552,7 @@ -- |
 type Normal_Type = PCDATA
 -- | 
-read_Normal_Type :: STM Result [Content i] Normal_Type
+read_Normal_Type :: StateT Result [Content i] Normal_Type
 read_Normal_Type = do
     y <- read_ELEMENT "normal-type"
     read_1 read_PCDATA (childs y)
@@ -1562,7 +1562,7 @@ -- |
 type Normal_Dot = ()
 -- | 
-read_Normal_Dot :: STM Result [Content i] Normal_Dot
+read_Normal_Dot :: StateT Result [Content i] Normal_Dot
 read_Normal_Dot = read_ELEMENT "normal-dot" >> return ()
 -- |
 show_Normal_Dot :: Normal_Dot -> [Content ()]
@@ -1604,7 +1604,7 @@ -- |
 type Dynamics = ((Print_Style, Placement),[Dynamics_])
 -- | 
-read_Dynamics :: Eq i => STM Result [Content i] Dynamics
+read_Dynamics :: Eq i => StateT Result [Content i] Dynamics
 read_Dynamics = do
     y <- read_ELEMENT "dynamics"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1643,7 +1643,7 @@                | Dynamics_24 Other_Dynamics
                  deriving (Eq, Show)
 -- |
-read_Dynamics_ :: STM Result [Content i] Dynamics_
+read_Dynamics_ :: StateT Result [Content i] Dynamics_
 read_Dynamics_  = 
    (read_P >>= return . Dynamics_1) `mplus`
    (read_PP >>= return . Dynamics_2) `mplus`
@@ -1698,7 +1698,7 @@ -- |
 type P = ()
 -- |
-read_P :: STM Result [Content i] P
+read_P :: StateT Result [Content i] P
 read_P = read_ELEMENT "p" >> return ()
 -- |
 show_P :: P -> [Content ()]
@@ -1706,7 +1706,7 @@ -- |
 type PP = ()
 -- | 
-read_PP :: STM Result [Content i] PP
+read_PP :: StateT Result [Content i] PP
 read_PP = read_ELEMENT "pp" >> return ()
 -- |
 show_PP :: PP -> [Content ()]
@@ -1714,7 +1714,7 @@ -- |
 type PPP = ()
 -- | 
-read_PPP :: STM Result [Content i] PPP
+read_PPP :: StateT Result [Content i] PPP
 read_PPP = read_ELEMENT "ppp" >> return ()
 -- |
 show_PPP :: PPP -> [Content ()]
@@ -1722,7 +1722,7 @@ -- |
 type PPPP = ()
 -- | 
-read_PPPP :: STM Result [Content i] PPPP
+read_PPPP :: StateT Result [Content i] PPPP
 read_PPPP = read_ELEMENT "pppp" >> return ()
 -- |
 show_PPPP :: PPPP -> [Content ()]
@@ -1730,7 +1730,7 @@ -- |
 type PPPPP = ()
 -- | 
-read_PPPPP :: STM Result [Content i] PPPPP
+read_PPPPP :: StateT Result [Content i] PPPPP
 read_PPPPP = read_ELEMENT "ppppp" >> return ()
 -- |
 show_PPPPP :: PPPPP -> [Content ()]
@@ -1738,7 +1738,7 @@ -- |
 type PPPPPP = ()
 -- | 
-read_PPPPPP :: STM Result [Content i] PPPPPP
+read_PPPPPP :: StateT Result [Content i] PPPPPP
 read_PPPPPP = read_ELEMENT "pppppp" >> return ()
 -- |
 show_PPPPPP :: PPPPPP -> [Content ()]
@@ -1746,7 +1746,7 @@ -- |
 type FFFFFF = ()
 -- | 
-read_FFFFFF :: STM Result [Content i] FFFFFF
+read_FFFFFF :: StateT Result [Content i] FFFFFF
 read_FFFFFF = read_ELEMENT "ffffff" >> return ()
 -- |
 show_FFFFFF :: FFFFFF -> [Content ()]
@@ -1754,7 +1754,7 @@ -- |
 type FFFFF = ()
 -- | 
-read_FFFFF :: STM Result [Content i] FFFFF
+read_FFFFF :: StateT Result [Content i] FFFFF
 read_FFFFF = read_ELEMENT "fffff" >> return ()
 -- |
 show_FFFFF :: FFFFF -> [Content ()]
@@ -1762,7 +1762,7 @@ -- |
 type FFFF = ()
 -- | 
-read_FFFF :: STM Result [Content i] FFFF
+read_FFFF :: StateT Result [Content i] FFFF
 read_FFFF = read_ELEMENT "ffff" >> return ()
 -- |
 show_FFFF :: FFFF -> [Content ()]
@@ -1770,7 +1770,7 @@ -- |
 type FFF = ()
 -- | 
-read_FFF :: STM Result [Content i] FFF
+read_FFF :: StateT Result [Content i] FFF
 read_FFF = read_ELEMENT "fff" >> return ()
 -- |
 show_FFF :: FFF -> [Content ()]
@@ -1778,7 +1778,7 @@ -- |
 type FF = ()
 -- | 
-read_FF :: STM Result [Content i] FF
+read_FF :: StateT Result [Content i] FF
 read_FF = read_ELEMENT "ff" >> return ()
 -- |
 show_FF :: FF -> [Content ()]
@@ -1786,7 +1786,7 @@ -- |
 type F = ()
 -- | 
-read_F :: STM Result [Content i] F
+read_F :: StateT Result [Content i] F
 read_F  = read_ELEMENT "f" >> return ()
 -- |
 show_F :: F -> [Content ()]
@@ -1794,7 +1794,7 @@ -- |
 type MP = ()
 -- | 
-read_MP :: STM Result [Content i] MP
+read_MP :: StateT Result [Content i] MP
 read_MP = read_ELEMENT "mp" >> return ()
 -- |
 show_MP :: MP -> [Content ()]
@@ -1802,7 +1802,7 @@ -- |
 type MF = ()
 -- | 
-read_MF :: STM Result [Content i] MF
+read_MF :: StateT Result [Content i] MF
 read_MF = read_ELEMENT "mf" >> return ()
 -- |
 show_MF :: MF -> [Content ()]
@@ -1810,7 +1810,7 @@ -- |
 type SF = ()
 -- | 
-read_SF :: STM Result [Content i] SF
+read_SF :: StateT Result [Content i] SF
 read_SF = read_ELEMENT "sf" >> return ()
 -- |
 show_SF :: SF -> [Content ()]
@@ -1818,7 +1818,7 @@ -- |
 type SFP = ()
 -- | 
-read_SFP :: STM Result [Content i] SFP
+read_SFP :: StateT Result [Content i] SFP
 read_SFP = read_ELEMENT "sfp" >> return ()
 -- |
 show_SFP :: SFP -> [Content ()]
@@ -1826,7 +1826,7 @@ -- |
 type SFPP = ()
 -- | 
-read_SFPP :: STM Result [Content i] SFPP
+read_SFPP :: StateT Result [Content i] SFPP
 read_SFPP = read_ELEMENT "sfpp" >> return ()
 -- |
 show_SFPP :: SFPP -> [Content ()]
@@ -1834,7 +1834,7 @@ -- |
 type FP = ()
 -- | 
-read_FP :: STM Result [Content i] FP
+read_FP :: StateT Result [Content i] FP
 read_FP = read_ELEMENT "fp" >> return ()
 -- |
 show_FP :: FP -> [Content ()]
@@ -1842,7 +1842,7 @@ -- |
 type RF = ()
 -- | 
-read_RF :: STM Result [Content i] RF
+read_RF :: StateT Result [Content i] RF
 read_RF = read_ELEMENT "rf" >> return ()
 -- |
 show_RF :: RF -> [Content ()]
@@ -1850,7 +1850,7 @@ -- |
 type RFZ = ()
 -- | 
-read_RFZ :: STM Result [Content i] RFZ
+read_RFZ :: StateT Result [Content i] RFZ
 read_RFZ = read_ELEMENT "rfz" >> return ()
 -- |
 show_RFZ :: RFZ -> [Content ()]
@@ -1858,7 +1858,7 @@ -- |
 type SFZ = ()
 -- | 
-read_SFZ :: STM Result [Content i] SFZ
+read_SFZ :: StateT Result [Content i] SFZ
 read_SFZ = read_ELEMENT "sfz" >> return ()
 -- |
 show_SFZ :: SFZ -> [Content ()]
@@ -1866,7 +1866,7 @@ -- |
 type SFFZ = ()
 -- | 
-read_SFFZ :: STM Result [Content i] SFFZ
+read_SFFZ :: StateT Result [Content i] SFFZ
 read_SFFZ = read_ELEMENT "sffz" >> return ()
 -- |
 show_SFFZ :: SFFZ -> [Content ()]
@@ -1874,7 +1874,7 @@ -- |
 type FZ = ()
 -- | 
-read_FZ :: STM Result [Content i] FZ
+read_FZ :: StateT Result [Content i] FZ
 read_FZ = read_ELEMENT "fz" >> return ()
 -- |
 show_FZ :: FZ -> [Content ()]
@@ -1882,7 +1882,7 @@ -- |
 type Other_Dynamics = PCDATA
 -- | 
-read_Other_Dynamics :: STM Result [Content i] Other_Dynamics
+read_Other_Dynamics :: StateT Result [Content i] Other_Dynamics
 read_Other_Dynamics = do
     y <- read_ELEMENT "other-dynamics" 
     read_1 read_PCDATA (childs y)
@@ -1909,7 +1909,7 @@ -- |
 type Fingering = ((Maybe Yes_No, Maybe Yes_No, Print_Style, Placement), PCDATA)
 -- |
-read_Fingering :: STM Result [Content i] Fingering
+read_Fingering :: StateT Result [Content i] Fingering
 read_Fingering = do
     y <- read_ELEMENT "fingering" 
     y1 <- read_4 (read_IMPLIED "substitution" read_Yes_No) 
@@ -1940,7 +1940,7 @@ -- |
 type Fret = ((Font, Color), PCDATA)
 -- |
-read_Fret :: STM Result [Content i] Fret
+read_Fret :: StateT Result [Content i] Fret
 read_Fret = do
     y <- read_ELEMENT "fret" 
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -1955,7 +1955,7 @@ -- |
 type String = ((Print_Style, Placement), PCDATA)
 -- |
-read_String :: STM Result [Content i] String
+read_String :: StateT Result [Content i] String
 read_String = do
     y <- read_ELEMENT "string"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1980,7 +1980,7 @@ -- |
 type Tuning_Step = PCDATA
 -- | 
-read_Tuning_Step :: STM Result [Content i] Tuning_Step
+read_Tuning_Step :: StateT Result [Content i] Tuning_Step
 read_Tuning_Step = do
     y <- read_ELEMENT "tuning-step" 
     read_1 read_PCDATA (childs y)
@@ -1990,7 +1990,7 @@ -- |
 type Tuning_Alter = PCDATA
 -- | 
-read_Tuning_Alter :: STM Result [Content i] Tuning_Alter
+read_Tuning_Alter :: StateT Result [Content i] Tuning_Alter
 read_Tuning_Alter = do
     y <- read_ELEMENT "tuning-alter" 
     read_1 read_PCDATA (childs y)
@@ -2000,7 +2000,7 @@ -- |
 type Tuning_Octave = PCDATA
 -- | 
-read_Tuning_Octave :: STM Result [Content i] Tuning_Octave
+read_Tuning_Octave :: StateT Result [Content i] Tuning_Octave
 read_Tuning_Octave = do
     y <- read_ELEMENT "tuning-octave"
     read_1 read_PCDATA (childs y)
@@ -2020,7 +2020,7 @@ -- |
 type Display_Text = (Text_Formatting, PCDATA)
 -- |
-read_Display_Text :: STM Result [Content i] Display_Text
+read_Display_Text :: StateT Result [Content i] Display_Text
 read_Display_Text = do
     y <- read_ELEMENT "display-text"
     y1 <- read_1 read_Text_Formatting (attributes y)
@@ -2044,7 +2044,7 @@ -- |
 type Accidental_Text = (Text_Formatting, PCDATA)
 -- |
-read_Accidental_Text :: STM Result [Content i] Accidental_Text
+read_Accidental_Text :: StateT Result [Content i] Accidental_Text
 read_Accidental_Text = do
     y <- read_ELEMENT "accidental-text"
     y1 <- read_1 read_Text_Formatting (attributes y)
@@ -2074,7 +2074,7 @@ \begin{code}
 type Part_Name_Display = (Print_Object, [Part_Name_Display_])
 -- |
-read_Part_Name_Display :: Eq i => STM Result [Content i] Part_Name_Display
+read_Part_Name_Display :: Eq i => StateT Result [Content i] Part_Name_Display
 read_Part_Name_Display = do
     y <- read_ELEMENT "part-name-display"
     y1 <- read_1 read_Print_Object (attributes y)
@@ -2091,7 +2091,7 @@                         | Part_Name_Display_2 Accidental_Text
                         deriving (Eq, Show)
 -- |
-read_Part_Name_Display_ :: STM Result [Content i] Part_Name_Display_
+read_Part_Name_Display_ :: StateT Result [Content i] Part_Name_Display_
 read_Part_Name_Display_ = 
     (read_Display_Text >>= (return . Part_Name_Display_1)) `mplus`
     (read_Accidental_Text >>= (return . Part_Name_Display_2)) `mplus`
@@ -2104,7 +2104,7 @@ type Part_Abbreviation_Display = (Print_Object, [Part_Abbreviation_Display_])
 -- |
 read_Part_Abbreviation_Display :: Eq i => 
-    STM Result [Content i] Part_Abbreviation_Display
+    StateT Result [Content i] Part_Abbreviation_Display
 read_Part_Abbreviation_Display = do
     y <- read_ELEMENT "part-abbreviation-display"
     y1 <- read_1 read_Print_Object (attributes y)
@@ -2123,7 +2123,7 @@       deriving (Eq, Show)
 -- |
 read_Part_Abbreviation_Display_ :: 
-    STM Result [Content i] Part_Abbreviation_Display_
+    StateT Result [Content i] Part_Abbreviation_Display_
 read_Part_Abbreviation_Display_ = 
     (read_Display_Text >>= (return . Part_Abbreviation_Display_1)) `mplus`
     (read_Accidental_Text >>= (return . Part_Abbreviation_Display_2)) `mplus`
@@ -2150,7 +2150,7 @@     Maybe Midi_Bank, Maybe Midi_Program, Maybe Midi_Unpitched,
     Maybe Volume, Maybe Pan, Maybe Elevation))
 -- |
-read_Midi_Instrument :: STM Result [Content i] Midi_Instrument
+read_Midi_Instrument :: StateT Result [Content i] Midi_Instrument
 read_Midi_Instrument = do
     y <- read_ELEMENT "midi-instrument"
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
@@ -2178,7 +2178,7 @@ -- |
 type Midi_Channel = PCDATA
 -- |
-read_Midi_Channel :: STM Result [Content i] Midi_Channel
+read_Midi_Channel :: StateT Result [Content i] Midi_Channel
 read_Midi_Channel = do
     y <- read_ELEMENT "midi-channel" 
     read_1 read_PCDATA (childs y)
@@ -2196,7 +2196,7 @@ -- |
 type Midi_Name = PCDATA
 -- |
-read_Midi_Name :: STM Result [Content i] Midi_Name
+read_Midi_Name :: StateT Result [Content i] Midi_Name
 read_Midi_Name = do
     y <- read_ELEMENT "midi-name" 
     read_1 read_PCDATA (childs y)
@@ -2213,7 +2213,7 @@ -- |
 type Midi_Bank = PCDATA
 -- |
-read_Midi_Bank :: STM Result [Content i] Midi_Bank
+read_Midi_Bank :: StateT Result [Content i] Midi_Bank
 read_Midi_Bank = do
     y <- read_ELEMENT "midi-bank" 
     read_1 read_PCDATA (childs y)
@@ -2230,7 +2230,7 @@ -- |
 type Midi_Program = PCDATA
 -- |
-read_Midi_Program :: STM Result [Content i] Midi_Program
+read_Midi_Program :: StateT Result [Content i] Midi_Program
 read_Midi_Program = do
     y <- read_ELEMENT "midi-program" 
     read_1 read_PCDATA (childs y)
@@ -2249,7 +2249,7 @@ -- |
 type Midi_Unpitched = PCDATA
 -- |
-read_Midi_Unpitched :: STM Result [Content i] Midi_Unpitched
+read_Midi_Unpitched :: StateT Result [Content i] Midi_Unpitched
 read_Midi_Unpitched = do
     y <- read_ELEMENT "midi-unpitched" 
     read_1 read_PCDATA (childs y)
@@ -2269,7 +2269,7 @@ -- |
 type Volume = PCDATA
 -- |
-read_Volume :: STM Result [Content i] Volume
+read_Volume :: StateT Result [Content i] Volume
 read_Volume = do
     y <- read_ELEMENT "volume" 
     read_1 read_PCDATA (childs y)
@@ -2292,7 +2292,7 @@ -- |
 type Pan = PCDATA
 -- |
-read_Pan :: STM Result [Content i] Pan
+read_Pan :: StateT Result [Content i] Pan
 read_Pan = do
     y <- read_ELEMENT "pan" 
     read_1 read_PCDATA (childs y)
@@ -2303,7 +2303,7 @@ -- |
 type Elevation = PCDATA
 -- |
-read_Elevation :: STM Result [Content i] Elevation
+read_Elevation :: StateT Result [Content i] Elevation
 read_Elevation = do
     y <- read_ELEMENT "elevation" 
     read_1 read_PCDATA (childs y)
src/Text/XML/MusicXML/Container.lhs view
@@ -78,7 +78,7 @@ -- |
 type Container = Rootfiles
 -- |
-read_Container :: Eq i => STM Result [Content i] Container
+read_Container :: Eq i => StateT Result [Content i] Container
 read_Container = do
     y <- read_ELEMENT "container"
     read_1 read_Rootfiles (childs y)
@@ -99,7 +99,7 @@ -- |
 type Rootfiles = [Rootfile]
 -- |
-read_Rootfiles :: Eq i => STM Result [Content i] Rootfiles
+read_Rootfiles :: Eq i => StateT Result [Content i] Rootfiles
 read_Rootfiles = do
     y <- read_ELEMENT "rootfiles"
     read_1 (read_LIST1 read_Rootfile) (childs y)
@@ -125,7 +125,7 @@ -- |
 type Rootfile = ((CDATA, Maybe CDATA), ())
 -- |
-read_Rootfile :: Eq i => STM Result [Content i] Rootfile
+read_Rootfile :: Eq i => StateT Result [Content i] Rootfile
 read_Rootfile = do
     y <- read_ELEMENT "rootfile"
     y1 <- read_2 (read_REQUIRED "full-path" read_CDATA) 
src/Text/XML/MusicXML/Direction.lhs view
@@ -42,7 +42,7 @@     ([Direction_Type], Maybe Offset, Editorial_Voice, 
     Maybe Staff, Maybe Sound))
 -- |
-read_Direction :: Eq i => STM Result [Content i] Direction
+read_Direction :: Eq i => StateT Result [Content i] Direction
 read_Direction = do
     y <- read_ELEMENT "direction"
     y1 <- read_2 read_Placement read_Directive (attributes y)
@@ -72,7 +72,7 @@ -- |
 type Direction_Type = Direction_Type_
 -- |
-read_Direction_Type :: Eq i => STM Result [Content i] Direction_Type
+read_Direction_Type :: Eq i => StateT Result [Content i] Direction_Type
 read_Direction_Type = do
     y <- read_ELEMENT "direction-type"
     read_1 read_Direction_Type_ (childs y)
@@ -102,7 +102,7 @@                      | Direction_Type_19 Other_Direction
                        deriving (Eq, Show)
 -- |
-read_Direction_Type_ :: Eq i => STM Result [Content i] Direction_Type_
+read_Direction_Type_ :: Eq i => StateT Result [Content i] Direction_Type_
 read_Direction_Type_ = 
     (read_LIST1 read_Rehearsal >>= return . Direction_Type_1) `mplus`
     (read_LIST1 read_Segno >>= return . Direction_Type_2) `mplus`
@@ -159,7 +159,7 @@         Maybe CDATA, Text_Direction, Text_Rotation,
         Maybe Rehearsal_), PCDATA)
 -- |
-read_Rehearsal :: STM Result [Content i] Rehearsal
+read_Rehearsal :: StateT Result [Content i] Rehearsal
 read_Rehearsal = do
     y <- read_ELEMENT "rehearsal" 
     y1 <- read_6 read_Print_Style read_Text_Decoration
@@ -203,7 +203,7 @@ -- |
 type Words = (Text_Formatting, PCDATA)
 -- |
-read_Words :: STM Result [Content i] Words
+read_Words :: StateT Result [Content i] Words
 read_Words = do
     y <- read_ELEMENT "words"
     y1 <- read_1 read_Text_Formatting (attributes y)
@@ -228,7 +228,7 @@ type Wedge = ((Wedge_, Maybe Number_Level, Maybe CDATA,
         Position, Color), ())
 -- |
-read_Wedge :: STM Result [Content i] Wedge
+read_Wedge :: StateT Result [Content i] Wedge
 read_Wedge = do
     y <- read_ELEMENT "wedge"
     y1 <- read_5 (read_REQUIRED "type" read_Wedge_)
@@ -268,7 +268,7 @@ type Dashes = ((Start_Stop, Maybe Number_Level, 
         Position, Color), ())
 -- |
-read_Dashes :: STM Result [Content i] Dashes
+read_Dashes :: StateT Result [Content i] Dashes
 read_Dashes = do
     y <- read_ELEMENT "dashes"
     y1 <- read_4 (read_REQUIRED "type" read_Start_Stop)
@@ -298,7 +298,7 @@ type Bracket = ((Start_Stop, Maybe Number_Level, 
         Bracket_, Maybe Tenths, Line_Type, Position, Color), ())
 -- |
-read_Bracket :: STM Result [Content i] Bracket
+read_Bracket :: StateT Result [Content i] Bracket
 read_Bracket = do
     y <- read_ELEMENT "bracket"
     y1 <- read_7 (read_REQUIRED "type" read_Start_Stop)
@@ -347,7 +347,7 @@ -- |
 type Pedal = ((Pedal_, Maybe Yes_No, Print_Style), ())
 -- |
-read_Pedal :: STM Result [Content i] Pedal
+read_Pedal :: StateT Result [Content i] Pedal
 read_Pedal = do
     y <- read_ELEMENT "pedal"
     y1 <- read_3 (read_REQUIRED "type" read_Pedal_)
@@ -413,7 +413,7 @@ -- |
 type Metronome = ((Print_Style, Maybe Yes_No), Metronome_A)
 -- |
-read_Metronome :: Eq i => STM Result [Content i] Metronome
+read_Metronome :: Eq i => StateT Result [Content i] Metronome
 read_Metronome = do
     y <- read_ELEMENT "metronome"
     y1 <- read_2 read_Print_Style (read_IMPLIED "parentheses" read_Yes_No)
@@ -432,7 +432,7 @@                                 Maybe (Metronome_Relation, [Metronome_Note]))
                  deriving (Eq, Show)
 -- |
-read_Metronome_A :: Eq i => STM Result [Content i] Metronome_A
+read_Metronome_A :: Eq i => StateT Result [Content i] Metronome_A
 read_Metronome_A = 
     (read_Metronome_A_aux1 >>= return . Metronome_1) `mplus`
     (read_Metronome_A_aux2 >>= return . Metronome_2) 
@@ -445,14 +445,14 @@                                        show_MAYBE show_Metronome_A_aux1 b
 -- |
 read_Metronome_A_aux1 :: Eq i => 
-    STM Result [Content i] (Beat_Unit, [Beat_Unit_Dot], Metronome_B)
+    StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot], Metronome_B)
 read_Metronome_A_aux1 = do
     y1 <- read_Beat_Unit
     y2 <- read_LIST read_Beat_Unit_Dot
     y3 <- read_Metronome_B
     return (y1,y2,y3)
 -- |
-read_Metronome_A_aux2 :: Eq i => STM Result [Content i] 
+read_Metronome_A_aux2 :: Eq i => StateT Result [Content i] 
     ([Metronome_Note], Maybe (Metronome_Relation, [Metronome_Note]))
 read_Metronome_A_aux2 = do
     y1 <- read_LIST1 read_Metronome_Note
@@ -460,7 +460,7 @@     return (y1,y2)
 -- |
 read_Metronome_A_aux3 :: Eq i => 
-    STM Result [Content i] (Metronome_Relation, [Metronome_Note])
+    StateT Result [Content i] (Metronome_Relation, [Metronome_Note])
 read_Metronome_A_aux3 = do
     y1 <- read_Metronome_Relation
     y2 <- read_LIST1 read_Metronome_Note
@@ -474,7 +474,7 @@                  | Metronome_4 (Beat_Unit, [Beat_Unit_Dot])
                  deriving (Eq, Show)
 -- |
-read_Metronome_B :: Eq i => STM Result [Content i] Metronome_B
+read_Metronome_B :: Eq i => StateT Result [Content i] Metronome_B
 read_Metronome_B = 
     (read_Per_Minute >>= return . Metronome_3) `mplus`
     (read_Metronome_B_aux1 >>= return . Metronome_4)     
@@ -485,7 +485,7 @@                                        show_LIST show_Beat_Unit_Dot b
 -- |
 read_Metronome_B_aux1 :: Eq i => 
-    STM Result [Content i] (Beat_Unit, [Beat_Unit_Dot])
+    StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot])
 read_Metronome_B_aux1 = do
     y1 <- read_Beat_Unit
     y2 <- read_LIST read_Beat_Unit_Dot
@@ -493,7 +493,7 @@ -- |
 type Beat_Unit = PCDATA
 -- |
-read_Beat_Unit :: STM Result [Content i] Beat_Unit
+read_Beat_Unit :: StateT Result [Content i] Beat_Unit
 read_Beat_Unit = do
     y <- read_ELEMENT "beat-unit" 
     read_1 read_PCDATA (childs y)
@@ -503,7 +503,7 @@ -- |
 type Beat_Unit_Dot = ()
 -- |
-read_Beat_Unit_Dot :: STM Result [Content i] Beat_Unit_Dot
+read_Beat_Unit_Dot :: StateT Result [Content i] Beat_Unit_Dot
 read_Beat_Unit_Dot = read_ELEMENT "beat-unit-dot" >> return ()
 -- |
 show_Beat_Unit_Dot :: Beat_Unit_Dot -> [Content ()]
@@ -511,7 +511,7 @@ -- |
 type Per_Minute = (Font, PCDATA)
 -- |
-read_Per_Minute :: STM Result [Content i] Per_Minute
+read_Per_Minute :: StateT Result [Content i] Per_Minute
 read_Per_Minute = do
     y <- read_ELEMENT "per-minute"
     y1 <- read_1 read_Font (attributes y)
@@ -525,7 +525,7 @@ type Metronome_Note = (Metronome_Type, [Metronome_Dot], 
     [Metronome_Beam], Maybe Metronome_Tuplet)
 -- |
-read_Metronome_Note :: Eq i => STM Result [Content i] Metronome_Note
+read_Metronome_Note :: Eq i => StateT Result [Content i] Metronome_Note
 read_Metronome_Note = do
     y <- read_ELEMENT "metronome-note"
     read_4 read_Metronome_Type (read_LIST read_Metronome_Dot)
@@ -540,7 +540,7 @@ -- |
 type Metronome_Relation = PCDATA
 -- |
-read_Metronome_Relation :: STM Result [Content i] Metronome_Relation
+read_Metronome_Relation :: StateT Result [Content i] Metronome_Relation
 read_Metronome_Relation = do
     y <- read_ELEMENT "metronome-relation" 
     read_1 read_PCDATA (childs y)
@@ -551,7 +551,7 @@ -- |
 type Metronome_Type = PCDATA
 -- |
-read_Metronome_Type :: STM Result [Content i] Metronome_Type
+read_Metronome_Type :: StateT Result [Content i] Metronome_Type
 read_Metronome_Type = do
     y <- read_ELEMENT "metronome-type" 
     read_1 read_PCDATA (childs y)
@@ -562,7 +562,7 @@ -- |
 type Metronome_Dot = ()
 -- |
-read_Metronome_Dot :: STM Result [Content i] Metronome_Dot
+read_Metronome_Dot :: StateT Result [Content i] Metronome_Dot
 read_Metronome_Dot = read_ELEMENT "metronome-dot" >> return ()
 -- |
 show_Metronome_Dot :: Metronome_Dot -> [Content ()]
@@ -571,7 +571,7 @@ -- |
 type Metronome_Beam = (Beam_Level, PCDATA)
 -- |
-read_Metronome_Beam :: STM Result [Content i] Metronome_Beam
+read_Metronome_Beam :: StateT Result [Content i] Metronome_Beam
 read_Metronome_Beam = do
     y <- read_ELEMENT "metronome-beam"
     y1 <- read_1 (read_DEFAULT "number" read_Beam_Level Beam_Level_1) 
@@ -587,7 +587,7 @@ type Metronome_Tuplet = ((Start_Stop, Maybe Yes_No, Maybe Metronome_Tuplet_), 
     (Actual_Notes, Normal_Notes, Maybe (Normal_Type, [Normal_Dot])))
 -- |
-read_Metronome_Tuplet :: Eq i => STM Result [Content i] Metronome_Tuplet
+read_Metronome_Tuplet :: Eq i => StateT Result [Content i] Metronome_Tuplet
 read_Metronome_Tuplet = do
     y <- read_ELEMENT "metronome-tuplet"
     y1 <- read_3 (read_REQUIRED "type" read_Start_Stop)
@@ -608,7 +608,7 @@          show_MAYBE show_Metronome_Tuplet_aux1 f)
 -- |
 read_Metronome_Tuplet_aux1 :: Eq i => 
-    STM Result [Content i] (Normal_Type, [Normal_Dot])
+    StateT Result [Content i] (Normal_Type, [Normal_Dot])
 read_Metronome_Tuplet_aux1 = do
     y1 <- read_Normal_Type
     y2 <- read_LIST read_Normal_Dot
@@ -650,7 +650,7 @@ type Octave_Shift = ((Octave_Shift_, Maybe Number_Level, 
     CDATA, Print_Style), ())
 -- |
-read_Octave_Shift :: STM Result [Content i] Octave_Shift
+read_Octave_Shift :: StateT Result [Content i] Octave_Shift
 read_Octave_Shift = do
     y <- read_ELEMENT "octave-shift"
     y1 <- read_4 (read_REQUIRED "type" read_Octave_Shift_)
@@ -694,7 +694,7 @@ -- |
 type Harp_Pedals = (Print_Style, [Pedal_Tuning])
 -- |
-read_Harp_Pedals :: Eq i => STM Result [Content i] Harp_Pedals
+read_Harp_Pedals :: Eq i => StateT Result [Content i] Harp_Pedals
 read_Harp_Pedals = do
     y <- read_ELEMENT "harp-pedals"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -708,7 +708,7 @@ -- |
 type Pedal_Tuning = (Pedal_Step, Pedal_Alter)
 -- |
-read_Pedal_Tuning :: STM Result [Content i] Pedal_Tuning
+read_Pedal_Tuning :: StateT Result [Content i] Pedal_Tuning
 read_Pedal_Tuning = do
     y <- read_ELEMENT "pedal-tuning"
     read_2 read_Pedal_Step read_Pedal_Alter (childs y)
@@ -720,7 +720,7 @@ -- |
 type Pedal_Step = PCDATA
 -- |
-read_Pedal_Step :: STM Result [Content i] Pedal_Step
+read_Pedal_Step :: StateT Result [Content i] Pedal_Step
 read_Pedal_Step = do
     y <- read_ELEMENT "pedal-step"
     read_1 read_PCDATA (childs y)
@@ -730,7 +730,7 @@ -- |
 type Pedal_Alter = PCDATA
 -- |
-read_Pedal_Alter :: STM Result [Content i] Pedal_Alter
+read_Pedal_Alter :: StateT Result [Content i] Pedal_Alter
 read_Pedal_Alter = do
     y <- read_ELEMENT "pedal-alter"
     read_1 read_PCDATA (childs y)
@@ -740,7 +740,7 @@ -- |
 type Damp = (Print_Style, ())
 -- |
-read_Damp :: STM Result [Content i] Damp
+read_Damp :: StateT Result [Content i] Damp
 read_Damp = do
     y <- read_ELEMENT "damp"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -751,7 +751,7 @@ -- |
 type Damp_All = (Print_Style, ())
 -- |
-read_Damp_All :: STM Result [Content i] Damp_All
+read_Damp_All :: StateT Result [Content i] Damp_All
 read_Damp_All = do
     y <- read_ELEMENT "damp-all"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -762,7 +762,7 @@ -- |
 type Eyeglasses = (Print_Style, ())
 -- |
-read_Eyeglasses :: STM Result [Content i] Eyeglasses
+read_Eyeglasses :: StateT Result [Content i] Eyeglasses
 read_Eyeglasses = do
     y <- read_ELEMENT "eyeglasses"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -784,7 +784,7 @@ -- |
 type Scordatura = [Accord]
 -- |
-read_Scordatura :: Eq i => STM Result [Content i] Scordatura
+read_Scordatura :: Eq i => StateT Result [Content i] Scordatura
 read_Scordatura = do
     y <- read_ELEMENT "scordatura"
     read_1 (read_LIST read_Accord) (childs y)
@@ -795,7 +795,7 @@ -- |
 type Accord = (CDATA, (Tuning_Step, Maybe Tuning_Alter, Tuning_Octave))
 -- |
-read_Accord :: STM Result [Content i] Accord
+read_Accord :: StateT Result [Content i] Accord
 read_Accord = do
     y <- read_ELEMENT "accord"
     y1 <- read_1 (read_REQUIRED "string" read_CDATA) (attributes y)
@@ -824,7 +824,7 @@ -- |
 type Image = ((CDATA, CDATA, Position, Halign, Valign_Image), ())
 -- |
-read_Image :: STM Result [Content i] Image
+read_Image :: StateT Result [Content i] Image
 read_Image = do
     y <- read_ELEMENT "image"
     y1 <- read_5 (read_REQUIRED "source" read_CDATA)
@@ -858,7 +858,7 @@ type Accordion_Registration = (Print_Style,
     (Maybe Accordion_High, Maybe Accordion_Middle, Maybe Accordion_Low))
 -- |
-read_Accordion_Registration :: STM Result [Content i] Accordion_Registration 
+read_Accordion_Registration :: StateT Result [Content i] Accordion_Registration 
 read_Accordion_Registration = do
     y <- read_ELEMENT "accordion-registration"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -877,7 +877,7 @@ -- |
 type Accordion_High = ()
 -- |
-read_Accordion_High :: STM Result [Content i] Accordion_High
+read_Accordion_High :: StateT Result [Content i] Accordion_High
 read_Accordion_High = read_ELEMENT "accordion-high" >> return ()
 -- |
 show_Accordion_High :: Accordion_High -> [Content ()]
@@ -885,7 +885,7 @@ -- |
 type Accordion_Middle = PCDATA
 -- |
-read_Accordion_Middle :: STM Result [Content i] Accordion_Middle
+read_Accordion_Middle :: StateT Result [Content i] Accordion_Middle
 read_Accordion_Middle = do 
     y <- read_ELEMENT "accordion-middle"
     read_1 read_PCDATA (childs y)
@@ -895,7 +895,7 @@ -- |
 type Accordion_Low = ()
 -- |
-read_Accordion_Low :: STM Result [Content i] Accordion_Low
+read_Accordion_Low :: StateT Result [Content i] Accordion_Low
 read_Accordion_Low = read_ELEMENT "accordion-low" >> return ()
 -- |
 show_Accordion_Low :: Accordion_Low -> [Content ()]
@@ -913,7 +913,7 @@ -- |
 type Other_Direction = ((Print_Object, Print_Style), PCDATA)
 -- |
-read_Other_Direction :: STM Result [Content i] Other_Direction
+read_Other_Direction :: StateT Result [Content i] Other_Direction
 read_Other_Direction = do 
     y <- read_ELEMENT "other-direction"
     y1 <- read_2 read_Print_Object read_Print_Style (attributes y)
@@ -946,7 +946,7 @@ -- |
 type Offset = (Maybe Yes_No, PCDATA)
 -- |
-read_Offset :: STM Result [Content i] Offset
+read_Offset :: StateT Result [Content i] Offset
 read_Offset = do
     y <- read_ELEMENT "offset"
     y1 <- read_1 (read_IMPLIED "sound" read_Yes_No) (attributes y)
@@ -991,7 +991,7 @@ type Harmony_Chord = (Harmony_Chord_, Kind, Maybe Inversion, 
                       Maybe Bass, [Degree])
 -- |
-read_Harmony_Chord :: Eq i => STM Result [Content i] Harmony_Chord
+read_Harmony_Chord :: Eq i => StateT Result [Content i] Harmony_Chord
 read_Harmony_Chord = do
     y1 <- read_Harmony_Chord_ 
     y2 <- read_Kind 
@@ -1010,7 +1010,7 @@                     | Harmony_Chord_2 Function
                       deriving (Eq, Show)
 -- |
-read_Harmony_Chord_ :: STM Result [Content i] Harmony_Chord_
+read_Harmony_Chord_ :: StateT Result [Content i] Harmony_Chord_
 read_Harmony_Chord_ = 
     (read_Root >>= return . Harmony_Chord_1) `mplus`
     (read_Function >>= return . Harmony_Chord_2) 
@@ -1024,7 +1024,7 @@     ([Harmony_Chord], Maybe Frame, 
     Maybe Offset, Editorial, Maybe Staff))
 -- |
-read_Harmony :: Eq i => STM Result [Content i] Harmony
+read_Harmony :: Eq i => StateT Result [Content i] Harmony
 read_Harmony = do
     y <- read_ELEMENT "harmony"
     y1 <- read_5 (read_IMPLIED "type" read_Harmony_) read_Print_Object
@@ -1085,7 +1085,7 @@ -- |
 type Root = (Root_Step, Maybe Root_Alter)
 -- |
-read_Root :: STM Result [Content i] Root
+read_Root :: StateT Result [Content i] Root
 read_Root = do 
     y <- read_ELEMENT "root"
     read_2 read_Root_Step (read_MAYBE read_Root_Alter) (childs y)
@@ -1097,7 +1097,7 @@ -- |
 type Root_Step = ((Maybe CDATA, Print_Style), PCDATA)
 -- |
-read_Root_Step :: STM Result [Content i] Root_Step
+read_Root_Step :: StateT Result [Content i] Root_Step
 read_Root_Step = do
     y <- read_ELEMENT "root-step"
     y1 <- read_2 (read_IMPLIED "text" read_CDATA) 
@@ -1113,7 +1113,7 @@ -- |
 type Root_Alter = ((Print_Object, Print_Style, Maybe Left_Right), PCDATA)
 -- |
-read_Root_Alter :: STM Result [Content i] Root_Alter
+read_Root_Alter :: StateT Result [Content i] Root_Alter
 read_Root_Alter = do
     y <- read_ELEMENT "root-alter"
     y1 <- read_3 read_Print_Object read_Print_Style 
@@ -1131,7 +1131,7 @@ -- |
 type Function = (Print_Style, PCDATA)
 -- |
-read_Function :: STM Result [Content i] Function
+read_Function :: StateT Result [Content i] Function
 read_Function = do
     y <- read_ELEMENT "function"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -1232,7 +1232,7 @@         Maybe Yes_No, Maybe Yes_No, Maybe Yes_No,
         Print_Style, Halign, Valign), PCDATA)
 -- |
-read_Kind :: STM Result [Content i] Kind
+read_Kind :: StateT Result [Content i] Kind
 read_Kind = do 
     y <- read_ELEMENT "kind"
     y1 <- read_8 (read_IMPLIED "use-symbols" read_Yes_No) 
@@ -1262,7 +1262,7 @@ \begin{code}
 type Inversion = (Print_Style, PCDATA)
 -- |
-read_Inversion :: STM Result [Content i] Inversion
+read_Inversion :: StateT Result [Content i] Inversion
 read_Inversion = do 
     y <- read_ELEMENT "inversion"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -1288,7 +1288,7 @@ -- |
 type Bass = (Bass_Step, Maybe Bass_Alter)
 -- |
-read_Bass :: STM Result [Content i] Bass
+read_Bass :: StateT Result [Content i] Bass
 read_Bass = do
     y <- read_ELEMENT "bass"
     read_2 read_Bass_Step (read_MAYBE read_Bass_Alter) (childs y)
@@ -1300,7 +1300,7 @@ -- |
 type Bass_Step = ((Maybe CDATA, Print_Style), PCDATA)
 -- |
-read_Bass_Step :: STM Result [Content i] Bass_Step
+read_Bass_Step :: StateT Result [Content i] Bass_Step
 read_Bass_Step = do
     y <- read_ELEMENT "bass-step"
     y1 <- read_2 (read_IMPLIED "text" read_CDATA) 
@@ -1316,7 +1316,7 @@ -- |
 type Bass_Alter = ((Print_Object, Print_Style, Maybe Bass_Alter_), PCDATA)
 -- |
-read_Bass_Alter :: STM Result [Content i] Bass_Alter
+read_Bass_Alter :: StateT Result [Content i] Bass_Alter
 read_Bass_Alter = do
     y <- read_ELEMENT "bass-alter"
     y1 <- read_3 read_Print_Object read_Print_Style 
@@ -1374,7 +1374,7 @@ -- |
 type Degree = (Print_Object, (Degree_Value, Degree_Alter, Degree_Type))
 -- |
-read_Degree :: STM Result [Content i] Degree
+read_Degree :: StateT Result [Content i] Degree
 read_Degree = do
     y <- read_ELEMENT "degree"
     y1 <- read_1 read_Print_Object (attributes y)
@@ -1391,7 +1391,7 @@ -- |
 type Degree_Value = ((Maybe CDATA, Print_Style), PCDATA)
 -- |
-read_Degree_Value :: STM Result [Content i] Degree_Value
+read_Degree_Value :: StateT Result [Content i] Degree_Value
 read_Degree_Value = do
     y <- read_ELEMENT "degree-value"
     y1 <- read_2 (read_IMPLIED "text" read_CDATA) 
@@ -1407,7 +1407,7 @@ -- |
 type Degree_Alter = ((Print_Style, Maybe Yes_No), PCDATA)
 -- |
-read_Degree_Alter :: STM Result [Content i] Degree_Alter
+read_Degree_Alter :: StateT Result [Content i] Degree_Alter
 read_Degree_Alter = do
     y <- read_ELEMENT "degree-alter"
     y1 <- read_2 read_Print_Style 
@@ -1423,7 +1423,7 @@ -- |
 type Degree_Type = ((Maybe CDATA, Print_Style), PCDATA)
 -- |
-read_Degree_Type :: STM Result [Content i] Degree_Type
+read_Degree_Type :: StateT Result [Content i] Degree_Type
 read_Degree_Type = do
     y <- read_ELEMENT "degree-type"
     y1 <- read_2 (read_IMPLIED "text" read_CDATA) 
@@ -1462,7 +1462,7 @@     ((Position, Color, Halign, Valign, Maybe Tenths, Maybe Tenths), 
     (Frame_Strings, Frame_Frets, Maybe First_Fret, [Frame_Note]))
 -- |
-read_Frame :: Eq i => STM Result [Content i] Frame
+read_Frame :: Eq i => StateT Result [Content i] Frame
 read_Frame = do
     y <- read_ELEMENT "frame"
     y1 <- read_6 read_Position read_Color read_Halign read_Valign 
@@ -1484,7 +1484,7 @@ -- |
 type Frame_Strings = PCDATA
 -- |
-read_Frame_Strings :: STM Result [Content i] Frame_Strings
+read_Frame_Strings :: StateT Result [Content i] Frame_Strings
 read_Frame_Strings = do
     y <- read_ELEMENT "frame-strings"
     read_1 read_PCDATA (childs y)
@@ -1494,7 +1494,7 @@ -- |
 type Frame_Frets = PCDATA
 -- |
-read_Frame_Frets :: STM Result [Content i] Frame_Frets
+read_Frame_Frets :: StateT Result [Content i] Frame_Frets
 read_Frame_Frets = do
     y <- read_ELEMENT "frame-frets"
     read_1 read_PCDATA (childs y)
@@ -1504,7 +1504,7 @@ -- |
 type First_Fret = ((Maybe CDATA, Maybe Left_Right), PCDATA)
 -- |
-read_First_Fret :: STM Result [Content i] First_Fret
+read_First_Fret :: StateT Result [Content i] First_Fret
 read_First_Fret = do
     y <- read_ELEMENT "first-fret"
     y1 <- read_2 (read_IMPLIED "text" read_CDATA) 
@@ -1521,7 +1521,7 @@ -- |
 type Frame_Note = (String, Fret, Maybe Fingering, Maybe Barre)
 -- |
-read_Frame_Note :: STM Result [Content i] Frame_Note
+read_Frame_Note :: StateT Result [Content i] Frame_Note
 read_Frame_Note = do
     y <- read_ELEMENT "frame-note"
     read_4 read_String read_Fret (read_MAYBE read_Fingering) 
@@ -1546,7 +1546,7 @@ -- |
 type Barre = ((Start_Stop, Color), ())
 -- |
-read_Barre :: STM Result [Content i] Barre
+read_Barre :: StateT Result [Content i] Barre
 read_Barre = do
     y <- read_ELEMENT "barre"
     y1 <- read_2 (read_REQUIRED "type" read_Start_Stop) 
@@ -1579,7 +1579,7 @@ -- |
 type Grouping = ((Start_Stop_Single, CDATA, Maybe CDATA), [Feature])
 -- |
-read_Grouping :: Eq i => STM Result [Content i] Grouping
+read_Grouping :: Eq i => StateT Result [Content i] Grouping
 read_Grouping = do
     y <- read_ELEMENT "grouping"
     y1 <- read_3 (read_REQUIRED "type" read_Start_Stop_Single)
@@ -1598,7 +1598,7 @@ -- |
 type Feature = (Maybe CDATA, PCDATA)
 -- |
-read_Feature :: STM Result [Content i] Feature
+read_Feature :: StateT Result [Content i] Feature
 read_Feature = do
     y <- read_ELEMENT "feature"
     y1 <- read_1 (read_IMPLIED "type" read_CDATA) (attributes y)
@@ -1656,7 +1656,7 @@     Maybe Measure_Layout, Maybe Measure_Numbering, Maybe Part_Name_Display,
     Maybe Part_Abbreviation_Display))
 -- |
-read_Print :: Eq i => STM Result [Content i] Print
+read_Print :: Eq i => StateT Result [Content i] Print
 read_Print = do
     y <- read_ELEMENT "print"
     y1 <- read_5 (read_IMPLIED "staff-spacing" read_Tenths)
@@ -1699,7 +1699,7 @@ -- |
 type Measure_Numbering = (Print_Style, PCDATA)
 -- |
-read_Measure_Numbering :: Eq i => STM Result [Content i] Measure_Numbering
+read_Measure_Numbering :: Eq i => StateT Result [Content i] Measure_Numbering
 read_Measure_Numbering = do
     y <- read_ELEMENT "measure-numbering"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -1801,7 +1801,7 @@         Maybe Yes_No_Number, Maybe Yes_No_Number), 
     ([Midi_Instrument], Maybe Offset))
 -- |
-read_Sound :: Eq i => STM Result [Content i] Sound
+read_Sound :: Eq i => StateT Result [Content i] Sound
 read_Sound = do
     y <- read_ELEMENT "sound"
     y1 <- read_17 (read_IMPLIED "tempo" read_CDATA)
src/Text/XML/MusicXML/Identity.lhs view
@@ -29,7 +29,7 @@ type Identification = ([Creator], [Rights], Maybe Encoding,
     Maybe Source, [Relation], Maybe Miscellaneous)
 -- |
-read_Identification :: Eq i => STM Result [Content i] Identification
+read_Identification :: Eq i => StateT Result [Content i] Identification
 read_Identification = do
     y <- read_ELEMENT "identification" 
     read_6 (read_LIST read_Creator) (read_LIST read_Rights)
@@ -65,7 +65,7 @@ -- |
 type Creator = (Maybe CDATA, PCDATA)
 -- |
-read_Creator :: Eq i => STM Result [Content i] Creator
+read_Creator :: Eq i => StateT Result [Content i] Creator
 read_Creator = do
     y <- read_ELEMENT "creator"
     y1 <- read_1 (read_IMPLIED "type" read_CDATA) (attributes y)
@@ -94,7 +94,7 @@ -- |
 type Rights = (Maybe CDATA, CDATA)
 -- |
-read_Rights :: Eq i => STM Result [Content i] Rights
+read_Rights :: Eq i => StateT Result [Content i] Rights
 read_Rights = do
     y <- read_ELEMENT "rights"
     y1 <- read_1 (read_IMPLIED "type" read_CDATA) (attributes y)
@@ -131,7 +131,7 @@ -- |
 type Encoding = [Encoding_]
 -- |
-read_Encoding :: Eq i => STM Result [Content i] Encoding
+read_Encoding :: Eq i => StateT Result [Content i] Encoding
 read_Encoding = do
     y <- read_ELEMENT "encoding"
     read_1 (read_LIST read_Encoding_) (childs y)
@@ -149,7 +149,7 @@                | Encoding_5 Supports
                  deriving (Eq, Show)
 -- |
-read_Encoding_ :: Eq i => STM Result [Content i] Encoding_
+read_Encoding_ :: Eq i => StateT Result [Content i] Encoding_
 read_Encoding_ = 
     (read_Encoding_Date >>= return . Encoding_1) `mplus`
     (read_Encoder >>= return . Encoding_2) `mplus`
@@ -166,7 +166,7 @@ -- |
 type Encoding_Date = YYYY_MM_DD
 -- |
-read_Encoding_Date :: Eq i => STM Result [Content i] Encoding_Date
+read_Encoding_Date :: Eq i => StateT Result [Content i] Encoding_Date
 read_Encoding_Date = do
     y <- read_ELEMENT "encoding-date"
     read_1 (read_YYYY_MM_DD) (childs y)
@@ -177,7 +177,7 @@ -- |
 type Encoder = (Maybe CDATA, PCDATA)
 -- |
-read_Encoder :: Eq i => STM Result [Content i] Encoder
+read_Encoder :: Eq i => StateT Result [Content i] Encoder
 read_Encoder = do 
     y <- read_ELEMENT "encoder"
     y1 <- read_1 (read_IMPLIED "type" read_CDATA) (attributes y)
@@ -191,7 +191,7 @@ -- |
 type Software = PCDATA
 -- |
-read_Software :: Eq i => STM Result [Content i] Software
+read_Software :: Eq i => StateT Result [Content i] Software
 read_Software = do
     y <- read_ELEMENT "software"
     read_1 read_PCDATA (childs y)
@@ -201,7 +201,7 @@ -- |
 type Encoding_Description = PCDATA
 -- |
-read_Encoding_Description :: STM Result [Content i] Encoding_Description
+read_Encoding_Description :: StateT Result [Content i] Encoding_Description
 read_Encoding_Description = do
     y <- read_ELEMENT "encoding-description"
     read_1 read_PCDATA (childs y)
@@ -212,7 +212,7 @@ -- |
 type Supports = ((Yes_No, CDATA, Maybe CDATA, Maybe CDATA), ())
 -- |
-read_Supports :: Eq i => STM Result [Content i] Supports
+read_Supports :: Eq i => StateT Result [Content i] Supports
 read_Supports = do
     y <- read_ELEMENT "supports"
     y1 <- read_4 (read_REQUIRED "type" read_Yes_No)
@@ -239,7 +239,7 @@ -- |
 type Source = PCDATA
 -- |
-read_Source :: STM Result [Content i] Source
+read_Source :: StateT Result [Content i] Source
 read_Source = do
     y <- read_ELEMENT "source"
     read_1 read_PCDATA (childs y)
@@ -259,7 +259,7 @@ -- |
 type Relation = (Maybe CDATA, CDATA)
 -- |
-read_Relation :: STM Result [Content i] Relation
+read_Relation :: StateT Result [Content i] Relation
 read_Relation = do
     y <- read_ELEMENT "relation"
     y1 <- read_1 (read_IMPLIED "type" read_CDATA) (attributes y)
@@ -281,7 +281,7 @@ -- |
 type Miscellaneous = [Miscellaneous_Field]
 -- |
-read_Miscellaneous :: Eq i => STM Result [Content i] Miscellaneous
+read_Miscellaneous :: Eq i => StateT Result [Content i] Miscellaneous
 read_Miscellaneous = do
     y <- read_ELEMENT "miscellaneous"
     read_1 (read_LIST read_Miscellaneous_Field) (childs y)
@@ -293,7 +293,7 @@ -- |
 type Miscellaneous_Field = (CDATA, PCDATA)
 -- |
-read_Miscellaneous_Field :: STM Result [Content i] Miscellaneous_Field
+read_Miscellaneous_Field :: StateT Result [Content i] Miscellaneous_Field
 read_Miscellaneous_Field = do
     y <- read_ELEMENT "miscellaneous-field"
     y1 <- read_1 (read_REQUIRED "name" read_CDATA) (attributes y)
src/Text/XML/MusicXML/Layout.lhs view
@@ -39,7 +39,7 @@ -- |
 type Scaling = (Millimeters, Tenths)
 -- |
-read_Scaling :: Eq i => STM Result [Content i] Scaling
+read_Scaling :: Eq i => StateT Result [Content i] Scaling
 read_Scaling = do
     y <- read_ELEMENT "scaling"
     read_2 read_Millimeters read_Tenths (childs y)
@@ -50,7 +50,7 @@ -- |
 type Millimeters = PCDATA
 -- |
-read_Millimeters :: Eq i => STM Result [Content i] Millimeters
+read_Millimeters :: Eq i => StateT Result [Content i] Millimeters
 read_Millimeters = do
     y <- read_ELEMENT "millimeters"
     read_1 read_PCDATA (childs y)
@@ -60,7 +60,7 @@ -- |
 type Tenths = Layout_Tenths
 -- |
-read_Tenths :: Eq i => STM Result [Content i] Tenths
+read_Tenths :: Eq i => StateT Result [Content i] Tenths
 read_Tenths = do
     y <- read_ELEMENT "tenths"
     read_1 read_Layout_Tenths (childs y)
@@ -78,7 +78,7 @@ -- |
 type Left_Margin = Layout_Tenths
 -- |
-read_Left_Margin :: STM Result [Content i] Left_Margin
+read_Left_Margin :: StateT Result [Content i] Left_Margin
 read_Left_Margin = do
     y <- read_ELEMENT "left-margin"
     read_1 read_Layout_Tenths (childs y)
@@ -88,7 +88,7 @@ -- |
 type Right_Margin = Layout_Tenths
 -- |
-read_Right_Margin :: STM Result [Content i] Right_Margin
+read_Right_Margin :: StateT Result [Content i] Right_Margin
 read_Right_Margin = do
     y <- read_ELEMENT "right-margin"
     read_1 read_Layout_Tenths (childs y)
@@ -98,7 +98,7 @@ -- |
 type Top_Margin = Layout_Tenths
 -- |
-read_Top_Margin :: STM Result [Content i] Top_Margin
+read_Top_Margin :: StateT Result [Content i] Top_Margin
 read_Top_Margin = do
     y <- read_ELEMENT "top-margin"
     read_1 read_Layout_Tenths (childs y)
@@ -108,7 +108,7 @@ -- |
 type Bottom_Margin = Layout_Tenths
 -- |
-read_Bottom_Margin :: STM Result [Content i] Bottom_Margin
+read_Bottom_Margin :: StateT Result [Content i] Bottom_Margin
 read_Bottom_Margin = do
     y <- read_ELEMENT "bottom-margin"
     read_1 read_Layout_Tenths (childs y)
@@ -131,7 +131,7 @@ type Page_Layout = (Maybe (Page_Height, Page_Width), 
     Maybe (Page_Margins, Maybe Page_Margins))
 -- |
-read_Page_Layout :: Eq i => STM Result [Content i] Page_Layout
+read_Page_Layout :: Eq i => StateT Result [Content i] Page_Layout
 read_Page_Layout = do
     y <- read_ELEMENT "page-layout"
     read_2 (read_MAYBE read_Page_Layout_aux1) 
@@ -142,7 +142,7 @@     show_ELEMENT "page-layout" [] (show_MAYBE show_Page_Layout_aux1 a ++ 
                                    show_MAYBE show_Page_Layout_aux2 b)
 -- |
-read_Page_Layout_aux1 :: Eq i => STM Result [Content i] (Page_Height, Page_Width)
+read_Page_Layout_aux1 :: Eq i => StateT Result [Content i] (Page_Height, Page_Width)
 read_Page_Layout_aux1 = do
     y1 <- read_Page_Height
     y2 <- read_Page_Width
@@ -152,7 +152,7 @@ show_Page_Layout_aux1 (a,b) = show_Page_Height a ++ show_Page_Width b
 -- |
 read_Page_Layout_aux2 :: Eq i => 
-    STM Result [Content i] (Page_Margins, Maybe Page_Margins)
+    StateT Result [Content i] (Page_Margins, Maybe Page_Margins)
 read_Page_Layout_aux2 = do
     y1 <- read_Page_Margins
     y2 <- read_MAYBE read_Page_Margins
@@ -164,7 +164,7 @@ -- |
 type Page_Height = Layout_Tenths 
 -- |
-read_Page_Height :: Eq i => STM Result [Content i] Page_Height
+read_Page_Height :: Eq i => StateT Result [Content i] Page_Height
 read_Page_Height = do
     y <- read_ELEMENT "page-height"
     read_1 read_Layout_Tenths (childs y)
@@ -174,7 +174,7 @@ -- |
 type Page_Width = Layout_Tenths
 -- |
-read_Page_Width :: Eq i => STM Result [Content i] Page_Width
+read_Page_Width :: Eq i => StateT Result [Content i] Page_Width
 read_Page_Width = do
     y <- read_ELEMENT "page-width"
     read_1 read_Layout_Tenths (childs y)
@@ -185,7 +185,7 @@ type Page_Margins = (Maybe Page_Margins_,
     (Left_Margin, Right_Margin, Top_Margin, Bottom_Margin))
 -- |
-read_Page_Margins :: Eq i => STM Result [Content i] Page_Margins
+read_Page_Margins :: Eq i => StateT Result [Content i] Page_Margins
 read_Page_Margins = do
     y <- read_ELEMENT "page-margins"
     y1 <- read_1 (read_IMPLIED "type" read_Page_Margins_) (attributes y)
@@ -240,7 +240,7 @@ type System_Layout = (Maybe System_Margins, 
     Maybe System_Distance, Maybe Top_System_Distance)
 -- |
-read_System_Layout :: STM Result [Content i] System_Layout
+read_System_Layout :: StateT Result [Content i] System_Layout
 read_System_Layout = do 
     y <- read_ELEMENT "system-layout" 
     read_3 (read_MAYBE read_System_Margins)
@@ -257,7 +257,7 @@ -- |
 type System_Margins = (Left_Margin, Right_Margin)
 -- |
-read_System_Margins :: STM Result [Content i] System_Margins
+read_System_Margins :: StateT Result [Content i] System_Margins
 read_System_Margins = do
     y <- read_ELEMENT "system-margins"
     read_2 read_Left_Margin read_Right_Margin (childs y)
@@ -269,7 +269,7 @@ -- |
 type System_Distance = Layout_Tenths
 -- |
-read_System_Distance :: STM Result [Content i] System_Distance
+read_System_Distance :: StateT Result [Content i] System_Distance
 read_System_Distance = do
     y <- read_ELEMENT "system-distance"
     read_1 read_Layout_Tenths (childs y)
@@ -280,7 +280,7 @@ -- |
 type Top_System_Distance = Layout_Tenths
 -- |
-read_Top_System_Distance :: STM Result [Content i] Top_System_Distance
+read_Top_System_Distance :: StateT Result [Content i] Top_System_Distance
 read_Top_System_Distance = do
     y <- read_ELEMENT "top-system-distance"
     read_1 read_Layout_Tenths (childs y)
@@ -306,7 +306,7 @@ -- |
 type Staff_Layout = (Maybe CDATA, Maybe Staff_Distance)
 -- |
-read_Staff_Layout :: STM Result [Content i] Staff_Layout
+read_Staff_Layout :: StateT Result [Content i] Staff_Layout
 read_Staff_Layout = do
     y <- read_ELEMENT "staff-layout"
     y1 <- read_1 (read_IMPLIED "number" read_CDATA) (attributes y)
@@ -321,7 +321,7 @@ -- |
 type Staff_Distance = Layout_Tenths
 -- |
-read_Staff_Distance :: STM Result [Content i] Staff_Distance
+read_Staff_Distance :: StateT Result [Content i] Staff_Distance
 read_Staff_Distance = do
     y <- read_ELEMENT "staff-distance"
     read_1 read_Layout_Tenths (childs y)
@@ -342,7 +342,7 @@ -- |
 type Measure_Layout = Maybe Measure_Distance
 -- |
-read_Measure_Layout :: Eq i => STM Result [Content i] Measure_Layout
+read_Measure_Layout :: Eq i => StateT Result [Content i] Measure_Layout
 read_Measure_Layout = do
     y <- read_ELEMENT "measure-layout"
     read_1 (read_MAYBE read_Measure_Distance) (childs y)
@@ -353,7 +353,7 @@ -- |
 type Measure_Distance = Layout_Tenths
 -- |
-read_Measure_Distance :: Eq i => STM Result [Content i] Measure_Distance
+read_Measure_Distance :: Eq i => StateT Result [Content i] Measure_Distance
 read_Measure_Distance = do
     y <- read_ELEMENT "measure-distance"
     read_1 read_Layout_Tenths (childs y)
@@ -399,7 +399,7 @@ -- |
 type Appearance = ([Line_Width],[Note_Size],[Other_Appearance])
 -- |
-read_Appearance :: Eq i => STM Result [Content i] Appearance
+read_Appearance :: Eq i => StateT Result [Content i] Appearance
 read_Appearance = do 
     y <- read_ELEMENT "appearance"
     read_3 (read_LIST read_Line_Width) (read_LIST read_Note_Size)
@@ -413,7 +413,7 @@ -- |
 type Line_Width = (CDATA, Layout_Tenths)
 -- |
-read_Line_Width :: STM Result [Content i] Line_Width
+read_Line_Width :: StateT Result [Content i] Line_Width
 read_Line_Width = do
     y <- read_ELEMENT "line-width"
     y1 <- read_1 (read_REQUIRED "type" read_CDATA) (attributes y)
@@ -427,7 +427,7 @@ -- |
 type Note_Size = (Note_Size_, PCDATA)
 -- |
-read_Note_Size :: STM Result [Content i] Note_Size
+read_Note_Size :: StateT Result [Content i] Note_Size
 read_Note_Size = do
     y <- read_ELEMENT "note-size"
     y1 <- read_1 (read_REQUIRED "type" read_Note_Size_) (attributes y)
@@ -455,7 +455,7 @@ -- |
 type Other_Appearance = (CDATA, PCDATA)
 -- |
-read_Other_Appearance :: STM Result [Content i] Other_Appearance
+read_Other_Appearance :: StateT Result [Content i] Other_Appearance
 read_Other_Appearance = do
     y <- read_ELEMENT "other-appearance"
     y1 <- read_1 (read_REQUIRED "type" read_CDATA) (attributes y)
src/Text/XML/MusicXML/Link.lhs view
@@ -21,7 +21,7 @@     Maybe CDATA, Maybe CDATA,
     Link_Attributes_A, Link_Attributes_B)
 -- |
-read_Link_Attributes :: STM Result [Attribute] Link_Attributes
+read_Link_Attributes :: StateT Result [Attribute] Link_Attributes
 read_Link_Attributes = do
     y1 <- read_FIXED "xmlns:xlink" read_CDATA "http://www.w3.org/1999/xlink"
     y2 <- read_REQUIRED "xlink:href" read_CDATA
@@ -109,7 +109,7 @@ type Link = ((Link_Attributes, 
         Maybe CDATA, Maybe CDATA, Maybe CDATA, Position), ())
 -- |
-read_Link :: Eq i => STM Result [Content i] Link
+read_Link :: Eq i => StateT Result [Content i] Link
 read_Link = do
     y <- read_ELEMENT "link"
     y1 <- read_5 read_Link_Attributes (read_IMPLIED "name" read_CDATA)
@@ -129,7 +129,7 @@ -- |
 type Bookmark = ((ID, Maybe CDATA, Maybe CDATA, Maybe CDATA), ())
 -- |
-read_Bookmark :: Eq i => STM Result [Content i] Bookmark
+read_Bookmark :: Eq i => StateT Result [Content i] Bookmark
 read_Bookmark = do
     y <- read_ELEMENT "bookmark"
     y1 <- read_4 (read_REQUIRED "id" read_ID) 
src/Text/XML/MusicXML/Note.lhs view
@@ -26,7 +26,7 @@ -- |
 type Full_Note = (Maybe Chord, Full_Note_)
 -- |
-read_Full_Note :: STM Result [Content i] Full_Note
+read_Full_Note :: StateT Result [Content i] Full_Note
 read_Full_Note = do
     y1 <- read_MAYBE read_Chord 
     y2 <- read_Full_Note_ 
@@ -42,7 +42,7 @@                 | Full_Note_3 Rest
                 deriving (Eq, Show)
 -- |
-read_Full_Note_ :: STM Result [Content i] Full_Note_
+read_Full_Note_ :: StateT Result [Content i] Full_Note_
 read_Full_Note_ = 
     (read_Pitch >>= return . Full_Note_1) `mplus`
     (read_Unpitched >>= return . Full_Note_2) `mplus`
@@ -95,7 +95,7 @@     Maybe Accidental, Maybe Time_Modification, Maybe Stem, Maybe Notehead, 
     Maybe Staff, [Beam], [Notations], [Lyric]))
 -- |
-read_Note :: Eq i => STM Result [Content i] Note
+read_Note :: Eq i => StateT Result [Content i] Note
 read_Note = do
     y <- read_ELEMENT "note"
     y1 <- read_8 read_Print_Style read_Printout
@@ -143,32 +143,32 @@            | Note_3 (Full_Note, Duration, Maybe (Tie, Maybe Tie))
            deriving (Eq, Show)
 -- |
-read_Note_ :: STM Result [Content i] Note_
+read_Note_ :: StateT Result [Content i] Note_
 read_Note_ = 
     (read_Note_aux1 >>= return . Note_1) `mplus`
     (read_Note_aux2 >>= return . Note_2) `mplus`
     (read_Note_aux3 >>= return . Note_3) 
 read_Note_aux1 :: 
-    STM Result [Content i] (Grace, Full_Note, Maybe (Tie, Maybe Tie))
+    StateT Result [Content i] (Grace, Full_Note, Maybe (Tie, Maybe Tie))
 read_Note_aux1 = do
     y1 <- read_Grace 
     y2 <- read_Full_Note
     y3 <- read_MAYBE read_Note_aux4 
     return (y1,y2,y3)
-read_Note_aux2 :: STM Result [Content i] (Cue, Full_Note, Duration)
+read_Note_aux2 :: StateT Result [Content i] (Cue, Full_Note, Duration)
 read_Note_aux2 = do
     y1 <- read_Cue
     y2 <- read_Full_Note
     y3 <- read_Duration
     return (y1,y2,y3)
 read_Note_aux3 :: 
-    STM Result [Content i] (Full_Note, Duration, Maybe (Tie, Maybe Tie))
+    StateT Result [Content i] (Full_Note, Duration, Maybe (Tie, Maybe Tie))
 read_Note_aux3 = do
     y1 <- read_Full_Note
     y2 <- read_Duration
     y3 <- read_MAYBE read_Note_aux4
     return (y1,y2,y3)
-read_Note_aux4 :: STM Result [Content i] (Tie, Maybe Tie)
+read_Note_aux4 :: StateT Result [Content i] (Tie, Maybe Tie)
 read_Note_aux4 = do
     y1 <- read_Tie
     y2 <- read_MAYBE read_Tie
@@ -201,7 +201,7 @@ -- |
 type Pitch = (Step, Maybe Alter, Octave)
 -- |
-read_Pitch :: STM Result [Content i] Pitch
+read_Pitch :: StateT Result [Content i] Pitch
 read_Pitch = do
     y <- read_ELEMENT "pitch" 
     read_3 read_Step (read_MAYBE read_Alter) read_Octave (childs y)
@@ -213,7 +213,7 @@ -- |
 type Step = PCDATA
 -- | 
-read_Step :: STM Result [Content i] Step
+read_Step :: StateT Result [Content i] Step
 read_Step = do
     y <- read_ELEMENT "step" 
     read_1 read_PCDATA (childs y)
@@ -223,7 +223,7 @@ -- |
 type Alter = PCDATA
 -- | 
-read_Alter :: STM Result [Content i] Alter
+read_Alter :: StateT Result [Content i] Alter
 read_Alter = do
     y <- read_ELEMENT "alter" 
     read_1 read_PCDATA (childs y)
@@ -233,7 +233,7 @@ -- |
 type Octave = PCDATA
 -- | 
-read_Octave :: STM Result [Content i] Octave
+read_Octave :: StateT Result [Content i] Octave
 read_Octave = do
     y <- read_ELEMENT "octave" 
     read_1 read_PCDATA (childs y)
@@ -258,7 +258,7 @@ -- |
 type Cue = ()
 -- |
-read_Cue :: STM Result [Content i] Cue
+read_Cue :: StateT Result [Content i] Cue
 read_Cue = read_ELEMENT "cue" >> return ()
 -- |
 show_Cue :: Cue -> [Content ()]
@@ -266,7 +266,7 @@ -- |
 type Grace = ((Maybe CDATA, Maybe CDATA, Maybe CDATA, Maybe Yes_No),())
 -- |
-read_Grace :: STM Result [Content i] Grace
+read_Grace :: StateT Result [Content i] Grace
 read_Grace = do
     y <- read_ELEMENT "grace" 
     y1 <- read_4 (read_IMPLIED "steal-time-previous" read_CDATA) 
@@ -297,7 +297,7 @@ -- |
 type Chord = ()
 -- |
-read_Chord :: STM Result [Content i] Chord
+read_Chord :: StateT Result [Content i] Chord
 read_Chord = 
     read_ELEMENT "chord" >> return ()
 -- |
@@ -319,12 +319,12 @@ \begin{code}
 type Unpitched = Maybe (Display_Step, Display_Octave)
 -- |
-read_Unpitched :: STM Result [Content i] Unpitched
+read_Unpitched :: StateT Result [Content i] Unpitched
 read_Unpitched = do
     y <- read_ELEMENT "unpitched" 
     read_1 (read_MAYBE read_Unpitched_aux1) (childs y)
 
-read_Unpitched_aux1 :: STM Result [Content i] (Display_Step, Display_Octave)
+read_Unpitched_aux1 :: StateT Result [Content i] (Display_Step, Display_Octave)
 read_Unpitched_aux1 = do
     y1 <- read_Display_Step 
     y2 <- read_Display_Octave 
@@ -339,7 +339,7 @@ -- |
 type Display_Step = PCDATA
 -- |
-read_Display_Step :: STM Result [Content i] Display_Step
+read_Display_Step :: StateT Result [Content i] Display_Step
 read_Display_Step = do
     y <- read_ELEMENT "display-step" 
     read_1 read_PCDATA (childs y)
@@ -349,7 +349,7 @@ -- |
 type Display_Octave = PCDATA
 -- |
-read_Display_Octave :: STM Result [Content i] Display_Octave
+read_Display_Octave :: StateT Result [Content i] Display_Octave
 read_Display_Octave = do
     y <- read_ELEMENT "display-octave" 
     read_1 read_PCDATA (childs y)
@@ -364,23 +364,16 @@ 	be specified using display-step and display-octave
 	elements.
 \end{musicxml}
-\begin{nocode}
-read_Rest_F :: [Content i] -> ([Content i],Maybe a)
-read_Rest_F l = 
-    let (l1,_) = read_ELEMENT_F "rest" l
---        y1 = read_PCDATA_F (childs_F y)
-    in (l1,Nothing)
-\end{nocode}
 \begin{code}
 -- |
 type Rest = Maybe (Display_Step, Display_Octave)
 -- |
-read_Rest :: STM Result [Content i] Rest
+read_Rest :: StateT Result [Content i] Rest
 read_Rest = do
     y <- read_ELEMENT "rest" 
     read_1 (read_MAYBE read_Rest_aux1) (childs y)
 -- |
-read_Rest_aux1 :: STM Result [Content i] (Display_Step, Display_Octave)
+read_Rest_aux1 :: StateT Result [Content i] (Display_Step, Display_Octave)
 read_Rest_aux1 = do
     y1 <- read_Display_Step 
     y2 <- read_Display_Octave 
@@ -409,7 +402,7 @@ \begin{code}
 type Duration = PCDATA
 -- | 
-read_Duration :: STM Result [Content i] Duration
+read_Duration :: StateT Result [Content i] Duration
 read_Duration = do
     y <- read_ELEMENT "duration" 
     read_1 read_PCDATA (childs y)
@@ -419,7 +412,7 @@ -- |
 type Tie = (Start_Stop, ())
 -- | 
-read_Tie :: STM Result [Content i] Tie
+read_Tie :: StateT Result [Content i] Tie
 read_Tie = do
     y <- read_ELEMENT "tie"
     y1 <- read_1 (read_REQUIRED "type" read_Start_Stop) (attributes y)
@@ -441,7 +434,7 @@ -- |
 type Instrument = (ID, ())
 -- | 
-read_Instrument :: STM Result [Content i] Instrument
+read_Instrument :: StateT Result [Content i] Instrument
 read_Instrument = do
     y <- read_ELEMENT "instrument" 
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
@@ -465,7 +458,7 @@ -- |
 type Type = (Maybe Symbol_Size,PCDATA)
 -- | 
-read_Type :: STM Result [Content i] Type
+read_Type :: StateT Result [Content i] Type
 read_Type = do
     y <- read_ELEMENT "type" 
     y1 <- read_1 (read_IMPLIED "size" read_Symbol_Size) (attributes y)
@@ -490,7 +483,7 @@ -- |
 type Dot = ((Print_Style, Placement), ())
 -- |
-read_Dot :: STM Result [Content i] Dot
+read_Dot :: StateT Result [Content i] Dot
 read_Dot = do
     y <- read_ELEMENT "dot" 
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -521,7 +514,7 @@ type Accidental = ((Maybe Yes_No, Maybe Yes_No, Level_Display, Print_Style), 
     PCDATA)
 -- |
-read_Accidental :: STM Result [Content i] Accidental
+read_Accidental :: StateT Result [Content i] Accidental
 read_Accidental = do
     y <- read_ELEMENT "accidental"
     y1 <- read_4 (read_IMPLIED "cautionary" read_Yes_No)
@@ -551,14 +544,14 @@ type Time_Modification = (Actual_Notes, Normal_Notes, 
     Maybe (Normal_Type, [Normal_Dot]))
 -- |
-read_Time_Modification :: Eq i => STM Result [Content i] Time_Modification
+read_Time_Modification :: Eq i => StateT Result [Content i] Time_Modification
 read_Time_Modification = do
     y <- read_ELEMENT "time-modification"
     read_3 read_Actual_Notes read_Normal_Notes 
            (read_MAYBE (read_Time_Modification_aux1)) (childs y)
 -- |
 read_Time_Modification_aux1 :: Eq i => 
-    STM Result [Content i] (Normal_Type, [Normal_Dot])
+    StateT Result [Content i] (Normal_Type, [Normal_Dot])
 read_Time_Modification_aux1 = do
     y1 <- read_Normal_Type
     y2 <- read_LIST read_Normal_Dot
@@ -586,7 +579,7 @@ -- |
 type Stem = ((Position, Color),PCDATA)
 -- |
-read_Stem :: STM Result [Content i] Stem
+read_Stem :: StateT Result [Content i] Stem
 read_Stem = do
     y <- read_ELEMENT "stem" 
     y1 <- read_2 read_Position read_Color (attributes y)
@@ -628,7 +621,7 @@ -- |
 type Notehead = ((Maybe Yes_No, Maybe Yes_No, Font, Color), PCDATA)
 -- |
-read_Notehead :: STM Result [Content i] Notehead
+read_Notehead :: StateT Result [Content i] Notehead
 read_Notehead = do
     y <- read_ELEMENT "notehead" 
     y1 <- read_4 (read_IMPLIED "filled" read_Yes_No) 
@@ -670,7 +663,7 @@ -- |
 type Beam = ((Beam_Level, Maybe Yes_No, Maybe Beam_, Color), PCDATA)
 -- |
-read_Beam :: STM Result [Content i] Beam
+read_Beam :: StateT Result [Content i] Beam
 read_Beam = do
     y <- read_ELEMENT "beam"
     y1 <- read_4 (read_DEFAULT "number" read_Beam_Level Beam_Level_1) 
@@ -716,25 +709,17 @@ \begin{code}
 -- ** Notations
 -- |
-type Notations = [(Editorial, Notations_)]
+type Notations = (Editorial, [Notations_])
 -- |
-read_Notations :: Eq i => STM Result [Content i] Notations
+read_Notations :: Eq i => StateT Result [Content i] Notations
 read_Notations = do 
     y <- read_ELEMENT "notations"
-    read_1 (read_LIST read_Notations_aux1) (childs y)
+    read_2 read_Editorial (read_LIST read_Notations_) (childs y)
 -- |
 show_Notations :: Notations -> [Content ()]
-show_Notations a = 
-    show_ELEMENT "notations" [] (show_LIST show_Notations_aux1 a)
--- |
-read_Notations_aux1 :: Eq i => STM Result [Content i] (Editorial, Notations_)
-read_Notations_aux1 = do
-    y1 <- read_Editorial
-    y2 <- read_Notations_
-    return (y1,y2)
--- |
-show_Notations_aux1 :: (Editorial, Notations_) -> [Content ()]
-show_Notations_aux1 (a,b) = show_Editorial a ++ show_Notations_ b
+show_Notations (a, b) = 
+    show_ELEMENT "notations" [] 
+        (show_Editorial a ++ show_LIST show_Notations_ b)
 -- |
 data Notations_ = Notations_1 Tied 
                 | Notations_2 Slur 
@@ -752,7 +737,7 @@                 | Notations_14 Other_Notation
                 deriving (Eq, Show)
 -- |
-read_Notations_ :: Eq i => STM Result [Content i] Notations_
+read_Notations_ :: Eq i => StateT Result [Content i] Notations_
 read_Notations_ = 
     (read_Tied >>= return . Notations_1) `mplus`
     (read_Slur >>= return . Notations_2) `mplus`
@@ -789,7 +774,7 @@ type Tied = ((Start_Stop, Maybe Number_Level, Line_Type, Position, Placement,
         Orientation, Bezier, Color),())
 -- |
-read_Tied :: STM Result [Content i] Tied
+read_Tied :: StateT Result [Content i] Tied
 read_Tied = do
     y <- read_ELEMENT "tied"
     y1 <- read_8 (read_REQUIRED "type" read_Start_Stop) 
@@ -824,7 +809,7 @@ type Slur = ((Start_Stop_Continue, Number_Level, Line_Type, Position, Placement,
         Orientation, Bezier, Color),())
 -- |
-read_Slur :: STM Result [Content i] Slur
+read_Slur :: StateT Result [Content i] Slur
 read_Slur = do
     y <- read_ELEMENT "slur"
     y1 <- read_8 (read_REQUIRED "type" read_Start_Stop_Continue) 
@@ -881,7 +866,7 @@         Maybe Tuplet_, Line_Shape, Position, Placement),
     (Maybe Tuplet_Actual, Maybe Tuplet_Normal))
 -- |
-read_Tuplet :: Eq i => STM Result [Content i] Tuplet
+read_Tuplet :: Eq i => StateT Result [Content i] Tuplet
 read_Tuplet = do
     y <- read_ELEMENT "tuplet"
     y1 <- read_8 (read_REQUIRED "type" read_Start_Stop)
@@ -925,7 +910,7 @@ -- |
 type Tuplet_Actual = (Maybe Tuplet_Number, Maybe Tuplet_Type, [Tuplet_Dot])
 -- |
-read_Tuplet_Actual :: Eq i => STM Result [Content i] Tuplet_Actual
+read_Tuplet_Actual :: Eq i => StateT Result [Content i] Tuplet_Actual
 read_Tuplet_Actual = do
     y <- read_ELEMENT "tuplet-actual"
     read_3 (read_MAYBE read_Tuplet_Number) 
@@ -941,7 +926,7 @@ -- |
 type Tuplet_Normal = (Maybe Tuplet_Number, Maybe Tuplet_Type, [Tuplet_Dot])
 -- |
-read_Tuplet_Normal :: Eq i => STM Result [Content i] Tuplet_Normal
+read_Tuplet_Normal :: Eq i => StateT Result [Content i] Tuplet_Normal
 read_Tuplet_Normal = do
     y <- read_ELEMENT "tuplet-normal"
     read_3 (read_MAYBE read_Tuplet_Number) 
@@ -957,7 +942,7 @@ -- |
 type Tuplet_Number = ((Font, Color), PCDATA)
 -- |
-read_Tuplet_Number :: STM Result [Content i] Tuplet_Number
+read_Tuplet_Number :: StateT Result [Content i] Tuplet_Number
 read_Tuplet_Number = do
     y <- read_ELEMENT "tuplet-number"
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -972,7 +957,7 @@ -- |
 type Tuplet_Type = ((Font, Color), PCDATA)
 -- |
-read_Tuplet_Type :: STM Result [Content i] Tuplet_Type
+read_Tuplet_Type :: StateT Result [Content i] Tuplet_Type
 read_Tuplet_Type = do
     y <- read_ELEMENT "tuplet-type"
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -987,7 +972,7 @@ -- |
 type Tuplet_Dot = ((Font, Color), ())
 -- |
-read_Tuplet_Dot :: STM Result [Content i] Tuplet_Dot
+read_Tuplet_Dot :: StateT Result [Content i] Tuplet_Dot
 read_Tuplet_Dot = do
     y <- read_ELEMENT "tuplet-dot"
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -1013,15 +998,15 @@ \begin{code}
 -- *** Glissando
 -- |
-type Glissando = ((Start_Stop, Number_Level, Line_Type, Print_Style),Text)
+type Glissando = ((Start_Stop, Number_Level, Line_Type, Print_Style),PCDATA)
 -- |
-read_Glissando :: STM Result [Content i] Glissando
+read_Glissando :: StateT Result [Content i] Glissando
 read_Glissando = do
     y <- read_ELEMENT "glissando" 
     y1 <- read_4 (read_REQUIRED "type" read_Start_Stop) 
                  (read_DEFAULT "number" read_Number_Level Number_Level_1) 
                  read_Line_Type read_Print_Style (attributes y)
-    y2 <- read_1 read_Text (childs y)
+    y2 <- read_1 read_PCDATA (childs y)
     return (y1,y2)
 -- | 
 show_Glissando :: Glissando -> [Content ()]
@@ -1030,19 +1015,20 @@         (show_REQUIRED "type" show_Start_Stop a ++
          show_IMPLIED "number" show_Number_Level (Just b) ++
          show_Line_Type c ++ show_Print_Style d)
-        (show_Text e)
+        (show_PCDATA e)
 -- *** Slide
 -- |
-type Slide = ((Start_Stop, Number_Level, Line_Type, Print_Style, Bend_Sound),Text)
+type Slide = ((Start_Stop, Number_Level, Line_Type, Print_Style, Bend_Sound), 
+                PCDATA)
 -- |
-read_Slide :: STM Result [Content i] Slide
+read_Slide :: StateT Result [Content i] Slide
 read_Slide = do
     y <- read_ELEMENT "slide" 
     y1 <- read_5 (read_REQUIRED "type" read_Start_Stop) 
                  (read_DEFAULT "number" read_Number_Level Number_Level_1) 
                  read_Line_Type read_Print_Style read_Bend_Sound 
                  (attributes y)
-    y2 <- read_1 read_Text (childs y)
+    y2 <- read_1 read_PCDATA (childs y)
     return (y1,y2)
 -- | 
 show_Slide :: Slide -> [Content ()]
@@ -1052,7 +1038,7 @@          show_IMPLIED "number" show_Number_Level (Just b) ++
          show_Line_Type c ++ show_Print_Style d ++
          show_Bend_Sound e)
-        (show_Text f)
+        (show_PCDATA f)
 \end{code}
 
 
@@ -1069,7 +1055,7 @@ type Other_Notation = ((Start_Stop_Single, Number_Level, Print_Object,
         Print_Style, Placement), PCDATA)
 -- |
-read_Other_Notation :: STM Result [Content i] Other_Notation
+read_Other_Notation :: StateT Result [Content i] Other_Notation
 read_Other_Notation = do
     y <- read_ELEMENT "other-notation" 
     y1 <- read_5 (read_REQUIRED "type" read_Start_Stop_Single) 
@@ -1101,11 +1087,11 @@ -- |
 type Ornaments = [(Ornaments_, [Accidental_Mark])]
 -- |
-read_Ornaments :: Eq i => STM Result [Content i] Ornaments
+read_Ornaments :: Eq i => StateT Result [Content i] Ornaments
 read_Ornaments = do
     y <- read_ELEMENT "ornaments" 
     read_1 (read_LIST read_Ornaments_aux1) (childs y)
-read_Ornaments_aux1 :: Eq i => STM Result [Content i] (Ornaments_, [Accidental_Mark])
+read_Ornaments_aux1 :: Eq i => StateT Result [Content i] (Ornaments_, [Accidental_Mark])
 read_Ornaments_aux1 = do
     y1 <- read_Ornaments_ 
     y2 <- read_LIST read_Accidental_Mark
@@ -1131,7 +1117,7 @@                 | Ornaments_11 Other_Ornament
                   deriving (Eq, Show)
 -- |
-read_Ornaments_ :: STM Result [Content i] Ornaments_
+read_Ornaments_ :: StateT Result [Content i] Ornaments_
 read_Ornaments_ = 
     (read_Trill_Mark >>= return . Ornaments_1) `mplus`
     (read_Turn >>= return . Ornaments_2) `mplus`
@@ -1160,7 +1146,7 @@ -- |
 type Trill_Mark = ((Print_Style, Placement, Trill_Sound),())
 -- | 
-read_Trill_Mark :: STM Result [Content i] Trill_Mark
+read_Trill_Mark :: StateT Result [Content i] Trill_Mark
 read_Trill_Mark = do
     y <- read_ELEMENT "trill-mark"
     y1 <- read_3 read_Print_Style read_Placement read_Trill_Sound 
@@ -1187,7 +1173,7 @@ -- |
 type Turn = ((Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Turn :: STM Result [Content i] Turn
+read_Turn :: StateT Result [Content i] Turn
 read_Turn = do
     y <- read_ELEMENT "turn"
     y1 <- read_3 read_Print_Style read_Placement read_Trill_Sound 
@@ -1203,7 +1189,7 @@ -- |
 type Delayed_Turn = ((Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Delayed_Turn :: STM Result [Content i] Delayed_Turn
+read_Delayed_Turn :: StateT Result [Content i] Delayed_Turn
 read_Delayed_Turn = do
     y <- read_ELEMENT "delayed-turn"
     y1 <- read_3 read_Print_Style read_Placement read_Trill_Sound 
@@ -1219,7 +1205,7 @@ -- |
 type Inverted_Turn = ((Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Inverted_Turn :: STM Result [Content i] Inverted_Turn
+read_Inverted_Turn :: StateT Result [Content i] Inverted_Turn
 read_Inverted_Turn = do
     y <- read_ELEMENT "inverted-turn"
     y1 <- read_3 read_Print_Style read_Placement read_Trill_Sound 
@@ -1235,7 +1221,7 @@ -- |
 type Shake = ((Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Shake :: STM Result [Content i] Shake
+read_Shake :: StateT Result [Content i] Shake
 read_Shake = do
     y <- read_ELEMENT "shake"
     y1 <- read_3 read_Print_Style read_Placement read_Trill_Sound 
@@ -1265,7 +1251,7 @@ -- |
 type Mordent = ((Maybe Yes_No, Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Mordent :: STM Result [Content i] Mordent
+read_Mordent :: StateT Result [Content i] Mordent
 read_Mordent = do
     y <- read_ELEMENT "mordent"
     y1 <- read_4 (read_IMPLIED "long" read_Yes_No) 
@@ -1283,7 +1269,7 @@ -- |
 type Inverted_Mordent = ((Maybe Yes_No, Print_Style, Placement, Trill_Sound), ())
 -- | 
-read_Inverted_Mordent :: STM Result [Content i] Inverted_Mordent
+read_Inverted_Mordent :: StateT Result [Content i] Inverted_Mordent
 read_Inverted_Mordent = do
     y <- read_ELEMENT "inverted-mordent"
     y1 <- read_4 (read_IMPLIED "long" read_Yes_No) 
@@ -1310,7 +1296,7 @@ -- |
 type Schleifer = ((Print_Style, Placement), ())
 -- |
-read_Schleifer :: STM Result [Content i] Schleifer
+read_Schleifer :: StateT Result [Content i] Schleifer
 read_Schleifer = do
     y <- read_ELEMENT "schleifer"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1340,7 +1326,7 @@ -- |
 type Tremolo = ((Start_Stop_Single, Print_Style, Placement), PCDATA)
 -- |
-read_Tremolo :: STM Result [Content i] Tremolo
+read_Tremolo :: StateT Result [Content i] Tremolo
 read_Tremolo = do
     y <- read_ELEMENT "tremolo"
     y1 <- read_3 (read_DEFAULT "type" read_Start_Stop_Single Start_Stop_Single_3) 
@@ -1365,7 +1351,7 @@ -- |
 type Other_Ornament = ((Print_Style, Placement), PCDATA)
 -- |
-read_Other_Ornament :: STM Result [Content i] Other_Ornament
+read_Other_Ornament :: StateT Result [Content i] Other_Ornament
 read_Other_Ornament = do
     y <- read_ELEMENT "other-ornament"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1390,7 +1376,7 @@ -- |
 type Accidental_Mark = ((Print_Style, Placement), CDATA)
 -- |
-read_Accidental_Mark :: STM Result [Content i] Accidental_Mark
+read_Accidental_Mark :: StateT Result [Content i] Accidental_Mark
 read_Accidental_Mark = do
     y <- read_ELEMENT "accidental-mark"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1413,7 +1399,7 @@ -- |
 type Technical = [Technical_]
 -- |
-read_Technical :: Eq i => STM Result [Content i] Technical
+read_Technical :: Eq i => StateT Result [Content i] Technical
 read_Technical = do
     y <- read_ELEMENT "technical" 
     read_1 (read_LIST read_Technical_) (childs y)
@@ -1445,7 +1431,7 @@                 | Technical_21 Other_Technical
                   deriving (Eq, Show)
 -- |
-read_Technical_ :: STM Result [Content i] Technical_
+read_Technical_ :: StateT Result [Content i] Technical_
 read_Technical_ = 
     (read_Up_Bow >>= return . Technical_1) `mplus`
     (read_Down_Bow >>= return . Technical_2) `mplus`
@@ -1503,7 +1489,7 @@ -- |
 type Up_Bow = ((Print_Style, Placement), ())
 -- |
-read_Up_Bow :: STM Result [Content i] Up_Bow
+read_Up_Bow :: StateT Result [Content i] Up_Bow
 read_Up_Bow = do
     y <- read_ELEMENT "up-bow"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1516,7 +1502,7 @@ -- |
 type Down_Bow = ((Print_Style, Placement), ())
 -- |
-read_Down_Bow :: STM Result [Content i] Down_Bow
+read_Down_Bow :: StateT Result [Content i] Down_Bow
 read_Down_Bow = do
     y <- read_ELEMENT "down-bow"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1546,7 +1532,7 @@ type Harmonic = ((Print_Object, Print_Style, Placement), 
     (Maybe Harmonic_A, Maybe Harmonic_B))
 -- |
-read_Harmonic :: STM Result [Content i] Harmonic
+read_Harmonic :: StateT Result [Content i] Harmonic
 read_Harmonic = do
     y <- read_ELEMENT "harmonic"
     y1 <- read_3 read_Print_Object read_Print_Style 
@@ -1567,7 +1553,7 @@                 | Harmonic_2 Artificial
                   deriving (Eq, Show)
 -- |
-read_Harmonic_A :: STM Result [Content i] Harmonic_A
+read_Harmonic_A :: StateT Result [Content i] Harmonic_A
 read_Harmonic_A = 
     (read_Natural >>= return . Harmonic_1) `mplus`
     (read_Artificial >>= return . Harmonic_2) 
@@ -1581,7 +1567,7 @@                 | Harmonic_5 Sounding_Pitch
                   deriving (Eq, Show)
 -- |
-read_Harmonic_B :: STM Result [Content i] Harmonic_B
+read_Harmonic_B :: StateT Result [Content i] Harmonic_B
 read_Harmonic_B = 
     (read_Base_Pitch >>= return . Harmonic_3) `mplus`
     (read_Touching_Pitch >>= return . Harmonic_4) `mplus`
@@ -1594,7 +1580,7 @@ -- |
 type Natural = ()
 -- |
-read_Natural :: STM Result [Content i] Natural
+read_Natural :: StateT Result [Content i] Natural
 read_Natural = do
     read_ELEMENT "natural" >> return ()
 -- |
@@ -1603,7 +1589,7 @@ -- |
 type Artificial = ()
 -- |
-read_Artificial :: STM Result [Content i] Artificial
+read_Artificial :: StateT Result [Content i] Artificial
 read_Artificial = do
     read_ELEMENT "artificial" >> return ()
 -- |
@@ -1612,7 +1598,7 @@ -- |
 type Base_Pitch = ()
 -- |
-read_Base_Pitch :: STM Result [Content i] Base_Pitch
+read_Base_Pitch :: StateT Result [Content i] Base_Pitch
 read_Base_Pitch = do
     read_ELEMENT "base-picth" >> return ()
 -- |
@@ -1621,7 +1607,7 @@ -- |
 type Touching_Pitch = ()
 -- |
-read_Touching_Pitch :: STM Result [Content i] Touching_Pitch
+read_Touching_Pitch :: StateT Result [Content i] Touching_Pitch
 read_Touching_Pitch = do
     read_ELEMENT "touching-pitch" >> return ()
 -- |
@@ -1630,7 +1616,7 @@ -- |
 type Sounding_Pitch = ()
 -- |
-read_Sounding_Pitch :: STM Result [Content i] Sounding_Pitch
+read_Sounding_Pitch :: StateT Result [Content i] Sounding_Pitch
 read_Sounding_Pitch = do
     read_ELEMENT "sounding-picth" >> return ()
 -- |
@@ -1639,7 +1625,7 @@ -- |
 type Open_String = ((Print_Style, Placement),())
 -- |
-read_Open_String :: STM Result [Content i] Open_String
+read_Open_String :: StateT Result [Content i] Open_String
 read_Open_String = do
     y <- read_ELEMENT "open-string"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1652,7 +1638,7 @@ -- |
 type Thumb_Position = ((Print_Style, Placement),())
 -- |
-read_Thumb_Position :: STM Result [Content i] Thumb_Position
+read_Thumb_Position :: StateT Result [Content i] Thumb_Position
 read_Thumb_Position = do
     y <- read_ELEMENT "thumb-position"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1675,7 +1661,7 @@ -- |
 type Pluck = ((Print_Style, Placement), PCDATA)
 -- |
-read_Pluck :: STM Result [Content i] Pluck
+read_Pluck :: StateT Result [Content i] Pluck
 read_Pluck = do
     y <- read_ELEMENT "pluck"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1690,7 +1676,7 @@ -- |
 type Double_Tongue = ((Print_Style, Placement),())
 -- |
-read_Double_Tongue :: STM Result [Content i] Double_Tongue
+read_Double_Tongue :: StateT Result [Content i] Double_Tongue
 read_Double_Tongue = do
     y <- read_ELEMENT "double-tongue"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1703,7 +1689,7 @@ -- |
 type Triple_Tongue = ((Print_Style, Placement),())
 -- |
-read_Triple_Tongue :: STM Result [Content i] Triple_Tongue
+read_Triple_Tongue :: StateT Result [Content i] Triple_Tongue
 read_Triple_Tongue = do
     y <- read_ELEMENT "triple-tongue"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1716,7 +1702,7 @@ -- |
 type Stopped = ((Print_Style, Placement),())
 -- |
-read_Stopped :: STM Result [Content i] Stopped
+read_Stopped :: StateT Result [Content i] Stopped
 read_Stopped = do
     y <- read_ELEMENT "stopped"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1729,7 +1715,7 @@ -- |
 type Snap_Pizzicato = ((Print_Style, Placement),())
 -- |
-read_Snap_Pizzicato :: STM Result [Content i] Snap_Pizzicato
+read_Snap_Pizzicato :: StateT Result [Content i] Snap_Pizzicato
 read_Snap_Pizzicato = do
     y <- read_ELEMENT "snap-pizzicato"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1754,7 +1740,7 @@ -- | 
 type Hammer_On = ((Start_Stop, Number_Level, Print_Style, Placement), PCDATA)
 -- |
-read_Hammer_On :: STM Result [Content i] Hammer_On
+read_Hammer_On :: StateT Result [Content i] Hammer_On
 read_Hammer_On = do
     y <- read_ELEMENT "hammer-on" 
     y1 <- read_4 (read_REQUIRED "type" read_Start_Stop) 
@@ -1773,7 +1759,7 @@ -- |
 type Pull_Off = ((Start_Stop, Number_Level, Print_Style, Placement), PCDATA)
 -- |
-read_Pull_Off :: STM Result [Content i] Pull_Off
+read_Pull_Off :: StateT Result [Content i] Pull_Off
 read_Pull_Off = do
     y <- read_ELEMENT "pull-off" 
     y1 <- read_4 (read_REQUIRED "type" read_Start_Stop) 
@@ -1808,7 +1794,7 @@ type Bend = ((Print_Style, Bend_Sound), 
     (Bend_Alter, Maybe Bend_, Maybe With_Bar))
 -- |
-read_Bend :: STM Result [Content i] Bend
+read_Bend :: StateT Result [Content i] Bend
 read_Bend = do
     y <- read_ELEMENT "bend"
     y1 <- read_2 read_Print_Style read_Bend_Sound (attributes y)
@@ -1827,7 +1813,7 @@ data Bend_ = Bend_1 Pre_Bend | Bend_2 Release
              deriving (Eq, Show)
 -- |
-read_Bend_ :: STM Result [Content i] Bend_
+read_Bend_ :: StateT Result [Content i] Bend_
 read_Bend_ = 
     (read_Pre_Bend >>= return . Bend_1) `mplus`
     (read_Release >>= return . Bend_2) 
@@ -1838,7 +1824,7 @@ -- |
 type Bend_Alter = PCDATA
 -- |
-read_Bend_Alter :: STM Result [Content i] Bend_Alter
+read_Bend_Alter :: StateT Result [Content i] Bend_Alter
 read_Bend_Alter = do
     y <- read_ELEMENT "bend-alter" 
     read_1 read_PCDATA (childs y)
@@ -1848,7 +1834,7 @@ -- |
 type Pre_Bend = ()
 -- |
-read_Pre_Bend :: STM Result [Content i] Pre_Bend
+read_Pre_Bend :: StateT Result [Content i] Pre_Bend
 read_Pre_Bend = read_ELEMENT "pre-bend" >> return ()
 -- |
 show_Pre_Bend :: Pre_Bend -> [Content ()]
@@ -1856,7 +1842,7 @@ -- |
 type Release = ()
 -- |
-read_Release :: STM Result [Content i] Release
+read_Release :: StateT Result [Content i] Release
 read_Release = read_ELEMENT "release" >> return ()
 -- |
 show_Release :: Release -> [Content ()]
@@ -1864,7 +1850,7 @@ -- |
 type With_Bar = ((Print_Style, Placement), CDATA)
 -- |
-read_With_Bar :: STM Result [Content i] With_Bar
+read_With_Bar :: StateT Result [Content i] With_Bar
 read_With_Bar = do
     y <- read_ELEMENT "with-bar"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1888,7 +1874,7 @@ -- |
 type Tap = ((Print_Style, Placement), CDATA)
 -- |
-read_Tap :: STM Result [Content i] Tap
+read_Tap :: StateT Result [Content i] Tap
 read_Tap = do
     y <- read_ELEMENT "tap"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1910,7 +1896,7 @@ -- |
 type Heel = ((Maybe Yes_No, Print_Style, Placement), ())
 -- |
-read_Heel :: STM Result [Content i] Heel
+read_Heel :: StateT Result [Content i] Heel
 read_Heel = do
     y <- read_ELEMENT "heel"
     y1 <- read_3 (read_IMPLIED "substitution" read_Yes_No) 
@@ -1926,7 +1912,7 @@ -- |
 type Toe = ((Maybe Yes_No, Print_Style, Placement), ())
 -- |
-read_Toe :: STM Result [Content i] Toe
+read_Toe :: StateT Result [Content i] Toe
 read_Toe = do
     y <- read_ELEMENT "toe"
     y1 <- read_3 (read_IMPLIED "substitution" read_Yes_No) 
@@ -1948,7 +1934,7 @@ -- |
 type Fingernails = ((Print_Style, Placement), ())
 -- |
-read_Fingernails :: STM Result [Content i] Fingernails
+read_Fingernails :: StateT Result [Content i] Fingernails
 read_Fingernails = do
     y <- read_ELEMENT "fingernails"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1971,7 +1957,7 @@ -- |
 type Other_Technical = ((Print_Style, Placement), CDATA)
 -- |
-read_Other_Technical :: STM Result [Content i] Other_Technical
+read_Other_Technical :: StateT Result [Content i] Other_Technical
 read_Other_Technical = do
     y <- read_ELEMENT "other-technical"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -1994,7 +1980,7 @@ -- |
 type Articulations = [Articulations_]
 -- |
-read_Articulations :: Eq i => STM Result [Content i] Articulations
+read_Articulations :: Eq i => StateT Result [Content i] Articulations
 read_Articulations = do
     y <- read_ELEMENT "articulations" 
     read_1 (read_LIST read_Articulations_) (childs y)
@@ -2020,7 +2006,7 @@                     | Articulations_16 Other_Articulation
                       deriving (Eq, Show)
 -- |
-read_Articulations_ :: STM Result [Content i] Articulations_
+read_Articulations_ :: StateT Result [Content i] Articulations_
 read_Articulations_ = 
     (read_Accent >>= return . Articulations_1) `mplus`
     (read_Strong_Accent >>= return . Articulations_2) `mplus`
@@ -2059,7 +2045,7 @@ -- |
 type Accent = ((Print_Style, Placement), ())
 -- |
-read_Accent :: STM Result [Content i] Accent
+read_Accent :: StateT Result [Content i] Accent
 read_Accent = do
     y <- read_ELEMENT "accent"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2072,7 +2058,7 @@ -- |
 type Strong_Accent = ((Print_Style, Placement, Up_Down), ())
 -- |
-read_Strong_Accent :: STM Result [Content i] Strong_Accent
+read_Strong_Accent :: StateT Result [Content i] Strong_Accent
 read_Strong_Accent = do
     y <- read_ELEMENT "strong-accent"
     y1 <- read_3 read_Print_Style read_Placement 
@@ -2094,7 +2080,7 @@ -- |
 type Staccato = ((Print_Style, Placement), ())
 -- |
-read_Staccato :: STM Result [Content i] Staccato
+read_Staccato :: StateT Result [Content i] Staccato
 read_Staccato = do
     y <- read_ELEMENT "staccato"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2107,7 +2093,7 @@ -- |
 type Tenuto = ((Print_Style, Placement), ())
 -- |
-read_Tenuto :: STM Result [Content i] Tenuto
+read_Tenuto :: StateT Result [Content i] Tenuto
 read_Tenuto = do
     y <- read_ELEMENT "tenuto"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2120,7 +2106,7 @@ -- |
 type Detached_Legato = ((Print_Style, Placement), ())
 -- |
-read_Detached_Legato :: STM Result [Content i] Detached_Legato
+read_Detached_Legato :: StateT Result [Content i] Detached_Legato
 read_Detached_Legato = do
     y <- read_ELEMENT "detached-legato"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2140,7 +2126,7 @@ -- |
 type Staccatissimo = ((Print_Style, Placement), ())
 -- |
-read_Staccatissimo :: STM Result [Content i] Staccato
+read_Staccatissimo :: StateT Result [Content i] Staccato
 read_Staccatissimo = do
     y <- read_ELEMENT "staccatissimo"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2160,7 +2146,7 @@ -- |
 type Spiccato = ((Print_Style, Placement), ())
 -- |
-read_Spiccato :: STM Result [Content i] Spiccato
+read_Spiccato :: StateT Result [Content i] Spiccato
 read_Spiccato = do
     y <- read_ELEMENT "spiccato"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2185,7 +2171,7 @@ -- |
 type Scoop = ((Line_Shape, Line_Type, Print_Style, Placement),())
 -- |
-read_Scoop :: STM Result [Content i] Scoop
+read_Scoop :: StateT Result [Content i] Scoop
 read_Scoop = do
     y <- read_ELEMENT "scoop"
     y1 <- read_4 read_Line_Shape read_Line_Type 
@@ -2200,7 +2186,7 @@ -- |
 type Plop = ((Line_Shape, Line_Type, Print_Style, Placement),())
 -- |
-read_Plop :: STM Result [Content i] Plop
+read_Plop :: StateT Result [Content i] Plop
 read_Plop = do
     y <- read_ELEMENT "plop"
     y1 <- read_4 read_Line_Shape read_Line_Type 
@@ -2215,7 +2201,7 @@ -- |
 type Doit = ((Line_Shape, Line_Type, Print_Style, Placement),())
 -- |
-read_Doit :: STM Result [Content i] Doit
+read_Doit :: StateT Result [Content i] Doit
 read_Doit = do
     y <- read_ELEMENT "doit"
     y1 <- read_4 read_Line_Shape read_Line_Type 
@@ -2230,7 +2216,7 @@ -- |
 type Falloff = ((Line_Shape, Line_Type, Print_Style, Placement),())
 -- |
-read_Falloff :: STM Result [Content i] Falloff
+read_Falloff :: StateT Result [Content i] Falloff
 read_Falloff = do
     y <- read_ELEMENT "falloff"
     y1 <- read_4 read_Line_Shape read_Line_Type 
@@ -2245,7 +2231,7 @@ -- |
 type Breath_Mark = ((Print_Style, Placement), ())
 -- |
-read_Breath_Mark :: STM Result [Content i] Breath_Mark
+read_Breath_Mark :: StateT Result [Content i] Breath_Mark
 read_Breath_Mark = do
     y <- read_ELEMENT "breath-mark"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2258,7 +2244,7 @@ -- |
 type Caesura = ((Print_Style, Placement), ())
 -- |
-read_Caesura :: STM Result [Content i] Caesura
+read_Caesura :: StateT Result [Content i] Caesura
 read_Caesura = do
     y <- read_ELEMENT "caesura"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2271,7 +2257,7 @@ -- |
 type Stress = ((Print_Style, Placement), ())
 -- |
-read_Stress :: STM Result [Content i] Stress
+read_Stress :: StateT Result [Content i] Stress
 read_Stress = do
     y <- read_ELEMENT "stress"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2284,7 +2270,7 @@ -- |
 type Unstress = ((Print_Style, Placement), ())
 -- |
-read_Unstress :: STM Result [Content i] Unstress
+read_Unstress :: StateT Result [Content i] Unstress
 read_Unstress = do
     y <- read_ELEMENT "unstress"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2307,7 +2293,7 @@ -- |
 type Other_Articulation = ((Print_Style, Placement), ())
 -- |
-read_Other_Articulation :: STM Result [Content i] Other_Articulation
+read_Other_Articulation :: StateT Result [Content i] Other_Articulation
 read_Other_Articulation = do
     y <- read_ELEMENT "other-articulation"
     y1 <- read_2 read_Print_Style read_Placement (attributes y)
@@ -2339,7 +2325,7 @@ type Arpeggiate = ((Maybe Number_Level, Maybe Up_Down, Position, Placement,
         Color), ())
 -- |
-read_Arpeggiate :: STM Result [Content i] Arpeggiate
+read_Arpeggiate :: StateT Result [Content i] Arpeggiate
 read_Arpeggiate = do
     y <- read_ELEMENT "arpeggiate"
     y1 <- read_5 (read_IMPLIED "number" read_Number_Level)
@@ -2368,7 +2354,7 @@ type Non_Arpeggiate = 
     ((Top_Bottom, Maybe Number_Level, Position, Placement,Color), ())
 -- |
-read_Non_Arpeggiate :: STM Result [Content i] Non_Arpeggiate
+read_Non_Arpeggiate :: StateT Result [Content i] Non_Arpeggiate
 read_Non_Arpeggiate = do
     y <- read_ELEMENT "non-arpeggiate"
     y1 <- read_5 (read_REQUIRED "type" read_Top_Bottom)
@@ -2418,7 +2404,7 @@ type Lyric = ((Maybe CDATA, Maybe CDATA, 
         Justify, Position, Placement, Color),
     (Lyric_, Maybe End_Line, Maybe End_Paragraph, Editorial))
-read_Lyric :: Eq i => STM Result [Content i] Lyric
+read_Lyric :: Eq i => StateT Result [Content i] Lyric
 read_Lyric = do
     y <- read_ELEMENT "lyric"
     y1 <- read_6 (read_IMPLIED "number" read_CDATA)
@@ -2447,14 +2433,14 @@             | Lyric_3 Laughing
             | Lyric_4 Humming
             deriving (Eq, Show)
-read_Lyric_ :: Eq i => STM Result [Content i] Lyric_
+read_Lyric_ :: Eq i => StateT Result [Content i] Lyric_
 read_Lyric_ = 
     (read_Lyric_aux1 >>= (return . Lyric_1)) `mplus`
     (read_Extend >>= (return . Lyric_2)) `mplus`
     (read_Laughing >>= (return . Lyric_3)) `mplus`
     (read_Humming >>= (return . Lyric_4)) `mplus`
     fail "No lyric_ parsed"
-read_Lyric_aux1 :: Eq i => STM Result [Content i] ((Maybe Syllabic, Text),
+read_Lyric_aux1 :: Eq i => StateT Result [Content i] ((Maybe Syllabic, Text),
                     [(Maybe Elision, Maybe Syllabic,Text)], Maybe Extend)
 read_Lyric_aux1 = do
     y1 <- read_MAYBE read_Syllabic
@@ -2462,7 +2448,7 @@     y3 <- read_LIST read_Lyric_aux2
     y4 <- read_MAYBE read_Extend
     return ((y1,y2),y3,y4)
-read_Lyric_aux2 :: STM Result [Content i] (Maybe Elision, Maybe Syllabic,Text)
+read_Lyric_aux2 :: StateT Result [Content i] (Maybe Elision, Maybe Syllabic,Text)
 read_Lyric_aux2 = do
     y1 <- read_MAYBE read_Elision
     y2 <- read_MAYBE read_Syllabic
@@ -2484,7 +2470,7 @@ type Text = ((Font, Color, Text_Decoration, Text_Rotation, Letter_Spacing,
         Maybe CDATA, Text_Direction), CDATA)
 -- | 
-read_Text :: STM Result [Content i] Text
+read_Text :: StateT Result [Content i] Text
 read_Text = do
     y <- read_ELEMENT "text" 
     y1 <- read_7 read_Font read_Color read_Text_Decoration 
@@ -2507,7 +2493,7 @@ -- |
 type Syllabic = PCDATA
 -- |
-read_Syllabic :: STM Result [Content i] Syllabic 
+read_Syllabic :: StateT Result [Content i] Syllabic 
 read_Syllabic = do
     y <- read_ELEMENT "syllabic"
     read_1 read_PCDATA (childs y)
@@ -2525,7 +2511,7 @@ \begin{code}
 type Elision = ((Font, Color), CDATA)
 -- |
-read_Elision :: STM Result [Content i] Elision
+read_Elision :: StateT Result [Content i] Elision
 read_Elision = do
     y <- read_ELEMENT "elision" 
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -2539,7 +2525,7 @@         (show_PCDATA c)
 type Extend = ((Font, Color), ())
 -- |
-read_Extend :: STM Result [Content i] Extend
+read_Extend :: StateT Result [Content i] Extend
 read_Extend = do
     y <- read_ELEMENT "extend"
     y1 <- read_2 read_Font read_Color (attributes y)
@@ -2551,7 +2537,7 @@ -- |
 type Laughing = ()
 -- |
-read_Laughing :: STM Result [Content i] Laughing 
+read_Laughing :: StateT Result [Content i] Laughing 
 read_Laughing = read_ELEMENT "laughing" >> return ()
 -- |
 show_Laughing :: Laughing -> [Content ()]
@@ -2559,7 +2545,7 @@ -- |
 type Humming = ()
 -- |
-read_Humming :: STM Result [Content i] Humming
+read_Humming :: StateT Result [Content i] Humming
 read_Humming = read_ELEMENT "humming" >> return ()
 -- |
 show_Humming :: Humming -> [Content ()]
@@ -2567,7 +2553,7 @@ -- |
 type End_Line = ()
 -- |
-read_End_Line :: STM Result [Content i] End_Line
+read_End_Line :: StateT Result [Content i] End_Line
 read_End_Line = read_ELEMENT "end-line" >> return ()
 -- |
 show_End_Line :: End_Line -> [Content ()]
@@ -2575,7 +2561,7 @@ -- |
 type End_Paragraph = ()
 -- |
-read_End_Paragraph :: STM Result [Content i] End_Paragraph
+read_End_Paragraph :: StateT Result [Content i] End_Paragraph
 read_End_Paragraph = read_ELEMENT "end-paragraph" >> return ()
 -- |
 show_End_Paragraph :: End_Paragraph -> [Content ()]
@@ -2604,7 +2590,7 @@ type Figured_Bass = ((Print_Style, Printout, Maybe Yes_No), 
     ([Figure], Maybe Duration, Editorial))
 -- |
-read_Figured_Bass :: Eq i => STM Result [Content i] Figured_Bass
+read_Figured_Bass :: Eq i => StateT Result [Content i] Figured_Bass
 read_Figured_Bass = do
     y <- read_ELEMENT "figured-bass" 
     y1 <- read_3 read_Print_Style read_Printout 
@@ -2623,7 +2609,7 @@ -- |
 type Figure = (Maybe Prefix, Maybe Figure_Number, Maybe Suffix, Maybe Extend)
 -- | 
-read_Figure :: STM Result [Content i] Figure
+read_Figure :: StateT Result [Content i] Figure
 read_Figure  = do
     y <- read_ELEMENT "figure" 
     read_4 (read_MAYBE read_Prefix) (read_MAYBE read_Figure_Number) 
@@ -2639,7 +2625,7 @@ -- |
 type Prefix = (Print_Style, CDATA)
 -- | 
-read_Prefix :: STM Result [Content i] Prefix
+read_Prefix :: StateT Result [Content i] Prefix
 read_Prefix = do
     y <- read_ELEMENT "prefix"
     y1 <- read_1 read_Print_Style (attributes y)
@@ -2654,7 +2640,7 @@ -- |
 type Figure_Number = (Print_Style, PCDATA)
 -- | 
-read_Figure_Number :: STM Result [Content i] Figure_Number
+read_Figure_Number :: StateT Result [Content i] Figure_Number
 read_Figure_Number = do
     y <- read_ELEMENT "figure-number" 
     y1 <- read_1 read_Print_Style (attributes y)
@@ -2669,7 +2655,7 @@ -- |
 type Suffix = (Print_Style, PCDATA)
 -- | 
-read_Suffix :: STM Result [Content i] Suffix
+read_Suffix :: StateT Result [Content i] Suffix
 read_Suffix = do
     y <- read_ELEMENT "suffix" 
     y1 <- read_1 read_Print_Style (attributes y)
@@ -2697,7 +2683,7 @@ -- |
 type Backup = (Duration, Editorial)
 -- |
-read_Backup :: STM Result [Content i] Backup
+read_Backup :: StateT Result [Content i] Backup
 read_Backup  = do
     y <- read_ELEMENT "backup"
     read_2 read_Duration read_Editorial (childs y)
@@ -2710,7 +2696,7 @@ -- |
 type Forward = (Duration, Editorial_Voice, Maybe Staff)
 -- |
-read_Forward :: STM Result [Content i] Forward
+read_Forward :: StateT Result [Content i] Forward
 read_Forward = do
     y <- read_ELEMENT "forward"
     read_3 read_Duration read_Editorial_Voice 
src/Text/XML/MusicXML/Opus.lhs view
@@ -57,7 +57,7 @@ -- |
 type Opus = (Document_Attributes, (Maybe Title, [Opus_]))
 -- |
-read_Opus :: Eq i => STM Result [Content i] Opus
+read_Opus :: Eq i => StateT Result [Content i] Opus
 read_Opus = do
     y <- read_ELEMENT "opus"
     y1 <- read_1 read_Document_Attributes (attributes y)
@@ -73,7 +73,7 @@ data Opus_ = Opus_1 Opus | Opus_2 Opus_Link | Opus_3 Score
     deriving (Eq, Show)
 -- |
-read_Opus_ :: Eq i => STM Result [Content i] Opus_
+read_Opus_ :: Eq i => StateT Result [Content i] Opus_
 read_Opus_ = 
     (read_Opus >>= return . Opus_1) `mplus`
     (read_Opus_Link >>= return . Opus_2) `mplus`
@@ -98,7 +98,7 @@ -- |
 type Score = ((Link_Attributes, Maybe Yes_No), ())
 -- |
-read_Score :: STM Result [Content i] Score
+read_Score :: StateT Result [Content i] Score
 read_Score = do
     y <- read_ELEMENT "score"
     y1 <- read_2 read_Link_Attributes 
@@ -120,7 +120,7 @@ -- |
 type Opus_Link = (Link_Attributes, ())
 -- |
-read_Opus_Link :: STM Result [Content i] Opus_Link
+read_Opus_Link :: StateT Result [Content i] Opus_Link
 read_Opus_Link = do
     y <- read_ELEMENT "opus-link"
     y1 <- read_1 read_Link_Attributes (attributes y)
@@ -139,7 +139,7 @@ -- |
 type Title = PCDATA
 -- |
-read_Title :: STM Result [Content i] Title
+read_Title :: StateT Result [Content i] Title
 read_Title = do
     y <- read_ELEMENT "title"
     read_1 read_PCDATA (childs y)
src/Text/XML/MusicXML/Partwise.lhs view
@@ -107,7 +107,7 @@ -- |
 type Score_Partwise = (Document_Attributes, (Score_Header, [Part]))
 -- |
-read_Score_Partwise :: Eq i => STM Result [Content i] Score_Partwise
+read_Score_Partwise :: Eq i => StateT Result [Content i] Score_Partwise
 read_Score_Partwise = do
     y <- read_ELEMENT "score-partwise"
     y1 <- read_1 read_Document_Attributes (attributes y)
@@ -126,7 +126,7 @@ -- |
 type Part = (ID, [Measure])
 -- |
-read_Part :: Eq i => STM Result [Content i] Part
+read_Part :: Eq i => StateT Result [Content i] Part
 read_Part = do
     y <- read_ELEMENT "part"
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
@@ -138,7 +138,7 @@ -- |
 type Measure = ((CDATA, Maybe Yes_No, Maybe Yes_No, Maybe Tenths), Music_Data)
 -- |
-read_Measure :: Eq i => STM Result [Content i] Measure
+read_Measure :: Eq i => StateT Result [Content i] Measure
 read_Measure = do
     y <- read_ELEMENT "measure"
     y1 <- read_4 (read_REQUIRED "number" read_CDATA)
src/Text/XML/MusicXML/Score.lhs view
@@ -30,7 +30,7 @@ -- |
 type Work = (Maybe Work_Number, Maybe Work_Title, Maybe Opus)
 -- |
-read_Work :: STM Result [Content i] Work
+read_Work :: StateT Result [Content i] Work
 read_Work = do
     y <- read_ELEMENT "work"
     read_3 (read_MAYBE read_Work_Number) 
@@ -46,7 +46,7 @@ -- |
 type Work_Number = PCDATA
 -- |
-read_Work_Number :: STM Result [Content i] Work_Number
+read_Work_Number :: StateT Result [Content i] Work_Number
 read_Work_Number = do
     y <- read_ELEMENT "work-number"
     read_1 read_PCDATA (childs y)
@@ -56,7 +56,7 @@ -- |
 type Work_Title = PCDATA
 -- |
-read_Work_Title :: STM Result [Content i] Work_Title
+read_Work_Title :: StateT Result [Content i] Work_Title
 read_Work_Title = do
     y <- read_ELEMENT "work-title"
     read_1 read_PCDATA (childs y)
@@ -66,7 +66,7 @@ -- |
 type Opus = (Link_Attributes, ())
 -- |
-read_Opus :: STM Result [Content i] Opus
+read_Opus :: StateT Result [Content i] Opus
 read_Opus = do
     y <- read_ELEMENT "opus"
     y1 <- read_1 read_Link_Attributes (attributes y)
@@ -77,7 +77,7 @@ -- |
 type Movement_Number = PCDATA
 -- |
-read_Movement_Number :: STM Result [Content i] Movement_Number
+read_Movement_Number :: StateT Result [Content i] Movement_Number
 read_Movement_Number = do
     y <- read_ELEMENT "movement-number"
     read_1 read_PCDATA (childs y)
@@ -87,7 +87,7 @@ -- |
 type Movement_Title = PCDATA
 -- |
-read_Movement_Title :: STM Result [Content i] Movement_Title
+read_Movement_Title :: StateT Result [Content i] Movement_Title
 read_Movement_Title = do
     y <- read_ELEMENT "movement-title"
     read_1 read_PCDATA (childs y)
@@ -115,7 +115,7 @@     Maybe System_Layout, [Staff_Layout], Maybe Appearance,
     Maybe Music_Font, Maybe Word_Font, [Lyric_Font], [Lyric_Language])
 -- |
-read_Defaults :: Eq i => STM Result [Content i] Defaults
+read_Defaults :: Eq i => StateT Result [Content i] Defaults
 read_Defaults = do
     y <- read_ELEMENT "defaults"
     read_9 (read_MAYBE read_Scaling) (read_MAYBE read_Page_Layout)
@@ -136,7 +136,7 @@ -- |
 type Music_Font = (Font, ())
 -- |
-read_Music_Font :: Eq i => STM Result [Content i] Music_Font
+read_Music_Font :: Eq i => StateT Result [Content i] Music_Font
 read_Music_Font = do
     y <- read_ELEMENT "music-font"
     y1 <- read_1 read_Font (attributes y)
@@ -148,7 +148,7 @@ -- |
 type Word_Font = (Font, ())
 -- |
-read_Word_Font :: Eq i => STM Result [Content i] Word_Font
+read_Word_Font :: Eq i => StateT Result [Content i] Word_Font
 read_Word_Font = do
     y <- read_ELEMENT "word-font"
     y1 <- read_1 read_Font (attributes y)
@@ -160,7 +160,7 @@ -- |
 type Lyric_Font = ((Maybe CDATA, Maybe CDATA, Font), ())
 -- |
-read_Lyric_Font :: Eq i => STM Result [Content i] Lyric_Font
+read_Lyric_Font :: Eq i => StateT Result [Content i] Lyric_Font
 read_Lyric_Font = do
     y <- read_ELEMENT "lyric-font"
     y1 <- read_3 (read_IMPLIED "number" read_CDATA)
@@ -176,7 +176,7 @@ -- |
 type Lyric_Language = ((Maybe CDATA, Maybe CDATA, CDATA), ())
 -- |
-read_Lyric_Language :: Eq i => STM Result [Content i] Lyric_Language
+read_Lyric_Language :: Eq i => StateT Result [Content i] Lyric_Language
 read_Lyric_Language = do
     y <- read_ELEMENT "lyric-language"
     y1 <- read_3 (read_IMPLIED "number" read_CDATA)
@@ -227,7 +227,7 @@ -- |
 type Credit = (Maybe CDATA, ([Link], [Bookmark], Credit_))
 -- |
-read_Credit :: Eq i => STM Result [Content i] Credit
+read_Credit :: Eq i => StateT Result [Content i] Credit
 read_Credit = do
     y <- read_ELEMENT "credit"
     y1 <- read_1 (read_IMPLIED "page" read_CDATA) (attributes y)
@@ -245,7 +245,7 @@              | Credit_2 (Credit_Words, [([Link], [Bookmark], Credit_Words)])
                deriving (Eq, Show)
 -- |
-read_Credit_ :: Eq i => STM Result [Content i] Credit_
+read_Credit_ :: Eq i => StateT Result [Content i] Credit_
 read_Credit_ = 
     (read_Credit_Image >>= return . Credit_1) `mplus`
     (read_Credit_aux1 >>= return . Credit_2)
@@ -255,14 +255,14 @@ show_Credit_ (Credit_2 (a,b)) = 
     show_Credit_Words a ++ show_LIST show_Credit_aux1 b
 -- |
-read_Credit_aux1 :: Eq i => STM Result [Content i] 
+read_Credit_aux1 :: Eq i => StateT Result [Content i] 
     (Credit_Words, [([Link], [Bookmark], Credit_Words)])
 read_Credit_aux1 = do
     y1 <- read_Credit_Words
     y2 <- read_LIST read_Credit_aux2
     return (y1,y2)
 -- |
-read_Credit_aux2 :: Eq i => STM Result [Content i] ([Link],[Bookmark],Credit_Words)
+read_Credit_aux2 :: Eq i => StateT Result [Content i] ([Link],[Bookmark],Credit_Words)
 read_Credit_aux2 = do
     y1 <- read_LIST read_Link
     y2 <- read_LIST read_Bookmark
@@ -276,7 +276,7 @@ -- |
 type Credit_Words = (Text_Formatting, PCDATA)
 -- |
-read_Credit_Words :: STM Result [Content i] Credit_Words
+read_Credit_Words :: StateT Result [Content i] Credit_Words
 read_Credit_Words = do
     y <- read_ELEMENT "credit-words"
     y1 <- read_1 read_Text_Formatting (attributes y)
@@ -290,7 +290,7 @@ type Credit_Image = ((CDATA, CDATA,
         Position, Halign, Valign_Image), ())
 -- |
-read_Credit_Image :: STM Result [Content i] Credit_Image
+read_Credit_Image :: StateT Result [Content i] Credit_Image
 read_Credit_Image = do
     y <- read_ELEMENT "credit-image"
     y1 <- read_5 (read_REQUIRED "source" read_CDATA) 
@@ -337,7 +337,7 @@ -- |
 type Part_List = ([Part_Group], Score_Part, [Part_List_])
 -- |
-read_Part_List :: Eq i => STM Result [Content i] Part_List
+read_Part_List :: Eq i => StateT Result [Content i] Part_List
 read_Part_List = do
     y <- read_ELEMENT "part-list"
     read_3 (read_LIST read_Part_Group) read_Score_Part 
@@ -353,7 +353,7 @@                 | Part_List_2 Score_Part
                   deriving (Eq, Show)
 -- |
-read_Part_List_ :: Eq i => STM Result [Content i] Part_List_
+read_Part_List_ :: Eq i => StateT Result [Content i] Part_List_
 read_Part_List_ = 
     (read_Part_Group >>= return . Part_List_1) `mplus`
     (read_Score_Part >>= return . Part_List_2) 
@@ -367,7 +367,7 @@     Maybe Part_Abbreviation, Maybe Part_Abbreviation_Display,
     [Group], [Score_Instrument], Maybe Midi_Device, [Midi_Instrument]))
 -- |
-read_Score_Part :: Eq i => STM Result [Content i] Score_Part
+read_Score_Part :: Eq i => StateT Result [Content i] Score_Part
 read_Score_Part = do
     y <- read_ELEMENT "score-part"
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
@@ -413,7 +413,7 @@ -- |
 type Part_Name = ((Print_Style, Print_Object, Justify), PCDATA)
 -- |
-read_Part_Name :: STM Result [Content i] Part_Name
+read_Part_Name :: StateT Result [Content i] Part_Name
 read_Part_Name = do
     y <- read_ELEMENT "part-name"
     y1 <- read_3 read_Print_Style read_Print_Object read_Justify
@@ -429,7 +429,7 @@ -- |
 type Part_Abbreviation = ((Print_Style, Print_Object, Justify), PCDATA)
 -- |
-read_Part_Abbreviation :: STM Result [Content i] Part_Abbreviation
+read_Part_Abbreviation :: StateT Result [Content i] Part_Abbreviation
 read_Part_Abbreviation = do
     y <- read_ELEMENT "part-abbreviation"
     y1 <- read_3 read_Print_Style read_Print_Object read_Justify
@@ -489,7 +489,7 @@     Maybe Group_Abbreviation, Maybe Group_Abbreviation_Display,
     Maybe Group_Symbol, Maybe Group_Barline, Maybe Group_Time, Editorial))
 -- |
-read_Part_Group :: Eq i => STM Result [Content i] Part_Group
+read_Part_Group :: Eq i => StateT Result [Content i] Part_Group
 read_Part_Group = do
     y <- read_ELEMENT "part-group"
     y1 <- read_2 (read_REQUIRED "type" read_Start_Stop)
@@ -517,7 +517,7 @@ -- |
 type Group_Name = ((Print_Style, Justify), PCDATA)
 -- |
-read_Group_Name :: STM Result [Content i] Group_Name
+read_Group_Name :: StateT Result [Content i] Group_Name
 read_Group_Name = do
     y <- read_ELEMENT "group-name"
     y1 <- read_2 read_Print_Style read_Justify (attributes y)
@@ -532,7 +532,7 @@ -- |
 type Group_Name_Display = (Print_Object, [Group_Name_Display_])
 -- |
-read_Group_Name_Display :: Eq i => STM Result [Content i] Group_Name_Display
+read_Group_Name_Display :: Eq i => StateT Result [Content i] Group_Name_Display
 read_Group_Name_Display = do
     y <- read_ELEMENT "group-name-display"
     y1 <- read_1 read_Print_Object (attributes y)
@@ -548,7 +548,7 @@                          | Group_Name_Display_2 Accidental_Text
                            deriving (Eq, Show)
 -- |
-read_Group_Name_Display_ :: STM Result [Content i] Group_Name_Display_
+read_Group_Name_Display_ :: StateT Result [Content i] Group_Name_Display_
 read_Group_Name_Display_ =
     (read_Display_Text >>= return . Group_Name_Display_1) `mplus`
     (read_Accidental_Text >>= return . Group_Name_Display_2)
@@ -559,7 +559,7 @@ -- |
 type Group_Abbreviation = ((Print_Style, Justify), PCDATA)
 -- |
-read_Group_Abbreviation :: STM Result [Content i] Group_Abbreviation
+read_Group_Abbreviation :: StateT Result [Content i] Group_Abbreviation
 read_Group_Abbreviation = do
     y <- read_ELEMENT "group-abbreviation"
     y1 <- read_2 read_Print_Style read_Justify (attributes y)
@@ -575,7 +575,7 @@ type Group_Abbreviation_Display = (Print_Object, [Group_Abbreviation_Display_])
 -- |
 read_Group_Abbreviation_Display :: Eq i => 
-    STM Result [Content i] Group_Abbreviation_Display
+    StateT Result [Content i] Group_Abbreviation_Display
 read_Group_Abbreviation_Display = do
     y <- read_ELEMENT "group-abbreviation-display"
     y1 <- read_1 read_Print_Object (attributes y)
@@ -594,7 +594,7 @@       deriving (Eq, Show)
 -- |
 read_Group_Abbreviation_Display_ :: 
-    STM Result [Content i] Group_Abbreviation_Display_
+    StateT Result [Content i] Group_Abbreviation_Display_
 read_Group_Abbreviation_Display_ =
     (read_Display_Text >>= return . Group_Abbreviation_Display_1) `mplus`
     (read_Accidental_Text >>= return . Group_Abbreviation_Display_2)
@@ -608,7 +608,7 @@ -- |
 type Group_Symbol = ((Position, Color), PCDATA)
 -- |
-read_Group_Symbol :: STM Result [Content i] Group_Symbol
+read_Group_Symbol :: StateT Result [Content i] Group_Symbol
 read_Group_Symbol = do
     y <- read_ELEMENT "group-symbol"
     y1 <- read_2 read_Position read_Color (attributes y)
@@ -622,7 +622,7 @@ -- |
 type Group_Barline = (Color, PCDATA)
 -- |
-read_Group_Barline :: STM Result [Content i] Group_Barline
+read_Group_Barline :: StateT Result [Content i] Group_Barline
 read_Group_Barline = do 
     y <- read_ELEMENT "group-barline"
     y1 <- read_1 read_Color (attributes y)
@@ -635,7 +635,7 @@ -- |
 type Group_Time = ()
 -- |
-read_Group_Time :: STM Result [Content i] Group_Time
+read_Group_Time :: StateT Result [Content i] Group_Time
 read_Group_Time = read_ELEMENT "group-time" >> return ()
 -- |
 show_Group_Time :: Group_Time -> [Content ()]
@@ -678,7 +678,7 @@ type Score_Instrument = (ID, (Instrument_Name, Maybe Instrument_Abbreviation,
     Maybe Score_Instrument_))
 -- |
-read_Score_Instrument :: STM Result [Content i] Score_Instrument
+read_Score_Instrument :: StateT Result [Content i] Score_Instrument
 read_Score_Instrument = do
     y <- read_ELEMENT "score-instrument"
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
@@ -698,7 +698,7 @@                        | Score_Instrument_2 Ensemble
                          deriving (Eq, Show)
 -- |
-read_Score_Instrument_ :: STM Result [Content i] Score_Instrument_
+read_Score_Instrument_ :: StateT Result [Content i] Score_Instrument_
 read_Score_Instrument_ = 
     (read_Solo >>= return . Score_Instrument_1) `mplus`
     (read_Ensemble >>= return . Score_Instrument_2)
@@ -709,7 +709,7 @@ -- |
 type Instrument_Name = PCDATA
 -- |
-read_Instrument_Name :: STM Result [Content i] Instrument_Name
+read_Instrument_Name :: StateT Result [Content i] Instrument_Name
 read_Instrument_Name = do
     y <- read_ELEMENT "instrument-name"
     read_1 read_PCDATA (childs y)
@@ -719,7 +719,7 @@ -- |
 type Instrument_Abbreviation = PCDATA
 -- |
-read_Instrument_Abbreviation :: STM Result [Content i] Instrument_Abbreviation
+read_Instrument_Abbreviation :: StateT Result [Content i] Instrument_Abbreviation
 read_Instrument_Abbreviation = do
     y <- read_ELEMENT "instrument-abbreviation"
     read_1 read_PCDATA (childs y)
@@ -730,7 +730,7 @@ -- |
 type Solo = ()
 -- |
-read_Solo :: STM Result [Content i] Solo
+read_Solo :: StateT Result [Content i] Solo
 read_Solo = read_ELEMENT "solo" >> return ()
 -- |
 show_Solo :: Solo -> [Content ()]
@@ -738,7 +738,7 @@ -- |
 type Ensemble = PCDATA
 -- |
-read_Ensemble :: STM Result [Content i] Ensemble
+read_Ensemble :: StateT Result [Content i] Ensemble
 read_Ensemble = do
     y <- read_ELEMENT "ensemble"
     read_1 read_PCDATA (childs y)
@@ -757,7 +757,7 @@ -- |
 type Midi_Device = (Maybe CDATA, PCDATA)
 -- |
-read_Midi_Device :: STM Result [Content i] Midi_Device
+read_Midi_Device :: StateT Result [Content i] Midi_Device
 read_Midi_Device = do
     y <- read_ELEMENT "midi-device"
     y1 <- read_1 (read_IMPLIED "port" read_CDATA) (attributes y)
@@ -782,7 +782,7 @@ -- |
 type Group = PCDATA
 -- |
-read_Group :: STM Result [Content i] Group
+read_Group :: StateT Result [Content i] Group
 read_Group = do
     y <- read_ELEMENT "group"
     read_1 read_PCDATA (childs y)
@@ -802,7 +802,7 @@ -- |
 type Music_Data = [Music_Data_]
 -- |
-read_Music_Data :: Eq i => STM Result [Content i] Music_Data
+read_Music_Data :: Eq i => StateT Result [Content i] Music_Data
 read_Music_Data = read_LIST read_Music_Data_
 -- |
 show_Music_Data :: Music_Data -> [Content ()]
@@ -823,7 +823,7 @@                  | Music_Data_13 Bookmark
                  deriving (Eq, Show)
 -- |
-read_Music_Data_ :: Eq i => STM Result [Content i] Music_Data_
+read_Music_Data_ :: Eq i => StateT Result [Content i] Music_Data_
 read_Music_Data_ = 
     (read_Note >>= return . Music_Data_1) `mplus`
     (read_Backup >>= return . Music_Data_2) `mplus`
@@ -869,7 +869,7 @@     Maybe Movement_Title, Maybe Identification, 
     Maybe Defaults, [Credit], Part_List)
 -- |
-read_Score_Header :: Eq i => STM Result [Content i] Score_Header
+read_Score_Header :: Eq i => StateT Result [Content i] Score_Header
 read_Score_Header = do
     y1 <- read_MAYBE read_Work
     y2 <- read_MAYBE read_Movement_Number
src/Text/XML/MusicXML/Timewise.lhs view
@@ -107,7 +107,7 @@ -- |
 type Score_Timewise = (Document_Attributes, (Score_Header, [Measure]))
 -- |
-read_Score_Timewise :: Eq i => STM Result [Content i] Score_Timewise
+read_Score_Timewise :: Eq i => StateT Result [Content i] Score_Timewise
 read_Score_Timewise = do
     y <- read_ELEMENT "score-timewise"
     y1 <- read_1 read_Document_Attributes (attributes y)
@@ -126,7 +126,7 @@ -- |
 type Measure = ((CDATA, Maybe Yes_No, Maybe Yes_No, Maybe Tenths),[Part])
 -- |
-read_Measure :: Eq i => STM Result [Content i] Measure
+read_Measure :: Eq i => StateT Result [Content i] Measure
 read_Measure = do
     y <- read_ELEMENT "measure"
     y1 <- read_4 (read_REQUIRED "number" read_CDATA)
@@ -147,7 +147,7 @@ -- |
 type Part = (ID, Music_Data)
 -- |
-read_Part :: Eq i => STM Result [Content i] Part
+read_Part :: Eq i => StateT Result [Content i] Part
 read_Part = do
     y <- read_ELEMENT "part"
     y1 <- read_1 (read_REQUIRED "id" read_ID) (attributes y)
src/Text/XML/MusicXML/Util.lhs view
@@ -53,44 +53,44 @@ fromError (Ok _)      = []
 fromError (Error msg) = msg
 
--- * ST
+-- * State
 -- |
-newtype ST s a = ST {state :: s -> (s,a)}
-instance Monad (ST s) where 
-    return x = ST (\s -> (s,x))
-    p >>= f  = ST (\s1 -> let (s2, r) = state p s1 in state (f r) s2)
-instance Functor (ST s) where 
-    fmap f st = ST (\s -> (\(x,y) -> (x, f y)) (state st s) )
+newtype State s a = State {state :: s -> (s,a)}
+instance Monad (State s) where 
+    return x = State (\s -> (s,x))
+    p >>= f  = State (\s1 -> let (s2, r) = state p s1 in state (f r) s2)
+instance Functor (State s) where 
+    fmap f st = State (\s -> (\(x,y) -> (x, f y)) (state st s) )
 -- |
-liftST :: (s -> a) -> ST s a
-liftST f = ST (\s -> (s,f s))
+liftState :: (s -> a) -> State s a
+liftState f = State (\s -> (s,f s))
 
--- * STM
+-- * StateT
 -- |
-newtype STM m s a = STM {stateM :: s -> m (s, a)}
+newtype StateT m s a = StateT {stateT :: s -> m (s, a)}
 -- |
-instance (Monad m) => Monad (STM m s) where
-    return x = STM (\s -> return (s,x))
-    p >>= f  = STM (\s -> do {
-        ; (s',l) <- stateM p s
-        ; stateM (f l) s'})
-    fail msg = STM (\_ -> fail msg)
+instance (Monad m) => Monad (StateT m s) where
+    return x = StateT (\s -> return (s,x))
+    p >>= f  = StateT (\s -> do {
+        ; (s',l) <- stateT p s
+        ; stateT (f l) s'})
+    fail msg = StateT (\_ -> fail msg)
 -- |
-instance MonadPlus m => MonadPlus (STM m s) where
-    mzero = STM (\_ -> mzero)
-    a `mplus` b = STM (\s -> (stateM a s) `mplus` (stateM b s))
+instance MonadPlus m => MonadPlus (StateT m s) where
+    mzero = StateT (\_ -> mzero)
+    a `mplus` b = StateT (\s -> (stateT a s) `mplus` (stateT b s))
 -- |
-instance Monad m => Functor (STM m s) where
-    fmap f stm = STM (\s -> stateM stm s >>= (\(s1, a) -> return (s1, f a)))
+instance Monad m => Functor (StateT m s) where
+    fmap f stm = StateT (\s -> stateT stm s >>= (\(s1, a) -> return (s1, f a)))
 -- |
-liftSTM :: Monad m => ST s (m a) -> STM m s a
-liftSTM p = STM (\s -> do {
+liftStateT :: Monad m => State s (m a) -> StateT m s a
+liftStateT p = StateT (\s -> do {
     ; let (s', l) = (state p s)
     ; lx <- l
     ; return (s',lx)})
 -- |
-returnSTM :: Monad m => m a -> STM m s a
-returnSTM x = STM (\s -> x>>=(\y -> return (s,y)))
+returnStateT :: Monad m => m a -> StateT m s a
+returnStateT x = StateT (\s -> x>>=(\y -> return (s,y)))
 \end{code}
 
 \begin{code}
@@ -127,14 +127,14 @@           result (Error _) = Nothing
 -- |
 read_IMPLIED :: Monad m => 
-    String -> (String -> Result a) -> STM m [Attribute] (Maybe a)
+    String -> (String -> Result a) -> StateT m [Attribute] (Maybe a)
 read_IMPLIED key func = 
-    STM (\s-> return (s, read_IMPLIED' key func s))
+    StateT (\s-> return (s, read_IMPLIED' key func s))
 -- |
 show_IMPLIED :: String -> (a -> String) -> Maybe a -> [Attribute]
 show_IMPLIED key function = maybe [] (show_REQUIRED key function)
 -- |
-read_REQUIRED :: Monad m => String -> (String -> Result a) -> STM m [Attribute] a
+read_REQUIRED :: Monad m => String -> (String -> Result a) -> StateT m [Attribute] a
 read_REQUIRED key func = 
     read_IMPLIED key func >>= 
     maybe (fail ("I expect "++key++" as required attribute")) return
@@ -144,7 +144,7 @@     (:[]) . (\x -> (key, x)) . AttValue . (:[]) . Left . function
 -- |
 read_DEFAULT :: Monad m => 
-    String -> (String -> Result a) -> a -> STM m [Attribute] a
+    String -> (String -> Result a) -> a -> StateT m [Attribute] a
 read_DEFAULT key func def = 
     read_IMPLIED key func >>= 
     maybe (return def) return
@@ -156,7 +156,7 @@ show_FIXED = show_REQUIRED
 -- |
 read_FIXED :: Monad m => 
-    String -> (String -> Result a) -> a -> STM m [Attribute] a
+    String -> (String -> Result a) -> a -> StateT m [Attribute] a
 read_FIXED key func def = 
     read_IMPLIED key func >>=
     maybe (return def) return
@@ -180,8 +180,8 @@           conts (CRef _ _) = "(ref)"
           conts (CMisc _ _) = "(misc)"
 -- |
-read_ELEMENT :: String -> STM Result [Content i] (Element i)
-read_ELEMENT tag = liftSTM (ST (\s -> read_ELEMENT' tag s))
+read_ELEMENT :: String -> StateT Result [Content i] (Element i)
+read_ELEMENT tag = liftStateT (State (\s -> read_ELEMENT' tag s))
 -- |
 show_ELEMENT :: String -> [Attribute] -> [Content ()] -> [Content ()]
 show_ELEMENT tag attr contents = [CElem (Elem tag attr contents) ()]
@@ -209,8 +209,8 @@ read_REF (RefEntity x) = '&' : x ++ ";"
 read_REF (RefChar x) = '#' : show x
 -- |
-read_PCDATA :: STM Result [Content i] PCDATA
-read_PCDATA = liftSTM (ST (\s -> read_PCDATA' s))
+read_PCDATA :: StateT Result [Content i] PCDATA
+read_PCDATA = liftStateT (State (\s -> read_PCDATA' s))
 -- |
 show_PCDATA :: PCDATA -> [Content ()]
 show_PCDATA pcdata = [CString False pcdata ()]
@@ -220,21 +220,21 @@ \begin{code}
 -- * Elements
 -- |
-read_MAYBE :: STM Result [Content i] a -> 
-    STM Result [Content i] (Maybe a)
-read_MAYBE st = STM (\s -> 
-        ((stateM st s) >>= (\(z1,z2) -> return (z1, return z2))) 
+read_MAYBE :: StateT Result [Content i] a -> 
+    StateT Result [Content i] (Maybe a)
+read_MAYBE st = StateT (\s -> 
+        ((stateT st s) >>= (\(z1,z2) -> return (z1, return z2))) 
         `mplus` return (s,Nothing) )
 -- |
 show_MAYBE :: (a -> [Content ()]) -> Maybe a -> [Content ()]
 show_MAYBE f = maybe [] f
 -- |
-read_LIST :: Eq i => STM Result [Content i] a -> STM Result [Content i] [a]
-read_LIST st = STM (\s -> 
-    let x = stateM st s
+read_LIST :: Eq i => StateT Result [Content i] a -> StateT Result [Content i] [a]
+read_LIST st = StateT (\s -> 
+    let x = stateT st s
     in case x of
        Ok (x1,x2) -> if s == x1 then return (s,[x2])
-                     else let y = stateM (read_LIST st) x1
+                     else let y = stateT (read_LIST st) x1
                           in case y of 
                                 Ok (y1,y2) -> return (y1, x2:y2)
                                 Error _ -> return (x1, [x2])
@@ -244,12 +244,12 @@ show_LIST :: (a -> [Content ()]) -> [a] -> [Content ()]
 show_LIST f = concat . map f
 -- |
-read_LIST1 :: Eq i => STM Result [Content i] a -> STM Result [Content i] [a]
-read_LIST1 st = STM (\s -> 
-    let x = stateM st s
+read_LIST1 :: Eq i => StateT Result [Content i] a -> StateT Result [Content i] [a]
+read_LIST1 st = StateT (\s -> 
+    let x = stateT st s
     in case x of
        Ok (x1,x2) -> if s == x1 then return (s,[x2])
-                     else let y = stateM (read_LIST1 st) x1
+                     else let y = stateT (read_LIST1 st) x1
                           in case y of 
                                 Ok (y1,y2) -> return (y1, x2:y2)
                                 Error _ -> return (x1, [x2])
@@ -264,199 +264,199 @@ \begin{code}
 -- * Read 
 -- |
-read_1 :: Monad m => STM m s a -> s -> STM m s' a
-read_1 st1 s = returnSTM (stateM st1 s >>= (\(_,x) -> return x) )
+read_1 :: Monad m => StateT m s a -> s -> StateT m s' a
+read_1 st1 s = returnStateT (stateT st1 s >>= (\(_,x) -> return x) )
 -- |
-read_2 :: Monad m => STM m s a -> STM m s b -> s -> STM m s' (a,b)
-read_2 st1 st2 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (_,b) <- stateM st2 s1
+read_2 :: Monad m => StateT m s a -> StateT m s b -> s -> StateT m s' (a,b)
+read_2 st1 st2 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (_,b) <- stateT st2 s1
     return (a,b))
 -- |
-read_3 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    s -> STM m s' (a,b,c)
-read_3 st1 st2 st3 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (_,c) <- stateM st3 s2
+read_3 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    s -> StateT m s' (a,b,c)
+read_3 st1 st2 st3 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (_,c) <- stateT st3 s2
     return (a,b,c))
 -- |
-read_4 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> s -> STM m s' (a,b,c,d)
-read_4 st1 st2 st3 st4 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (_,d) <- stateM st4 s3
+read_4 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> s -> StateT m s' (a,b,c,d)
+read_4 st1 st2 st3 st4 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (_,d) <- stateT st4 s3
     return (a,b,c,d))
 -- |
-read_5 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> s -> STM m s' (a,b,c,d,e)
-read_5 st1 st2 st3 st4 st5 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (_,e) <- stateM st5 s4
+read_5 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> s -> StateT m s' (a,b,c,d,e)
+read_5 st1 st2 st3 st4 st5 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (_,e) <- stateT st5 s4
     return (a,b,c,d,e))
 -- |
-read_6 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> s -> STM m s' (a,b,c,d,e,f)
-read_6 st1 st2 st3 st4 st5 st6 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (_,f) <- stateM st6 s5
+read_6 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> s -> StateT m s' (a,b,c,d,e,f)
+read_6 st1 st2 st3 st4 st5 st6 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (_,f) <- stateT st6 s5
     return (a,b,c,d,e,f))
 -- |
-read_7 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    s -> STM m s' (a,b,c,d,e,f,g)
-read_7 st1 st2 st3 st4 st5 st6 st7 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (_,g) <- stateM st7 s6
+read_7 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    s -> StateT m s' (a,b,c,d,e,f,g)
+read_7 st1 st2 st3 st4 st5 st6 st7 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (_,g) <- stateT st7 s6
     return (a,b,c,d,e,f,g))
 -- |
-read_8 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> s -> STM m s' (a,b,c,d,e,f,g,h)
-read_8 st1 st2 st3 st4 st5 st6 st7 st8 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (_,h) <- stateM st8 s7
+read_8 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> s -> StateT m s' (a,b,c,d,e,f,g,h)
+read_8 st1 st2 st3 st4 st5 st6 st7 st8 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (_,h) <- stateT st8 s7
     return (a,b,c,d,e,f,g,h))
 -- |
-read_9 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> s -> STM m s' (a,b,c,d,e,f,g,h,i)
-read_9 st1 st2 st3 st4 st5 st6 st7 st8 st9 s = returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (_,i) <- stateM st9 s8
+read_9 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> s -> StateT m s' (a,b,c,d,e,f,g,h,i)
+read_9 st1 st2 st3 st4 st5 st6 st7 st8 st9 s = returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (_,i) <- stateT st9 s8
     return (a,b,c,d,e,f,g,h,i))
 -- |
-read_10 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> STM m s j -> 
-    s -> STM m s' (a,b,c,d,e,f,g,h,i,j)
+read_10 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> StateT m s j -> 
+    s -> StateT m s' (a,b,c,d,e,f,g,h,i,j)
 read_10 st1 st2 st3 st4 st5 st6 st7 st8 st9 st10 s = 
-  returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (s9,i) <- stateM st9 s8
-    (_,j) <- stateM st10 s9
+  returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (s9,i) <- stateT st9 s8
+    (_,j) <- stateT st10 s9
     return (a,b,c,d,e,f,g,h,i,j))
 -- |
-read_11 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> STM m s j -> STM m s k ->
-    s -> STM m s' (a,b,c,d,e,f,g,h,i,j,k)
+read_11 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k ->
+    s -> StateT m s' (a,b,c,d,e,f,g,h,i,j,k)
 read_11 st1 st2 st3 st4 st5 st6 st7 st8 st9 st10 st11 s = 
-  returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (s9,i) <- stateM st9 s8
-    (s10,j) <- stateM st10 s9
-    (_,k) <- stateM st11 s10
+  returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (s9,i) <- stateT st9 s8
+    (s10,j) <- stateT st10 s9
+    (_,k) <- stateT st11 s10
     return (a,b,c,d,e,f,g,h,i,j,k))
 -- |
-read_12 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> STM m s j -> STM m s k -> 
-    STM m s l -> s -> STM m s' (a,b,c,d,e,f,g,h,i,j,k,l)
+read_12 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> 
+    StateT m s l -> s -> StateT m s' (a,b,c,d,e,f,g,h,i,j,k,l)
 read_12 st1 st2 st3 st4 st5 st6 st7 st8 st9 st10 st11 st12 s = 
-  returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (s9,i) <- stateM st9 s8
-    (s10,j) <- stateM st10 s9
-    (s11,k) <- stateM st11 s10
-    (_,l) <- stateM st12 s11
+  returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (s9,i) <- stateT st9 s8
+    (s10,j) <- stateT st10 s9
+    (s11,k) <- stateT st11 s10
+    (_,l) <- stateT st12 s11
     return (a,b,c,d,e,f,g,h,i,j,k,l))
 -- |
-read_13 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> STM m s j -> STM m s k -> 
-    STM m s l -> STM m s n -> s -> STM m s' (a,b,c,d,e,f,g,h,i,j,k,l,n)
+read_13 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> 
+    StateT m s l -> StateT m s n -> s -> StateT m s' (a,b,c,d,e,f,g,h,i,j,k,l,n)
 read_13 st1 st2 st3 st4 st5 st6 st7 st8 st9 st10 st11 st12 st13 s = 
-  returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (s9,i) <- stateM st9 s8
-    (s10,j) <- stateM st10 s9
-    (s11,k) <- stateM st11 s10
-    (s12,l) <- stateM st12 s11
-    (_,m) <- stateM st13 s12
+  returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (s9,i) <- stateT st9 s8
+    (s10,j) <- stateT st10 s9
+    (s11,k) <- stateT st11 s10
+    (s12,l) <- stateT st12 s11
+    (_,m) <- stateT st13 s12
     return (a,b,c,d,e,f,g,h,i,j,k,l,m))
 -- |
-read_17 :: Monad m => STM m s a -> STM m s b -> STM m s c -> 
-    STM m s d -> STM m s e -> STM m s f -> STM m s g -> 
-    STM m s h -> STM m s i -> STM m s j -> STM m s k -> 
-    STM m s l -> STM m s n -> STM m s o -> STM m s p -> 
-    STM m s q -> STM m s r -> s -> 
-    STM m s' (a,b,c,d,e,f,g,h,i,j,k,l,n,o,p,q,r)
+read_17 :: Monad m => StateT m s a -> StateT m s b -> StateT m s c -> 
+    StateT m s d -> StateT m s e -> StateT m s f -> StateT m s g -> 
+    StateT m s h -> StateT m s i -> StateT m s j -> StateT m s k -> 
+    StateT m s l -> StateT m s n -> StateT m s o -> StateT m s p -> 
+    StateT m s q -> StateT m s r -> s -> 
+    StateT m s' (a,b,c,d,e,f,g,h,i,j,k,l,n,o,p,q,r)
 read_17 st1  st2  st3  st4  st5  st6  st7  st8  st9
         st10 st11 st12 st13 st14 st15 st16 st17 s = 
-  returnSTM (do
-    (s1,a) <- stateM st1 s
-    (s2,b) <- stateM st2 s1
-    (s3,c) <- stateM st3 s2
-    (s4,d) <- stateM st4 s3
-    (s5,e) <- stateM st5 s4
-    (s6,f) <- stateM st6 s5
-    (s7,g) <- stateM st7 s6
-    (s8,h) <- stateM st8 s7
-    (s9,i) <- stateM st9 s8
-    (s10,j) <- stateM st10 s9
-    (s11,k) <- stateM st11 s10
-    (s12,l) <- stateM st12 s11
-    (s13,n) <- stateM st13 s12
-    (s14,o) <- stateM st14 s13
-    (s15,p) <- stateM st15 s14
-    (s16,q) <- stateM st16 s15
-    (_,r)   <- stateM st17 s16
+  returnStateT (do
+    (s1,a) <- stateT st1 s
+    (s2,b) <- stateT st2 s1
+    (s3,c) <- stateT st3 s2
+    (s4,d) <- stateT st4 s3
+    (s5,e) <- stateT st5 s4
+    (s6,f) <- stateT st6 s5
+    (s7,g) <- stateT st7 s6
+    (s8,h) <- stateT st8 s7
+    (s9,i) <- stateT st9 s8
+    (s10,j) <- stateT st10 s9
+    (s11,k) <- stateT st11 s10
+    (s12,l) <- stateT st12 s11
+    (s13,n) <- stateT st13 s12
+    (s14,o) <- stateT st14 s13
+    (s15,p) <- stateT st15 s14
+    (s16,q) <- stateT st16 s15
+    (_,r)   <- stateT st17 s16
     return (a,b,c,d,e,f,g,h,i,j,k,l,n,o,p,q,r))
 \end{code}
 
− tests/Test/MusicXML.lhs
@@ -1,90 +0,0 @@-\begin{code}
--- |
-module Main where
-
-import Text.XML.MusicXML hiding (String)            -- MusicXML package
-import System.IO
-import Data.Maybe
-import System.Environment
-import System.Console.GetOpt
-import Prelude
-\end{code}
-
-\begin{code}
--- |
-data Option = List FilePath
-            | Help 
-            | Version
-              deriving (Eq, Show)
-options :: [OptDescr Option]
-options = [
-      Option ['v','V'] ["version"] (NoArg Version) "show version number"
-    , Option ['h','H','?'] ["help"] (NoArg Help) "show help"
-    , Option ['l','m'] ["manifest"] (ReqArg List "MANIFEST") "manifest file"
-    ]
--- |
-header :: String -> String
-header prog = "Usage: "++ prog ++" [OPTIONS...] FILES..."
--- |
-proc :: [Option] -> [String] -> IO ()
-proc [] files = main' (zip ([1..]::[Int]) files)
-proc ((List file):t) files = do
-    list <- readFile file
-    proc t (lines list ++ files)
-proc (_:t) files = proc t files
-\end{code}
-
-
-\begin{code}
-mkoutput :: FilePath -> FilePath
-mkoutput = reverse . ("lmx.tuptuo-"++) . drop 4 . reverse
-\end{code}
-
-\begin{code}
--- |
-put :: String -> IO ()
-put msg = putStr msg >> hFlush stdout
-putLn :: String -> IO ()
-putLn msg = putStrLn msg >> hFlush stdout
-
-putBool :: Bool -> IO ()
-putBool True = putStrLn "[Ok]"
-putBool False = putStrLn "[Failed]"
-\end{code}
-
-\begin{code}
--- |
-inout :: FilePath -> IO () 
-inout file = do
-    putLn ("file: "++show file) >> put "Reading "
-    contents <- readFile file 
-    r1 <- return (read_CONTENTS read_MusicXMLDoc file contents)
-    r2 <- return (case isOK r1 of
-                  True -> Just (mkoutput file, fromOK r1); False -> Nothing)
-    putBool (isOK r1)
-    put "Writing "
-    r3 <- return (fmap (\(a,b) -> 
-          (a, show_CONTENTS show_MusicXMLDoc b)) r2)
-    maybe (return ()) (uncurry writeFile) r3
-    putBool (isJust r3)
-\end{code}
-
-\begin{code}
--- |
-main :: IO ()
-main = do
-    argv <- getArgs
-    prog <- getProgName
-    case getOpt Permute options argv of
-        (o,n,[]) | Help`elem`o -> putStrLn (usageInfo (header prog) options)
-                 | Version`elem`o -> putStrLn (unwords [prog])
-                 | otherwise -> proc o n
-        (_,_,errs) -> putStrLn (unlines errs ++ usageInfo (header prog) options)
--- |
-main' :: [(Int, FilePath)] -> IO ()
-main' [] = return ()
-main' ((a,b):t) = do
-    putLn ("\nNumber: " ++ show a) >> inout b >> main' t
-\end{code}
-
-