Remove some unnecessary type assertions from the tests, and fix testFill

Author: Dretch

test/Test/Node/Buffer/Mutable.purs

@@ -78,24 +78,24 @@ testMutableBuffer _ run = do
   where
     testCreate :: Effect Unit
     testCreate = do
-      buf <- run ((create 3 :: m buf) >>= toArray)
+      buf <- run (create 3 >>= toArray)
       assertEqual {expected: [0, 0, 0], actual: buf}
 
     testFreeze :: Effect Unit
     testFreeze = do
-      buf <- Buffer.toArray <$> run ((fromArray [1, 2, 3] :: m buf) >>= freeze)
+      buf <- Buffer.toArray <$> run (fromArray [1, 2, 3] >>= freeze)
       assertEqual {expected: [1, 2, 3], actual: buf}
 
     testThaw :: Effect Unit
     testThaw = do
-      buf <- run ((thaw (Buffer.fromArray [1, 2, 3]) :: m buf) >>= toArray)
+      buf <- run (thaw (Buffer.fromArray [1, 2, 3]) >>= toArray)
       assertEqual {expected: [1, 2, 3], actual: buf}
 
     testReadWrite :: Effect Unit
     testReadWrite = do
       let val = 42
       readVal <- run do
-        buf <- create 1 :: m buf
+        buf <- create 1
         write UInt8 val 0 buf
         read UInt8 0 buf
 
@@ -104,7 +104,7 @@ testMutableBuffer _ run = do
     testFromArray :: Effect Unit
     testFromArray = do
       readVal <- run do
-        buf <- fromArray [1,2,3,4,5] :: m buf
+        buf <- fromArray [1,2,3,4,5]
         read UInt8 2 buf
 
       assertEqual {expected: 3, actual: readVal}
@@ -113,7 +113,7 @@ testMutableBuffer _ run = do
     testToArray = do
       let val = [1,2,67,3,3,7,8,3,4,237]
       valOut <- run do
-        buf <- fromArray val :: m buf
+        buf <- fromArray val
         toArray buf
 
       assertEqual {expected: val, actual: valOut}
@@ -122,7 +122,7 @@ testMutableBuffer _ run = do
     testFromString = do
       let str = "hello, world"
       val <- run do
-        buf <- fromString str ASCII :: m buf
+        buf <- fromString str ASCII
         read UInt8 6 buf
 
       assertEqual {expected: 32, actual: val} -- ASCII space
@@ -140,7 +140,7 @@ testMutableBuffer _ run = do
     testToString = do
       let str = "hello, world"
       strOut <-run do
-        buf <- fromString str ASCII :: m buf
+        buf <- fromString str ASCII
         toString ASCII buf
 
       assertEqual {expected: str, actual: strOut}
@@ -149,16 +149,16 @@ testMutableBuffer _ run = do
     testReadString = do
       let str = "hello, world"
       strOut <- run do
-        buf <- fromString str ASCII :: m buf
+        buf <- fromString str ASCII
         readString ASCII 7 12 buf
 
       assertEqual {expected: "world", actual: strOut}
 
     testSlice :: Effect Unit
     testSlice = do
       {bufArr, bufSliceArr} <- run do
-        buf <- fromArray [1, 2, 3, 4] :: m buf
-        let bufSlice = slice 1 3 buf :: buf
+        buf <- fromArray [1, 2, 3, 4]
+        let bufSlice = slice 1 3 buf
         setAtOffset 42 1 bufSlice
         bufArr <- toArray buf
         bufSliceArr <- toArray bufSlice
@@ -170,7 +170,7 @@ testMutableBuffer _ run = do
     testCopy :: Effect Unit
     testCopy = do
       {copied, out} <- run do
-        buf1 <- fromArray [1,2,3,4,5] :: m buf
+        buf1 <- fromArray [1,2,3,4,5]
         buf2 <- fromArray [10,9,8,7,6]
         copied <- copy 0 3 buf1 2 buf2
         out <- toArray buf2
@@ -181,26 +181,26 @@ testMutableBuffer _ run = do
 
     testFill :: Effect Unit
     testFill = do
-      let out = ST.run do
-            buf <- fromArray [1,1,1,1,1]
-            fill 42 2 4 buf
-            toArray buf
+      out <- run do
+        buf <- fromArray [1,1,1,1,1]
+        fill 42 2 4 buf
+        toArray buf
 
       assertEqual {expected: [1,1,42,42,1], actual: out}
 
     testConcat' :: Effect Unit
     testConcat' = do
       out <- run do
         bufs <- traverse fromArray $ map (\x -> [x, x+1, x+2]) [0,3,6,9,12]
-        buf  <- concat' bufs 15 :: m buf
+        buf  <- concat' bufs 15
         toArray buf
 
       assertEqual {expected: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14], actual: out}
 
     testGetAtOffset :: Effect Unit
     testGetAtOffset = do
       {o1, o4, om1} <- run do
-        buf <- fromArray [1, 2, 3, 4] :: m buf
+        buf <- fromArray [1, 2, 3, 4]
         o1 <- getAtOffset 1 buf
         o4 <- getAtOffset 4 buf
         om1 <- getAtOffset (-1) buf