ParserMonad: tentative implementation for boundRepeat

Read: few functions, some incomplete (track, messages, message, deltaTime, etc.)

hitting a bump with getVarLen for now, but I assume the implementation will look easier (to the procedural programmer) implemented in the CE

Author: smoothdeveloper

src/ZMidi/Internal/ParserMonad.fs

@@ -158,6 +158,14 @@ module ParserMonad =
             work length state (fun msg -> Error msg) (fun st ac -> Ok (ac, st)) 
                 |> Result.map (fun (ans, st) -> (List.toArray ans, st))
 
+    let boundRepeat n p =
+        parseMidi {
+          return [|
+          for i in 0 .. (n - 1) do
+            yield! p
+          |]
+        }
+
     /// Drop a byte (word8).
     let dropByte : ParserMonad<unit> = 
         checkedParseM "dropByte" <| 

src/ZMidi/Read.fs

@@ -57,6 +57,52 @@ module ReadFile =
                      timeDivision = timeDivision
                      format = format }
             }
+    let trackHeader =
+        parseMidi {
+          let! _ = assertString "MTrk"
+          return! readUInt32be
+        }
+    let event : ParserMonad<MidiMessage> = 
+      parseMidi {
+        return! fatalError (Other "not implemented") }
+    let getVarLen : ParserMonad<uint32> = 
+      parseMidi {
+        return! fatalError (Other "not implemented")
+        //getVarlen :: ParserM Word32
+        //getVarlen = liftM fromVarlen step1
+        //  where
+        //    step1     = word8 >>= \a -> if msbHigh a then step2 a else return (V1 a)
+        //    step2 a   = word8 >>= \b -> if msbHigh b then step3 a b else return (V2 a b)
+        //    step3 a b = word8 >>= \c -> if msbHigh c then do { d <- word8
+        //                                                     ; return (V4 a b c d) }
+        //                                             else return (V3 a b c)  
+        
+        
+      }
+
+
+    let deltaTime = 
+      parseMidi {
+          return! getVarLen
+      } <??> (fun p -> "delta time")
+
+    let message = 
+        parseMidi {
+          let! deltaTime = deltaTime
+          let! event = event
+          return deltaTime, event
+        }
+    let messages i = 
+      parseMidi {
+          return! fatalError (Other "not implemented")
+          //let! messages = boundRepeat i message
+      }
+    let track : ParserMonad<MidiTrack> =
+        parseMidi {
+            let header = trackHeader
+            return! fatalError (Other "not implemented")
+           // let! messages = messages
+        }
     //let midiFile =
     //  parseMidi {
     //    let! header = P.header