module Sound.MIDI.File.Event.Meta (
   T(..),
   ElapsedTime, fromElapsedTime, toElapsedTime,
   Tempo,       fromTempo,       toTempo,
   defltTempo,
   SMPTEHours, SMPTEMinutes, SMPTESeconds, SMPTEFrames, SMPTEBits,
   get, put, ) where

import Sound.MIDI.Message.Channel (Channel, toChannel, fromChannel, )

import qualified Sound.MIDI.KeySignature as KeySig

import Sound.MIDI.Parser.Primitive (get1, get2, get3, getVar, getBigN, )
import qualified Sound.MIDI.Parser.Class as Parser
import qualified Sound.MIDI.Parser.Restricted as ParserRestricted

import Control.Monad (liftM, liftM4, liftM5, )

import qualified Sound.MIDI.Writer.Basic as Writer
import qualified Sound.MIDI.Bit as Bit

import Sound.MIDI.Monoid ((+#+))

import qualified Numeric.NonNegative.Wrapper as NonNeg
import Sound.MIDI.IO (ByteList, listCharFromByte, listByteFromChar, )

import Sound.MIDI.Utility
         (arbitraryString, arbitraryByteList, )

import Test.QuickCheck (Arbitrary(arbitrary), )
import qualified Test.QuickCheck as QC

import Prelude hiding (putStr, )


{- * Meta Events -}

type ElapsedTime  = NonNeg.Integer
type Tempo        = NonNeg.Int
type SMPTEHours   = Int
type SMPTEMinutes = Int
type SMPTESeconds = Int
type SMPTEFrames  = Int
type SMPTEBits    = Int

data T =
     SequenceNum Int
   | TextEvent String
   | Copyright String
   | TrackName String
   | InstrumentName String
   | Lyric String
   | Marker String
   | CuePoint String
   | MIDIPrefix Channel
   | EndOfTrack
   | SetTempo Tempo
   | SMPTEOffset SMPTEHours SMPTEMinutes SMPTESeconds SMPTEFrames SMPTEBits
   | TimeSig Int Int Int Int
   | KeySig KeySig.T
   | SequencerSpecific ByteList
   | Unknown Int ByteList
     deriving (Int -> T -> ShowS
[T] -> ShowS
T -> String
(Int -> T -> ShowS) -> (T -> String) -> ([T] -> ShowS) -> Show T
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [T] -> ShowS
$cshowList :: [T] -> ShowS
show :: T -> String
$cshow :: T -> String
showsPrec :: Int -> T -> ShowS
$cshowsPrec :: Int -> T -> ShowS
Show, T -> T -> Bool
(T -> T -> Bool) -> (T -> T -> Bool) -> Eq T
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: T -> T -> Bool
$c/= :: T -> T -> Bool
== :: T -> T -> Bool
$c== :: T -> T -> Bool
Eq, Eq T
Eq T
-> (T -> T -> Ordering)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> T)
-> (T -> T -> T)
-> Ord T
T -> T -> Bool
T -> T -> Ordering
T -> T -> T
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: T -> T -> T
$cmin :: T -> T -> T
max :: T -> T -> T
$cmax :: T -> T -> T
>= :: T -> T -> Bool
$c>= :: T -> T -> Bool
> :: T -> T -> Bool
$c> :: T -> T -> Bool
<= :: T -> T -> Bool
$c<= :: T -> T -> Bool
< :: T -> T -> Bool
$c< :: T -> T -> Bool
compare :: T -> T -> Ordering
$ccompare :: T -> T -> Ordering
$cp1Ord :: Eq T
Ord)


instance Arbitrary T where
   arbitrary :: Gen T
arbitrary =
      [Gen T] -> Gen T
forall a. [Gen a] -> Gen a
QC.oneof ([Gen T] -> Gen T) -> [Gen T] -> Gen T
forall a b. (a -> b) -> a -> b
$
         (Int -> T) -> Gen Int -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  Int -> T
SequenceNum ((Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
QC.choose (Int
0,Int
0xFFFF)) Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
TextEvent Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
Copyright Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
TrackName Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
InstrumentName Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
Lyric Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
Marker Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (String -> T) -> Gen String -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  String -> T
CuePoint Gen String
arbitraryString Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (Int -> T) -> Gen Int -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  (Channel -> T
MIDIPrefix (Channel -> T) -> (Int -> Channel) -> Int -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Channel
toChannel) ((Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
QC.choose (Int
0,Int
15)) Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
--         return EndOfTrack :
         (Int -> T) -> Gen Int -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  (Tempo -> T
SetTempo (Tempo -> T) -> (Int -> Tempo) -> Int -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Int -> Tempo
forall a. (Ord a, Num a) => String -> a -> T a
NonNeg.fromNumberMsg String
"Tempo always positive") ((Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
QC.choose (Int
0,Int
0xFFFFFF)) Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (Int -> Int -> Int -> Int -> Int -> T)
-> Gen Int -> Gen Int -> Gen Int -> Gen Int -> Gen Int -> Gen T
forall (m :: * -> *) a1 a2 a3 a4 a5 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> a5 -> r)
-> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM5 Int -> Int -> Int -> Int -> Int -> T
SMPTEOffset Gen Int
arbitraryByte Gen Int
arbitraryByte Gen Int
arbitraryByte Gen Int
arbitraryByte Gen Int
arbitraryByte Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (Int -> Int -> Int -> Int -> T)
-> Gen Int -> Gen Int -> Gen Int -> Gen Int -> Gen T
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 Int -> Int -> Int -> Int -> T
TimeSig Gen Int
arbitraryByte Gen Int
arbitraryByte Gen Int
arbitraryByte Gen Int
arbitraryByte Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (T -> T) -> Gen T -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  T -> T
KeySig Gen T
forall a. Arbitrary a => Gen a
arbitrary Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
         (ByteList -> T) -> Gen ByteList -> Gen T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM  ByteList -> T
SequencerSpecific Gen ByteList
arbitraryByteList Gen T -> [Gen T] -> [Gen T]
forall a. a -> [a] -> [a]
:
--         liftM  Unknown arbitrary arbitraryByteList :
         []

arbitraryByte :: QC.Gen Int
arbitraryByte :: Gen Int
arbitraryByte = (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
QC.choose (Int
0,Int
0xFF::Int)


toElapsedTime :: Integer -> ElapsedTime
toElapsedTime :: Integer -> ElapsedTime
toElapsedTime = String -> Integer -> ElapsedTime
forall a. (Ord a, Num a) => String -> a -> T a
NonNeg.fromNumberMsg String
"toElapsedTime"

fromElapsedTime :: ElapsedTime -> Integer
fromElapsedTime :: ElapsedTime -> Integer
fromElapsedTime = ElapsedTime -> Integer
forall a. T a -> a
NonNeg.toNumber


toTempo :: Int -> Tempo
toTempo :: Int -> Tempo
toTempo = String -> Int -> Tempo
forall a. (Ord a, Num a) => String -> a -> T a
NonNeg.fromNumberMsg String
"toTempo"

fromTempo :: Tempo -> Int
fromTempo :: Tempo -> Int
fromTempo = Tempo -> Int
forall a. T a -> a
NonNeg.toNumber

{- |
The default SetTempo value, in microseconds per quarter note.
This expresses the default of 120 beats per minute.
-}
defltTempo :: Tempo
defltTempo :: Tempo
defltTempo = Tempo
500000



-- * serialization

get :: Parser.C parser => Parser.Fragile parser T
get :: Fragile parser T
get =
   do Int
code <- Fragile parser Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
      ElapsedTime
len  <- Fragile parser ElapsedTime
forall (parser :: * -> *). C parser => Fragile parser ElapsedTime
getVar
      let parse :: Fragile (T parser) a -> Fragile parser a
parse = ElapsedTime -> Fragile (T parser) a -> Fragile parser a
forall (parser :: * -> *) a.
C parser =>
ElapsedTime -> Fragile (T parser) a -> Fragile parser a
ParserRestricted.runFragile ElapsedTime
len
      let returnText :: (String -> r) -> ExceptionalT String parser r
returnText String -> r
cons = (ByteList -> r)
-> ExceptionalT String parser ByteList
-> ExceptionalT String parser r
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (String -> r
cons (String -> r) -> (ByteList -> String) -> ByteList -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteList -> String
listCharFromByte) (ExceptionalT String parser ByteList
 -> ExceptionalT String parser r)
-> ExceptionalT String parser ByteList
-> ExceptionalT String parser r
forall a b. (a -> b) -> a -> b
$ ElapsedTime -> ExceptionalT String parser ByteList
forall (parser :: * -> *).
C parser =>
ElapsedTime -> Fragile parser ByteList
getBigN ElapsedTime
len
      case Int
code of
         Int
000 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$ (Int -> T)
-> ExceptionalT String (T parser) Int -> Fragile (T parser) T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Int -> T
SequenceNum ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get2
         Int
001 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
TextEvent
         Int
002 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
Copyright
         Int
003 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
TrackName
         Int
004 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
InstrumentName
         Int
005 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
Lyric
         Int
006 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
Marker
         Int
007 -> (String -> T) -> Fragile parser T
forall (parser :: * -> *) r.
C parser =>
(String -> r) -> ExceptionalT String parser r
returnText String -> T
CuePoint

         Int
032 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$
                (Int -> T)
-> ExceptionalT String (T parser) Int -> Fragile (T parser) T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Channel -> T
MIDIPrefix (Channel -> T) -> (Int -> Channel) -> Int -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Channel
toChannel) ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
         Int
047 -> T -> Fragile parser T
forall (m :: * -> *) a. Monad m => a -> m a
return T
EndOfTrack
         Int
081 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$
                (Int -> T)
-> ExceptionalT String (T parser) Int -> Fragile (T parser) T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Tempo -> T
SetTempo (Tempo -> T) -> (Int -> Tempo) -> Int -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Tempo
toTempo) ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get3

         Int
084 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$
                do {Int
hrs    <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1 ; Int
mins <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1 ; Int
secs <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1;
                    Int
frames <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1 ; Int
bits <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1 ;
                    T -> Fragile (T parser) T
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Int -> Int -> Int -> Int -> T
SMPTEOffset Int
hrs Int
mins Int
secs Int
frames Int
bits)}

         Int
088 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$
                do
                   Int
n <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
                   Int
d <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
                   Int
c <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
                   Int
b <- ExceptionalT String (T parser) Int
forall (parser :: * -> *). C parser => Fragile parser Int
get1
                   T -> Fragile (T parser) T
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Int -> Int -> Int -> T
TimeSig Int
n Int
d Int
c Int
b)

         Int
089 -> Fragile (T parser) T -> Fragile parser T
forall a. Fragile (T parser) a -> Fragile parser a
parse (Fragile (T parser) T -> Fragile parser T)
-> Fragile (T parser) T -> Fragile parser T
forall a b. (a -> b) -> a -> b
$ (T -> T)
-> ExceptionalT String (T parser) T -> Fragile (T parser) T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM T -> T
KeySig ExceptionalT String (T parser) T
forall (parser :: * -> *). C parser => Fragile parser T
KeySig.get

         Int
127 -> (ByteList -> T)
-> ExceptionalT String parser ByteList -> Fragile parser T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ByteList -> T
SequencerSpecific (ExceptionalT String parser ByteList -> Fragile parser T)
-> ExceptionalT String parser ByteList -> Fragile parser T
forall a b. (a -> b) -> a -> b
$ ElapsedTime -> ExceptionalT String parser ByteList
forall (parser :: * -> *).
C parser =>
ElapsedTime -> Fragile parser ByteList
getBigN ElapsedTime
len

         Int
_   -> (ByteList -> T)
-> ExceptionalT String parser ByteList -> Fragile parser T
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Int -> ByteList -> T
Unknown Int
code) (ExceptionalT String parser ByteList -> Fragile parser T)
-> ExceptionalT String parser ByteList -> Fragile parser T
forall a b. (a -> b) -> a -> b
$ ElapsedTime -> ExceptionalT String parser ByteList
forall (parser :: * -> *).
C parser =>
ElapsedTime -> Fragile parser ByteList
getBigN ElapsedTime
len


put :: Writer.C writer => T -> writer
put :: T -> writer
put T
ev =
   Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
255 writer -> writer -> writer
forall m. Monoid m => m -> m -> m
+#+
   case T
ev of
     SequenceNum Int
num  -> Int -> Int -> Int -> writer
forall writer. C writer => Int -> Int -> Int -> writer
putInt    Int
0 Int
2 Int
num
     TextEvent String
s      -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
1 String
s
     Copyright String
s      -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
2 String
s
     TrackName String
s      -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
3 String
s
     InstrumentName String
s -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
4 String
s
     Lyric String
s          -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
5 String
s
     Marker String
s         -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
6 String
s
     CuePoint String
s       -> Int -> String -> writer
forall writer. C writer => Int -> String -> writer
putStr    Int
7 String
s
     MIDIPrefix Channel
c     -> Int -> [Int] -> writer
forall writer. C writer => Int -> [Int] -> writer
putList  Int
32 [Channel -> Int
fromChannel Channel
c]
     T
EndOfTrack       -> Int -> [Int] -> writer
forall writer. C writer => Int -> [Int] -> writer
putList  Int
47 []

     SetTempo Tempo
tp      -> Int -> Int -> Int -> writer
forall writer. C writer => Int -> Int -> Int -> writer
putInt   Int
81 Int
3 (Tempo -> Int
fromTempo Tempo
tp)
     SMPTEOffset Int
hr Int
mn Int
se Int
fr Int
ff
                      -> Int -> [Int] -> writer
forall writer. C writer => Int -> [Int] -> writer
putList  Int
84 [Int
hr,Int
mn,Int
se,Int
fr,Int
ff]
     TimeSig Int
n Int
d Int
c Int
b  -> Int -> [Int] -> writer
forall writer. C writer => Int -> [Int] -> writer
putList  Int
88 [Int
n,Int
d,Int
c,Int
b]
     KeySig T
key       -> Int -> [Int] -> writer
forall writer. C writer => Int -> [Int] -> writer
putList  Int
89 ([Int] -> writer) -> [Int] -> writer
forall a b. (a -> b) -> a -> b
$ T -> [Int]
KeySig.toBytes T
key
     SequencerSpecific ByteList
codes
                      -> Int -> ByteList -> writer
forall writer. C writer => Int -> ByteList -> writer
putByteList Int
127 ByteList
codes
     Unknown Int
typ ByteList
s    -> Int -> ByteList -> writer
forall writer. C writer => Int -> ByteList -> writer
putByteList Int
typ ByteList
s


putByteList :: Writer.C writer => Int -> ByteList -> writer
putByteList :: Int -> ByteList -> writer
putByteList Int
code ByteList
bytes =
   Int -> writer
forall writer. C writer => Int -> writer
Writer.putIntAsByte Int
code writer -> writer -> writer
forall m. Monoid m => m -> m -> m
+#+
   ByteList -> writer
forall writer. C writer => ByteList -> writer
Writer.putLenByteList ByteList
bytes

putInt :: Writer.C writer => Int -> Int -> Int -> writer
putInt :: Int -> Int -> Int -> writer
putInt Int
code Int
numBytes Int
x =
   Int -> writer
forall writer. C writer => Int -> writer
Writer.putIntAsByte Int
code writer -> writer -> writer
forall m. Monoid m => m -> m -> m
+#+
   ElapsedTime -> writer
forall writer. C writer => ElapsedTime -> writer
Writer.putVar (Int -> ElapsedTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
numBytes) writer -> writer -> writer
forall m. Monoid m => m -> m -> m
+#+
   ByteList -> writer
forall writer. C writer => ByteList -> writer
Writer.putByteList
      ((Word8 -> Word8) -> ByteList -> ByteList
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteList -> ByteList) -> ByteList -> ByteList
forall a b. (a -> b) -> a -> b
$ Int -> Int -> ByteList
forall a. Integral a => Int -> a -> ByteList
Bit.someBytes Int
numBytes Int
x)

putStr :: Writer.C writer => Int -> String -> writer
putStr :: Int -> String -> writer
putStr Int
code =
   Int -> ByteList -> writer
forall writer. C writer => Int -> ByteList -> writer
putByteList Int
code (ByteList -> writer) -> (String -> ByteList) -> String -> writer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteList
listByteFromChar

putList :: Writer.C writer => Int -> [Int] -> writer
putList :: Int -> [Int] -> writer
putList Int
code =
   Int -> ByteList -> writer
forall writer. C writer => Int -> ByteList -> writer
putByteList Int
code (ByteList -> writer) -> ([Int] -> ByteList) -> [Int] -> writer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Word8) -> [Int] -> ByteList
forall a b. (a -> b) -> [a] -> [b]
map Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral