{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE UndecidableInstances #-}

module Dahdit.Midi.Midi
  ( Channel (..)
  , ChannelCount (..)
  , Note (..)
  , Velocity (..)
  , ControlNum (..)
  , ControlVal (..)
  , Pressure (..)
  , ProgramNum (..)
  , PitchBend (..)
  , Song (..)
  , Position (..)
  , ShortManf (..)
  , LongManf (..)
  , Manf (..)
  , QuarterTimeUnit (..)
  , QuarterTime (..)
  , ChanStatus (..)
  , RtStatus (..)
  , CommonStatus (..)
  , LiveStatus (..)
  , RecStatus (..)
  , ShortStatus (..)
  , ChanStatusType (..)
  , ChanVoiceData (..)
  , ChanModeData (..)
  , ChanData (..)
  , UnivSysEx (..)
  , ManfSysEx (..)
  , SysExData (..)
  , CommonData (..)
  , LiveMsg (..)
  , MetaString (..)
  , MetaData (..)
  , RecMsg (..)
  , ShortMsg (..)
  , msgNoteOn
  , msgNoteOff
  , Event (..)
  , Track (..)
  , MidFileType (..)
  , MidFile (..)
  , SysExDump (..)
  )
where

import Control.Monad (unless, void)
import Control.Newtype (Newtype)
import Dahdit
  ( Binary (..)
  , BinaryRep (..)
  , ByteCount (..)
  , ExactBytes (..)
  , Get
  , Put
  , PutM
  , StaticByteSized (..)
  , ViaBinaryRep (..)
  , ViaGeneric (..)
  , Word16BE (..)
  , Word32BE (..)
  , byteSizeFoldable
  , getByteString
  , getExact
  , getExpect
  , getLookAhead
  , getRemainingSeq
  , getRemainingSize
  , getSeq
  , putByteString
  , putSeq
  )
import Dahdit.Midi.Binary (BoundedBinary (..), MidiInt14 (..), MidiWord14 (..), MidiWord7 (..), VarWord (..))
import Data.Bits (Bits (..))
import Data.ByteString.Short (ShortByteString)
import Data.ByteString.Short qualified as BSS
import Data.Hashable (Hashable)
import Data.Proxy (Proxy (..))
import Data.Sequence (Seq (..))
import Data.Sequence qualified as Seq
import Data.ShortWord (Word4)
import Data.String (IsString (..))
import Data.Word (Word16, Word8)
import GHC.Generics (Generic)

newtype Channel = Channel {Channel -> MidiWord7
unChannel :: MidiWord7}
  deriving stock (Int -> Channel -> ShowS
[Channel] -> ShowS
Channel -> String
(Int -> Channel -> ShowS)
-> (Channel -> String) -> ([Channel] -> ShowS) -> Show Channel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Channel -> ShowS
showsPrec :: Int -> Channel -> ShowS
$cshow :: Channel -> String
show :: Channel -> String
$cshowList :: [Channel] -> ShowS
showList :: [Channel] -> ShowS
Show)
  deriving newtype (Channel -> Channel -> Bool
(Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool) -> Eq Channel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Channel -> Channel -> Bool
== :: Channel -> Channel -> Bool
$c/= :: Channel -> Channel -> Bool
/= :: Channel -> Channel -> Bool
Eq, Eq Channel
Eq Channel =>
(Channel -> Channel -> Ordering)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> Ord Channel
Channel -> Channel -> Bool
Channel -> Channel -> Ordering
Channel -> Channel -> Channel
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
$ccompare :: Channel -> Channel -> Ordering
compare :: Channel -> Channel -> Ordering
$c< :: Channel -> Channel -> Bool
< :: Channel -> Channel -> Bool
$c<= :: Channel -> Channel -> Bool
<= :: Channel -> Channel -> Bool
$c> :: Channel -> Channel -> Bool
> :: Channel -> Channel -> Bool
$c>= :: Channel -> Channel -> Bool
>= :: Channel -> Channel -> Bool
$cmax :: Channel -> Channel -> Channel
max :: Channel -> Channel -> Channel
$cmin :: Channel -> Channel -> Channel
min :: Channel -> Channel -> Channel
Ord, Int -> Channel
Channel -> Int
Channel -> [Channel]
Channel -> Channel
Channel -> Channel -> [Channel]
Channel -> Channel -> Channel -> [Channel]
(Channel -> Channel)
-> (Channel -> Channel)
-> (Int -> Channel)
-> (Channel -> Int)
-> (Channel -> [Channel])
-> (Channel -> Channel -> [Channel])
-> (Channel -> Channel -> [Channel])
-> (Channel -> Channel -> Channel -> [Channel])
-> Enum Channel
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Channel -> Channel
succ :: Channel -> Channel
$cpred :: Channel -> Channel
pred :: Channel -> Channel
$ctoEnum :: Int -> Channel
toEnum :: Int -> Channel
$cfromEnum :: Channel -> Int
fromEnum :: Channel -> Int
$cenumFrom :: Channel -> [Channel]
enumFrom :: Channel -> [Channel]
$cenumFromThen :: Channel -> Channel -> [Channel]
enumFromThen :: Channel -> Channel -> [Channel]
$cenumFromTo :: Channel -> Channel -> [Channel]
enumFromTo :: Channel -> Channel -> [Channel]
$cenumFromThenTo :: Channel -> Channel -> Channel -> [Channel]
enumFromThenTo :: Channel -> Channel -> Channel -> [Channel]
Enum, Integer -> Channel
Channel -> Channel
Channel -> Channel -> Channel
(Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel)
-> (Channel -> Channel)
-> (Channel -> Channel)
-> (Integer -> Channel)
-> Num Channel
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Channel -> Channel -> Channel
+ :: Channel -> Channel -> Channel
$c- :: Channel -> Channel -> Channel
- :: Channel -> Channel -> Channel
$c* :: Channel -> Channel -> Channel
* :: Channel -> Channel -> Channel
$cnegate :: Channel -> Channel
negate :: Channel -> Channel
$cabs :: Channel -> Channel
abs :: Channel -> Channel
$csignum :: Channel -> Channel
signum :: Channel -> Channel
$cfromInteger :: Integer -> Channel
fromInteger :: Integer -> Channel
Num, Num Channel
Ord Channel
(Num Channel, Ord Channel) => (Channel -> Rational) -> Real Channel
Channel -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Channel -> Rational
toRational :: Channel -> Rational
Real, Enum Channel
Real Channel
(Real Channel, Enum Channel) =>
(Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> (Channel, Channel))
-> (Channel -> Channel -> (Channel, Channel))
-> (Channel -> Integer)
-> Integral Channel
Channel -> Integer
Channel -> Channel -> (Channel, Channel)
Channel -> Channel -> Channel
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Channel -> Channel -> Channel
quot :: Channel -> Channel -> Channel
$crem :: Channel -> Channel -> Channel
rem :: Channel -> Channel -> Channel
$cdiv :: Channel -> Channel -> Channel
div :: Channel -> Channel -> Channel
$cmod :: Channel -> Channel -> Channel
mod :: Channel -> Channel -> Channel
$cquotRem :: Channel -> Channel -> (Channel, Channel)
quotRem :: Channel -> Channel -> (Channel, Channel)
$cdivMod :: Channel -> Channel -> (Channel, Channel)
divMod :: Channel -> Channel -> (Channel, Channel)
$ctoInteger :: Channel -> Integer
toInteger :: Channel -> Integer
Integral, Eq Channel
Eq Channel =>
(Int -> Channel -> Int) -> (Channel -> Int) -> Hashable Channel
Int -> Channel -> Int
Channel -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Channel -> Int
hashWithSalt :: Int -> Channel -> Int
$chash :: Channel -> Int
hash :: Channel -> Int
Hashable, KnownNat (StaticSize Channel)
KnownNat (StaticSize Channel) =>
(Proxy Channel -> ByteCount) -> StaticByteSized Channel
Proxy Channel -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Channel -> ByteCount
staticByteSize :: Proxy Channel -> ByteCount
StaticByteSized)
  deriving (Get Channel
Channel -> ByteCount
Channel -> Put
(Channel -> ByteCount)
-> Get Channel -> (Channel -> Put) -> Binary Channel
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Channel -> ByteCount
byteSize :: Channel -> ByteCount
$cget :: Get Channel
get :: Get Channel
$cput :: Channel -> Put
put :: Channel -> Put
Binary) via (BoundedBinary "Channel" Channel MidiWord7)

instance Newtype Channel MidiWord7

instance Bounded Channel where
  minBound :: Channel
minBound = Channel
0
  maxBound :: Channel
maxBound = Channel
15

newtype ChannelCount = ChannelCount {ChannelCount -> MidiWord7
unChannelCount :: MidiWord7}
  deriving stock (Int -> ChannelCount -> ShowS
[ChannelCount] -> ShowS
ChannelCount -> String
(Int -> ChannelCount -> ShowS)
-> (ChannelCount -> String)
-> ([ChannelCount] -> ShowS)
-> Show ChannelCount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChannelCount -> ShowS
showsPrec :: Int -> ChannelCount -> ShowS
$cshow :: ChannelCount -> String
show :: ChannelCount -> String
$cshowList :: [ChannelCount] -> ShowS
showList :: [ChannelCount] -> ShowS
Show)
  deriving newtype
    (ChannelCount -> ChannelCount -> Bool
(ChannelCount -> ChannelCount -> Bool)
-> (ChannelCount -> ChannelCount -> Bool) -> Eq ChannelCount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChannelCount -> ChannelCount -> Bool
== :: ChannelCount -> ChannelCount -> Bool
$c/= :: ChannelCount -> ChannelCount -> Bool
/= :: ChannelCount -> ChannelCount -> Bool
Eq, Eq ChannelCount
Eq ChannelCount =>
(ChannelCount -> ChannelCount -> Ordering)
-> (ChannelCount -> ChannelCount -> Bool)
-> (ChannelCount -> ChannelCount -> Bool)
-> (ChannelCount -> ChannelCount -> Bool)
-> (ChannelCount -> ChannelCount -> Bool)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> Ord ChannelCount
ChannelCount -> ChannelCount -> Bool
ChannelCount -> ChannelCount -> Ordering
ChannelCount -> ChannelCount -> ChannelCount
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
$ccompare :: ChannelCount -> ChannelCount -> Ordering
compare :: ChannelCount -> ChannelCount -> Ordering
$c< :: ChannelCount -> ChannelCount -> Bool
< :: ChannelCount -> ChannelCount -> Bool
$c<= :: ChannelCount -> ChannelCount -> Bool
<= :: ChannelCount -> ChannelCount -> Bool
$c> :: ChannelCount -> ChannelCount -> Bool
> :: ChannelCount -> ChannelCount -> Bool
$c>= :: ChannelCount -> ChannelCount -> Bool
>= :: ChannelCount -> ChannelCount -> Bool
$cmax :: ChannelCount -> ChannelCount -> ChannelCount
max :: ChannelCount -> ChannelCount -> ChannelCount
$cmin :: ChannelCount -> ChannelCount -> ChannelCount
min :: ChannelCount -> ChannelCount -> ChannelCount
Ord, Int -> ChannelCount
ChannelCount -> Int
ChannelCount -> [ChannelCount]
ChannelCount -> ChannelCount
ChannelCount -> ChannelCount -> [ChannelCount]
ChannelCount -> ChannelCount -> ChannelCount -> [ChannelCount]
(ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount)
-> (Int -> ChannelCount)
-> (ChannelCount -> Int)
-> (ChannelCount -> [ChannelCount])
-> (ChannelCount -> ChannelCount -> [ChannelCount])
-> (ChannelCount -> ChannelCount -> [ChannelCount])
-> (ChannelCount -> ChannelCount -> ChannelCount -> [ChannelCount])
-> Enum ChannelCount
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ChannelCount -> ChannelCount
succ :: ChannelCount -> ChannelCount
$cpred :: ChannelCount -> ChannelCount
pred :: ChannelCount -> ChannelCount
$ctoEnum :: Int -> ChannelCount
toEnum :: Int -> ChannelCount
$cfromEnum :: ChannelCount -> Int
fromEnum :: ChannelCount -> Int
$cenumFrom :: ChannelCount -> [ChannelCount]
enumFrom :: ChannelCount -> [ChannelCount]
$cenumFromThen :: ChannelCount -> ChannelCount -> [ChannelCount]
enumFromThen :: ChannelCount -> ChannelCount -> [ChannelCount]
$cenumFromTo :: ChannelCount -> ChannelCount -> [ChannelCount]
enumFromTo :: ChannelCount -> ChannelCount -> [ChannelCount]
$cenumFromThenTo :: ChannelCount -> ChannelCount -> ChannelCount -> [ChannelCount]
enumFromThenTo :: ChannelCount -> ChannelCount -> ChannelCount -> [ChannelCount]
Enum, Integer -> ChannelCount
ChannelCount -> ChannelCount
ChannelCount -> ChannelCount -> ChannelCount
(ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount)
-> (Integer -> ChannelCount)
-> Num ChannelCount
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ChannelCount -> ChannelCount -> ChannelCount
+ :: ChannelCount -> ChannelCount -> ChannelCount
$c- :: ChannelCount -> ChannelCount -> ChannelCount
- :: ChannelCount -> ChannelCount -> ChannelCount
$c* :: ChannelCount -> ChannelCount -> ChannelCount
* :: ChannelCount -> ChannelCount -> ChannelCount
$cnegate :: ChannelCount -> ChannelCount
negate :: ChannelCount -> ChannelCount
$cabs :: ChannelCount -> ChannelCount
abs :: ChannelCount -> ChannelCount
$csignum :: ChannelCount -> ChannelCount
signum :: ChannelCount -> ChannelCount
$cfromInteger :: Integer -> ChannelCount
fromInteger :: Integer -> ChannelCount
Num, Num ChannelCount
Ord ChannelCount
(Num ChannelCount, Ord ChannelCount) =>
(ChannelCount -> Rational) -> Real ChannelCount
ChannelCount -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ChannelCount -> Rational
toRational :: ChannelCount -> Rational
Real, Enum ChannelCount
Real ChannelCount
(Real ChannelCount, Enum ChannelCount) =>
(ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> ChannelCount)
-> (ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount))
-> (ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount))
-> (ChannelCount -> Integer)
-> Integral ChannelCount
ChannelCount -> Integer
ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount)
ChannelCount -> ChannelCount -> ChannelCount
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ChannelCount -> ChannelCount -> ChannelCount
quot :: ChannelCount -> ChannelCount -> ChannelCount
$crem :: ChannelCount -> ChannelCount -> ChannelCount
rem :: ChannelCount -> ChannelCount -> ChannelCount
$cdiv :: ChannelCount -> ChannelCount -> ChannelCount
div :: ChannelCount -> ChannelCount -> ChannelCount
$cmod :: ChannelCount -> ChannelCount -> ChannelCount
mod :: ChannelCount -> ChannelCount -> ChannelCount
$cquotRem :: ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount)
quotRem :: ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount)
$cdivMod :: ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount)
divMod :: ChannelCount -> ChannelCount -> (ChannelCount, ChannelCount)
$ctoInteger :: ChannelCount -> Integer
toInteger :: ChannelCount -> Integer
Integral, Eq ChannelCount
Eq ChannelCount =>
(Int -> ChannelCount -> Int)
-> (ChannelCount -> Int) -> Hashable ChannelCount
Int -> ChannelCount -> Int
ChannelCount -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ChannelCount -> Int
hashWithSalt :: Int -> ChannelCount -> Int
$chash :: ChannelCount -> Int
hash :: ChannelCount -> Int
Hashable, KnownNat (StaticSize ChannelCount)
KnownNat (StaticSize ChannelCount) =>
(Proxy ChannelCount -> ByteCount) -> StaticByteSized ChannelCount
Proxy ChannelCount -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy ChannelCount -> ByteCount
staticByteSize :: Proxy ChannelCount -> ByteCount
StaticByteSized, Get ChannelCount
ChannelCount -> ByteCount
ChannelCount -> Put
(ChannelCount -> ByteCount)
-> Get ChannelCount -> (ChannelCount -> Put) -> Binary ChannelCount
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: ChannelCount -> ByteCount
byteSize :: ChannelCount -> ByteCount
$cget :: Get ChannelCount
get :: Get ChannelCount
$cput :: ChannelCount -> Put
put :: ChannelCount -> Put
Binary)

newtype Note = Note {Note -> MidiWord7
unNote :: MidiWord7}
  deriving stock (Int -> Note -> ShowS
[Note] -> ShowS
Note -> String
(Int -> Note -> ShowS)
-> (Note -> String) -> ([Note] -> ShowS) -> Show Note
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Note -> ShowS
showsPrec :: Int -> Note -> ShowS
$cshow :: Note -> String
show :: Note -> String
$cshowList :: [Note] -> ShowS
showList :: [Note] -> ShowS
Show)
  deriving newtype
    (Note -> Note -> Bool
(Note -> Note -> Bool) -> (Note -> Note -> Bool) -> Eq Note
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Note -> Note -> Bool
== :: Note -> Note -> Bool
$c/= :: Note -> Note -> Bool
/= :: Note -> Note -> Bool
Eq, Eq Note
Eq Note =>
(Note -> Note -> Ordering)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Note)
-> (Note -> Note -> Note)
-> Ord Note
Note -> Note -> Bool
Note -> Note -> Ordering
Note -> Note -> Note
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
$ccompare :: Note -> Note -> Ordering
compare :: Note -> Note -> Ordering
$c< :: Note -> Note -> Bool
< :: Note -> Note -> Bool
$c<= :: Note -> Note -> Bool
<= :: Note -> Note -> Bool
$c> :: Note -> Note -> Bool
> :: Note -> Note -> Bool
$c>= :: Note -> Note -> Bool
>= :: Note -> Note -> Bool
$cmax :: Note -> Note -> Note
max :: Note -> Note -> Note
$cmin :: Note -> Note -> Note
min :: Note -> Note -> Note
Ord, Int -> Note
Note -> Int
Note -> [Note]
Note -> Note
Note -> Note -> [Note]
Note -> Note -> Note -> [Note]
(Note -> Note)
-> (Note -> Note)
-> (Int -> Note)
-> (Note -> Int)
-> (Note -> [Note])
-> (Note -> Note -> [Note])
-> (Note -> Note -> [Note])
-> (Note -> Note -> Note -> [Note])
-> Enum Note
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Note -> Note
succ :: Note -> Note
$cpred :: Note -> Note
pred :: Note -> Note
$ctoEnum :: Int -> Note
toEnum :: Int -> Note
$cfromEnum :: Note -> Int
fromEnum :: Note -> Int
$cenumFrom :: Note -> [Note]
enumFrom :: Note -> [Note]
$cenumFromThen :: Note -> Note -> [Note]
enumFromThen :: Note -> Note -> [Note]
$cenumFromTo :: Note -> Note -> [Note]
enumFromTo :: Note -> Note -> [Note]
$cenumFromThenTo :: Note -> Note -> Note -> [Note]
enumFromThenTo :: Note -> Note -> Note -> [Note]
Enum, Integer -> Note
Note -> Note
Note -> Note -> Note
(Note -> Note -> Note)
-> (Note -> Note -> Note)
-> (Note -> Note -> Note)
-> (Note -> Note)
-> (Note -> Note)
-> (Note -> Note)
-> (Integer -> Note)
-> Num Note
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Note -> Note -> Note
+ :: Note -> Note -> Note
$c- :: Note -> Note -> Note
- :: Note -> Note -> Note
$c* :: Note -> Note -> Note
* :: Note -> Note -> Note
$cnegate :: Note -> Note
negate :: Note -> Note
$cabs :: Note -> Note
abs :: Note -> Note
$csignum :: Note -> Note
signum :: Note -> Note
$cfromInteger :: Integer -> Note
fromInteger :: Integer -> Note
Num, Num Note
Ord Note
(Num Note, Ord Note) => (Note -> Rational) -> Real Note
Note -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Note -> Rational
toRational :: Note -> Rational
Real, Enum Note
Real Note
(Real Note, Enum Note) =>
(Note -> Note -> Note)
-> (Note -> Note -> Note)
-> (Note -> Note -> Note)
-> (Note -> Note -> Note)
-> (Note -> Note -> (Note, Note))
-> (Note -> Note -> (Note, Note))
-> (Note -> Integer)
-> Integral Note
Note -> Integer
Note -> Note -> (Note, Note)
Note -> Note -> Note
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Note -> Note -> Note
quot :: Note -> Note -> Note
$crem :: Note -> Note -> Note
rem :: Note -> Note -> Note
$cdiv :: Note -> Note -> Note
div :: Note -> Note -> Note
$cmod :: Note -> Note -> Note
mod :: Note -> Note -> Note
$cquotRem :: Note -> Note -> (Note, Note)
quotRem :: Note -> Note -> (Note, Note)
$cdivMod :: Note -> Note -> (Note, Note)
divMod :: Note -> Note -> (Note, Note)
$ctoInteger :: Note -> Integer
toInteger :: Note -> Integer
Integral, Eq Note
Eq Note => (Int -> Note -> Int) -> (Note -> Int) -> Hashable Note
Int -> Note -> Int
Note -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Note -> Int
hashWithSalt :: Int -> Note -> Int
$chash :: Note -> Int
hash :: Note -> Int
Hashable, KnownNat (StaticSize Note)
KnownNat (StaticSize Note) =>
(Proxy Note -> ByteCount) -> StaticByteSized Note
Proxy Note -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Note -> ByteCount
staticByteSize :: Proxy Note -> ByteCount
StaticByteSized, Get Note
Note -> ByteCount
Note -> Put
(Note -> ByteCount) -> Get Note -> (Note -> Put) -> Binary Note
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Note -> ByteCount
byteSize :: Note -> ByteCount
$cget :: Get Note
get :: Get Note
$cput :: Note -> Put
put :: Note -> Put
Binary)

newtype Velocity = Velocity {Velocity -> MidiWord7
unVelocity :: MidiWord7}
  deriving stock (Int -> Velocity -> ShowS
[Velocity] -> ShowS
Velocity -> String
(Int -> Velocity -> ShowS)
-> (Velocity -> String) -> ([Velocity] -> ShowS) -> Show Velocity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Velocity -> ShowS
showsPrec :: Int -> Velocity -> ShowS
$cshow :: Velocity -> String
show :: Velocity -> String
$cshowList :: [Velocity] -> ShowS
showList :: [Velocity] -> ShowS
Show)
  deriving newtype
    (Velocity -> Velocity -> Bool
(Velocity -> Velocity -> Bool)
-> (Velocity -> Velocity -> Bool) -> Eq Velocity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Velocity -> Velocity -> Bool
== :: Velocity -> Velocity -> Bool
$c/= :: Velocity -> Velocity -> Bool
/= :: Velocity -> Velocity -> Bool
Eq, Eq Velocity
Eq Velocity =>
(Velocity -> Velocity -> Ordering)
-> (Velocity -> Velocity -> Bool)
-> (Velocity -> Velocity -> Bool)
-> (Velocity -> Velocity -> Bool)
-> (Velocity -> Velocity -> Bool)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> Ord Velocity
Velocity -> Velocity -> Bool
Velocity -> Velocity -> Ordering
Velocity -> Velocity -> Velocity
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
$ccompare :: Velocity -> Velocity -> Ordering
compare :: Velocity -> Velocity -> Ordering
$c< :: Velocity -> Velocity -> Bool
< :: Velocity -> Velocity -> Bool
$c<= :: Velocity -> Velocity -> Bool
<= :: Velocity -> Velocity -> Bool
$c> :: Velocity -> Velocity -> Bool
> :: Velocity -> Velocity -> Bool
$c>= :: Velocity -> Velocity -> Bool
>= :: Velocity -> Velocity -> Bool
$cmax :: Velocity -> Velocity -> Velocity
max :: Velocity -> Velocity -> Velocity
$cmin :: Velocity -> Velocity -> Velocity
min :: Velocity -> Velocity -> Velocity
Ord, Int -> Velocity
Velocity -> Int
Velocity -> [Velocity]
Velocity -> Velocity
Velocity -> Velocity -> [Velocity]
Velocity -> Velocity -> Velocity -> [Velocity]
(Velocity -> Velocity)
-> (Velocity -> Velocity)
-> (Int -> Velocity)
-> (Velocity -> Int)
-> (Velocity -> [Velocity])
-> (Velocity -> Velocity -> [Velocity])
-> (Velocity -> Velocity -> [Velocity])
-> (Velocity -> Velocity -> Velocity -> [Velocity])
-> Enum Velocity
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Velocity -> Velocity
succ :: Velocity -> Velocity
$cpred :: Velocity -> Velocity
pred :: Velocity -> Velocity
$ctoEnum :: Int -> Velocity
toEnum :: Int -> Velocity
$cfromEnum :: Velocity -> Int
fromEnum :: Velocity -> Int
$cenumFrom :: Velocity -> [Velocity]
enumFrom :: Velocity -> [Velocity]
$cenumFromThen :: Velocity -> Velocity -> [Velocity]
enumFromThen :: Velocity -> Velocity -> [Velocity]
$cenumFromTo :: Velocity -> Velocity -> [Velocity]
enumFromTo :: Velocity -> Velocity -> [Velocity]
$cenumFromThenTo :: Velocity -> Velocity -> Velocity -> [Velocity]
enumFromThenTo :: Velocity -> Velocity -> Velocity -> [Velocity]
Enum, Integer -> Velocity
Velocity -> Velocity
Velocity -> Velocity -> Velocity
(Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity)
-> (Velocity -> Velocity)
-> (Velocity -> Velocity)
-> (Integer -> Velocity)
-> Num Velocity
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Velocity -> Velocity -> Velocity
+ :: Velocity -> Velocity -> Velocity
$c- :: Velocity -> Velocity -> Velocity
- :: Velocity -> Velocity -> Velocity
$c* :: Velocity -> Velocity -> Velocity
* :: Velocity -> Velocity -> Velocity
$cnegate :: Velocity -> Velocity
negate :: Velocity -> Velocity
$cabs :: Velocity -> Velocity
abs :: Velocity -> Velocity
$csignum :: Velocity -> Velocity
signum :: Velocity -> Velocity
$cfromInteger :: Integer -> Velocity
fromInteger :: Integer -> Velocity
Num, Num Velocity
Ord Velocity
(Num Velocity, Ord Velocity) =>
(Velocity -> Rational) -> Real Velocity
Velocity -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Velocity -> Rational
toRational :: Velocity -> Rational
Real, Enum Velocity
Real Velocity
(Real Velocity, Enum Velocity) =>
(Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> Velocity)
-> (Velocity -> Velocity -> (Velocity, Velocity))
-> (Velocity -> Velocity -> (Velocity, Velocity))
-> (Velocity -> Integer)
-> Integral Velocity
Velocity -> Integer
Velocity -> Velocity -> (Velocity, Velocity)
Velocity -> Velocity -> Velocity
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Velocity -> Velocity -> Velocity
quot :: Velocity -> Velocity -> Velocity
$crem :: Velocity -> Velocity -> Velocity
rem :: Velocity -> Velocity -> Velocity
$cdiv :: Velocity -> Velocity -> Velocity
div :: Velocity -> Velocity -> Velocity
$cmod :: Velocity -> Velocity -> Velocity
mod :: Velocity -> Velocity -> Velocity
$cquotRem :: Velocity -> Velocity -> (Velocity, Velocity)
quotRem :: Velocity -> Velocity -> (Velocity, Velocity)
$cdivMod :: Velocity -> Velocity -> (Velocity, Velocity)
divMod :: Velocity -> Velocity -> (Velocity, Velocity)
$ctoInteger :: Velocity -> Integer
toInteger :: Velocity -> Integer
Integral, Eq Velocity
Eq Velocity =>
(Int -> Velocity -> Int) -> (Velocity -> Int) -> Hashable Velocity
Int -> Velocity -> Int
Velocity -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Velocity -> Int
hashWithSalt :: Int -> Velocity -> Int
$chash :: Velocity -> Int
hash :: Velocity -> Int
Hashable, KnownNat (StaticSize Velocity)
KnownNat (StaticSize Velocity) =>
(Proxy Velocity -> ByteCount) -> StaticByteSized Velocity
Proxy Velocity -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Velocity -> ByteCount
staticByteSize :: Proxy Velocity -> ByteCount
StaticByteSized, Get Velocity
Velocity -> ByteCount
Velocity -> Put
(Velocity -> ByteCount)
-> Get Velocity -> (Velocity -> Put) -> Binary Velocity
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Velocity -> ByteCount
byteSize :: Velocity -> ByteCount
$cget :: Get Velocity
get :: Get Velocity
$cput :: Velocity -> Put
put :: Velocity -> Put
Binary)

newtype ControlNum = ControlNum {ControlNum -> MidiWord7
unControlNum :: MidiWord7}
  deriving stock (Int -> ControlNum -> ShowS
[ControlNum] -> ShowS
ControlNum -> String
(Int -> ControlNum -> ShowS)
-> (ControlNum -> String)
-> ([ControlNum] -> ShowS)
-> Show ControlNum
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ControlNum -> ShowS
showsPrec :: Int -> ControlNum -> ShowS
$cshow :: ControlNum -> String
show :: ControlNum -> String
$cshowList :: [ControlNum] -> ShowS
showList :: [ControlNum] -> ShowS
Show)
  deriving newtype
    (ControlNum -> ControlNum -> Bool
(ControlNum -> ControlNum -> Bool)
-> (ControlNum -> ControlNum -> Bool) -> Eq ControlNum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ControlNum -> ControlNum -> Bool
== :: ControlNum -> ControlNum -> Bool
$c/= :: ControlNum -> ControlNum -> Bool
/= :: ControlNum -> ControlNum -> Bool
Eq, Eq ControlNum
Eq ControlNum =>
(ControlNum -> ControlNum -> Ordering)
-> (ControlNum -> ControlNum -> Bool)
-> (ControlNum -> ControlNum -> Bool)
-> (ControlNum -> ControlNum -> Bool)
-> (ControlNum -> ControlNum -> Bool)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> Ord ControlNum
ControlNum -> ControlNum -> Bool
ControlNum -> ControlNum -> Ordering
ControlNum -> ControlNum -> ControlNum
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
$ccompare :: ControlNum -> ControlNum -> Ordering
compare :: ControlNum -> ControlNum -> Ordering
$c< :: ControlNum -> ControlNum -> Bool
< :: ControlNum -> ControlNum -> Bool
$c<= :: ControlNum -> ControlNum -> Bool
<= :: ControlNum -> ControlNum -> Bool
$c> :: ControlNum -> ControlNum -> Bool
> :: ControlNum -> ControlNum -> Bool
$c>= :: ControlNum -> ControlNum -> Bool
>= :: ControlNum -> ControlNum -> Bool
$cmax :: ControlNum -> ControlNum -> ControlNum
max :: ControlNum -> ControlNum -> ControlNum
$cmin :: ControlNum -> ControlNum -> ControlNum
min :: ControlNum -> ControlNum -> ControlNum
Ord, Int -> ControlNum
ControlNum -> Int
ControlNum -> [ControlNum]
ControlNum -> ControlNum
ControlNum -> ControlNum -> [ControlNum]
ControlNum -> ControlNum -> ControlNum -> [ControlNum]
(ControlNum -> ControlNum)
-> (ControlNum -> ControlNum)
-> (Int -> ControlNum)
-> (ControlNum -> Int)
-> (ControlNum -> [ControlNum])
-> (ControlNum -> ControlNum -> [ControlNum])
-> (ControlNum -> ControlNum -> [ControlNum])
-> (ControlNum -> ControlNum -> ControlNum -> [ControlNum])
-> Enum ControlNum
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ControlNum -> ControlNum
succ :: ControlNum -> ControlNum
$cpred :: ControlNum -> ControlNum
pred :: ControlNum -> ControlNum
$ctoEnum :: Int -> ControlNum
toEnum :: Int -> ControlNum
$cfromEnum :: ControlNum -> Int
fromEnum :: ControlNum -> Int
$cenumFrom :: ControlNum -> [ControlNum]
enumFrom :: ControlNum -> [ControlNum]
$cenumFromThen :: ControlNum -> ControlNum -> [ControlNum]
enumFromThen :: ControlNum -> ControlNum -> [ControlNum]
$cenumFromTo :: ControlNum -> ControlNum -> [ControlNum]
enumFromTo :: ControlNum -> ControlNum -> [ControlNum]
$cenumFromThenTo :: ControlNum -> ControlNum -> ControlNum -> [ControlNum]
enumFromThenTo :: ControlNum -> ControlNum -> ControlNum -> [ControlNum]
Enum, Integer -> ControlNum
ControlNum -> ControlNum
ControlNum -> ControlNum -> ControlNum
(ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum)
-> (ControlNum -> ControlNum)
-> (ControlNum -> ControlNum)
-> (Integer -> ControlNum)
-> Num ControlNum
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ControlNum -> ControlNum -> ControlNum
+ :: ControlNum -> ControlNum -> ControlNum
$c- :: ControlNum -> ControlNum -> ControlNum
- :: ControlNum -> ControlNum -> ControlNum
$c* :: ControlNum -> ControlNum -> ControlNum
* :: ControlNum -> ControlNum -> ControlNum
$cnegate :: ControlNum -> ControlNum
negate :: ControlNum -> ControlNum
$cabs :: ControlNum -> ControlNum
abs :: ControlNum -> ControlNum
$csignum :: ControlNum -> ControlNum
signum :: ControlNum -> ControlNum
$cfromInteger :: Integer -> ControlNum
fromInteger :: Integer -> ControlNum
Num, Num ControlNum
Ord ControlNum
(Num ControlNum, Ord ControlNum) =>
(ControlNum -> Rational) -> Real ControlNum
ControlNum -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ControlNum -> Rational
toRational :: ControlNum -> Rational
Real, Enum ControlNum
Real ControlNum
(Real ControlNum, Enum ControlNum) =>
(ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> ControlNum)
-> (ControlNum -> ControlNum -> (ControlNum, ControlNum))
-> (ControlNum -> ControlNum -> (ControlNum, ControlNum))
-> (ControlNum -> Integer)
-> Integral ControlNum
ControlNum -> Integer
ControlNum -> ControlNum -> (ControlNum, ControlNum)
ControlNum -> ControlNum -> ControlNum
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ControlNum -> ControlNum -> ControlNum
quot :: ControlNum -> ControlNum -> ControlNum
$crem :: ControlNum -> ControlNum -> ControlNum
rem :: ControlNum -> ControlNum -> ControlNum
$cdiv :: ControlNum -> ControlNum -> ControlNum
div :: ControlNum -> ControlNum -> ControlNum
$cmod :: ControlNum -> ControlNum -> ControlNum
mod :: ControlNum -> ControlNum -> ControlNum
$cquotRem :: ControlNum -> ControlNum -> (ControlNum, ControlNum)
quotRem :: ControlNum -> ControlNum -> (ControlNum, ControlNum)
$cdivMod :: ControlNum -> ControlNum -> (ControlNum, ControlNum)
divMod :: ControlNum -> ControlNum -> (ControlNum, ControlNum)
$ctoInteger :: ControlNum -> Integer
toInteger :: ControlNum -> Integer
Integral, Eq ControlNum
Eq ControlNum =>
(Int -> ControlNum -> Int)
-> (ControlNum -> Int) -> Hashable ControlNum
Int -> ControlNum -> Int
ControlNum -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ControlNum -> Int
hashWithSalt :: Int -> ControlNum -> Int
$chash :: ControlNum -> Int
hash :: ControlNum -> Int
Hashable, KnownNat (StaticSize ControlNum)
KnownNat (StaticSize ControlNum) =>
(Proxy ControlNum -> ByteCount) -> StaticByteSized ControlNum
Proxy ControlNum -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy ControlNum -> ByteCount
staticByteSize :: Proxy ControlNum -> ByteCount
StaticByteSized, Get ControlNum
ControlNum -> ByteCount
ControlNum -> Put
(ControlNum -> ByteCount)
-> Get ControlNum -> (ControlNum -> Put) -> Binary ControlNum
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: ControlNum -> ByteCount
byteSize :: ControlNum -> ByteCount
$cget :: Get ControlNum
get :: Get ControlNum
$cput :: ControlNum -> Put
put :: ControlNum -> Put
Binary)

newtype ControlVal = ControlVal {ControlVal -> MidiWord7
unControlVal :: MidiWord7}
  deriving stock (Int -> ControlVal -> ShowS
[ControlVal] -> ShowS
ControlVal -> String
(Int -> ControlVal -> ShowS)
-> (ControlVal -> String)
-> ([ControlVal] -> ShowS)
-> Show ControlVal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ControlVal -> ShowS
showsPrec :: Int -> ControlVal -> ShowS
$cshow :: ControlVal -> String
show :: ControlVal -> String
$cshowList :: [ControlVal] -> ShowS
showList :: [ControlVal] -> ShowS
Show)
  deriving newtype
    (ControlVal -> ControlVal -> Bool
(ControlVal -> ControlVal -> Bool)
-> (ControlVal -> ControlVal -> Bool) -> Eq ControlVal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ControlVal -> ControlVal -> Bool
== :: ControlVal -> ControlVal -> Bool
$c/= :: ControlVal -> ControlVal -> Bool
/= :: ControlVal -> ControlVal -> Bool
Eq, Eq ControlVal
Eq ControlVal =>
(ControlVal -> ControlVal -> Ordering)
-> (ControlVal -> ControlVal -> Bool)
-> (ControlVal -> ControlVal -> Bool)
-> (ControlVal -> ControlVal -> Bool)
-> (ControlVal -> ControlVal -> Bool)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> Ord ControlVal
ControlVal -> ControlVal -> Bool
ControlVal -> ControlVal -> Ordering
ControlVal -> ControlVal -> ControlVal
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
$ccompare :: ControlVal -> ControlVal -> Ordering
compare :: ControlVal -> ControlVal -> Ordering
$c< :: ControlVal -> ControlVal -> Bool
< :: ControlVal -> ControlVal -> Bool
$c<= :: ControlVal -> ControlVal -> Bool
<= :: ControlVal -> ControlVal -> Bool
$c> :: ControlVal -> ControlVal -> Bool
> :: ControlVal -> ControlVal -> Bool
$c>= :: ControlVal -> ControlVal -> Bool
>= :: ControlVal -> ControlVal -> Bool
$cmax :: ControlVal -> ControlVal -> ControlVal
max :: ControlVal -> ControlVal -> ControlVal
$cmin :: ControlVal -> ControlVal -> ControlVal
min :: ControlVal -> ControlVal -> ControlVal
Ord, Int -> ControlVal
ControlVal -> Int
ControlVal -> [ControlVal]
ControlVal -> ControlVal
ControlVal -> ControlVal -> [ControlVal]
ControlVal -> ControlVal -> ControlVal -> [ControlVal]
(ControlVal -> ControlVal)
-> (ControlVal -> ControlVal)
-> (Int -> ControlVal)
-> (ControlVal -> Int)
-> (ControlVal -> [ControlVal])
-> (ControlVal -> ControlVal -> [ControlVal])
-> (ControlVal -> ControlVal -> [ControlVal])
-> (ControlVal -> ControlVal -> ControlVal -> [ControlVal])
-> Enum ControlVal
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ControlVal -> ControlVal
succ :: ControlVal -> ControlVal
$cpred :: ControlVal -> ControlVal
pred :: ControlVal -> ControlVal
$ctoEnum :: Int -> ControlVal
toEnum :: Int -> ControlVal
$cfromEnum :: ControlVal -> Int
fromEnum :: ControlVal -> Int
$cenumFrom :: ControlVal -> [ControlVal]
enumFrom :: ControlVal -> [ControlVal]
$cenumFromThen :: ControlVal -> ControlVal -> [ControlVal]
enumFromThen :: ControlVal -> ControlVal -> [ControlVal]
$cenumFromTo :: ControlVal -> ControlVal -> [ControlVal]
enumFromTo :: ControlVal -> ControlVal -> [ControlVal]
$cenumFromThenTo :: ControlVal -> ControlVal -> ControlVal -> [ControlVal]
enumFromThenTo :: ControlVal -> ControlVal -> ControlVal -> [ControlVal]
Enum, Integer -> ControlVal
ControlVal -> ControlVal
ControlVal -> ControlVal -> ControlVal
(ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal)
-> (ControlVal -> ControlVal)
-> (ControlVal -> ControlVal)
-> (Integer -> ControlVal)
-> Num ControlVal
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ControlVal -> ControlVal -> ControlVal
+ :: ControlVal -> ControlVal -> ControlVal
$c- :: ControlVal -> ControlVal -> ControlVal
- :: ControlVal -> ControlVal -> ControlVal
$c* :: ControlVal -> ControlVal -> ControlVal
* :: ControlVal -> ControlVal -> ControlVal
$cnegate :: ControlVal -> ControlVal
negate :: ControlVal -> ControlVal
$cabs :: ControlVal -> ControlVal
abs :: ControlVal -> ControlVal
$csignum :: ControlVal -> ControlVal
signum :: ControlVal -> ControlVal
$cfromInteger :: Integer -> ControlVal
fromInteger :: Integer -> ControlVal
Num, Num ControlVal
Ord ControlVal
(Num ControlVal, Ord ControlVal) =>
(ControlVal -> Rational) -> Real ControlVal
ControlVal -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ControlVal -> Rational
toRational :: ControlVal -> Rational
Real, Enum ControlVal
Real ControlVal
(Real ControlVal, Enum ControlVal) =>
(ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> ControlVal)
-> (ControlVal -> ControlVal -> (ControlVal, ControlVal))
-> (ControlVal -> ControlVal -> (ControlVal, ControlVal))
-> (ControlVal -> Integer)
-> Integral ControlVal
ControlVal -> Integer
ControlVal -> ControlVal -> (ControlVal, ControlVal)
ControlVal -> ControlVal -> ControlVal
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ControlVal -> ControlVal -> ControlVal
quot :: ControlVal -> ControlVal -> ControlVal
$crem :: ControlVal -> ControlVal -> ControlVal
rem :: ControlVal -> ControlVal -> ControlVal
$cdiv :: ControlVal -> ControlVal -> ControlVal
div :: ControlVal -> ControlVal -> ControlVal
$cmod :: ControlVal -> ControlVal -> ControlVal
mod :: ControlVal -> ControlVal -> ControlVal
$cquotRem :: ControlVal -> ControlVal -> (ControlVal, ControlVal)
quotRem :: ControlVal -> ControlVal -> (ControlVal, ControlVal)
$cdivMod :: ControlVal -> ControlVal -> (ControlVal, ControlVal)
divMod :: ControlVal -> ControlVal -> (ControlVal, ControlVal)
$ctoInteger :: ControlVal -> Integer
toInteger :: ControlVal -> Integer
Integral, Eq ControlVal
Eq ControlVal =>
(Int -> ControlVal -> Int)
-> (ControlVal -> Int) -> Hashable ControlVal
Int -> ControlVal -> Int
ControlVal -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ControlVal -> Int
hashWithSalt :: Int -> ControlVal -> Int
$chash :: ControlVal -> Int
hash :: ControlVal -> Int
Hashable, KnownNat (StaticSize ControlVal)
KnownNat (StaticSize ControlVal) =>
(Proxy ControlVal -> ByteCount) -> StaticByteSized ControlVal
Proxy ControlVal -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy ControlVal -> ByteCount
staticByteSize :: Proxy ControlVal -> ByteCount
StaticByteSized, Get ControlVal
ControlVal -> ByteCount
ControlVal -> Put
(ControlVal -> ByteCount)
-> Get ControlVal -> (ControlVal -> Put) -> Binary ControlVal
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: ControlVal -> ByteCount
byteSize :: ControlVal -> ByteCount
$cget :: Get ControlVal
get :: Get ControlVal
$cput :: ControlVal -> Put
put :: ControlVal -> Put
Binary)

newtype Pressure = Pressure {Pressure -> MidiWord7
unPressure :: MidiWord7}
  deriving stock (Int -> Pressure -> ShowS
[Pressure] -> ShowS
Pressure -> String
(Int -> Pressure -> ShowS)
-> (Pressure -> String) -> ([Pressure] -> ShowS) -> Show Pressure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pressure -> ShowS
showsPrec :: Int -> Pressure -> ShowS
$cshow :: Pressure -> String
show :: Pressure -> String
$cshowList :: [Pressure] -> ShowS
showList :: [Pressure] -> ShowS
Show)
  deriving newtype
    (Pressure -> Pressure -> Bool
(Pressure -> Pressure -> Bool)
-> (Pressure -> Pressure -> Bool) -> Eq Pressure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pressure -> Pressure -> Bool
== :: Pressure -> Pressure -> Bool
$c/= :: Pressure -> Pressure -> Bool
/= :: Pressure -> Pressure -> Bool
Eq, Eq Pressure
Eq Pressure =>
(Pressure -> Pressure -> Ordering)
-> (Pressure -> Pressure -> Bool)
-> (Pressure -> Pressure -> Bool)
-> (Pressure -> Pressure -> Bool)
-> (Pressure -> Pressure -> Bool)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> Ord Pressure
Pressure -> Pressure -> Bool
Pressure -> Pressure -> Ordering
Pressure -> Pressure -> Pressure
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
$ccompare :: Pressure -> Pressure -> Ordering
compare :: Pressure -> Pressure -> Ordering
$c< :: Pressure -> Pressure -> Bool
< :: Pressure -> Pressure -> Bool
$c<= :: Pressure -> Pressure -> Bool
<= :: Pressure -> Pressure -> Bool
$c> :: Pressure -> Pressure -> Bool
> :: Pressure -> Pressure -> Bool
$c>= :: Pressure -> Pressure -> Bool
>= :: Pressure -> Pressure -> Bool
$cmax :: Pressure -> Pressure -> Pressure
max :: Pressure -> Pressure -> Pressure
$cmin :: Pressure -> Pressure -> Pressure
min :: Pressure -> Pressure -> Pressure
Ord, Int -> Pressure
Pressure -> Int
Pressure -> [Pressure]
Pressure -> Pressure
Pressure -> Pressure -> [Pressure]
Pressure -> Pressure -> Pressure -> [Pressure]
(Pressure -> Pressure)
-> (Pressure -> Pressure)
-> (Int -> Pressure)
-> (Pressure -> Int)
-> (Pressure -> [Pressure])
-> (Pressure -> Pressure -> [Pressure])
-> (Pressure -> Pressure -> [Pressure])
-> (Pressure -> Pressure -> Pressure -> [Pressure])
-> Enum Pressure
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Pressure -> Pressure
succ :: Pressure -> Pressure
$cpred :: Pressure -> Pressure
pred :: Pressure -> Pressure
$ctoEnum :: Int -> Pressure
toEnum :: Int -> Pressure
$cfromEnum :: Pressure -> Int
fromEnum :: Pressure -> Int
$cenumFrom :: Pressure -> [Pressure]
enumFrom :: Pressure -> [Pressure]
$cenumFromThen :: Pressure -> Pressure -> [Pressure]
enumFromThen :: Pressure -> Pressure -> [Pressure]
$cenumFromTo :: Pressure -> Pressure -> [Pressure]
enumFromTo :: Pressure -> Pressure -> [Pressure]
$cenumFromThenTo :: Pressure -> Pressure -> Pressure -> [Pressure]
enumFromThenTo :: Pressure -> Pressure -> Pressure -> [Pressure]
Enum, Integer -> Pressure
Pressure -> Pressure
Pressure -> Pressure -> Pressure
(Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure)
-> (Pressure -> Pressure)
-> (Pressure -> Pressure)
-> (Integer -> Pressure)
-> Num Pressure
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Pressure -> Pressure -> Pressure
+ :: Pressure -> Pressure -> Pressure
$c- :: Pressure -> Pressure -> Pressure
- :: Pressure -> Pressure -> Pressure
$c* :: Pressure -> Pressure -> Pressure
* :: Pressure -> Pressure -> Pressure
$cnegate :: Pressure -> Pressure
negate :: Pressure -> Pressure
$cabs :: Pressure -> Pressure
abs :: Pressure -> Pressure
$csignum :: Pressure -> Pressure
signum :: Pressure -> Pressure
$cfromInteger :: Integer -> Pressure
fromInteger :: Integer -> Pressure
Num, Num Pressure
Ord Pressure
(Num Pressure, Ord Pressure) =>
(Pressure -> Rational) -> Real Pressure
Pressure -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Pressure -> Rational
toRational :: Pressure -> Rational
Real, Enum Pressure
Real Pressure
(Real Pressure, Enum Pressure) =>
(Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> Pressure)
-> (Pressure -> Pressure -> (Pressure, Pressure))
-> (Pressure -> Pressure -> (Pressure, Pressure))
-> (Pressure -> Integer)
-> Integral Pressure
Pressure -> Integer
Pressure -> Pressure -> (Pressure, Pressure)
Pressure -> Pressure -> Pressure
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Pressure -> Pressure -> Pressure
quot :: Pressure -> Pressure -> Pressure
$crem :: Pressure -> Pressure -> Pressure
rem :: Pressure -> Pressure -> Pressure
$cdiv :: Pressure -> Pressure -> Pressure
div :: Pressure -> Pressure -> Pressure
$cmod :: Pressure -> Pressure -> Pressure
mod :: Pressure -> Pressure -> Pressure
$cquotRem :: Pressure -> Pressure -> (Pressure, Pressure)
quotRem :: Pressure -> Pressure -> (Pressure, Pressure)
$cdivMod :: Pressure -> Pressure -> (Pressure, Pressure)
divMod :: Pressure -> Pressure -> (Pressure, Pressure)
$ctoInteger :: Pressure -> Integer
toInteger :: Pressure -> Integer
Integral, Eq Pressure
Eq Pressure =>
(Int -> Pressure -> Int) -> (Pressure -> Int) -> Hashable Pressure
Int -> Pressure -> Int
Pressure -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Pressure -> Int
hashWithSalt :: Int -> Pressure -> Int
$chash :: Pressure -> Int
hash :: Pressure -> Int
Hashable, KnownNat (StaticSize Pressure)
KnownNat (StaticSize Pressure) =>
(Proxy Pressure -> ByteCount) -> StaticByteSized Pressure
Proxy Pressure -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Pressure -> ByteCount
staticByteSize :: Proxy Pressure -> ByteCount
StaticByteSized, Get Pressure
Pressure -> ByteCount
Pressure -> Put
(Pressure -> ByteCount)
-> Get Pressure -> (Pressure -> Put) -> Binary Pressure
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Pressure -> ByteCount
byteSize :: Pressure -> ByteCount
$cget :: Get Pressure
get :: Get Pressure
$cput :: Pressure -> Put
put :: Pressure -> Put
Binary)

newtype ProgramNum = ProgramNum {ProgramNum -> MidiWord7
unProgramNum :: MidiWord7}
  deriving stock (Int -> ProgramNum -> ShowS
[ProgramNum] -> ShowS
ProgramNum -> String
(Int -> ProgramNum -> ShowS)
-> (ProgramNum -> String)
-> ([ProgramNum] -> ShowS)
-> Show ProgramNum
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProgramNum -> ShowS
showsPrec :: Int -> ProgramNum -> ShowS
$cshow :: ProgramNum -> String
show :: ProgramNum -> String
$cshowList :: [ProgramNum] -> ShowS
showList :: [ProgramNum] -> ShowS
Show)
  deriving newtype
    (ProgramNum -> ProgramNum -> Bool
(ProgramNum -> ProgramNum -> Bool)
-> (ProgramNum -> ProgramNum -> Bool) -> Eq ProgramNum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProgramNum -> ProgramNum -> Bool
== :: ProgramNum -> ProgramNum -> Bool
$c/= :: ProgramNum -> ProgramNum -> Bool
/= :: ProgramNum -> ProgramNum -> Bool
Eq, Eq ProgramNum
Eq ProgramNum =>
(ProgramNum -> ProgramNum -> Ordering)
-> (ProgramNum -> ProgramNum -> Bool)
-> (ProgramNum -> ProgramNum -> Bool)
-> (ProgramNum -> ProgramNum -> Bool)
-> (ProgramNum -> ProgramNum -> Bool)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> Ord ProgramNum
ProgramNum -> ProgramNum -> Bool
ProgramNum -> ProgramNum -> Ordering
ProgramNum -> ProgramNum -> ProgramNum
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
$ccompare :: ProgramNum -> ProgramNum -> Ordering
compare :: ProgramNum -> ProgramNum -> Ordering
$c< :: ProgramNum -> ProgramNum -> Bool
< :: ProgramNum -> ProgramNum -> Bool
$c<= :: ProgramNum -> ProgramNum -> Bool
<= :: ProgramNum -> ProgramNum -> Bool
$c> :: ProgramNum -> ProgramNum -> Bool
> :: ProgramNum -> ProgramNum -> Bool
$c>= :: ProgramNum -> ProgramNum -> Bool
>= :: ProgramNum -> ProgramNum -> Bool
$cmax :: ProgramNum -> ProgramNum -> ProgramNum
max :: ProgramNum -> ProgramNum -> ProgramNum
$cmin :: ProgramNum -> ProgramNum -> ProgramNum
min :: ProgramNum -> ProgramNum -> ProgramNum
Ord, Int -> ProgramNum
ProgramNum -> Int
ProgramNum -> [ProgramNum]
ProgramNum -> ProgramNum
ProgramNum -> ProgramNum -> [ProgramNum]
ProgramNum -> ProgramNum -> ProgramNum -> [ProgramNum]
(ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum)
-> (Int -> ProgramNum)
-> (ProgramNum -> Int)
-> (ProgramNum -> [ProgramNum])
-> (ProgramNum -> ProgramNum -> [ProgramNum])
-> (ProgramNum -> ProgramNum -> [ProgramNum])
-> (ProgramNum -> ProgramNum -> ProgramNum -> [ProgramNum])
-> Enum ProgramNum
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ProgramNum -> ProgramNum
succ :: ProgramNum -> ProgramNum
$cpred :: ProgramNum -> ProgramNum
pred :: ProgramNum -> ProgramNum
$ctoEnum :: Int -> ProgramNum
toEnum :: Int -> ProgramNum
$cfromEnum :: ProgramNum -> Int
fromEnum :: ProgramNum -> Int
$cenumFrom :: ProgramNum -> [ProgramNum]
enumFrom :: ProgramNum -> [ProgramNum]
$cenumFromThen :: ProgramNum -> ProgramNum -> [ProgramNum]
enumFromThen :: ProgramNum -> ProgramNum -> [ProgramNum]
$cenumFromTo :: ProgramNum -> ProgramNum -> [ProgramNum]
enumFromTo :: ProgramNum -> ProgramNum -> [ProgramNum]
$cenumFromThenTo :: ProgramNum -> ProgramNum -> ProgramNum -> [ProgramNum]
enumFromThenTo :: ProgramNum -> ProgramNum -> ProgramNum -> [ProgramNum]
Enum, Integer -> ProgramNum
ProgramNum -> ProgramNum
ProgramNum -> ProgramNum -> ProgramNum
(ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum)
-> (Integer -> ProgramNum)
-> Num ProgramNum
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ProgramNum -> ProgramNum -> ProgramNum
+ :: ProgramNum -> ProgramNum -> ProgramNum
$c- :: ProgramNum -> ProgramNum -> ProgramNum
- :: ProgramNum -> ProgramNum -> ProgramNum
$c* :: ProgramNum -> ProgramNum -> ProgramNum
* :: ProgramNum -> ProgramNum -> ProgramNum
$cnegate :: ProgramNum -> ProgramNum
negate :: ProgramNum -> ProgramNum
$cabs :: ProgramNum -> ProgramNum
abs :: ProgramNum -> ProgramNum
$csignum :: ProgramNum -> ProgramNum
signum :: ProgramNum -> ProgramNum
$cfromInteger :: Integer -> ProgramNum
fromInteger :: Integer -> ProgramNum
Num, Num ProgramNum
Ord ProgramNum
(Num ProgramNum, Ord ProgramNum) =>
(ProgramNum -> Rational) -> Real ProgramNum
ProgramNum -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ProgramNum -> Rational
toRational :: ProgramNum -> Rational
Real, Enum ProgramNum
Real ProgramNum
(Real ProgramNum, Enum ProgramNum) =>
(ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> ProgramNum)
-> (ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum))
-> (ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum))
-> (ProgramNum -> Integer)
-> Integral ProgramNum
ProgramNum -> Integer
ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum)
ProgramNum -> ProgramNum -> ProgramNum
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ProgramNum -> ProgramNum -> ProgramNum
quot :: ProgramNum -> ProgramNum -> ProgramNum
$crem :: ProgramNum -> ProgramNum -> ProgramNum
rem :: ProgramNum -> ProgramNum -> ProgramNum
$cdiv :: ProgramNum -> ProgramNum -> ProgramNum
div :: ProgramNum -> ProgramNum -> ProgramNum
$cmod :: ProgramNum -> ProgramNum -> ProgramNum
mod :: ProgramNum -> ProgramNum -> ProgramNum
$cquotRem :: ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum)
quotRem :: ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum)
$cdivMod :: ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum)
divMod :: ProgramNum -> ProgramNum -> (ProgramNum, ProgramNum)
$ctoInteger :: ProgramNum -> Integer
toInteger :: ProgramNum -> Integer
Integral, Eq ProgramNum
Eq ProgramNum =>
(Int -> ProgramNum -> Int)
-> (ProgramNum -> Int) -> Hashable ProgramNum
Int -> ProgramNum -> Int
ProgramNum -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ProgramNum -> Int
hashWithSalt :: Int -> ProgramNum -> Int
$chash :: ProgramNum -> Int
hash :: ProgramNum -> Int
Hashable, KnownNat (StaticSize ProgramNum)
KnownNat (StaticSize ProgramNum) =>
(Proxy ProgramNum -> ByteCount) -> StaticByteSized ProgramNum
Proxy ProgramNum -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy ProgramNum -> ByteCount
staticByteSize :: Proxy ProgramNum -> ByteCount
StaticByteSized, Get ProgramNum
ProgramNum -> ByteCount
ProgramNum -> Put
(ProgramNum -> ByteCount)
-> Get ProgramNum -> (ProgramNum -> Put) -> Binary ProgramNum
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: ProgramNum -> ByteCount
byteSize :: ProgramNum -> ByteCount
$cget :: Get ProgramNum
get :: Get ProgramNum
$cput :: ProgramNum -> Put
put :: ProgramNum -> Put
Binary)

newtype PitchBend = PitchBend {PitchBend -> MidiInt14
unPitchBend :: MidiInt14}
  deriving stock (Int -> PitchBend -> ShowS
[PitchBend] -> ShowS
PitchBend -> String
(Int -> PitchBend -> ShowS)
-> (PitchBend -> String)
-> ([PitchBend] -> ShowS)
-> Show PitchBend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PitchBend -> ShowS
showsPrec :: Int -> PitchBend -> ShowS
$cshow :: PitchBend -> String
show :: PitchBend -> String
$cshowList :: [PitchBend] -> ShowS
showList :: [PitchBend] -> ShowS
Show)
  deriving newtype
    (PitchBend -> PitchBend -> Bool
(PitchBend -> PitchBend -> Bool)
-> (PitchBend -> PitchBend -> Bool) -> Eq PitchBend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PitchBend -> PitchBend -> Bool
== :: PitchBend -> PitchBend -> Bool
$c/= :: PitchBend -> PitchBend -> Bool
/= :: PitchBend -> PitchBend -> Bool
Eq, Eq PitchBend
Eq PitchBend =>
(PitchBend -> PitchBend -> Ordering)
-> (PitchBend -> PitchBend -> Bool)
-> (PitchBend -> PitchBend -> Bool)
-> (PitchBend -> PitchBend -> Bool)
-> (PitchBend -> PitchBend -> Bool)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> Ord PitchBend
PitchBend -> PitchBend -> Bool
PitchBend -> PitchBend -> Ordering
PitchBend -> PitchBend -> PitchBend
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
$ccompare :: PitchBend -> PitchBend -> Ordering
compare :: PitchBend -> PitchBend -> Ordering
$c< :: PitchBend -> PitchBend -> Bool
< :: PitchBend -> PitchBend -> Bool
$c<= :: PitchBend -> PitchBend -> Bool
<= :: PitchBend -> PitchBend -> Bool
$c> :: PitchBend -> PitchBend -> Bool
> :: PitchBend -> PitchBend -> Bool
$c>= :: PitchBend -> PitchBend -> Bool
>= :: PitchBend -> PitchBend -> Bool
$cmax :: PitchBend -> PitchBend -> PitchBend
max :: PitchBend -> PitchBend -> PitchBend
$cmin :: PitchBend -> PitchBend -> PitchBend
min :: PitchBend -> PitchBend -> PitchBend
Ord, Int -> PitchBend
PitchBend -> Int
PitchBend -> [PitchBend]
PitchBend -> PitchBend
PitchBend -> PitchBend -> [PitchBend]
PitchBend -> PitchBend -> PitchBend -> [PitchBend]
(PitchBend -> PitchBend)
-> (PitchBend -> PitchBend)
-> (Int -> PitchBend)
-> (PitchBend -> Int)
-> (PitchBend -> [PitchBend])
-> (PitchBend -> PitchBend -> [PitchBend])
-> (PitchBend -> PitchBend -> [PitchBend])
-> (PitchBend -> PitchBend -> PitchBend -> [PitchBend])
-> Enum PitchBend
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: PitchBend -> PitchBend
succ :: PitchBend -> PitchBend
$cpred :: PitchBend -> PitchBend
pred :: PitchBend -> PitchBend
$ctoEnum :: Int -> PitchBend
toEnum :: Int -> PitchBend
$cfromEnum :: PitchBend -> Int
fromEnum :: PitchBend -> Int
$cenumFrom :: PitchBend -> [PitchBend]
enumFrom :: PitchBend -> [PitchBend]
$cenumFromThen :: PitchBend -> PitchBend -> [PitchBend]
enumFromThen :: PitchBend -> PitchBend -> [PitchBend]
$cenumFromTo :: PitchBend -> PitchBend -> [PitchBend]
enumFromTo :: PitchBend -> PitchBend -> [PitchBend]
$cenumFromThenTo :: PitchBend -> PitchBend -> PitchBend -> [PitchBend]
enumFromThenTo :: PitchBend -> PitchBend -> PitchBend -> [PitchBend]
Enum, Integer -> PitchBend
PitchBend -> PitchBend
PitchBend -> PitchBend -> PitchBend
(PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend)
-> (PitchBend -> PitchBend)
-> (PitchBend -> PitchBend)
-> (Integer -> PitchBend)
-> Num PitchBend
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: PitchBend -> PitchBend -> PitchBend
+ :: PitchBend -> PitchBend -> PitchBend
$c- :: PitchBend -> PitchBend -> PitchBend
- :: PitchBend -> PitchBend -> PitchBend
$c* :: PitchBend -> PitchBend -> PitchBend
* :: PitchBend -> PitchBend -> PitchBend
$cnegate :: PitchBend -> PitchBend
negate :: PitchBend -> PitchBend
$cabs :: PitchBend -> PitchBend
abs :: PitchBend -> PitchBend
$csignum :: PitchBend -> PitchBend
signum :: PitchBend -> PitchBend
$cfromInteger :: Integer -> PitchBend
fromInteger :: Integer -> PitchBend
Num, Num PitchBend
Ord PitchBend
(Num PitchBend, Ord PitchBend) =>
(PitchBend -> Rational) -> Real PitchBend
PitchBend -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: PitchBend -> Rational
toRational :: PitchBend -> Rational
Real, Enum PitchBend
Real PitchBend
(Real PitchBend, Enum PitchBend) =>
(PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> PitchBend)
-> (PitchBend -> PitchBend -> (PitchBend, PitchBend))
-> (PitchBend -> PitchBend -> (PitchBend, PitchBend))
-> (PitchBend -> Integer)
-> Integral PitchBend
PitchBend -> Integer
PitchBend -> PitchBend -> (PitchBend, PitchBend)
PitchBend -> PitchBend -> PitchBend
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: PitchBend -> PitchBend -> PitchBend
quot :: PitchBend -> PitchBend -> PitchBend
$crem :: PitchBend -> PitchBend -> PitchBend
rem :: PitchBend -> PitchBend -> PitchBend
$cdiv :: PitchBend -> PitchBend -> PitchBend
div :: PitchBend -> PitchBend -> PitchBend
$cmod :: PitchBend -> PitchBend -> PitchBend
mod :: PitchBend -> PitchBend -> PitchBend
$cquotRem :: PitchBend -> PitchBend -> (PitchBend, PitchBend)
quotRem :: PitchBend -> PitchBend -> (PitchBend, PitchBend)
$cdivMod :: PitchBend -> PitchBend -> (PitchBend, PitchBend)
divMod :: PitchBend -> PitchBend -> (PitchBend, PitchBend)
$ctoInteger :: PitchBend -> Integer
toInteger :: PitchBend -> Integer
Integral, Eq PitchBend
Eq PitchBend =>
(Int -> PitchBend -> Int)
-> (PitchBend -> Int) -> Hashable PitchBend
Int -> PitchBend -> Int
PitchBend -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> PitchBend -> Int
hashWithSalt :: Int -> PitchBend -> Int
$chash :: PitchBend -> Int
hash :: PitchBend -> Int
Hashable, KnownNat (StaticSize PitchBend)
KnownNat (StaticSize PitchBend) =>
(Proxy PitchBend -> ByteCount) -> StaticByteSized PitchBend
Proxy PitchBend -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy PitchBend -> ByteCount
staticByteSize :: Proxy PitchBend -> ByteCount
StaticByteSized, Get PitchBend
PitchBend -> ByteCount
PitchBend -> Put
(PitchBend -> ByteCount)
-> Get PitchBend -> (PitchBend -> Put) -> Binary PitchBend
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: PitchBend -> ByteCount
byteSize :: PitchBend -> ByteCount
$cget :: Get PitchBend
get :: Get PitchBend
$cput :: PitchBend -> Put
put :: PitchBend -> Put
Binary)

newtype Song = Song {Song -> MidiWord7
unSong :: MidiWord7}
  deriving stock (Int -> Song -> ShowS
[Song] -> ShowS
Song -> String
(Int -> Song -> ShowS)
-> (Song -> String) -> ([Song] -> ShowS) -> Show Song
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Song -> ShowS
showsPrec :: Int -> Song -> ShowS
$cshow :: Song -> String
show :: Song -> String
$cshowList :: [Song] -> ShowS
showList :: [Song] -> ShowS
Show)
  deriving newtype
    (Song -> Song -> Bool
(Song -> Song -> Bool) -> (Song -> Song -> Bool) -> Eq Song
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Song -> Song -> Bool
== :: Song -> Song -> Bool
$c/= :: Song -> Song -> Bool
/= :: Song -> Song -> Bool
Eq, Eq Song
Eq Song =>
(Song -> Song -> Ordering)
-> (Song -> Song -> Bool)
-> (Song -> Song -> Bool)
-> (Song -> Song -> Bool)
-> (Song -> Song -> Bool)
-> (Song -> Song -> Song)
-> (Song -> Song -> Song)
-> Ord Song
Song -> Song -> Bool
Song -> Song -> Ordering
Song -> Song -> Song
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
$ccompare :: Song -> Song -> Ordering
compare :: Song -> Song -> Ordering
$c< :: Song -> Song -> Bool
< :: Song -> Song -> Bool
$c<= :: Song -> Song -> Bool
<= :: Song -> Song -> Bool
$c> :: Song -> Song -> Bool
> :: Song -> Song -> Bool
$c>= :: Song -> Song -> Bool
>= :: Song -> Song -> Bool
$cmax :: Song -> Song -> Song
max :: Song -> Song -> Song
$cmin :: Song -> Song -> Song
min :: Song -> Song -> Song
Ord, Int -> Song
Song -> Int
Song -> [Song]
Song -> Song
Song -> Song -> [Song]
Song -> Song -> Song -> [Song]
(Song -> Song)
-> (Song -> Song)
-> (Int -> Song)
-> (Song -> Int)
-> (Song -> [Song])
-> (Song -> Song -> [Song])
-> (Song -> Song -> [Song])
-> (Song -> Song -> Song -> [Song])
-> Enum Song
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Song -> Song
succ :: Song -> Song
$cpred :: Song -> Song
pred :: Song -> Song
$ctoEnum :: Int -> Song
toEnum :: Int -> Song
$cfromEnum :: Song -> Int
fromEnum :: Song -> Int
$cenumFrom :: Song -> [Song]
enumFrom :: Song -> [Song]
$cenumFromThen :: Song -> Song -> [Song]
enumFromThen :: Song -> Song -> [Song]
$cenumFromTo :: Song -> Song -> [Song]
enumFromTo :: Song -> Song -> [Song]
$cenumFromThenTo :: Song -> Song -> Song -> [Song]
enumFromThenTo :: Song -> Song -> Song -> [Song]
Enum, Integer -> Song
Song -> Song
Song -> Song -> Song
(Song -> Song -> Song)
-> (Song -> Song -> Song)
-> (Song -> Song -> Song)
-> (Song -> Song)
-> (Song -> Song)
-> (Song -> Song)
-> (Integer -> Song)
-> Num Song
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Song -> Song -> Song
+ :: Song -> Song -> Song
$c- :: Song -> Song -> Song
- :: Song -> Song -> Song
$c* :: Song -> Song -> Song
* :: Song -> Song -> Song
$cnegate :: Song -> Song
negate :: Song -> Song
$cabs :: Song -> Song
abs :: Song -> Song
$csignum :: Song -> Song
signum :: Song -> Song
$cfromInteger :: Integer -> Song
fromInteger :: Integer -> Song
Num, Num Song
Ord Song
(Num Song, Ord Song) => (Song -> Rational) -> Real Song
Song -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Song -> Rational
toRational :: Song -> Rational
Real, Enum Song
Real Song
(Real Song, Enum Song) =>
(Song -> Song -> Song)
-> (Song -> Song -> Song)
-> (Song -> Song -> Song)
-> (Song -> Song -> Song)
-> (Song -> Song -> (Song, Song))
-> (Song -> Song -> (Song, Song))
-> (Song -> Integer)
-> Integral Song
Song -> Integer
Song -> Song -> (Song, Song)
Song -> Song -> Song
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Song -> Song -> Song
quot :: Song -> Song -> Song
$crem :: Song -> Song -> Song
rem :: Song -> Song -> Song
$cdiv :: Song -> Song -> Song
div :: Song -> Song -> Song
$cmod :: Song -> Song -> Song
mod :: Song -> Song -> Song
$cquotRem :: Song -> Song -> (Song, Song)
quotRem :: Song -> Song -> (Song, Song)
$cdivMod :: Song -> Song -> (Song, Song)
divMod :: Song -> Song -> (Song, Song)
$ctoInteger :: Song -> Integer
toInteger :: Song -> Integer
Integral, Eq Song
Eq Song => (Int -> Song -> Int) -> (Song -> Int) -> Hashable Song
Int -> Song -> Int
Song -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Song -> Int
hashWithSalt :: Int -> Song -> Int
$chash :: Song -> Int
hash :: Song -> Int
Hashable, KnownNat (StaticSize Song)
KnownNat (StaticSize Song) =>
(Proxy Song -> ByteCount) -> StaticByteSized Song
Proxy Song -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Song -> ByteCount
staticByteSize :: Proxy Song -> ByteCount
StaticByteSized, Get Song
Song -> ByteCount
Song -> Put
(Song -> ByteCount) -> Get Song -> (Song -> Put) -> Binary Song
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Song -> ByteCount
byteSize :: Song -> ByteCount
$cget :: Get Song
get :: Get Song
$cput :: Song -> Put
put :: Song -> Put
Binary)

newtype Position = Position {Position -> MidiWord14
unPosition :: MidiWord14}
  deriving stock (Int -> Position -> ShowS
[Position] -> ShowS
Position -> String
(Int -> Position -> ShowS)
-> (Position -> String) -> ([Position] -> ShowS) -> Show Position
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Position -> ShowS
showsPrec :: Int -> Position -> ShowS
$cshow :: Position -> String
show :: Position -> String
$cshowList :: [Position] -> ShowS
showList :: [Position] -> ShowS
Show)
  deriving newtype
    (Position -> Position -> Bool
(Position -> Position -> Bool)
-> (Position -> Position -> Bool) -> Eq Position
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Position -> Position -> Bool
== :: Position -> Position -> Bool
$c/= :: Position -> Position -> Bool
/= :: Position -> Position -> Bool
Eq, Eq Position
Eq Position =>
(Position -> Position -> Ordering)
-> (Position -> Position -> Bool)
-> (Position -> Position -> Bool)
-> (Position -> Position -> Bool)
-> (Position -> Position -> Bool)
-> (Position -> Position -> Position)
-> (Position -> Position -> Position)
-> Ord Position
Position -> Position -> Bool
Position -> Position -> Ordering
Position -> Position -> Position
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
$ccompare :: Position -> Position -> Ordering
compare :: Position -> Position -> Ordering
$c< :: Position -> Position -> Bool
< :: Position -> Position -> Bool
$c<= :: Position -> Position -> Bool
<= :: Position -> Position -> Bool
$c> :: Position -> Position -> Bool
> :: Position -> Position -> Bool
$c>= :: Position -> Position -> Bool
>= :: Position -> Position -> Bool
$cmax :: Position -> Position -> Position
max :: Position -> Position -> Position
$cmin :: Position -> Position -> Position
min :: Position -> Position -> Position
Ord, Int -> Position
Position -> Int
Position -> [Position]
Position -> Position
Position -> Position -> [Position]
Position -> Position -> Position -> [Position]
(Position -> Position)
-> (Position -> Position)
-> (Int -> Position)
-> (Position -> Int)
-> (Position -> [Position])
-> (Position -> Position -> [Position])
-> (Position -> Position -> [Position])
-> (Position -> Position -> Position -> [Position])
-> Enum Position
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Position -> Position
succ :: Position -> Position
$cpred :: Position -> Position
pred :: Position -> Position
$ctoEnum :: Int -> Position
toEnum :: Int -> Position
$cfromEnum :: Position -> Int
fromEnum :: Position -> Int
$cenumFrom :: Position -> [Position]
enumFrom :: Position -> [Position]
$cenumFromThen :: Position -> Position -> [Position]
enumFromThen :: Position -> Position -> [Position]
$cenumFromTo :: Position -> Position -> [Position]
enumFromTo :: Position -> Position -> [Position]
$cenumFromThenTo :: Position -> Position -> Position -> [Position]
enumFromThenTo :: Position -> Position -> Position -> [Position]
Enum, Integer -> Position
Position -> Position
Position -> Position -> Position
(Position -> Position -> Position)
-> (Position -> Position -> Position)
-> (Position -> Position -> Position)
-> (Position -> Position)
-> (Position -> Position)
-> (Position -> Position)
-> (Integer -> Position)
-> Num Position
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Position -> Position -> Position
+ :: Position -> Position -> Position
$c- :: Position -> Position -> Position
- :: Position -> Position -> Position
$c* :: Position -> Position -> Position
* :: Position -> Position -> Position
$cnegate :: Position -> Position
negate :: Position -> Position
$cabs :: Position -> Position
abs :: Position -> Position
$csignum :: Position -> Position
signum :: Position -> Position
$cfromInteger :: Integer -> Position
fromInteger :: Integer -> Position
Num, Num Position
Ord Position
(Num Position, Ord Position) =>
(Position -> Rational) -> Real Position
Position -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Position -> Rational
toRational :: Position -> Rational
Real, Enum Position
Real Position
(Real Position, Enum Position) =>
(Position -> Position -> Position)
-> (Position -> Position -> Position)
-> (Position -> Position -> Position)
-> (Position -> Position -> Position)
-> (Position -> Position -> (Position, Position))
-> (Position -> Position -> (Position, Position))
-> (Position -> Integer)
-> Integral Position
Position -> Integer
Position -> Position -> (Position, Position)
Position -> Position -> Position
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Position -> Position -> Position
quot :: Position -> Position -> Position
$crem :: Position -> Position -> Position
rem :: Position -> Position -> Position
$cdiv :: Position -> Position -> Position
div :: Position -> Position -> Position
$cmod :: Position -> Position -> Position
mod :: Position -> Position -> Position
$cquotRem :: Position -> Position -> (Position, Position)
quotRem :: Position -> Position -> (Position, Position)
$cdivMod :: Position -> Position -> (Position, Position)
divMod :: Position -> Position -> (Position, Position)
$ctoInteger :: Position -> Integer
toInteger :: Position -> Integer
Integral, Eq Position
Eq Position =>
(Int -> Position -> Int) -> (Position -> Int) -> Hashable Position
Int -> Position -> Int
Position -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Position -> Int
hashWithSalt :: Int -> Position -> Int
$chash :: Position -> Int
hash :: Position -> Int
Hashable, KnownNat (StaticSize Position)
KnownNat (StaticSize Position) =>
(Proxy Position -> ByteCount) -> StaticByteSized Position
Proxy Position -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy Position -> ByteCount
staticByteSize :: Proxy Position -> ByteCount
StaticByteSized, Get Position
Position -> ByteCount
Position -> Put
(Position -> ByteCount)
-> Get Position -> (Position -> Put) -> Binary Position
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: Position -> ByteCount
byteSize :: Position -> ByteCount
$cget :: Get Position
get :: Get Position
$cput :: Position -> Put
put :: Position -> Put
Binary)

newtype ShortManf = ShortManf {ShortManf -> MidiWord7
unShortManf :: MidiWord7}
  deriving stock (Int -> ShortManf -> ShowS
[ShortManf] -> ShowS
ShortManf -> String
(Int -> ShortManf -> ShowS)
-> (ShortManf -> String)
-> ([ShortManf] -> ShowS)
-> Show ShortManf
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShortManf -> ShowS
showsPrec :: Int -> ShortManf -> ShowS
$cshow :: ShortManf -> String
show :: ShortManf -> String
$cshowList :: [ShortManf] -> ShowS
showList :: [ShortManf] -> ShowS
Show)
  deriving newtype
    (ShortManf -> ShortManf -> Bool
(ShortManf -> ShortManf -> Bool)
-> (ShortManf -> ShortManf -> Bool) -> Eq ShortManf
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShortManf -> ShortManf -> Bool
== :: ShortManf -> ShortManf -> Bool
$c/= :: ShortManf -> ShortManf -> Bool
/= :: ShortManf -> ShortManf -> Bool
Eq, Eq ShortManf
Eq ShortManf =>
(ShortManf -> ShortManf -> Ordering)
-> (ShortManf -> ShortManf -> Bool)
-> (ShortManf -> ShortManf -> Bool)
-> (ShortManf -> ShortManf -> Bool)
-> (ShortManf -> ShortManf -> Bool)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> Ord ShortManf
ShortManf -> ShortManf -> Bool
ShortManf -> ShortManf -> Ordering
ShortManf -> ShortManf -> ShortManf
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
$ccompare :: ShortManf -> ShortManf -> Ordering
compare :: ShortManf -> ShortManf -> Ordering
$c< :: ShortManf -> ShortManf -> Bool
< :: ShortManf -> ShortManf -> Bool
$c<= :: ShortManf -> ShortManf -> Bool
<= :: ShortManf -> ShortManf -> Bool
$c> :: ShortManf -> ShortManf -> Bool
> :: ShortManf -> ShortManf -> Bool
$c>= :: ShortManf -> ShortManf -> Bool
>= :: ShortManf -> ShortManf -> Bool
$cmax :: ShortManf -> ShortManf -> ShortManf
max :: ShortManf -> ShortManf -> ShortManf
$cmin :: ShortManf -> ShortManf -> ShortManf
min :: ShortManf -> ShortManf -> ShortManf
Ord, Int -> ShortManf
ShortManf -> Int
ShortManf -> [ShortManf]
ShortManf -> ShortManf
ShortManf -> ShortManf -> [ShortManf]
ShortManf -> ShortManf -> ShortManf -> [ShortManf]
(ShortManf -> ShortManf)
-> (ShortManf -> ShortManf)
-> (Int -> ShortManf)
-> (ShortManf -> Int)
-> (ShortManf -> [ShortManf])
-> (ShortManf -> ShortManf -> [ShortManf])
-> (ShortManf -> ShortManf -> [ShortManf])
-> (ShortManf -> ShortManf -> ShortManf -> [ShortManf])
-> Enum ShortManf
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ShortManf -> ShortManf
succ :: ShortManf -> ShortManf
$cpred :: ShortManf -> ShortManf
pred :: ShortManf -> ShortManf
$ctoEnum :: Int -> ShortManf
toEnum :: Int -> ShortManf
$cfromEnum :: ShortManf -> Int
fromEnum :: ShortManf -> Int
$cenumFrom :: ShortManf -> [ShortManf]
enumFrom :: ShortManf -> [ShortManf]
$cenumFromThen :: ShortManf -> ShortManf -> [ShortManf]
enumFromThen :: ShortManf -> ShortManf -> [ShortManf]
$cenumFromTo :: ShortManf -> ShortManf -> [ShortManf]
enumFromTo :: ShortManf -> ShortManf -> [ShortManf]
$cenumFromThenTo :: ShortManf -> ShortManf -> ShortManf -> [ShortManf]
enumFromThenTo :: ShortManf -> ShortManf -> ShortManf -> [ShortManf]
Enum, Integer -> ShortManf
ShortManf -> ShortManf
ShortManf -> ShortManf -> ShortManf
(ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf)
-> (ShortManf -> ShortManf)
-> (ShortManf -> ShortManf)
-> (Integer -> ShortManf)
-> Num ShortManf
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ShortManf -> ShortManf -> ShortManf
+ :: ShortManf -> ShortManf -> ShortManf
$c- :: ShortManf -> ShortManf -> ShortManf
- :: ShortManf -> ShortManf -> ShortManf
$c* :: ShortManf -> ShortManf -> ShortManf
* :: ShortManf -> ShortManf -> ShortManf
$cnegate :: ShortManf -> ShortManf
negate :: ShortManf -> ShortManf
$cabs :: ShortManf -> ShortManf
abs :: ShortManf -> ShortManf
$csignum :: ShortManf -> ShortManf
signum :: ShortManf -> ShortManf
$cfromInteger :: Integer -> ShortManf
fromInteger :: Integer -> ShortManf
Num, Num ShortManf
Ord ShortManf
(Num ShortManf, Ord ShortManf) =>
(ShortManf -> Rational) -> Real ShortManf
ShortManf -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ShortManf -> Rational
toRational :: ShortManf -> Rational
Real, Enum ShortManf
Real ShortManf
(Real ShortManf, Enum ShortManf) =>
(ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> ShortManf)
-> (ShortManf -> ShortManf -> (ShortManf, ShortManf))
-> (ShortManf -> ShortManf -> (ShortManf, ShortManf))
-> (ShortManf -> Integer)
-> Integral ShortManf
ShortManf -> Integer
ShortManf -> ShortManf -> (ShortManf, ShortManf)
ShortManf -> ShortManf -> ShortManf
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ShortManf -> ShortManf -> ShortManf
quot :: ShortManf -> ShortManf -> ShortManf
$crem :: ShortManf -> ShortManf -> ShortManf
rem :: ShortManf -> ShortManf -> ShortManf
$cdiv :: ShortManf -> ShortManf -> ShortManf
div :: ShortManf -> ShortManf -> ShortManf
$cmod :: ShortManf -> ShortManf -> ShortManf
mod :: ShortManf -> ShortManf -> ShortManf
$cquotRem :: ShortManf -> ShortManf -> (ShortManf, ShortManf)
quotRem :: ShortManf -> ShortManf -> (ShortManf, ShortManf)
$cdivMod :: ShortManf -> ShortManf -> (ShortManf, ShortManf)
divMod :: ShortManf -> ShortManf -> (ShortManf, ShortManf)
$ctoInteger :: ShortManf -> Integer
toInteger :: ShortManf -> Integer
Integral, Eq ShortManf
Eq ShortManf =>
(Int -> ShortManf -> Int)
-> (ShortManf -> Int) -> Hashable ShortManf
Int -> ShortManf -> Int
ShortManf -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ShortManf -> Int
hashWithSalt :: Int -> ShortManf -> Int
$chash :: ShortManf -> Int
hash :: ShortManf -> Int
Hashable, KnownNat (StaticSize ShortManf)
KnownNat (StaticSize ShortManf) =>
(Proxy ShortManf -> ByteCount) -> StaticByteSized ShortManf
Proxy ShortManf -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy ShortManf -> ByteCount
staticByteSize :: Proxy ShortManf -> ByteCount
StaticByteSized, Get ShortManf
ShortManf -> ByteCount
ShortManf -> Put
(ShortManf -> ByteCount)
-> Get ShortManf -> (ShortManf -> Put) -> Binary ShortManf
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: ShortManf -> ByteCount
byteSize :: ShortManf -> ByteCount
$cget :: Get ShortManf
get :: Get ShortManf
$cput :: ShortManf -> Put
put :: ShortManf -> Put
Binary)

newtype LongManf = LongManf {LongManf -> Word16
unLongManf :: Word16}
  deriving stock (Int -> LongManf -> ShowS
[LongManf] -> ShowS
LongManf -> String
(Int -> LongManf -> ShowS)
-> (LongManf -> String) -> ([LongManf] -> ShowS) -> Show LongManf
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LongManf -> ShowS
showsPrec :: Int -> LongManf -> ShowS
$cshow :: LongManf -> String
show :: LongManf -> String
$cshowList :: [LongManf] -> ShowS
showList :: [LongManf] -> ShowS
Show)
  deriving newtype
    (LongManf -> LongManf -> Bool
(LongManf -> LongManf -> Bool)
-> (LongManf -> LongManf -> Bool) -> Eq LongManf
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LongManf -> LongManf -> Bool
== :: LongManf -> LongManf -> Bool
$c/= :: LongManf -> LongManf -> Bool
/= :: LongManf -> LongManf -> Bool
Eq, Eq LongManf
Eq LongManf =>
(LongManf -> LongManf -> Ordering)
-> (LongManf -> LongManf -> Bool)
-> (LongManf -> LongManf -> Bool)
-> (LongManf -> LongManf -> Bool)
-> (LongManf -> LongManf -> Bool)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> Ord LongManf
LongManf -> LongManf -> Bool
LongManf -> LongManf -> Ordering
LongManf -> LongManf -> LongManf
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
$ccompare :: LongManf -> LongManf -> Ordering
compare :: LongManf -> LongManf -> Ordering
$c< :: LongManf -> LongManf -> Bool
< :: LongManf -> LongManf -> Bool
$c<= :: LongManf -> LongManf -> Bool
<= :: LongManf -> LongManf -> Bool
$c> :: LongManf -> LongManf -> Bool
> :: LongManf -> LongManf -> Bool
$c>= :: LongManf -> LongManf -> Bool
>= :: LongManf -> LongManf -> Bool
$cmax :: LongManf -> LongManf -> LongManf
max :: LongManf -> LongManf -> LongManf
$cmin :: LongManf -> LongManf -> LongManf
min :: LongManf -> LongManf -> LongManf
Ord, Int -> LongManf
LongManf -> Int
LongManf -> [LongManf]
LongManf -> LongManf
LongManf -> LongManf -> [LongManf]
LongManf -> LongManf -> LongManf -> [LongManf]
(LongManf -> LongManf)
-> (LongManf -> LongManf)
-> (Int -> LongManf)
-> (LongManf -> Int)
-> (LongManf -> [LongManf])
-> (LongManf -> LongManf -> [LongManf])
-> (LongManf -> LongManf -> [LongManf])
-> (LongManf -> LongManf -> LongManf -> [LongManf])
-> Enum LongManf
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: LongManf -> LongManf
succ :: LongManf -> LongManf
$cpred :: LongManf -> LongManf
pred :: LongManf -> LongManf
$ctoEnum :: Int -> LongManf
toEnum :: Int -> LongManf
$cfromEnum :: LongManf -> Int
fromEnum :: LongManf -> Int
$cenumFrom :: LongManf -> [LongManf]
enumFrom :: LongManf -> [LongManf]
$cenumFromThen :: LongManf -> LongManf -> [LongManf]
enumFromThen :: LongManf -> LongManf -> [LongManf]
$cenumFromTo :: LongManf -> LongManf -> [LongManf]
enumFromTo :: LongManf -> LongManf -> [LongManf]
$cenumFromThenTo :: LongManf -> LongManf -> LongManf -> [LongManf]
enumFromThenTo :: LongManf -> LongManf -> LongManf -> [LongManf]
Enum, Integer -> LongManf
LongManf -> LongManf
LongManf -> LongManf -> LongManf
(LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf)
-> (LongManf -> LongManf)
-> (LongManf -> LongManf)
-> (Integer -> LongManf)
-> Num LongManf
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: LongManf -> LongManf -> LongManf
+ :: LongManf -> LongManf -> LongManf
$c- :: LongManf -> LongManf -> LongManf
- :: LongManf -> LongManf -> LongManf
$c* :: LongManf -> LongManf -> LongManf
* :: LongManf -> LongManf -> LongManf
$cnegate :: LongManf -> LongManf
negate :: LongManf -> LongManf
$cabs :: LongManf -> LongManf
abs :: LongManf -> LongManf
$csignum :: LongManf -> LongManf
signum :: LongManf -> LongManf
$cfromInteger :: Integer -> LongManf
fromInteger :: Integer -> LongManf
Num, Num LongManf
Ord LongManf
(Num LongManf, Ord LongManf) =>
(LongManf -> Rational) -> Real LongManf
LongManf -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: LongManf -> Rational
toRational :: LongManf -> Rational
Real, Enum LongManf
Real LongManf
(Real LongManf, Enum LongManf) =>
(LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> LongManf)
-> (LongManf -> LongManf -> (LongManf, LongManf))
-> (LongManf -> LongManf -> (LongManf, LongManf))
-> (LongManf -> Integer)
-> Integral LongManf
LongManf -> Integer
LongManf -> LongManf -> (LongManf, LongManf)
LongManf -> LongManf -> LongManf
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: LongManf -> LongManf -> LongManf
quot :: LongManf -> LongManf -> LongManf
$crem :: LongManf -> LongManf -> LongManf
rem :: LongManf -> LongManf -> LongManf
$cdiv :: LongManf -> LongManf -> LongManf
div :: LongManf -> LongManf -> LongManf
$cmod :: LongManf -> LongManf -> LongManf
mod :: LongManf -> LongManf -> LongManf
$cquotRem :: LongManf -> LongManf -> (LongManf, LongManf)
quotRem :: LongManf -> LongManf -> (LongManf, LongManf)
$cdivMod :: LongManf -> LongManf -> (LongManf, LongManf)
divMod :: LongManf -> LongManf -> (LongManf, LongManf)
$ctoInteger :: LongManf -> Integer
toInteger :: LongManf -> Integer
Integral, Eq LongManf
Eq LongManf =>
(Int -> LongManf -> Int) -> (LongManf -> Int) -> Hashable LongManf
Int -> LongManf -> Int
LongManf -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> LongManf -> Int
hashWithSalt :: Int -> LongManf -> Int
$chash :: LongManf -> Int
hash :: LongManf -> Int
Hashable, KnownNat (StaticSize LongManf)
KnownNat (StaticSize LongManf) =>
(Proxy LongManf -> ByteCount) -> StaticByteSized LongManf
Proxy LongManf -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy LongManf -> ByteCount
staticByteSize :: Proxy LongManf -> ByteCount
StaticByteSized, Get LongManf
LongManf -> ByteCount
LongManf -> Put
(LongManf -> ByteCount)
-> Get LongManf -> (LongManf -> Put) -> Binary LongManf
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: LongManf -> ByteCount
byteSize :: LongManf -> ByteCount
$cget :: Get LongManf
get :: Get LongManf
$cput :: LongManf -> Put
put :: LongManf -> Put
Binary)

data Manf = ManfShort !ShortManf | ManfLong !LongManf
  deriving stock (Manf -> Manf -> Bool
(Manf -> Manf -> Bool) -> (Manf -> Manf -> Bool) -> Eq Manf
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Manf -> Manf -> Bool
== :: Manf -> Manf -> Bool
$c/= :: Manf -> Manf -> Bool
/= :: Manf -> Manf -> Bool
Eq, Eq Manf
Eq Manf =>
(Manf -> Manf -> Ordering)
-> (Manf -> Manf -> Bool)
-> (Manf -> Manf -> Bool)
-> (Manf -> Manf -> Bool)
-> (Manf -> Manf -> Bool)
-> (Manf -> Manf -> Manf)
-> (Manf -> Manf -> Manf)
-> Ord Manf
Manf -> Manf -> Bool
Manf -> Manf -> Ordering
Manf -> Manf -> Manf
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
$ccompare :: Manf -> Manf -> Ordering
compare :: Manf -> Manf -> Ordering
$c< :: Manf -> Manf -> Bool
< :: Manf -> Manf -> Bool
$c<= :: Manf -> Manf -> Bool
<= :: Manf -> Manf -> Bool
$c> :: Manf -> Manf -> Bool
> :: Manf -> Manf -> Bool
$c>= :: Manf -> Manf -> Bool
>= :: Manf -> Manf -> Bool
$cmax :: Manf -> Manf -> Manf
max :: Manf -> Manf -> Manf
$cmin :: Manf -> Manf -> Manf
min :: Manf -> Manf -> Manf
Ord, Int -> Manf -> ShowS
[Manf] -> ShowS
Manf -> String
(Int -> Manf -> ShowS)
-> (Manf -> String) -> ([Manf] -> ShowS) -> Show Manf
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Manf -> ShowS
showsPrec :: Int -> Manf -> ShowS
$cshow :: Manf -> String
show :: Manf -> String
$cshowList :: [Manf] -> ShowS
showList :: [Manf] -> ShowS
Show, (forall x. Manf -> Rep Manf x)
-> (forall x. Rep Manf x -> Manf) -> Generic Manf
forall x. Rep Manf x -> Manf
forall x. Manf -> Rep Manf x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Manf -> Rep Manf x
from :: forall x. Manf -> Rep Manf x
$cto :: forall x. Rep Manf x -> Manf
to :: forall x. Rep Manf x -> Manf
Generic)

instance Binary Manf where
  byteSize :: Manf -> ByteCount
byteSize = \case
    ManfShort ShortManf
_ -> ByteCount
1
    ManfLong LongManf
_ -> ByteCount
3
  get :: Get Manf
get = do
    ShortManf
sm <- forall a. Binary a => Get a
get @ShortManf
    if ShortManf
sm ShortManf -> ShortManf -> Bool
forall a. Eq a => a -> a -> Bool
== ShortManf
0
      then (Word16 -> Manf) -> Get Word16 -> Get Manf
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LongManf -> Manf
ManfLong (LongManf -> Manf) -> (Word16 -> LongManf) -> Word16 -> Manf
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> LongManf
LongManf) Get Word16
forall a. Binary a => Get a
get
      else Manf -> Get Manf
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShortManf -> Manf
ManfShort ShortManf
sm)
  put :: Manf -> Put
put = \case
    ManfShort ShortManf
sm -> ShortManf -> Put
forall a. Binary a => a -> Put
put ShortManf
sm
    ManfLong LongManf
lm -> forall a. Binary a => a -> Put
put @Word8 Word8
0 Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> LongManf -> Put
forall a. Binary a => a -> Put
put LongManf
lm

-- | Manf id usable for non-commercial applications
eduManf :: Manf
eduManf :: Manf
eduManf = ShortManf -> Manf
ManfShort (MidiWord7 -> ShortManf
ShortManf MidiWord7
0x7D)

data QuarterTimeUnit
  = QTUFramesLow
  | QTUFramesHigh
  | QTUSecondsLow
  | QTUSecondsHigh
  | QTUMinutesLow
  | QTUMinutesHigh
  | QTUHoursLow
  | QTUHoursHigh
  deriving stock (QuarterTimeUnit -> QuarterTimeUnit -> Bool
(QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> (QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> Eq QuarterTimeUnit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
== :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
$c/= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
/= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
Eq, Eq QuarterTimeUnit
Eq QuarterTimeUnit =>
(QuarterTimeUnit -> QuarterTimeUnit -> Ordering)
-> (QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> (QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> (QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> (QuarterTimeUnit -> QuarterTimeUnit -> Bool)
-> (QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit)
-> (QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit)
-> Ord QuarterTimeUnit
QuarterTimeUnit -> QuarterTimeUnit -> Bool
QuarterTimeUnit -> QuarterTimeUnit -> Ordering
QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit
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
$ccompare :: QuarterTimeUnit -> QuarterTimeUnit -> Ordering
compare :: QuarterTimeUnit -> QuarterTimeUnit -> Ordering
$c< :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
< :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
$c<= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
<= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
$c> :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
> :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
$c>= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
>= :: QuarterTimeUnit -> QuarterTimeUnit -> Bool
$cmax :: QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit
max :: QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit
$cmin :: QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit
min :: QuarterTimeUnit -> QuarterTimeUnit -> QuarterTimeUnit
Ord, Int -> QuarterTimeUnit -> ShowS
[QuarterTimeUnit] -> ShowS
QuarterTimeUnit -> String
(Int -> QuarterTimeUnit -> ShowS)
-> (QuarterTimeUnit -> String)
-> ([QuarterTimeUnit] -> ShowS)
-> Show QuarterTimeUnit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QuarterTimeUnit -> ShowS
showsPrec :: Int -> QuarterTimeUnit -> ShowS
$cshow :: QuarterTimeUnit -> String
show :: QuarterTimeUnit -> String
$cshowList :: [QuarterTimeUnit] -> ShowS
showList :: [QuarterTimeUnit] -> ShowS
Show, Int -> QuarterTimeUnit
QuarterTimeUnit -> Int
QuarterTimeUnit -> [QuarterTimeUnit]
QuarterTimeUnit -> QuarterTimeUnit
QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
QuarterTimeUnit
-> QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
(QuarterTimeUnit -> QuarterTimeUnit)
-> (QuarterTimeUnit -> QuarterTimeUnit)
-> (Int -> QuarterTimeUnit)
-> (QuarterTimeUnit -> Int)
-> (QuarterTimeUnit -> [QuarterTimeUnit])
-> (QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit])
-> (QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit])
-> (QuarterTimeUnit
    -> QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit])
-> Enum QuarterTimeUnit
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: QuarterTimeUnit -> QuarterTimeUnit
succ :: QuarterTimeUnit -> QuarterTimeUnit
$cpred :: QuarterTimeUnit -> QuarterTimeUnit
pred :: QuarterTimeUnit -> QuarterTimeUnit
$ctoEnum :: Int -> QuarterTimeUnit
toEnum :: Int -> QuarterTimeUnit
$cfromEnum :: QuarterTimeUnit -> Int
fromEnum :: QuarterTimeUnit -> Int
$cenumFrom :: QuarterTimeUnit -> [QuarterTimeUnit]
enumFrom :: QuarterTimeUnit -> [QuarterTimeUnit]
$cenumFromThen :: QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
enumFromThen :: QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
$cenumFromTo :: QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
enumFromTo :: QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
$cenumFromThenTo :: QuarterTimeUnit
-> QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
enumFromThenTo :: QuarterTimeUnit
-> QuarterTimeUnit -> QuarterTimeUnit -> [QuarterTimeUnit]
Enum, QuarterTimeUnit
QuarterTimeUnit -> QuarterTimeUnit -> Bounded QuarterTimeUnit
forall a. a -> a -> Bounded a
$cminBound :: QuarterTimeUnit
minBound :: QuarterTimeUnit
$cmaxBound :: QuarterTimeUnit
maxBound :: QuarterTimeUnit
Bounded, (forall x. QuarterTimeUnit -> Rep QuarterTimeUnit x)
-> (forall x. Rep QuarterTimeUnit x -> QuarterTimeUnit)
-> Generic QuarterTimeUnit
forall x. Rep QuarterTimeUnit x -> QuarterTimeUnit
forall x. QuarterTimeUnit -> Rep QuarterTimeUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QuarterTimeUnit -> Rep QuarterTimeUnit x
from :: forall x. QuarterTimeUnit -> Rep QuarterTimeUnit x
$cto :: forall x. Rep QuarterTimeUnit x -> QuarterTimeUnit
to :: forall x. Rep QuarterTimeUnit x -> QuarterTimeUnit
Generic)

data QuarterTime = QuarterTime
  { QuarterTime -> QuarterTimeUnit
qtUnit :: !QuarterTimeUnit
  , QuarterTime -> Word4
qtValue :: !Word4
  }
  deriving stock (QuarterTime -> QuarterTime -> Bool
(QuarterTime -> QuarterTime -> Bool)
-> (QuarterTime -> QuarterTime -> Bool) -> Eq QuarterTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QuarterTime -> QuarterTime -> Bool
== :: QuarterTime -> QuarterTime -> Bool
$c/= :: QuarterTime -> QuarterTime -> Bool
/= :: QuarterTime -> QuarterTime -> Bool
Eq, Eq QuarterTime
Eq QuarterTime =>
(QuarterTime -> QuarterTime -> Ordering)
-> (QuarterTime -> QuarterTime -> Bool)
-> (QuarterTime -> QuarterTime -> Bool)
-> (QuarterTime -> QuarterTime -> Bool)
-> (QuarterTime -> QuarterTime -> Bool)
-> (QuarterTime -> QuarterTime -> QuarterTime)
-> (QuarterTime -> QuarterTime -> QuarterTime)
-> Ord QuarterTime
QuarterTime -> QuarterTime -> Bool
QuarterTime -> QuarterTime -> Ordering
QuarterTime -> QuarterTime -> QuarterTime
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
$ccompare :: QuarterTime -> QuarterTime -> Ordering
compare :: QuarterTime -> QuarterTime -> Ordering
$c< :: QuarterTime -> QuarterTime -> Bool
< :: QuarterTime -> QuarterTime -> Bool
$c<= :: QuarterTime -> QuarterTime -> Bool
<= :: QuarterTime -> QuarterTime -> Bool
$c> :: QuarterTime -> QuarterTime -> Bool
> :: QuarterTime -> QuarterTime -> Bool
$c>= :: QuarterTime -> QuarterTime -> Bool
>= :: QuarterTime -> QuarterTime -> Bool
$cmax :: QuarterTime -> QuarterTime -> QuarterTime
max :: QuarterTime -> QuarterTime -> QuarterTime
$cmin :: QuarterTime -> QuarterTime -> QuarterTime
min :: QuarterTime -> QuarterTime -> QuarterTime
Ord, Int -> QuarterTime -> ShowS
[QuarterTime] -> ShowS
QuarterTime -> String
(Int -> QuarterTime -> ShowS)
-> (QuarterTime -> String)
-> ([QuarterTime] -> ShowS)
-> Show QuarterTime
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QuarterTime -> ShowS
showsPrec :: Int -> QuarterTime -> ShowS
$cshow :: QuarterTime -> String
show :: QuarterTime -> String
$cshowList :: [QuarterTime] -> ShowS
showList :: [QuarterTime] -> ShowS
Show, (forall x. QuarterTime -> Rep QuarterTime x)
-> (forall x. Rep QuarterTime x -> QuarterTime)
-> Generic QuarterTime
forall x. Rep QuarterTime x -> QuarterTime
forall x. QuarterTime -> Rep QuarterTime x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QuarterTime -> Rep QuarterTime x
from :: forall x. QuarterTime -> Rep QuarterTime x
$cto :: forall x. Rep QuarterTime x -> QuarterTime
to :: forall x. Rep QuarterTime x -> QuarterTime
Generic)

instance StaticByteSized QuarterTime where
  type StaticSize QuarterTime = 1
  staticByteSize :: Proxy QuarterTime -> ByteCount
staticByteSize Proxy QuarterTime
_ = ByteCount
1

instance Binary QuarterTime where
  byteSize :: QuarterTime -> ByteCount
byteSize QuarterTime
_ = ByteCount
1
  get :: Get QuarterTime
get = do
    Word8
w <- forall a. Binary a => Get a
get @Word8
    let x :: Word8
x = Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
shiftR Word8
w Int
4
    Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
8) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Invalid quarter time unit: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
x))
    let unit :: QuarterTimeUnit
unit = Int -> QuarterTimeUnit
forall a. Enum a => Int -> a
toEnum (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x)
        val :: Word4
val = Word8 -> Word4
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
0x0F Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
w)
    QuarterTime -> Get QuarterTime
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (QuarterTimeUnit -> Word4 -> QuarterTime
QuarterTime QuarterTimeUnit
unit Word4
val)
  put :: QuarterTime -> Put
put (QuarterTime QuarterTimeUnit
unit Word4
val) =
    forall a. Binary a => a -> Put
put @Word8 (Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
shiftL (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (QuarterTimeUnit -> Int
forall a. Enum a => a -> Int
fromEnum QuarterTimeUnit
unit)) Int
4 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word4 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word4
val)

data ChanStatusType
  = ChanStatusNoteOff
  | ChanStatusNoteOn
  | ChanStatusKeyAftertouch
  | ChanStatusControlChange
  | ChanStatusProgramChange
  | ChanStatusChanAftertouch
  | ChanStatusPitchBend
  deriving stock (ChanStatusType -> ChanStatusType -> Bool
(ChanStatusType -> ChanStatusType -> Bool)
-> (ChanStatusType -> ChanStatusType -> Bool) -> Eq ChanStatusType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChanStatusType -> ChanStatusType -> Bool
== :: ChanStatusType -> ChanStatusType -> Bool
$c/= :: ChanStatusType -> ChanStatusType -> Bool
/= :: ChanStatusType -> ChanStatusType -> Bool
Eq, Eq ChanStatusType
Eq ChanStatusType =>
(ChanStatusType -> ChanStatusType -> Ordering)
-> (ChanStatusType -> ChanStatusType -> Bool)
-> (ChanStatusType -> ChanStatusType -> Bool)
-> (ChanStatusType -> ChanStatusType -> Bool)
-> (ChanStatusType -> ChanStatusType -> Bool)
-> (ChanStatusType -> ChanStatusType -> ChanStatusType)
-> (ChanStatusType -> ChanStatusType -> ChanStatusType)
-> Ord ChanStatusType
ChanStatusType -> ChanStatusType -> Bool
ChanStatusType -> ChanStatusType -> Ordering
ChanStatusType -> ChanStatusType -> ChanStatusType
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
$ccompare :: ChanStatusType -> ChanStatusType -> Ordering
compare :: ChanStatusType -> ChanStatusType -> Ordering
$c< :: ChanStatusType -> ChanStatusType -> Bool
< :: ChanStatusType -> ChanStatusType -> Bool
$c<= :: ChanStatusType -> ChanStatusType -> Bool
<= :: ChanStatusType -> ChanStatusType -> Bool
$c> :: ChanStatusType -> ChanStatusType -> Bool
> :: ChanStatusType -> ChanStatusType -> Bool
$c>= :: ChanStatusType -> ChanStatusType -> Bool
>= :: ChanStatusType -> ChanStatusType -> Bool
$cmax :: ChanStatusType -> ChanStatusType -> ChanStatusType
max :: ChanStatusType -> ChanStatusType -> ChanStatusType
$cmin :: ChanStatusType -> ChanStatusType -> ChanStatusType
min :: ChanStatusType -> ChanStatusType -> ChanStatusType
Ord, Int -> ChanStatusType -> ShowS
[ChanStatusType] -> ShowS
ChanStatusType -> String
(Int -> ChanStatusType -> ShowS)
-> (ChanStatusType -> String)
-> ([ChanStatusType] -> ShowS)
-> Show ChanStatusType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChanStatusType -> ShowS
showsPrec :: Int -> ChanStatusType -> ShowS
$cshow :: ChanStatusType -> String
show :: ChanStatusType -> String
$cshowList :: [ChanStatusType] -> ShowS
showList :: [ChanStatusType] -> ShowS
Show, Int -> ChanStatusType
ChanStatusType -> Int
ChanStatusType -> [ChanStatusType]
ChanStatusType -> ChanStatusType
ChanStatusType -> ChanStatusType -> [ChanStatusType]
ChanStatusType
-> ChanStatusType -> ChanStatusType -> [ChanStatusType]
(ChanStatusType -> ChanStatusType)
-> (ChanStatusType -> ChanStatusType)
-> (Int -> ChanStatusType)
-> (ChanStatusType -> Int)
-> (ChanStatusType -> [ChanStatusType])
-> (ChanStatusType -> ChanStatusType -> [ChanStatusType])
-> (ChanStatusType -> ChanStatusType -> [ChanStatusType])
-> (ChanStatusType
    -> ChanStatusType -> ChanStatusType -> [ChanStatusType])
-> Enum ChanStatusType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ChanStatusType -> ChanStatusType
succ :: ChanStatusType -> ChanStatusType
$cpred :: ChanStatusType -> ChanStatusType
pred :: ChanStatusType -> ChanStatusType
$ctoEnum :: Int -> ChanStatusType
toEnum :: Int -> ChanStatusType
$cfromEnum :: ChanStatusType -> Int
fromEnum :: ChanStatusType -> Int
$cenumFrom :: ChanStatusType -> [ChanStatusType]
enumFrom :: ChanStatusType -> [ChanStatusType]
$cenumFromThen :: ChanStatusType -> ChanStatusType -> [ChanStatusType]
enumFromThen :: ChanStatusType -> ChanStatusType -> [ChanStatusType]
$cenumFromTo :: ChanStatusType -> ChanStatusType -> [ChanStatusType]
enumFromTo :: ChanStatusType -> ChanStatusType -> [ChanStatusType]
$cenumFromThenTo :: ChanStatusType
-> ChanStatusType -> ChanStatusType -> [ChanStatusType]
enumFromThenTo :: ChanStatusType
-> ChanStatusType -> ChanStatusType -> [ChanStatusType]
Enum, ChanStatusType
ChanStatusType -> ChanStatusType -> Bounded ChanStatusType
forall a. a -> a -> Bounded a
$cminBound :: ChanStatusType
minBound :: ChanStatusType
$cmaxBound :: ChanStatusType
maxBound :: ChanStatusType
Bounded, (forall x. ChanStatusType -> Rep ChanStatusType x)
-> (forall x. Rep ChanStatusType x -> ChanStatusType)
-> Generic ChanStatusType
forall x. Rep ChanStatusType x -> ChanStatusType
forall x. ChanStatusType -> Rep ChanStatusType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChanStatusType -> Rep ChanStatusType x
from :: forall x. ChanStatusType -> Rep ChanStatusType x
$cto :: forall x. Rep ChanStatusType x -> ChanStatusType
to :: forall x. Rep ChanStatusType x -> ChanStatusType
Generic)

data CommonStatus
  = CommonStatusTimeFrame
  | CommonStatusSongPointer
  | CommonStatusSongSelect
  | CommonStatusTuneRequest
  deriving stock (CommonStatus -> CommonStatus -> Bool
(CommonStatus -> CommonStatus -> Bool)
-> (CommonStatus -> CommonStatus -> Bool) -> Eq CommonStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommonStatus -> CommonStatus -> Bool
== :: CommonStatus -> CommonStatus -> Bool
$c/= :: CommonStatus -> CommonStatus -> Bool
/= :: CommonStatus -> CommonStatus -> Bool
Eq, Eq CommonStatus
Eq CommonStatus =>
(CommonStatus -> CommonStatus -> Ordering)
-> (CommonStatus -> CommonStatus -> Bool)
-> (CommonStatus -> CommonStatus -> Bool)
-> (CommonStatus -> CommonStatus -> Bool)
-> (CommonStatus -> CommonStatus -> Bool)
-> (CommonStatus -> CommonStatus -> CommonStatus)
-> (CommonStatus -> CommonStatus -> CommonStatus)
-> Ord CommonStatus
CommonStatus -> CommonStatus -> Bool
CommonStatus -> CommonStatus -> Ordering
CommonStatus -> CommonStatus -> CommonStatus
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
$ccompare :: CommonStatus -> CommonStatus -> Ordering
compare :: CommonStatus -> CommonStatus -> Ordering
$c< :: CommonStatus -> CommonStatus -> Bool
< :: CommonStatus -> CommonStatus -> Bool
$c<= :: CommonStatus -> CommonStatus -> Bool
<= :: CommonStatus -> CommonStatus -> Bool
$c> :: CommonStatus -> CommonStatus -> Bool
> :: CommonStatus -> CommonStatus -> Bool
$c>= :: CommonStatus -> CommonStatus -> Bool
>= :: CommonStatus -> CommonStatus -> Bool
$cmax :: CommonStatus -> CommonStatus -> CommonStatus
max :: CommonStatus -> CommonStatus -> CommonStatus
$cmin :: CommonStatus -> CommonStatus -> CommonStatus
min :: CommonStatus -> CommonStatus -> CommonStatus
Ord, Int -> CommonStatus -> ShowS
[CommonStatus] -> ShowS
CommonStatus -> String
(Int -> CommonStatus -> ShowS)
-> (CommonStatus -> String)
-> ([CommonStatus] -> ShowS)
-> Show CommonStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CommonStatus -> ShowS
showsPrec :: Int -> CommonStatus -> ShowS
$cshow :: CommonStatus -> String
show :: CommonStatus -> String
$cshowList :: [CommonStatus] -> ShowS
showList :: [CommonStatus] -> ShowS
Show, Int -> CommonStatus
CommonStatus -> Int
CommonStatus -> [CommonStatus]
CommonStatus -> CommonStatus
CommonStatus -> CommonStatus -> [CommonStatus]
CommonStatus -> CommonStatus -> CommonStatus -> [CommonStatus]
(CommonStatus -> CommonStatus)
-> (CommonStatus -> CommonStatus)
-> (Int -> CommonStatus)
-> (CommonStatus -> Int)
-> (CommonStatus -> [CommonStatus])
-> (CommonStatus -> CommonStatus -> [CommonStatus])
-> (CommonStatus -> CommonStatus -> [CommonStatus])
-> (CommonStatus -> CommonStatus -> CommonStatus -> [CommonStatus])
-> Enum CommonStatus
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CommonStatus -> CommonStatus
succ :: CommonStatus -> CommonStatus
$cpred :: CommonStatus -> CommonStatus
pred :: CommonStatus -> CommonStatus
$ctoEnum :: Int -> CommonStatus
toEnum :: Int -> CommonStatus
$cfromEnum :: CommonStatus -> Int
fromEnum :: CommonStatus -> Int
$cenumFrom :: CommonStatus -> [CommonStatus]
enumFrom :: CommonStatus -> [CommonStatus]
$cenumFromThen :: CommonStatus -> CommonStatus -> [CommonStatus]
enumFromThen :: CommonStatus -> CommonStatus -> [CommonStatus]
$cenumFromTo :: CommonStatus -> CommonStatus -> [CommonStatus]
enumFromTo :: CommonStatus -> CommonStatus -> [CommonStatus]
$cenumFromThenTo :: CommonStatus -> CommonStatus -> CommonStatus -> [CommonStatus]
enumFromThenTo :: CommonStatus -> CommonStatus -> CommonStatus -> [CommonStatus]
Enum, CommonStatus
CommonStatus -> CommonStatus -> Bounded CommonStatus
forall a. a -> a -> Bounded a
$cminBound :: CommonStatus
minBound :: CommonStatus
$cmaxBound :: CommonStatus
maxBound :: CommonStatus
Bounded, (forall x. CommonStatus -> Rep CommonStatus x)
-> (forall x. Rep CommonStatus x -> CommonStatus)
-> Generic CommonStatus
forall x. Rep CommonStatus x -> CommonStatus
forall x. CommonStatus -> Rep CommonStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CommonStatus -> Rep CommonStatus x
from :: forall x. CommonStatus -> Rep CommonStatus x
$cto :: forall x. Rep CommonStatus x -> CommonStatus
to :: forall x. Rep CommonStatus x -> CommonStatus
Generic)

data RtStatus
  = RtStatusTimingClock
  | RtStatusStart
  | RtStatusContinue
  | RtStatusStop
  | RtStatusActiveSensing
  | RtStatusSystemReset
  deriving stock (RtStatus -> RtStatus -> Bool
(RtStatus -> RtStatus -> Bool)
-> (RtStatus -> RtStatus -> Bool) -> Eq RtStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RtStatus -> RtStatus -> Bool
== :: RtStatus -> RtStatus -> Bool
$c/= :: RtStatus -> RtStatus -> Bool
/= :: RtStatus -> RtStatus -> Bool
Eq, Eq RtStatus
Eq RtStatus =>
(RtStatus -> RtStatus -> Ordering)
-> (RtStatus -> RtStatus -> Bool)
-> (RtStatus -> RtStatus -> Bool)
-> (RtStatus -> RtStatus -> Bool)
-> (RtStatus -> RtStatus -> Bool)
-> (RtStatus -> RtStatus -> RtStatus)
-> (RtStatus -> RtStatus -> RtStatus)
-> Ord RtStatus
RtStatus -> RtStatus -> Bool
RtStatus -> RtStatus -> Ordering
RtStatus -> RtStatus -> RtStatus
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
$ccompare :: RtStatus -> RtStatus -> Ordering
compare :: RtStatus -> RtStatus -> Ordering
$c< :: RtStatus -> RtStatus -> Bool
< :: RtStatus -> RtStatus -> Bool
$c<= :: RtStatus -> RtStatus -> Bool
<= :: RtStatus -> RtStatus -> Bool
$c> :: RtStatus -> RtStatus -> Bool
> :: RtStatus -> RtStatus -> Bool
$c>= :: RtStatus -> RtStatus -> Bool
>= :: RtStatus -> RtStatus -> Bool
$cmax :: RtStatus -> RtStatus -> RtStatus
max :: RtStatus -> RtStatus -> RtStatus
$cmin :: RtStatus -> RtStatus -> RtStatus
min :: RtStatus -> RtStatus -> RtStatus
Ord, Int -> RtStatus -> ShowS
[RtStatus] -> ShowS
RtStatus -> String
(Int -> RtStatus -> ShowS)
-> (RtStatus -> String) -> ([RtStatus] -> ShowS) -> Show RtStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RtStatus -> ShowS
showsPrec :: Int -> RtStatus -> ShowS
$cshow :: RtStatus -> String
show :: RtStatus -> String
$cshowList :: [RtStatus] -> ShowS
showList :: [RtStatus] -> ShowS
Show, Int -> RtStatus
RtStatus -> Int
RtStatus -> [RtStatus]
RtStatus -> RtStatus
RtStatus -> RtStatus -> [RtStatus]
RtStatus -> RtStatus -> RtStatus -> [RtStatus]
(RtStatus -> RtStatus)
-> (RtStatus -> RtStatus)
-> (Int -> RtStatus)
-> (RtStatus -> Int)
-> (RtStatus -> [RtStatus])
-> (RtStatus -> RtStatus -> [RtStatus])
-> (RtStatus -> RtStatus -> [RtStatus])
-> (RtStatus -> RtStatus -> RtStatus -> [RtStatus])
-> Enum RtStatus
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: RtStatus -> RtStatus
succ :: RtStatus -> RtStatus
$cpred :: RtStatus -> RtStatus
pred :: RtStatus -> RtStatus
$ctoEnum :: Int -> RtStatus
toEnum :: Int -> RtStatus
$cfromEnum :: RtStatus -> Int
fromEnum :: RtStatus -> Int
$cenumFrom :: RtStatus -> [RtStatus]
enumFrom :: RtStatus -> [RtStatus]
$cenumFromThen :: RtStatus -> RtStatus -> [RtStatus]
enumFromThen :: RtStatus -> RtStatus -> [RtStatus]
$cenumFromTo :: RtStatus -> RtStatus -> [RtStatus]
enumFromTo :: RtStatus -> RtStatus -> [RtStatus]
$cenumFromThenTo :: RtStatus -> RtStatus -> RtStatus -> [RtStatus]
enumFromThenTo :: RtStatus -> RtStatus -> RtStatus -> [RtStatus]
Enum, RtStatus
RtStatus -> RtStatus -> Bounded RtStatus
forall a. a -> a -> Bounded a
$cminBound :: RtStatus
minBound :: RtStatus
$cmaxBound :: RtStatus
maxBound :: RtStatus
Bounded, (forall x. RtStatus -> Rep RtStatus x)
-> (forall x. Rep RtStatus x -> RtStatus) -> Generic RtStatus
forall x. Rep RtStatus x -> RtStatus
forall x. RtStatus -> Rep RtStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RtStatus -> Rep RtStatus x
from :: forall x. RtStatus -> Rep RtStatus x
$cto :: forall x. Rep RtStatus x -> RtStatus
to :: forall x. Rep RtStatus x -> RtStatus
Generic)

data ChanStatus = ChanStatus !Channel !ChanStatusType
  deriving stock (ChanStatus -> ChanStatus -> Bool
(ChanStatus -> ChanStatus -> Bool)
-> (ChanStatus -> ChanStatus -> Bool) -> Eq ChanStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChanStatus -> ChanStatus -> Bool
== :: ChanStatus -> ChanStatus -> Bool
$c/= :: ChanStatus -> ChanStatus -> Bool
/= :: ChanStatus -> ChanStatus -> Bool
Eq, Eq ChanStatus
Eq ChanStatus =>
(ChanStatus -> ChanStatus -> Ordering)
-> (ChanStatus -> ChanStatus -> Bool)
-> (ChanStatus -> ChanStatus -> Bool)
-> (ChanStatus -> ChanStatus -> Bool)
-> (ChanStatus -> ChanStatus -> Bool)
-> (ChanStatus -> ChanStatus -> ChanStatus)
-> (ChanStatus -> ChanStatus -> ChanStatus)
-> Ord ChanStatus
ChanStatus -> ChanStatus -> Bool
ChanStatus -> ChanStatus -> Ordering
ChanStatus -> ChanStatus -> ChanStatus
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
$ccompare :: ChanStatus -> ChanStatus -> Ordering
compare :: ChanStatus -> ChanStatus -> Ordering
$c< :: ChanStatus -> ChanStatus -> Bool
< :: ChanStatus -> ChanStatus -> Bool
$c<= :: ChanStatus -> ChanStatus -> Bool
<= :: ChanStatus -> ChanStatus -> Bool
$c> :: ChanStatus -> ChanStatus -> Bool
> :: ChanStatus -> ChanStatus -> Bool
$c>= :: ChanStatus -> ChanStatus -> Bool
>= :: ChanStatus -> ChanStatus -> Bool
$cmax :: ChanStatus -> ChanStatus -> ChanStatus
max :: ChanStatus -> ChanStatus -> ChanStatus
$cmin :: ChanStatus -> ChanStatus -> ChanStatus
min :: ChanStatus -> ChanStatus -> ChanStatus
Ord, Int -> ChanStatus -> ShowS
[ChanStatus] -> ShowS
ChanStatus -> String
(Int -> ChanStatus -> ShowS)
-> (ChanStatus -> String)
-> ([ChanStatus] -> ShowS)
-> Show ChanStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChanStatus -> ShowS
showsPrec :: Int -> ChanStatus -> ShowS
$cshow :: ChanStatus -> String
show :: ChanStatus -> String
$cshowList :: [ChanStatus] -> ShowS
showList :: [ChanStatus] -> ShowS
Show, (forall x. ChanStatus -> Rep ChanStatus x)
-> (forall x. Rep ChanStatus x -> ChanStatus) -> Generic ChanStatus
forall x. Rep ChanStatus x -> ChanStatus
forall x. ChanStatus -> Rep ChanStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChanStatus -> Rep ChanStatus x
from :: forall x. ChanStatus -> Rep ChanStatus x
$cto :: forall x. Rep ChanStatus x -> ChanStatus
to :: forall x. Rep ChanStatus x -> ChanStatus
Generic)

-- private
data StatusPeek
  = StatusPeekYes
  | StatusPeekNo !Word8
  deriving stock (StatusPeek -> StatusPeek -> Bool
(StatusPeek -> StatusPeek -> Bool)
-> (StatusPeek -> StatusPeek -> Bool) -> Eq StatusPeek
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusPeek -> StatusPeek -> Bool
== :: StatusPeek -> StatusPeek -> Bool
$c/= :: StatusPeek -> StatusPeek -> Bool
/= :: StatusPeek -> StatusPeek -> Bool
Eq, Int -> StatusPeek -> ShowS
[StatusPeek] -> ShowS
StatusPeek -> String
(Int -> StatusPeek -> ShowS)
-> (StatusPeek -> String)
-> ([StatusPeek] -> ShowS)
-> Show StatusPeek
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusPeek -> ShowS
showsPrec :: Int -> StatusPeek -> ShowS
$cshow :: StatusPeek -> String
show :: StatusPeek -> String
$cshowList :: [StatusPeek] -> ShowS
showList :: [StatusPeek] -> ShowS
Show)

-- private
peekStatus :: Get StatusPeek
peekStatus :: Get StatusPeek
peekStatus = Get StatusPeek -> Get StatusPeek
forall a. Get a -> Get a
getLookAhead (Get StatusPeek -> Get StatusPeek)
-> Get StatusPeek -> Get StatusPeek
forall a b. (a -> b) -> a -> b
$ do
  Word8
b <- forall a. Binary a => Get a
get @Word8
  StatusPeek -> Get StatusPeek
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StatusPeek -> Get StatusPeek) -> StatusPeek -> Get StatusPeek
forall a b. (a -> b) -> a -> b
$!
    if Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x80 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
      then Word8 -> StatusPeek
StatusPeekNo Word8
b
      else StatusPeek
StatusPeekYes

class HasChanStatus s where
  statusIsChan :: s -> Bool
  statusAsChan :: s -> Maybe ChanStatus
  statusFromChan :: ChanStatus -> s

data LiveStatus
  = LiveStatusChan !ChanStatus
  | LiveStatusSysEx
  | LiveStatusSysCommon !CommonStatus
  | LiveStatusSysRt !RtStatus
  deriving stock (LiveStatus -> LiveStatus -> Bool
(LiveStatus -> LiveStatus -> Bool)
-> (LiveStatus -> LiveStatus -> Bool) -> Eq LiveStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LiveStatus -> LiveStatus -> Bool
== :: LiveStatus -> LiveStatus -> Bool
$c/= :: LiveStatus -> LiveStatus -> Bool
/= :: LiveStatus -> LiveStatus -> Bool
Eq, Eq LiveStatus
Eq LiveStatus =>
(LiveStatus -> LiveStatus -> Ordering)
-> (LiveStatus -> LiveStatus -> Bool)
-> (LiveStatus -> LiveStatus -> Bool)
-> (LiveStatus -> LiveStatus -> Bool)
-> (LiveStatus -> LiveStatus -> Bool)
-> (LiveStatus -> LiveStatus -> LiveStatus)
-> (LiveStatus -> LiveStatus -> LiveStatus)
-> Ord LiveStatus
LiveStatus -> LiveStatus -> Bool
LiveStatus -> LiveStatus -> Ordering
LiveStatus -> LiveStatus -> LiveStatus
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
$ccompare :: LiveStatus -> LiveStatus -> Ordering
compare :: LiveStatus -> LiveStatus -> Ordering
$c< :: LiveStatus -> LiveStatus -> Bool
< :: LiveStatus -> LiveStatus -> Bool
$c<= :: LiveStatus -> LiveStatus -> Bool
<= :: LiveStatus -> LiveStatus -> Bool
$c> :: LiveStatus -> LiveStatus -> Bool
> :: LiveStatus -> LiveStatus -> Bool
$c>= :: LiveStatus -> LiveStatus -> Bool
>= :: LiveStatus -> LiveStatus -> Bool
$cmax :: LiveStatus -> LiveStatus -> LiveStatus
max :: LiveStatus -> LiveStatus -> LiveStatus
$cmin :: LiveStatus -> LiveStatus -> LiveStatus
min :: LiveStatus -> LiveStatus -> LiveStatus
Ord, Int -> LiveStatus -> ShowS
[LiveStatus] -> ShowS
LiveStatus -> String
(Int -> LiveStatus -> ShowS)
-> (LiveStatus -> String)
-> ([LiveStatus] -> ShowS)
-> Show LiveStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LiveStatus -> ShowS
showsPrec :: Int -> LiveStatus -> ShowS
$cshow :: LiveStatus -> String
show :: LiveStatus -> String
$cshowList :: [LiveStatus] -> ShowS
showList :: [LiveStatus] -> ShowS
Show, (forall x. LiveStatus -> Rep LiveStatus x)
-> (forall x. Rep LiveStatus x -> LiveStatus) -> Generic LiveStatus
forall x. Rep LiveStatus x -> LiveStatus
forall x. LiveStatus -> Rep LiveStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LiveStatus -> Rep LiveStatus x
from :: forall x. LiveStatus -> Rep LiveStatus x
$cto :: forall x. Rep LiveStatus x -> LiveStatus
to :: forall x. Rep LiveStatus x -> LiveStatus
Generic)

instance StaticByteSized LiveStatus where
  type StaticSize LiveStatus = 1
  staticByteSize :: Proxy LiveStatus -> ByteCount
staticByteSize Proxy LiveStatus
_ = ByteCount
1

instance HasChanStatus LiveStatus where
  statusIsChan :: LiveStatus -> Bool
statusIsChan = \case
    LiveStatusChan ChanStatus
_ -> Bool
True
    LiveStatus
_ -> Bool
False

  statusAsChan :: LiveStatus -> Maybe ChanStatus
statusAsChan = \case
    LiveStatusChan ChanStatus
cs -> ChanStatus -> Maybe ChanStatus
forall a. a -> Maybe a
Just ChanStatus
cs
    LiveStatus
_ -> Maybe ChanStatus
forall a. Maybe a
Nothing

  statusFromChan :: ChanStatus -> LiveStatus
statusFromChan = ChanStatus -> LiveStatus
LiveStatusChan

instance Binary LiveStatus where
  byteSize :: LiveStatus -> ByteCount
byteSize LiveStatus
_ = ByteCount
1
  get :: Get LiveStatus
get = do
    Word8
b <- forall a. Binary a => Get a
get @Word8
    let x :: Word8
x = Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xF0
    if
      | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
0x80 -> String -> Get LiveStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Live status byte with high bit clear: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0xF0 ->
          case Word8
b of
            Word8
0xF0 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure LiveStatus
LiveStatusSysEx
            Word8
0xF1 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> LiveStatus
LiveStatusSysCommon CommonStatus
CommonStatusTimeFrame)
            Word8
0xF2 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> LiveStatus
LiveStatusSysCommon CommonStatus
CommonStatusSongPointer)
            Word8
0xF3 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> LiveStatus
LiveStatusSysCommon CommonStatus
CommonStatusSongSelect)
            Word8
0xF6 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> LiveStatus
LiveStatusSysCommon CommonStatus
CommonStatusTuneRequest)
            Word8
0xF8 -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusTimingClock)
            Word8
0xFA -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusStart)
            Word8
0xFB -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusContinue)
            Word8
0xFC -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusStop)
            Word8
0xFE -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusActiveSensing)
            Word8
0xFF -> LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
RtStatusSystemReset)
            Word8
_ -> String -> Get LiveStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unknown system status byte: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Bool
otherwise -> do
          let c :: Channel
c = MidiWord7 -> Channel
Channel (Word8 -> MidiWord7
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0F))
          LiveStatus -> Get LiveStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LiveStatus -> Get LiveStatus) -> LiveStatus -> Get LiveStatus
forall a b. (a -> b) -> a -> b
$ ChanStatus -> LiveStatus
LiveStatusChan (ChanStatus -> LiveStatus) -> ChanStatus -> LiveStatus
forall a b. (a -> b) -> a -> b
$ Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
c (ChanStatusType -> ChanStatus) -> ChanStatusType -> ChanStatus
forall a b. (a -> b) -> a -> b
$ case Word8
x of
            Word8
0x80 -> ChanStatusType
ChanStatusNoteOff
            Word8
0x90 -> ChanStatusType
ChanStatusNoteOn
            Word8
0xA0 -> ChanStatusType
ChanStatusKeyAftertouch
            Word8
0xB0 -> ChanStatusType
ChanStatusControlChange
            Word8
0xC0 -> ChanStatusType
ChanStatusProgramChange
            Word8
0xD0 -> ChanStatusType
ChanStatusChanAftertouch
            Word8
0xE0 -> ChanStatusType
ChanStatusPitchBend
            Word8
_ -> String -> ChanStatusType
forall a. HasCallStack => String -> a
error String
"impossible"
  put :: LiveStatus -> Put
put = \case
    LiveStatusChan (ChanStatus Channel
c ChanStatusType
cs) ->
      let d :: Word8
d = MidiWord7 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Channel -> MidiWord7
unChannel Channel
c)
          x :: Word8
x = case ChanStatusType
cs of
            ChanStatusType
ChanStatusNoteOff -> Word8
0x80
            ChanStatusType
ChanStatusNoteOn -> Word8
0x90
            ChanStatusType
ChanStatusKeyAftertouch -> Word8
0xA0
            ChanStatusType
ChanStatusControlChange -> Word8
0xB0
            ChanStatusType
ChanStatusProgramChange -> Word8
0xC0
            ChanStatusType
ChanStatusChanAftertouch -> Word8
0xD0
            ChanStatusType
ChanStatusPitchBend -> Word8
0xE0
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
d Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
    LiveStatus
LiveStatusSysEx -> forall a. Binary a => a -> Put
put @Word8 Word8
0xF0
    LiveStatusSysCommon CommonStatus
cs ->
      let x :: Word8
x = case CommonStatus
cs of
            CommonStatus
CommonStatusTimeFrame -> Word8
0x01
            CommonStatus
CommonStatusSongPointer -> Word8
0x02
            CommonStatus
CommonStatusSongSelect -> Word8
0x03
            CommonStatus
CommonStatusTuneRequest -> Word8
0x06
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
0xF0 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
    LiveStatusSysRt RtStatus
rs ->
      let !x :: Word8
x = case RtStatus
rs of
            RtStatus
RtStatusTimingClock -> Word8
0x00
            RtStatus
RtStatusStart -> Word8
0x02
            RtStatus
RtStatusContinue -> Word8
0x03
            RtStatus
RtStatusStop -> Word8
0x04
            RtStatus
RtStatusActiveSensing -> Word8
0x06
            RtStatus
RtStatusSystemReset -> Word8
0x7
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
0xF8 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)

data RecStatus
  = RecStatusChan !ChanStatus
  | RecStatusSysEx
  | RecStatusMeta
  deriving stock (RecStatus -> RecStatus -> Bool
(RecStatus -> RecStatus -> Bool)
-> (RecStatus -> RecStatus -> Bool) -> Eq RecStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecStatus -> RecStatus -> Bool
== :: RecStatus -> RecStatus -> Bool
$c/= :: RecStatus -> RecStatus -> Bool
/= :: RecStatus -> RecStatus -> Bool
Eq, Eq RecStatus
Eq RecStatus =>
(RecStatus -> RecStatus -> Ordering)
-> (RecStatus -> RecStatus -> Bool)
-> (RecStatus -> RecStatus -> Bool)
-> (RecStatus -> RecStatus -> Bool)
-> (RecStatus -> RecStatus -> Bool)
-> (RecStatus -> RecStatus -> RecStatus)
-> (RecStatus -> RecStatus -> RecStatus)
-> Ord RecStatus
RecStatus -> RecStatus -> Bool
RecStatus -> RecStatus -> Ordering
RecStatus -> RecStatus -> RecStatus
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
$ccompare :: RecStatus -> RecStatus -> Ordering
compare :: RecStatus -> RecStatus -> Ordering
$c< :: RecStatus -> RecStatus -> Bool
< :: RecStatus -> RecStatus -> Bool
$c<= :: RecStatus -> RecStatus -> Bool
<= :: RecStatus -> RecStatus -> Bool
$c> :: RecStatus -> RecStatus -> Bool
> :: RecStatus -> RecStatus -> Bool
$c>= :: RecStatus -> RecStatus -> Bool
>= :: RecStatus -> RecStatus -> Bool
$cmax :: RecStatus -> RecStatus -> RecStatus
max :: RecStatus -> RecStatus -> RecStatus
$cmin :: RecStatus -> RecStatus -> RecStatus
min :: RecStatus -> RecStatus -> RecStatus
Ord, Int -> RecStatus -> ShowS
[RecStatus] -> ShowS
RecStatus -> String
(Int -> RecStatus -> ShowS)
-> (RecStatus -> String)
-> ([RecStatus] -> ShowS)
-> Show RecStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecStatus -> ShowS
showsPrec :: Int -> RecStatus -> ShowS
$cshow :: RecStatus -> String
show :: RecStatus -> String
$cshowList :: [RecStatus] -> ShowS
showList :: [RecStatus] -> ShowS
Show, (forall x. RecStatus -> Rep RecStatus x)
-> (forall x. Rep RecStatus x -> RecStatus) -> Generic RecStatus
forall x. Rep RecStatus x -> RecStatus
forall x. RecStatus -> Rep RecStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RecStatus -> Rep RecStatus x
from :: forall x. RecStatus -> Rep RecStatus x
$cto :: forall x. Rep RecStatus x -> RecStatus
to :: forall x. Rep RecStatus x -> RecStatus
Generic)

instance StaticByteSized RecStatus where
  type StaticSize RecStatus = 1
  staticByteSize :: Proxy RecStatus -> ByteCount
staticByteSize Proxy RecStatus
_ = ByteCount
1

instance HasChanStatus RecStatus where
  statusIsChan :: RecStatus -> Bool
statusIsChan = \case
    RecStatusChan ChanStatus
_ -> Bool
True
    RecStatus
_ -> Bool
False

  statusAsChan :: RecStatus -> Maybe ChanStatus
statusAsChan = \case
    RecStatusChan ChanStatus
cs -> ChanStatus -> Maybe ChanStatus
forall a. a -> Maybe a
Just ChanStatus
cs
    RecStatus
_ -> Maybe ChanStatus
forall a. Maybe a
Nothing

  statusFromChan :: ChanStatus -> RecStatus
statusFromChan = ChanStatus -> RecStatus
RecStatusChan

instance Binary RecStatus where
  byteSize :: RecStatus -> ByteCount
byteSize RecStatus
_ = ByteCount
1
  get :: Get RecStatus
get = do
    Word8
b <- forall a. Binary a => Get a
get @Word8
    let x :: Word8
x = Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xF0
    if
      | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
0x80 -> String -> Get RecStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Rec status byte with high bit clear: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0xF0 ->
          case Word8
b of
            Word8
0xF0 -> RecStatus -> Get RecStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RecStatus
RecStatusSysEx
            Word8
0xFF -> RecStatus -> Get RecStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RecStatus
RecStatusMeta
            Word8
_ -> String -> Get RecStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unknown rec status byte: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Bool
otherwise -> do
          let c :: Channel
c = MidiWord7 -> Channel
Channel (Word8 -> MidiWord7
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0F))
          RecStatus -> Get RecStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RecStatus -> Get RecStatus) -> RecStatus -> Get RecStatus
forall a b. (a -> b) -> a -> b
$ ChanStatus -> RecStatus
RecStatusChan (ChanStatus -> RecStatus) -> ChanStatus -> RecStatus
forall a b. (a -> b) -> a -> b
$ Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
c (ChanStatusType -> ChanStatus) -> ChanStatusType -> ChanStatus
forall a b. (a -> b) -> a -> b
$ case Word8
x of
            Word8
0x80 -> ChanStatusType
ChanStatusNoteOff
            Word8
0x90 -> ChanStatusType
ChanStatusNoteOn
            Word8
0xA0 -> ChanStatusType
ChanStatusKeyAftertouch
            Word8
0xB0 -> ChanStatusType
ChanStatusControlChange
            Word8
0xC0 -> ChanStatusType
ChanStatusProgramChange
            Word8
0xD0 -> ChanStatusType
ChanStatusChanAftertouch
            Word8
0xE0 -> ChanStatusType
ChanStatusPitchBend
            Word8
_ -> String -> ChanStatusType
forall a. HasCallStack => String -> a
error String
"impossible"
  put :: RecStatus -> Put
put = \case
    RecStatusChan (ChanStatus Channel
c ChanStatusType
cs) ->
      let d :: Word8
d = MidiWord7 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Channel -> MidiWord7
unChannel Channel
c)
          x :: Word8
x = case ChanStatusType
cs of
            ChanStatusType
ChanStatusNoteOff -> Word8
0x80
            ChanStatusType
ChanStatusNoteOn -> Word8
0x90
            ChanStatusType
ChanStatusKeyAftertouch -> Word8
0xA0
            ChanStatusType
ChanStatusControlChange -> Word8
0xB0
            ChanStatusType
ChanStatusProgramChange -> Word8
0xC0
            ChanStatusType
ChanStatusChanAftertouch -> Word8
0xD0
            ChanStatusType
ChanStatusPitchBend -> Word8
0xE0
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
d Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
    RecStatus
RecStatusSysEx -> forall a. Binary a => a -> Put
put @Word8 Word8
0xF0
    RecStatus
RecStatusMeta -> forall a. Binary a => a -> Put
put @Word8 Word8
0xFF

data ShortStatus
  = ShortStatusChan !ChanStatus
  | ShortStatusSysCommon !CommonStatus
  | ShortStatusSysRt !RtStatus
  deriving stock (ShortStatus -> ShortStatus -> Bool
(ShortStatus -> ShortStatus -> Bool)
-> (ShortStatus -> ShortStatus -> Bool) -> Eq ShortStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShortStatus -> ShortStatus -> Bool
== :: ShortStatus -> ShortStatus -> Bool
$c/= :: ShortStatus -> ShortStatus -> Bool
/= :: ShortStatus -> ShortStatus -> Bool
Eq, Eq ShortStatus
Eq ShortStatus =>
(ShortStatus -> ShortStatus -> Ordering)
-> (ShortStatus -> ShortStatus -> Bool)
-> (ShortStatus -> ShortStatus -> Bool)
-> (ShortStatus -> ShortStatus -> Bool)
-> (ShortStatus -> ShortStatus -> Bool)
-> (ShortStatus -> ShortStatus -> ShortStatus)
-> (ShortStatus -> ShortStatus -> ShortStatus)
-> Ord ShortStatus
ShortStatus -> ShortStatus -> Bool
ShortStatus -> ShortStatus -> Ordering
ShortStatus -> ShortStatus -> ShortStatus
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
$ccompare :: ShortStatus -> ShortStatus -> Ordering
compare :: ShortStatus -> ShortStatus -> Ordering
$c< :: ShortStatus -> ShortStatus -> Bool
< :: ShortStatus -> ShortStatus -> Bool
$c<= :: ShortStatus -> ShortStatus -> Bool
<= :: ShortStatus -> ShortStatus -> Bool
$c> :: ShortStatus -> ShortStatus -> Bool
> :: ShortStatus -> ShortStatus -> Bool
$c>= :: ShortStatus -> ShortStatus -> Bool
>= :: ShortStatus -> ShortStatus -> Bool
$cmax :: ShortStatus -> ShortStatus -> ShortStatus
max :: ShortStatus -> ShortStatus -> ShortStatus
$cmin :: ShortStatus -> ShortStatus -> ShortStatus
min :: ShortStatus -> ShortStatus -> ShortStatus
Ord, Int -> ShortStatus -> ShowS
[ShortStatus] -> ShowS
ShortStatus -> String
(Int -> ShortStatus -> ShowS)
-> (ShortStatus -> String)
-> ([ShortStatus] -> ShowS)
-> Show ShortStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShortStatus -> ShowS
showsPrec :: Int -> ShortStatus -> ShowS
$cshow :: ShortStatus -> String
show :: ShortStatus -> String
$cshowList :: [ShortStatus] -> ShowS
showList :: [ShortStatus] -> ShowS
Show, (forall x. ShortStatus -> Rep ShortStatus x)
-> (forall x. Rep ShortStatus x -> ShortStatus)
-> Generic ShortStatus
forall x. Rep ShortStatus x -> ShortStatus
forall x. ShortStatus -> Rep ShortStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ShortStatus -> Rep ShortStatus x
from :: forall x. ShortStatus -> Rep ShortStatus x
$cto :: forall x. Rep ShortStatus x -> ShortStatus
to :: forall x. Rep ShortStatus x -> ShortStatus
Generic)

instance StaticByteSized ShortStatus where
  type StaticSize ShortStatus = 1
  staticByteSize :: Proxy ShortStatus -> ByteCount
staticByteSize Proxy ShortStatus
_ = ByteCount
1

instance HasChanStatus ShortStatus where
  statusIsChan :: ShortStatus -> Bool
statusIsChan = \case
    ShortStatusChan ChanStatus
_ -> Bool
True
    ShortStatus
_ -> Bool
False

  statusAsChan :: ShortStatus -> Maybe ChanStatus
statusAsChan = \case
    ShortStatusChan ChanStatus
cs -> ChanStatus -> Maybe ChanStatus
forall a. a -> Maybe a
Just ChanStatus
cs
    ShortStatus
_ -> Maybe ChanStatus
forall a. Maybe a
Nothing

  statusFromChan :: ChanStatus -> ShortStatus
statusFromChan = ChanStatus -> ShortStatus
ShortStatusChan

instance Binary ShortStatus where
  byteSize :: ShortStatus -> ByteCount
byteSize ShortStatus
_ = ByteCount
1
  get :: Get ShortStatus
get = do
    Word8
b <- forall a. Binary a => Get a
get @Word8
    let x :: Word8
x = Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xF0
    if
      | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
0x80 -> String -> Get ShortStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Short status byte with high bit clear: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0xF0 ->
          case Word8
b of
            Word8
0xF1 -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> ShortStatus
ShortStatusSysCommon CommonStatus
CommonStatusTimeFrame)
            Word8
0xF2 -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> ShortStatus
ShortStatusSysCommon CommonStatus
CommonStatusSongPointer)
            Word8
0xF3 -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> ShortStatus
ShortStatusSysCommon CommonStatus
CommonStatusSongSelect)
            Word8
0xF6 -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonStatus -> ShortStatus
ShortStatusSysCommon CommonStatus
CommonStatusTuneRequest)
            Word8
0xF8 -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusTimingClock)
            Word8
0xFA -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusStart)
            Word8
0xFB -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusContinue)
            Word8
0xFC -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusStop)
            Word8
0xFE -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusActiveSensing)
            Word8
0xFF -> ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
RtStatusSystemReset)
            Word8
_ -> String -> Get ShortStatus
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unknown system status byte: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
b)
      | Bool
otherwise -> do
          let c :: Channel
c = MidiWord7 -> Channel
Channel (Word8 -> MidiWord7
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
b Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0F))
          ShortStatus -> Get ShortStatus
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShortStatus -> Get ShortStatus) -> ShortStatus -> Get ShortStatus
forall a b. (a -> b) -> a -> b
$ ChanStatus -> ShortStatus
ShortStatusChan (ChanStatus -> ShortStatus) -> ChanStatus -> ShortStatus
forall a b. (a -> b) -> a -> b
$ Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
c (ChanStatusType -> ChanStatus) -> ChanStatusType -> ChanStatus
forall a b. (a -> b) -> a -> b
$ case Word8
x of
            Word8
0x80 -> ChanStatusType
ChanStatusNoteOff
            Word8
0x90 -> ChanStatusType
ChanStatusNoteOn
            Word8
0xA0 -> ChanStatusType
ChanStatusKeyAftertouch
            Word8
0xB0 -> ChanStatusType
ChanStatusControlChange
            Word8
0xC0 -> ChanStatusType
ChanStatusProgramChange
            Word8
0xD0 -> ChanStatusType
ChanStatusChanAftertouch
            Word8
0xE0 -> ChanStatusType
ChanStatusPitchBend
            Word8
_ -> String -> ChanStatusType
forall a. HasCallStack => String -> a
error String
"impossible"
  put :: ShortStatus -> Put
put = \case
    ShortStatusChan (ChanStatus Channel
c ChanStatusType
cs) ->
      let d :: Word8
d = MidiWord7 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Channel -> MidiWord7
unChannel Channel
c)
          x :: Word8
x = case ChanStatusType
cs of
            ChanStatusType
ChanStatusNoteOff -> Word8
0x80
            ChanStatusType
ChanStatusNoteOn -> Word8
0x90
            ChanStatusType
ChanStatusKeyAftertouch -> Word8
0xA0
            ChanStatusType
ChanStatusControlChange -> Word8
0xB0
            ChanStatusType
ChanStatusProgramChange -> Word8
0xC0
            ChanStatusType
ChanStatusChanAftertouch -> Word8
0xD0
            ChanStatusType
ChanStatusPitchBend -> Word8
0xE0
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
d Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
    ShortStatusSysCommon CommonStatus
cs ->
      let x :: Word8
x = case CommonStatus
cs of
            CommonStatus
CommonStatusTimeFrame -> Word8
0x01
            CommonStatus
CommonStatusSongPointer -> Word8
0x02
            CommonStatus
CommonStatusSongSelect -> Word8
0x03
            CommonStatus
CommonStatusTuneRequest -> Word8
0x06
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
0xF0 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
    ShortStatusSysRt RtStatus
rs ->
      let !x :: Word8
x = case RtStatus
rs of
            RtStatus
RtStatusTimingClock -> Word8
0x00
            RtStatus
RtStatusStart -> Word8
0x02
            RtStatus
RtStatusContinue -> Word8
0x03
            RtStatus
RtStatusStop -> Word8
0x04
            RtStatus
RtStatusActiveSensing -> Word8
0x06
            RtStatus
RtStatusSystemReset -> Word8
0x7
      in  forall a. Binary a => a -> Put
put @Word8 (Word8
0xF8 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)

-- | A byte string prefixed by a single-byte length
newtype MetaString = MetaString {MetaString -> ShortByteString
unMetaString :: ShortByteString}
  deriving stock (Int -> MetaString -> ShowS
[MetaString] -> ShowS
MetaString -> String
(Int -> MetaString -> ShowS)
-> (MetaString -> String)
-> ([MetaString] -> ShowS)
-> Show MetaString
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetaString -> ShowS
showsPrec :: Int -> MetaString -> ShowS
$cshow :: MetaString -> String
show :: MetaString -> String
$cshowList :: [MetaString] -> ShowS
showList :: [MetaString] -> ShowS
Show)
  deriving newtype (MetaString -> MetaString -> Bool
(MetaString -> MetaString -> Bool)
-> (MetaString -> MetaString -> Bool) -> Eq MetaString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetaString -> MetaString -> Bool
== :: MetaString -> MetaString -> Bool
$c/= :: MetaString -> MetaString -> Bool
/= :: MetaString -> MetaString -> Bool
Eq, Eq MetaString
Eq MetaString =>
(MetaString -> MetaString -> Ordering)
-> (MetaString -> MetaString -> Bool)
-> (MetaString -> MetaString -> Bool)
-> (MetaString -> MetaString -> Bool)
-> (MetaString -> MetaString -> Bool)
-> (MetaString -> MetaString -> MetaString)
-> (MetaString -> MetaString -> MetaString)
-> Ord MetaString
MetaString -> MetaString -> Bool
MetaString -> MetaString -> Ordering
MetaString -> MetaString -> MetaString
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
$ccompare :: MetaString -> MetaString -> Ordering
compare :: MetaString -> MetaString -> Ordering
$c< :: MetaString -> MetaString -> Bool
< :: MetaString -> MetaString -> Bool
$c<= :: MetaString -> MetaString -> Bool
<= :: MetaString -> MetaString -> Bool
$c> :: MetaString -> MetaString -> Bool
> :: MetaString -> MetaString -> Bool
$c>= :: MetaString -> MetaString -> Bool
>= :: MetaString -> MetaString -> Bool
$cmax :: MetaString -> MetaString -> MetaString
max :: MetaString -> MetaString -> MetaString
$cmin :: MetaString -> MetaString -> MetaString
min :: MetaString -> MetaString -> MetaString
Ord, String -> MetaString
(String -> MetaString) -> IsString MetaString
forall a. (String -> a) -> IsString a
$cfromString :: String -> MetaString
fromString :: String -> MetaString
IsString)

instance Binary MetaString where
  byteSize :: MetaString -> ByteCount
byteSize = ByteCount -> ByteCount
forall a. Enum a => a -> a
succ (ByteCount -> ByteCount)
-> (MetaString -> ByteCount) -> MetaString -> ByteCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> ByteCount)
-> (MetaString -> Int) -> MetaString -> ByteCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> Int
BSS.length (ShortByteString -> Int)
-> (MetaString -> ShortByteString) -> MetaString -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MetaString -> ShortByteString
unMetaString
  get :: Get MetaString
get = do
    Word8
len <- forall a. Binary a => Get a
get @Word8
    ShortByteString
s <- ByteCount -> Get ShortByteString
getByteString (Word8 -> ByteCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
len)
    MetaString -> Get MetaString
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShortByteString -> MetaString
MetaString ShortByteString
s)
  put :: MetaString -> Put
put (MetaString ShortByteString
s) = do
    let len :: Int
len = ShortByteString -> Int
BSS.length ShortByteString
s
    if Int
len Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
255
      then do
        forall a. Binary a => a -> Put
put @Word8 Word8
255
        ShortByteString -> Put
putByteString (Int -> ShortByteString -> ShortByteString
BSS.take Int
255 ShortByteString
s)
      else do
        forall a. Binary a => a -> Put
put @Word8 (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
        ShortByteString -> Put
putByteString ShortByteString
s

data MetaData = MetaData
  { MetaData -> Word8
mdType :: !Word8
  , MetaData -> MetaString
mdBody :: !MetaString
  }
  deriving stock (MetaData -> MetaData -> Bool
(MetaData -> MetaData -> Bool)
-> (MetaData -> MetaData -> Bool) -> Eq MetaData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetaData -> MetaData -> Bool
== :: MetaData -> MetaData -> Bool
$c/= :: MetaData -> MetaData -> Bool
/= :: MetaData -> MetaData -> Bool
Eq, Eq MetaData
Eq MetaData =>
(MetaData -> MetaData -> Ordering)
-> (MetaData -> MetaData -> Bool)
-> (MetaData -> MetaData -> Bool)
-> (MetaData -> MetaData -> Bool)
-> (MetaData -> MetaData -> Bool)
-> (MetaData -> MetaData -> MetaData)
-> (MetaData -> MetaData -> MetaData)
-> Ord MetaData
MetaData -> MetaData -> Bool
MetaData -> MetaData -> Ordering
MetaData -> MetaData -> MetaData
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
$ccompare :: MetaData -> MetaData -> Ordering
compare :: MetaData -> MetaData -> Ordering
$c< :: MetaData -> MetaData -> Bool
< :: MetaData -> MetaData -> Bool
$c<= :: MetaData -> MetaData -> Bool
<= :: MetaData -> MetaData -> Bool
$c> :: MetaData -> MetaData -> Bool
> :: MetaData -> MetaData -> Bool
$c>= :: MetaData -> MetaData -> Bool
>= :: MetaData -> MetaData -> Bool
$cmax :: MetaData -> MetaData -> MetaData
max :: MetaData -> MetaData -> MetaData
$cmin :: MetaData -> MetaData -> MetaData
min :: MetaData -> MetaData -> MetaData
Ord, Int -> MetaData -> ShowS
[MetaData] -> ShowS
MetaData -> String
(Int -> MetaData -> ShowS)
-> (MetaData -> String) -> ([MetaData] -> ShowS) -> Show MetaData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetaData -> ShowS
showsPrec :: Int -> MetaData -> ShowS
$cshow :: MetaData -> String
show :: MetaData -> String
$cshowList :: [MetaData] -> ShowS
showList :: [MetaData] -> ShowS
Show, (forall x. MetaData -> Rep MetaData x)
-> (forall x. Rep MetaData x -> MetaData) -> Generic MetaData
forall x. Rep MetaData x -> MetaData
forall x. MetaData -> Rep MetaData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MetaData -> Rep MetaData x
from :: forall x. MetaData -> Rep MetaData x
$cto :: forall x. Rep MetaData x -> MetaData
to :: forall x. Rep MetaData x -> MetaData
Generic)
  deriving (Get MetaData
MetaData -> ByteCount
MetaData -> Put
(MetaData -> ByteCount)
-> Get MetaData -> (MetaData -> Put) -> Binary MetaData
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: MetaData -> ByteCount
byteSize :: MetaData -> ByteCount
$cget :: Get MetaData
get :: Get MetaData
$cput :: MetaData -> Put
put :: MetaData -> Put
Binary) via (ViaGeneric MetaData)

-- newtype Tempo = Tempo {unTempo :: Word24BE}
--   deriving stock (Show)
--   deriving newtype (Eq, Ord, ByteSized, StaticByteSized, Binary)

-- data MetaData
--   = MDSeqNum !Word16
--   | MDText !MetaString
--   | MDCopyright !MetaString
--   | MDSeqName !MetaString
--   | MDInstName !MetaString
--   | MDLyrics !MetaString
--   | MDMarker !MetaString
--   | MDCuePoint !MetaString
--   | MDChanPrefix !Channel
--   | MDEndTrack
--   | MDSetTempo !Tempo
--   | MDSmpteOffset !Word8 !Word8 !Word8 !Word8 !Word8
--   | MDTimeSig !Word8 !Word8 !Word8 !Word8
--   | MDKeySig !Word8 !Word8
--   | MDSeqSpecific !SysExString
--   deriving stock (Eq, Ord, Show)

-- instance Arb I MetaData where
--   arb = genMD where
--     genMD = genSum $ NE.fromList
--       [ MDSeqNum <$> arb
--       , MDText <$> genS
--       , MDCopyright <$> genS
--       , MDSeqName <$> genS
--       , MDInstName <$> genS
--       , MDLyrics <$> genS
--       , MDMarker <$> genS
--       , MDCuePoint <$> genS
--       , MDChanPrefix <$> arb
--       , pure MDEndTrack
--       -- TODO fill in the rest
--       ]
--     genS = MetaString <$> arbSBS 0 3

-- instance Binary MetaData where
--   byteSize = succ . \case
--     MDSeqNum _ -> 2
--     MDText t -> byteSize t
--     MDCopyright t -> byteSize t
--     MDSeqName t -> byteSize t
--     MDInstName t -> byteSize t
--     MDLyrics t -> byteSize t
--     MDMarker t -> byteSize t
--     MDCuePoint t -> byteSize t
--     MDChanPrefix _ -> 1
--     MDEndTrack -> 0
--     MDSetTempo _ -> 3
--     MDSmpteOffset {} -> 5
--     MDTimeSig {} -> 4
--     MDKeySig _ _ -> 2
--     MDSeqSpecific ss -> byteSize ss
--   get = do
--     m <- get @Word8
--     case m of
--       0x00 -> fmap (MDSeqNum . unWord16BE) get
--       0x01 -> fmap MDText get
--       0x02 -> fmap MDCopyright get
--       0x03 -> fmap MDSeqName get
--       0x04 -> fmap MDInstName get
--       0x05 -> fmap MDLyrics get
--       0x06 -> fmap MDMarker get
--       0x07 -> fmap MDCuePoint get
--       0x20 -> fmap MDChanPrefix get
--       0x2F -> pure MDEndTrack
--       0x51 -> fmap MDSetTempo get
--       0x54 -> MDSmpteOffset <$> get <*> get <*> get <*> get <*> get
--       0x58 -> MDTimeSig <$> get <*> get <*> get <*> get
--       0x59 -> MDKeySig <$> get <*> get
--       0x7F -> fmap MDSeqSpecific get
--       _ -> fail ("Unknown metadata type: " ++ show m)
--   put = \case
--     MDSeqNum w -> put @Word8 0x00 *> put (Word16BE w)
--     MDText s -> put @Word8 0x01 *> put s
--     MDCopyright s -> put @Word8 0x02 *> put s
--     MDSeqName s -> put @Word8 0x03 *> put s
--     MDInstName s -> put @Word8 0x04 *> put s
--     MDLyrics s -> put @Word8 0x05 *> put s
--     MDMarker s -> put @Word8 0x06 *> put s
--     MDCuePoint s -> put @Word8 0x07 *> put s
--     MDChanPrefix c -> put @Word8 0x20 *> put c
--     MDEndTrack -> put @Word8 0x2F
--     MDSetTempo t -> put @Word8 0x51 *> put t
--     MDSmpteOffset {} -> put @Word8 0x54 *> error "TODO"
--     MDTimeSig {} -> put @Word8 0x58 *> error "TODO"
--     MDKeySig {} -> put @Word8 0x59 *> error "TODO"
--     MDSeqSpecific ss -> put @Word8 0x7F *> put ss

data ChanVoiceData
  = ChanVoiceDataNoteOff !Note !Velocity
  | ChanVoiceDataNoteOn !Note !Velocity
  | ChanVoiceKeyAftertouch !Note !Pressure
  | ChanVoiceControlChange !ControlNum !ControlVal
  | ChanVoiceProgramChange !ProgramNum
  | ChanVoiceChanAftertouch !Pressure
  | ChanVoicePitchBend !PitchBend
  deriving stock (ChanVoiceData -> ChanVoiceData -> Bool
(ChanVoiceData -> ChanVoiceData -> Bool)
-> (ChanVoiceData -> ChanVoiceData -> Bool) -> Eq ChanVoiceData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChanVoiceData -> ChanVoiceData -> Bool
== :: ChanVoiceData -> ChanVoiceData -> Bool
$c/= :: ChanVoiceData -> ChanVoiceData -> Bool
/= :: ChanVoiceData -> ChanVoiceData -> Bool
Eq, Eq ChanVoiceData
Eq ChanVoiceData =>
(ChanVoiceData -> ChanVoiceData -> Ordering)
-> (ChanVoiceData -> ChanVoiceData -> Bool)
-> (ChanVoiceData -> ChanVoiceData -> Bool)
-> (ChanVoiceData -> ChanVoiceData -> Bool)
-> (ChanVoiceData -> ChanVoiceData -> Bool)
-> (ChanVoiceData -> ChanVoiceData -> ChanVoiceData)
-> (ChanVoiceData -> ChanVoiceData -> ChanVoiceData)
-> Ord ChanVoiceData
ChanVoiceData -> ChanVoiceData -> Bool
ChanVoiceData -> ChanVoiceData -> Ordering
ChanVoiceData -> ChanVoiceData -> ChanVoiceData
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
$ccompare :: ChanVoiceData -> ChanVoiceData -> Ordering
compare :: ChanVoiceData -> ChanVoiceData -> Ordering
$c< :: ChanVoiceData -> ChanVoiceData -> Bool
< :: ChanVoiceData -> ChanVoiceData -> Bool
$c<= :: ChanVoiceData -> ChanVoiceData -> Bool
<= :: ChanVoiceData -> ChanVoiceData -> Bool
$c> :: ChanVoiceData -> ChanVoiceData -> Bool
> :: ChanVoiceData -> ChanVoiceData -> Bool
$c>= :: ChanVoiceData -> ChanVoiceData -> Bool
>= :: ChanVoiceData -> ChanVoiceData -> Bool
$cmax :: ChanVoiceData -> ChanVoiceData -> ChanVoiceData
max :: ChanVoiceData -> ChanVoiceData -> ChanVoiceData
$cmin :: ChanVoiceData -> ChanVoiceData -> ChanVoiceData
min :: ChanVoiceData -> ChanVoiceData -> ChanVoiceData
Ord, Int -> ChanVoiceData -> ShowS
[ChanVoiceData] -> ShowS
ChanVoiceData -> String
(Int -> ChanVoiceData -> ShowS)
-> (ChanVoiceData -> String)
-> ([ChanVoiceData] -> ShowS)
-> Show ChanVoiceData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChanVoiceData -> ShowS
showsPrec :: Int -> ChanVoiceData -> ShowS
$cshow :: ChanVoiceData -> String
show :: ChanVoiceData -> String
$cshowList :: [ChanVoiceData] -> ShowS
showList :: [ChanVoiceData] -> ShowS
Show)

byteSizeChanVoiceData :: ChanVoiceData -> ByteCount
byteSizeChanVoiceData :: ChanVoiceData -> ByteCount
byteSizeChanVoiceData = \case
  ChanVoiceDataNoteOff Note
_ Velocity
_ -> ByteCount
2
  ChanVoiceDataNoteOn Note
_ Velocity
_ -> ByteCount
2
  ChanVoiceKeyAftertouch Note
_ Pressure
_ -> ByteCount
2
  ChanVoiceControlChange ControlNum
_ ControlVal
_ -> ByteCount
2
  ChanVoiceProgramChange ProgramNum
_ -> ByteCount
1
  ChanVoiceChanAftertouch Pressure
_ -> ByteCount
1
  ChanVoicePitchBend PitchBend
_ -> ByteCount
2

-- private
putChanVoiceData :: ChanVoiceData -> Put
putChanVoiceData :: ChanVoiceData -> Put
putChanVoiceData = \case
  ChanVoiceDataNoteOff Note
n Velocity
v -> Note -> Put
forall a. Binary a => a -> Put
put Note
n Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Velocity -> Put
forall a. Binary a => a -> Put
put Velocity
v
  ChanVoiceDataNoteOn Note
n Velocity
v -> Note -> Put
forall a. Binary a => a -> Put
put Note
n Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Velocity -> Put
forall a. Binary a => a -> Put
put Velocity
v
  ChanVoiceKeyAftertouch Note
n Pressure
p -> Note -> Put
forall a. Binary a => a -> Put
put Note
n Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Pressure -> Put
forall a. Binary a => a -> Put
put Pressure
p
  ChanVoiceControlChange ControlNum
cn ControlVal
cv -> ControlNum -> Put
forall a. Binary a => a -> Put
put ControlNum
cn Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ControlVal -> Put
forall a. Binary a => a -> Put
put ControlVal
cv
  ChanVoiceProgramChange ProgramNum
pn -> ProgramNum -> Put
forall a. Binary a => a -> Put
put ProgramNum
pn
  ChanVoiceChanAftertouch Pressure
p -> Pressure -> Put
forall a. Binary a => a -> Put
put Pressure
p
  ChanVoicePitchBend PitchBend
pb -> PitchBend -> Put
forall a. Binary a => a -> Put
put PitchBend
pb

data ChanModeData
  = ChanModeAllSoundOff
  | ChanModeResetAllControllers
  | ChanModeLocalControlOff
  | ChanModeLocalControlOn
  | ChanModeAllNotesOff
  | ChanModeOmniOff
  | ChanModeOmniOn
  | ChanModeMonoOn !ChannelCount
  | ChanModeMonoOff
  deriving stock (ChanModeData -> ChanModeData -> Bool
(ChanModeData -> ChanModeData -> Bool)
-> (ChanModeData -> ChanModeData -> Bool) -> Eq ChanModeData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChanModeData -> ChanModeData -> Bool
== :: ChanModeData -> ChanModeData -> Bool
$c/= :: ChanModeData -> ChanModeData -> Bool
/= :: ChanModeData -> ChanModeData -> Bool
Eq, Eq ChanModeData
Eq ChanModeData =>
(ChanModeData -> ChanModeData -> Ordering)
-> (ChanModeData -> ChanModeData -> Bool)
-> (ChanModeData -> ChanModeData -> Bool)
-> (ChanModeData -> ChanModeData -> Bool)
-> (ChanModeData -> ChanModeData -> Bool)
-> (ChanModeData -> ChanModeData -> ChanModeData)
-> (ChanModeData -> ChanModeData -> ChanModeData)
-> Ord ChanModeData
ChanModeData -> ChanModeData -> Bool
ChanModeData -> ChanModeData -> Ordering
ChanModeData -> ChanModeData -> ChanModeData
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
$ccompare :: ChanModeData -> ChanModeData -> Ordering
compare :: ChanModeData -> ChanModeData -> Ordering
$c< :: ChanModeData -> ChanModeData -> Bool
< :: ChanModeData -> ChanModeData -> Bool
$c<= :: ChanModeData -> ChanModeData -> Bool
<= :: ChanModeData -> ChanModeData -> Bool
$c> :: ChanModeData -> ChanModeData -> Bool
> :: ChanModeData -> ChanModeData -> Bool
$c>= :: ChanModeData -> ChanModeData -> Bool
>= :: ChanModeData -> ChanModeData -> Bool
$cmax :: ChanModeData -> ChanModeData -> ChanModeData
max :: ChanModeData -> ChanModeData -> ChanModeData
$cmin :: ChanModeData -> ChanModeData -> ChanModeData
min :: ChanModeData -> ChanModeData -> ChanModeData
Ord, Int -> ChanModeData -> ShowS
[ChanModeData] -> ShowS
ChanModeData -> String
(Int -> ChanModeData -> ShowS)
-> (ChanModeData -> String)
-> ([ChanModeData] -> ShowS)
-> Show ChanModeData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChanModeData -> ShowS
showsPrec :: Int -> ChanModeData -> ShowS
$cshow :: ChanModeData -> String
show :: ChanModeData -> String
$cshowList :: [ChanModeData] -> ShowS
showList :: [ChanModeData] -> ShowS
Show, (forall x. ChanModeData -> Rep ChanModeData x)
-> (forall x. Rep ChanModeData x -> ChanModeData)
-> Generic ChanModeData
forall x. Rep ChanModeData x -> ChanModeData
forall x. ChanModeData -> Rep ChanModeData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChanModeData -> Rep ChanModeData x
from :: forall x. ChanModeData -> Rep ChanModeData x
$cto :: forall x. Rep ChanModeData x -> ChanModeData
to :: forall x. Rep ChanModeData x -> ChanModeData
Generic)

instance StaticByteSized ChanModeData where
  type StaticSize ChanModeData = 2
  staticByteSize :: Proxy ChanModeData -> ByteCount
staticByteSize Proxy ChanModeData
_ = ByteCount
2

-- private
putChanModeData :: ChanModeData -> Put
putChanModeData :: ChanModeData -> Put
putChanModeData = \case
  ChanModeData
ChanModeAllSoundOff -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x78
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeData
ChanModeResetAllControllers -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x79
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeData
ChanModeLocalControlOff -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7A
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeData
ChanModeLocalControlOn -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7A
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7F
  ChanModeData
ChanModeAllNotesOff -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7B
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeData
ChanModeOmniOff -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7C
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeData
ChanModeOmniOn -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7D
    forall a. Binary a => a -> Put
put @Word8 Word8
0
  ChanModeMonoOn ChannelCount
cc -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7E
    ChannelCount -> Put
forall a. Binary a => a -> Put
put ChannelCount
cc
  ChanModeData
ChanModeMonoOff -> do
    forall a. Binary a => a -> Put
put @Word8 Word8
0x7F
    forall a. Binary a => a -> Put
put @Word8 Word8
0

data ChanData
  = ChanDataVoice !ChanVoiceData
  | ChanDataMode !ChanModeData
  deriving stock (ChanData -> ChanData -> Bool
(ChanData -> ChanData -> Bool)
-> (ChanData -> ChanData -> Bool) -> Eq ChanData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChanData -> ChanData -> Bool
== :: ChanData -> ChanData -> Bool
$c/= :: ChanData -> ChanData -> Bool
/= :: ChanData -> ChanData -> Bool
Eq, Eq ChanData
Eq ChanData =>
(ChanData -> ChanData -> Ordering)
-> (ChanData -> ChanData -> Bool)
-> (ChanData -> ChanData -> Bool)
-> (ChanData -> ChanData -> Bool)
-> (ChanData -> ChanData -> Bool)
-> (ChanData -> ChanData -> ChanData)
-> (ChanData -> ChanData -> ChanData)
-> Ord ChanData
ChanData -> ChanData -> Bool
ChanData -> ChanData -> Ordering
ChanData -> ChanData -> ChanData
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
$ccompare :: ChanData -> ChanData -> Ordering
compare :: ChanData -> ChanData -> Ordering
$c< :: ChanData -> ChanData -> Bool
< :: ChanData -> ChanData -> Bool
$c<= :: ChanData -> ChanData -> Bool
<= :: ChanData -> ChanData -> Bool
$c> :: ChanData -> ChanData -> Bool
> :: ChanData -> ChanData -> Bool
$c>= :: ChanData -> ChanData -> Bool
>= :: ChanData -> ChanData -> Bool
$cmax :: ChanData -> ChanData -> ChanData
max :: ChanData -> ChanData -> ChanData
$cmin :: ChanData -> ChanData -> ChanData
min :: ChanData -> ChanData -> ChanData
Ord, Int -> ChanData -> ShowS
[ChanData] -> ShowS
ChanData -> String
(Int -> ChanData -> ShowS)
-> (ChanData -> String) -> ([ChanData] -> ShowS) -> Show ChanData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChanData -> ShowS
showsPrec :: Int -> ChanData -> ShowS
$cshow :: ChanData -> String
show :: ChanData -> String
$cshowList :: [ChanData] -> ShowS
showList :: [ChanData] -> ShowS
Show, (forall x. ChanData -> Rep ChanData x)
-> (forall x. Rep ChanData x -> ChanData) -> Generic ChanData
forall x. Rep ChanData x -> ChanData
forall x. ChanData -> Rep ChanData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChanData -> Rep ChanData x
from :: forall x. ChanData -> Rep ChanData x
$cto :: forall x. Rep ChanData x -> ChanData
to :: forall x. Rep ChanData x -> ChanData
Generic)

byteSizeChanData :: ChanData -> ByteCount
byteSizeChanData :: ChanData -> ByteCount
byteSizeChanData = \case
  ChanDataVoice ChanVoiceData
cvd -> ChanVoiceData -> ByteCount
byteSizeChanVoiceData ChanVoiceData
cvd
  ChanDataMode ChanModeData
_ -> Proxy ChanModeData -> ByteCount
forall a. StaticByteSized a => Proxy a -> ByteCount
staticByteSize (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @ChanModeData)

chanDataType :: ChanData -> ChanStatusType
chanDataType :: ChanData -> ChanStatusType
chanDataType = \case
  ChanDataVoice ChanVoiceData
cvd -> case ChanVoiceData
cvd of
    ChanVoiceDataNoteOff Note
_ Velocity
_ -> ChanStatusType
ChanStatusNoteOff
    ChanVoiceDataNoteOn Note
_ Velocity
_ -> ChanStatusType
ChanStatusNoteOn
    ChanVoiceKeyAftertouch Note
_ Pressure
_ -> ChanStatusType
ChanStatusKeyAftertouch
    ChanVoiceControlChange ControlNum
_ ControlVal
_ -> ChanStatusType
ChanStatusControlChange
    ChanVoiceProgramChange ProgramNum
_ -> ChanStatusType
ChanStatusProgramChange
    ChanVoiceChanAftertouch Pressure
_ -> ChanStatusType
ChanStatusChanAftertouch
    ChanVoicePitchBend PitchBend
_ -> ChanStatusType
ChanStatusPitchBend
  ChanDataMode ChanModeData
_ -> ChanStatusType
ChanStatusControlChange

-- private
getChanData :: ChanStatus -> Get ChanData
getChanData :: ChanStatus -> Get ChanData
getChanData (ChanStatus Channel
_ ChanStatusType
ty) = case ChanStatusType
ty of
  ChanStatusType
ChanStatusNoteOff -> do
    Note
n <- forall a. Binary a => Get a
get @Note
    Velocity
v <- forall a. Binary a => Get a
get @Velocity
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (Note -> Velocity -> ChanVoiceData
ChanVoiceDataNoteOff Note
n Velocity
v))
  ChanStatusType
ChanStatusNoteOn -> do
    Note
n <- forall a. Binary a => Get a
get @Note
    Velocity
v <- forall a. Binary a => Get a
get @Velocity
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (Note -> Velocity -> ChanVoiceData
ChanVoiceDataNoteOn Note
n Velocity
v))
  ChanStatusType
ChanStatusKeyAftertouch -> do
    Note
n <- forall a. Binary a => Get a
get @Note
    Pressure
p <- forall a. Binary a => Get a
get @Pressure
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (Note -> Pressure -> ChanVoiceData
ChanVoiceKeyAftertouch Note
n Pressure
p))
  ChanStatusType
ChanStatusControlChange -> do
    ControlNum
cn <- forall a. Binary a => Get a
get @ControlNum
    ControlVal
cv <- forall a. Binary a => Get a
get @ControlVal
    case ControlNum -> MidiWord7
unControlNum ControlNum
cn of
      MidiWord7
0x78 -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode all sound off must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeAllSoundOff)
      MidiWord7
0x79 -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode reset all controllers must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeResetAllControllers)
      MidiWord7
0x7A -> do
        case ControlVal -> MidiWord7
unControlVal ControlVal
cv of
          MidiWord7
0 -> ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeLocalControlOff)
          MidiWord7
0x7F -> ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeLocalControlOn)
          MidiWord7
_ -> String -> Get ChanData
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode local control must be 0 or 127"
      MidiWord7
0x7B -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode all notes off must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeAllNotesOff)
      MidiWord7
0x7C -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode omni off must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeOmniOff)
      MidiWord7
0x7D -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode omni on must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeOmniOn)
      MidiWord7
0x7E ->
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode (ChannelCount -> ChanModeData
ChanModeMonoOn (MidiWord7 -> ChannelCount
ChannelCount (ControlVal -> MidiWord7
unControlVal ControlVal
cv))))
      MidiWord7
0x7F -> do
        Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ControlVal
cv ControlVal -> ControlVal -> Bool
forall a. Eq a => a -> a -> Bool
== ControlVal
0) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Chan mode mono off must have value 0")
        ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanModeData -> ChanData
ChanDataMode ChanModeData
ChanModeMonoOff)
      MidiWord7
_ -> ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (ControlNum -> ControlVal -> ChanVoiceData
ChanVoiceControlChange ControlNum
cn ControlVal
cv))
  ChanStatusType
ChanStatusProgramChange -> do
    ProgramNum
pn <- forall a. Binary a => Get a
get @ProgramNum
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (ProgramNum -> ChanVoiceData
ChanVoiceProgramChange ProgramNum
pn))
  ChanStatusType
ChanStatusChanAftertouch -> do
    Pressure
p <- forall a. Binary a => Get a
get @Pressure
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (Pressure -> ChanVoiceData
ChanVoiceChanAftertouch Pressure
p))
  ChanStatusType
ChanStatusPitchBend -> do
    PitchBend
pb <- forall a. Binary a => Get a
get @PitchBend
    ChanData -> Get ChanData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ChanVoiceData -> ChanData
ChanDataVoice (PitchBend -> ChanVoiceData
ChanVoicePitchBend PitchBend
pb))

putChanData :: ChanData -> Put
putChanData :: ChanData -> Put
putChanData = \case
  ChanDataVoice ChanVoiceData
cvd -> ChanVoiceData -> Put
putChanVoiceData ChanVoiceData
cvd
  ChanDataMode ChanModeData
cmd -> ChanModeData -> Put
putChanModeData ChanModeData
cmd

-- Gets bytestring until delimiter (consuming delimiter but not including in string)
getPayload :: Get ShortByteString
getPayload :: Get ShortByteString
getPayload = Get ShortByteString
go
 where
  go :: Get ShortByteString
go = do
    ByteCount
len <- Get ByteCount -> Get ByteCount
forall a. Get a -> Get a
getLookAhead (ByteCount -> Get ByteCount
forall {t}. Num t => t -> Get t
goFind ByteCount
0)
    ShortByteString
s <- ByteCount -> Get ShortByteString
getByteString ByteCount
len
    Word8
_ <- forall a. Binary a => Get a
get @Word8
    ShortByteString -> Get ShortByteString
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ShortByteString
s
  goFind :: t -> Get t
goFind !t
i = do
    Word8
w <- forall a. Binary a => Get a
get @Word8
    if Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0xF7
      then t -> Get t
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure t
i
      else t -> Get t
goFind (t
i t -> t -> t
forall a. Num a => a -> a -> a
+ t
1)

data UnivSysEx = UnivSysEx
  { UnivSysEx -> Word8
useSubId :: !Word8
  , UnivSysEx -> ShortByteString
usePayload :: !ShortByteString
  }
  deriving stock (UnivSysEx -> UnivSysEx -> Bool
(UnivSysEx -> UnivSysEx -> Bool)
-> (UnivSysEx -> UnivSysEx -> Bool) -> Eq UnivSysEx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnivSysEx -> UnivSysEx -> Bool
== :: UnivSysEx -> UnivSysEx -> Bool
$c/= :: UnivSysEx -> UnivSysEx -> Bool
/= :: UnivSysEx -> UnivSysEx -> Bool
Eq, Eq UnivSysEx
Eq UnivSysEx =>
(UnivSysEx -> UnivSysEx -> Ordering)
-> (UnivSysEx -> UnivSysEx -> Bool)
-> (UnivSysEx -> UnivSysEx -> Bool)
-> (UnivSysEx -> UnivSysEx -> Bool)
-> (UnivSysEx -> UnivSysEx -> Bool)
-> (UnivSysEx -> UnivSysEx -> UnivSysEx)
-> (UnivSysEx -> UnivSysEx -> UnivSysEx)
-> Ord UnivSysEx
UnivSysEx -> UnivSysEx -> Bool
UnivSysEx -> UnivSysEx -> Ordering
UnivSysEx -> UnivSysEx -> UnivSysEx
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
$ccompare :: UnivSysEx -> UnivSysEx -> Ordering
compare :: UnivSysEx -> UnivSysEx -> Ordering
$c< :: UnivSysEx -> UnivSysEx -> Bool
< :: UnivSysEx -> UnivSysEx -> Bool
$c<= :: UnivSysEx -> UnivSysEx -> Bool
<= :: UnivSysEx -> UnivSysEx -> Bool
$c> :: UnivSysEx -> UnivSysEx -> Bool
> :: UnivSysEx -> UnivSysEx -> Bool
$c>= :: UnivSysEx -> UnivSysEx -> Bool
>= :: UnivSysEx -> UnivSysEx -> Bool
$cmax :: UnivSysEx -> UnivSysEx -> UnivSysEx
max :: UnivSysEx -> UnivSysEx -> UnivSysEx
$cmin :: UnivSysEx -> UnivSysEx -> UnivSysEx
min :: UnivSysEx -> UnivSysEx -> UnivSysEx
Ord, Int -> UnivSysEx -> ShowS
[UnivSysEx] -> ShowS
UnivSysEx -> String
(Int -> UnivSysEx -> ShowS)
-> (UnivSysEx -> String)
-> ([UnivSysEx] -> ShowS)
-> Show UnivSysEx
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnivSysEx -> ShowS
showsPrec :: Int -> UnivSysEx -> ShowS
$cshow :: UnivSysEx -> String
show :: UnivSysEx -> String
$cshowList :: [UnivSysEx] -> ShowS
showList :: [UnivSysEx] -> ShowS
Show)

instance Binary UnivSysEx where
  byteSize :: UnivSysEx -> ByteCount
byteSize (UnivSysEx Word8
_ ShortByteString
p) = ByteCount
2 ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Int -> ByteCount
ByteCount (ShortByteString -> Int
BSS.length ShortByteString
p)
  get :: Get UnivSysEx
get = do
    Word8
i <- forall a. Binary a => Get a
get @Word8
    Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Word8
i Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x7E Bool -> Bool -> Bool
|| Word8
i Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x7F) (String -> Get ()
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Expected universal sys ex id: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
i))
    (ShortByteString -> UnivSysEx)
-> Get ShortByteString -> Get UnivSysEx
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Word8 -> ShortByteString -> UnivSysEx
UnivSysEx Word8
i) Get ShortByteString
getPayload
  put :: UnivSysEx -> Put
put (UnivSysEx Word8
i ShortByteString
s) = do
    Word8 -> Put
forall a. Binary a => a -> Put
put Word8
i
    ShortByteString -> Put
putByteString ShortByteString
s
    forall a. Binary a => a -> Put
put @Word8 Word8
0xF7

data ManfSysEx = ManfSysEx
  { ManfSysEx -> Manf
mseManf :: !Manf
  , ManfSysEx -> ShortByteString
msePayload :: !ShortByteString
  }
  deriving stock (ManfSysEx -> ManfSysEx -> Bool
(ManfSysEx -> ManfSysEx -> Bool)
-> (ManfSysEx -> ManfSysEx -> Bool) -> Eq ManfSysEx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ManfSysEx -> ManfSysEx -> Bool
== :: ManfSysEx -> ManfSysEx -> Bool
$c/= :: ManfSysEx -> ManfSysEx -> Bool
/= :: ManfSysEx -> ManfSysEx -> Bool
Eq, Eq ManfSysEx
Eq ManfSysEx =>
(ManfSysEx -> ManfSysEx -> Ordering)
-> (ManfSysEx -> ManfSysEx -> Bool)
-> (ManfSysEx -> ManfSysEx -> Bool)
-> (ManfSysEx -> ManfSysEx -> Bool)
-> (ManfSysEx -> ManfSysEx -> Bool)
-> (ManfSysEx -> ManfSysEx -> ManfSysEx)
-> (ManfSysEx -> ManfSysEx -> ManfSysEx)
-> Ord ManfSysEx
ManfSysEx -> ManfSysEx -> Bool
ManfSysEx -> ManfSysEx -> Ordering
ManfSysEx -> ManfSysEx -> ManfSysEx
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
$ccompare :: ManfSysEx -> ManfSysEx -> Ordering
compare :: ManfSysEx -> ManfSysEx -> Ordering
$c< :: ManfSysEx -> ManfSysEx -> Bool
< :: ManfSysEx -> ManfSysEx -> Bool
$c<= :: ManfSysEx -> ManfSysEx -> Bool
<= :: ManfSysEx -> ManfSysEx -> Bool
$c> :: ManfSysEx -> ManfSysEx -> Bool
> :: ManfSysEx -> ManfSysEx -> Bool
$c>= :: ManfSysEx -> ManfSysEx -> Bool
>= :: ManfSysEx -> ManfSysEx -> Bool
$cmax :: ManfSysEx -> ManfSysEx -> ManfSysEx
max :: ManfSysEx -> ManfSysEx -> ManfSysEx
$cmin :: ManfSysEx -> ManfSysEx -> ManfSysEx
min :: ManfSysEx -> ManfSysEx -> ManfSysEx
Ord, Int -> ManfSysEx -> ShowS
[ManfSysEx] -> ShowS
ManfSysEx -> String
(Int -> ManfSysEx -> ShowS)
-> (ManfSysEx -> String)
-> ([ManfSysEx] -> ShowS)
-> Show ManfSysEx
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ManfSysEx -> ShowS
showsPrec :: Int -> ManfSysEx -> ShowS
$cshow :: ManfSysEx -> String
show :: ManfSysEx -> String
$cshowList :: [ManfSysEx] -> ShowS
showList :: [ManfSysEx] -> ShowS
Show)

instance Binary ManfSysEx where
  byteSize :: ManfSysEx -> ByteCount
byteSize (ManfSysEx Manf
m ShortByteString
p) = ByteCount
1 ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Manf -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize Manf
m ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Int -> ByteCount
ByteCount (ShortByteString -> Int
BSS.length ShortByteString
p)
  get :: Get ManfSysEx
get = do
    Manf
m <- Get Manf
forall a. Binary a => Get a
get
    (ShortByteString -> ManfSysEx)
-> Get ShortByteString -> Get ManfSysEx
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Manf -> ShortByteString -> ManfSysEx
ManfSysEx Manf
m) Get ShortByteString
getPayload
  put :: ManfSysEx -> Put
put (ManfSysEx Manf
m ShortByteString
s) = do
    Manf -> Put
forall a. Binary a => a -> Put
put Manf
m
    ShortByteString -> Put
putByteString ShortByteString
s
    forall a. Binary a => a -> Put
put @Word8 Word8
0xF7

data SysExData
  = SysExDataUniv !UnivSysEx
  | SysExDataManf !ManfSysEx
  deriving stock (SysExData -> SysExData -> Bool
(SysExData -> SysExData -> Bool)
-> (SysExData -> SysExData -> Bool) -> Eq SysExData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SysExData -> SysExData -> Bool
== :: SysExData -> SysExData -> Bool
$c/= :: SysExData -> SysExData -> Bool
/= :: SysExData -> SysExData -> Bool
Eq, Eq SysExData
Eq SysExData =>
(SysExData -> SysExData -> Ordering)
-> (SysExData -> SysExData -> Bool)
-> (SysExData -> SysExData -> Bool)
-> (SysExData -> SysExData -> Bool)
-> (SysExData -> SysExData -> Bool)
-> (SysExData -> SysExData -> SysExData)
-> (SysExData -> SysExData -> SysExData)
-> Ord SysExData
SysExData -> SysExData -> Bool
SysExData -> SysExData -> Ordering
SysExData -> SysExData -> SysExData
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
$ccompare :: SysExData -> SysExData -> Ordering
compare :: SysExData -> SysExData -> Ordering
$c< :: SysExData -> SysExData -> Bool
< :: SysExData -> SysExData -> Bool
$c<= :: SysExData -> SysExData -> Bool
<= :: SysExData -> SysExData -> Bool
$c> :: SysExData -> SysExData -> Bool
> :: SysExData -> SysExData -> Bool
$c>= :: SysExData -> SysExData -> Bool
>= :: SysExData -> SysExData -> Bool
$cmax :: SysExData -> SysExData -> SysExData
max :: SysExData -> SysExData -> SysExData
$cmin :: SysExData -> SysExData -> SysExData
min :: SysExData -> SysExData -> SysExData
Ord, Int -> SysExData -> ShowS
[SysExData] -> ShowS
SysExData -> String
(Int -> SysExData -> ShowS)
-> (SysExData -> String)
-> ([SysExData] -> ShowS)
-> Show SysExData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SysExData -> ShowS
showsPrec :: Int -> SysExData -> ShowS
$cshow :: SysExData -> String
show :: SysExData -> String
$cshowList :: [SysExData] -> ShowS
showList :: [SysExData] -> ShowS
Show, (forall x. SysExData -> Rep SysExData x)
-> (forall x. Rep SysExData x -> SysExData) -> Generic SysExData
forall x. Rep SysExData x -> SysExData
forall x. SysExData -> Rep SysExData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SysExData -> Rep SysExData x
from :: forall x. SysExData -> Rep SysExData x
$cto :: forall x. Rep SysExData x -> SysExData
to :: forall x. Rep SysExData x -> SysExData
Generic)

instance Binary SysExData where
  byteSize :: SysExData -> ByteCount
byteSize = \case
    SysExDataUniv UnivSysEx
x -> UnivSysEx -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize UnivSysEx
x
    SysExDataManf ManfSysEx
y -> ManfSysEx -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize ManfSysEx
y
  get :: Get SysExData
get = do
    Word8
peek <- Get Word8 -> Get Word8
forall a. Get a -> Get a
getLookAhead (forall a. Binary a => Get a
get @Word8)
    if Word8
peek Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x7E Bool -> Bool -> Bool
|| Word8
peek Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x7F
      then (UnivSysEx -> SysExData) -> Get UnivSysEx -> Get SysExData
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UnivSysEx -> SysExData
SysExDataUniv Get UnivSysEx
forall a. Binary a => Get a
get
      else (ManfSysEx -> SysExData) -> Get ManfSysEx -> Get SysExData
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ManfSysEx -> SysExData
SysExDataManf Get ManfSysEx
forall a. Binary a => Get a
get
  put :: SysExData -> Put
put = \case
    SysExDataUniv UnivSysEx
x -> UnivSysEx -> Put
forall a. Binary a => a -> Put
put UnivSysEx
x
    SysExDataManf ManfSysEx
y -> ManfSysEx -> Put
forall a. Binary a => a -> Put
put ManfSysEx
y

data CommonData
  = CommonDataTimeFrame !QuarterTime
  | CommonDataSongPointer !Position
  | CommonDataSongSelect !Song
  | CommonDataTuneRequest
  deriving stock (CommonData -> CommonData -> Bool
(CommonData -> CommonData -> Bool)
-> (CommonData -> CommonData -> Bool) -> Eq CommonData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommonData -> CommonData -> Bool
== :: CommonData -> CommonData -> Bool
$c/= :: CommonData -> CommonData -> Bool
/= :: CommonData -> CommonData -> Bool
Eq, Eq CommonData
Eq CommonData =>
(CommonData -> CommonData -> Ordering)
-> (CommonData -> CommonData -> Bool)
-> (CommonData -> CommonData -> Bool)
-> (CommonData -> CommonData -> Bool)
-> (CommonData -> CommonData -> Bool)
-> (CommonData -> CommonData -> CommonData)
-> (CommonData -> CommonData -> CommonData)
-> Ord CommonData
CommonData -> CommonData -> Bool
CommonData -> CommonData -> Ordering
CommonData -> CommonData -> CommonData
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
$ccompare :: CommonData -> CommonData -> Ordering
compare :: CommonData -> CommonData -> Ordering
$c< :: CommonData -> CommonData -> Bool
< :: CommonData -> CommonData -> Bool
$c<= :: CommonData -> CommonData -> Bool
<= :: CommonData -> CommonData -> Bool
$c> :: CommonData -> CommonData -> Bool
> :: CommonData -> CommonData -> Bool
$c>= :: CommonData -> CommonData -> Bool
>= :: CommonData -> CommonData -> Bool
$cmax :: CommonData -> CommonData -> CommonData
max :: CommonData -> CommonData -> CommonData
$cmin :: CommonData -> CommonData -> CommonData
min :: CommonData -> CommonData -> CommonData
Ord, Int -> CommonData -> ShowS
[CommonData] -> ShowS
CommonData -> String
(Int -> CommonData -> ShowS)
-> (CommonData -> String)
-> ([CommonData] -> ShowS)
-> Show CommonData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CommonData -> ShowS
showsPrec :: Int -> CommonData -> ShowS
$cshow :: CommonData -> String
show :: CommonData -> String
$cshowList :: [CommonData] -> ShowS
showList :: [CommonData] -> ShowS
Show, (forall x. CommonData -> Rep CommonData x)
-> (forall x. Rep CommonData x -> CommonData) -> Generic CommonData
forall x. Rep CommonData x -> CommonData
forall x. CommonData -> Rep CommonData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CommonData -> Rep CommonData x
from :: forall x. CommonData -> Rep CommonData x
$cto :: forall x. Rep CommonData x -> CommonData
to :: forall x. Rep CommonData x -> CommonData
Generic)

byteSizeCommonData :: CommonData -> ByteCount
byteSizeCommonData :: CommonData -> ByteCount
byteSizeCommonData = \case
  CommonDataTimeFrame QuarterTime
_ -> ByteCount
1
  CommonDataSongPointer Position
_ -> ByteCount
2
  CommonDataSongSelect Song
_ -> ByteCount
1
  CommonData
CommonDataTuneRequest -> ByteCount
0

getCommonData :: CommonStatus -> Get CommonData
getCommonData :: CommonStatus -> Get CommonData
getCommonData = \case
  CommonStatus
CommonStatusTimeFrame -> (QuarterTime -> CommonData) -> Get QuarterTime -> Get CommonData
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QuarterTime -> CommonData
CommonDataTimeFrame Get QuarterTime
forall a. Binary a => Get a
get
  CommonStatus
CommonStatusSongPointer -> (Position -> CommonData) -> Get Position -> Get CommonData
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Position -> CommonData
CommonDataSongPointer Get Position
forall a. Binary a => Get a
get
  CommonStatus
CommonStatusSongSelect -> (Song -> CommonData) -> Get Song -> Get CommonData
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Song -> CommonData
CommonDataSongSelect Get Song
forall a. Binary a => Get a
get
  CommonStatus
CommonStatusTuneRequest -> CommonData -> Get CommonData
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CommonData
CommonDataTuneRequest

putCommonData :: CommonData -> Put
putCommonData :: CommonData -> Put
putCommonData = \case
  CommonDataTimeFrame QuarterTime
qt -> QuarterTime -> Put
forall a. Binary a => a -> Put
put QuarterTime
qt
  CommonDataSongPointer Position
po -> Position -> Put
forall a. Binary a => a -> Put
put Position
po
  CommonDataSongSelect Song
so -> Song -> Put
forall a. Binary a => a -> Put
put Song
so
  CommonData
CommonDataTuneRequest -> () -> Put
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

class (HasChanStatus s) => HasChanData s c | c -> s where
  extractStatus :: c -> s
  embedChanData :: Channel -> ChanData -> c

data LiveMsg
  = LiveMsgChan !Channel !ChanData
  | LiveMsgSysEx !SysExData
  | LiveMsgSysCommon !CommonData
  | LiveMsgSysRt !RtStatus
  deriving stock (LiveMsg -> LiveMsg -> Bool
(LiveMsg -> LiveMsg -> Bool)
-> (LiveMsg -> LiveMsg -> Bool) -> Eq LiveMsg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LiveMsg -> LiveMsg -> Bool
== :: LiveMsg -> LiveMsg -> Bool
$c/= :: LiveMsg -> LiveMsg -> Bool
/= :: LiveMsg -> LiveMsg -> Bool
Eq, Eq LiveMsg
Eq LiveMsg =>
(LiveMsg -> LiveMsg -> Ordering)
-> (LiveMsg -> LiveMsg -> Bool)
-> (LiveMsg -> LiveMsg -> Bool)
-> (LiveMsg -> LiveMsg -> Bool)
-> (LiveMsg -> LiveMsg -> Bool)
-> (LiveMsg -> LiveMsg -> LiveMsg)
-> (LiveMsg -> LiveMsg -> LiveMsg)
-> Ord LiveMsg
LiveMsg -> LiveMsg -> Bool
LiveMsg -> LiveMsg -> Ordering
LiveMsg -> LiveMsg -> LiveMsg
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
$ccompare :: LiveMsg -> LiveMsg -> Ordering
compare :: LiveMsg -> LiveMsg -> Ordering
$c< :: LiveMsg -> LiveMsg -> Bool
< :: LiveMsg -> LiveMsg -> Bool
$c<= :: LiveMsg -> LiveMsg -> Bool
<= :: LiveMsg -> LiveMsg -> Bool
$c> :: LiveMsg -> LiveMsg -> Bool
> :: LiveMsg -> LiveMsg -> Bool
$c>= :: LiveMsg -> LiveMsg -> Bool
>= :: LiveMsg -> LiveMsg -> Bool
$cmax :: LiveMsg -> LiveMsg -> LiveMsg
max :: LiveMsg -> LiveMsg -> LiveMsg
$cmin :: LiveMsg -> LiveMsg -> LiveMsg
min :: LiveMsg -> LiveMsg -> LiveMsg
Ord, Int -> LiveMsg -> ShowS
[LiveMsg] -> ShowS
LiveMsg -> String
(Int -> LiveMsg -> ShowS)
-> (LiveMsg -> String) -> ([LiveMsg] -> ShowS) -> Show LiveMsg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LiveMsg -> ShowS
showsPrec :: Int -> LiveMsg -> ShowS
$cshow :: LiveMsg -> String
show :: LiveMsg -> String
$cshowList :: [LiveMsg] -> ShowS
showList :: [LiveMsg] -> ShowS
Show, (forall x. LiveMsg -> Rep LiveMsg x)
-> (forall x. Rep LiveMsg x -> LiveMsg) -> Generic LiveMsg
forall x. Rep LiveMsg x -> LiveMsg
forall x. LiveMsg -> Rep LiveMsg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LiveMsg -> Rep LiveMsg x
from :: forall x. LiveMsg -> Rep LiveMsg x
$cto :: forall x. Rep LiveMsg x -> LiveMsg
to :: forall x. Rep LiveMsg x -> LiveMsg
Generic)

instance HasChanData LiveStatus LiveMsg where
  extractStatus :: LiveMsg -> LiveStatus
extractStatus = LiveMsg -> LiveStatus
liveMsgStatus
  embedChanData :: Channel -> ChanData -> LiveMsg
embedChanData = Channel -> ChanData -> LiveMsg
LiveMsgChan

instance Binary LiveMsg where
  byteSize :: LiveMsg -> ByteCount
byteSize =
    ByteCount -> ByteCount
forall a. Enum a => a -> a
succ (ByteCount -> ByteCount)
-> (LiveMsg -> ByteCount) -> LiveMsg -> ByteCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
      LiveMsgChan Channel
_ ChanData
cd -> ChanData -> ByteCount
byteSizeChanData ChanData
cd
      LiveMsgSysEx SysExData
sed -> SysExData -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize SysExData
sed
      LiveMsgSysCommon CommonData
cd -> CommonData -> ByteCount
byteSizeCommonData CommonData
cd
      LiveMsgSysRt RtStatus
_ -> ByteCount
0
  get :: Get LiveMsg
get = forall a. Binary a => Get a
get @LiveStatus Get LiveStatus -> (LiveStatus -> Get LiveMsg) -> Get LiveMsg
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LiveStatus -> Get LiveMsg
getLiveMsgWithStatus
  put :: LiveMsg -> Put
put = PutM (Maybe ChanStatus) -> Put
forall (f :: * -> *) a. Functor f => f a -> f ()
void (PutM (Maybe ChanStatus) -> Put)
-> (LiveMsg -> PutM (Maybe ChanStatus)) -> LiveMsg -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LiveMsg -> Put)
-> Maybe ChanStatus -> LiveMsg -> PutM (Maybe ChanStatus)
forall s c.
(HasChanData s c, Binary s) =>
(c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning LiveMsg -> Put
putLiveMsgData Maybe ChanStatus
forall a. Maybe a
Nothing

-- private
getLiveMsgWithStatus :: LiveStatus -> Get LiveMsg
getLiveMsgWithStatus :: LiveStatus -> Get LiveMsg
getLiveMsgWithStatus = \case
  LiveStatusChan cs :: ChanStatus
cs@(ChanStatus Channel
chan ChanStatusType
_) -> (ChanData -> LiveMsg) -> Get ChanData -> Get LiveMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Channel -> ChanData -> LiveMsg
LiveMsgChan Channel
chan) (ChanStatus -> Get ChanData
getChanData ChanStatus
cs)
  LiveStatus
LiveStatusSysEx -> (SysExData -> LiveMsg) -> Get SysExData -> Get LiveMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SysExData -> LiveMsg
LiveMsgSysEx Get SysExData
forall a. Binary a => Get a
get
  LiveStatusSysCommon CommonStatus
cs -> (CommonData -> LiveMsg) -> Get CommonData -> Get LiveMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CommonData -> LiveMsg
LiveMsgSysCommon (CommonStatus -> Get CommonData
getCommonData CommonStatus
cs)
  LiveStatusSysRt RtStatus
rs -> LiveMsg -> Get LiveMsg
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> LiveMsg
LiveMsgSysRt RtStatus
rs)

-- private
-- Running status is for Voice and Mode messages only!
getMsgRunning :: (Binary s, HasChanStatus s) => (s -> Get c) -> Maybe ChanStatus -> Get c
getMsgRunning :: forall s c.
(Binary s, HasChanStatus s) =>
(s -> Get c) -> Maybe ChanStatus -> Get c
getMsgRunning s -> Get c
getter Maybe ChanStatus
mayLastStatus = do
  StatusPeek
peeked <- Get StatusPeek
peekStatus
  case StatusPeek
peeked of
    StatusPeek
StatusPeekYes -> do
      s
status <- Get s
forall a. Binary a => Get a
get
      s -> Get c
getter s
status
    StatusPeekNo Word8
dat ->
      case Maybe ChanStatus
mayLastStatus of
        Maybe ChanStatus
Nothing -> String -> Get c
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Expected status byte (no running status): " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
dat)
        Just ChanStatus
lastStatus -> s -> Get c
getter (ChanStatus -> s
forall s. HasChanStatus s => ChanStatus -> s
statusFromChan ChanStatus
lastStatus)

-- private
putMsgRunning :: (HasChanData s c, Binary s) => (c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning :: forall s c.
(HasChanData s c, Binary s) =>
(c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning c -> Put
putter Maybe ChanStatus
mayLastStatus c
msg = do
  Maybe ChanStatus
mayCurStatus <- Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
forall s c.
(HasChanData s c, Binary s) =>
Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgStatusRunning Maybe ChanStatus
mayLastStatus c
msg
  c -> Put
putter c
msg
  Maybe ChanStatus -> PutM (Maybe ChanStatus)
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ChanStatus
mayCurStatus

-- private
putMsgStatusRunning :: (HasChanData s c, Binary s) => Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgStatusRunning :: forall s c.
(HasChanData s c, Binary s) =>
Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgStatusRunning Maybe ChanStatus
mayLastStatus c
msg =
  let curStatus :: s
curStatus = c -> s
forall s c. HasChanData s c => c -> s
extractStatus c
msg
      mayChanStatus :: Maybe ChanStatus
mayChanStatus = s -> Maybe ChanStatus
forall s. HasChanStatus s => s -> Maybe ChanStatus
statusAsChan s
curStatus
  in  case Maybe ChanStatus
mayLastStatus of
        Maybe ChanStatus
Nothing -> do
          s -> Put
forall a. Binary a => a -> Put
put s
curStatus
          Maybe ChanStatus -> PutM (Maybe ChanStatus)
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ChanStatus
mayChanStatus
        Just ChanStatus
lastStatus ->
          case Maybe ChanStatus
mayChanStatus of
            Just ChanStatus
chanStatus ->
              if ChanStatus
chanStatus ChanStatus -> ChanStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ChanStatus
lastStatus
                then Maybe ChanStatus -> PutM (Maybe ChanStatus)
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ChanStatus
mayLastStatus
                else ChanStatus -> Maybe ChanStatus
forall a. a -> Maybe a
Just ChanStatus
chanStatus Maybe ChanStatus -> Put -> PutM (Maybe ChanStatus)
forall a b. a -> PutM b -> PutM a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ s -> Put
forall a. Binary a => a -> Put
put s
curStatus
            Maybe ChanStatus
_ -> Maybe ChanStatus
forall a. Maybe a
Nothing Maybe ChanStatus -> Put -> PutM (Maybe ChanStatus)
forall a b. a -> PutM b -> PutM a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ s -> Put
forall a. Binary a => a -> Put
put s
curStatus

-- private
putLiveMsgData :: LiveMsg -> Put
putLiveMsgData :: LiveMsg -> Put
putLiveMsgData = \case
  LiveMsgChan Channel
_ ChanData
cd -> ChanData -> Put
putChanData ChanData
cd
  LiveMsgSysEx SysExData
sed -> SysExData -> Put
forall a. Binary a => a -> Put
put SysExData
sed
  LiveMsgSysCommon CommonData
cd -> CommonData -> Put
putCommonData CommonData
cd
  LiveMsgSysRt RtStatus
_ -> () -> Put
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

commonMsgStatus :: CommonData -> CommonStatus
commonMsgStatus :: CommonData -> CommonStatus
commonMsgStatus = \case
  CommonDataTimeFrame QuarterTime
_ -> CommonStatus
CommonStatusTimeFrame
  CommonDataSongPointer Position
_ -> CommonStatus
CommonStatusSongPointer
  CommonDataSongSelect Song
_ -> CommonStatus
CommonStatusSongSelect
  CommonData
CommonDataTuneRequest -> CommonStatus
CommonStatusTuneRequest

liveMsgStatus :: LiveMsg -> LiveStatus
liveMsgStatus :: LiveMsg -> LiveStatus
liveMsgStatus = \case
  LiveMsgChan Channel
chan ChanData
cd -> ChanStatus -> LiveStatus
LiveStatusChan (Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
chan (ChanData -> ChanStatusType
chanDataType ChanData
cd))
  LiveMsgSysEx SysExData
_ -> LiveStatus
LiveStatusSysEx
  LiveMsgSysCommon CommonData
cd -> CommonStatus -> LiveStatus
LiveStatusSysCommon (CommonData -> CommonStatus
commonMsgStatus CommonData
cd)
  LiveMsgSysRt RtStatus
rs -> RtStatus -> LiveStatus
LiveStatusSysRt RtStatus
rs

msgNoteOn :: (HasChanData s c) => Channel -> Note -> Velocity -> c
msgNoteOn :: forall s c. HasChanData s c => Channel -> Note -> Velocity -> c
msgNoteOn Channel
c Note
k Velocity
v = Channel -> ChanData -> c
forall s c. HasChanData s c => Channel -> ChanData -> c
embedChanData Channel
c (ChanVoiceData -> ChanData
ChanDataVoice (Note -> Velocity -> ChanVoiceData
ChanVoiceDataNoteOn Note
k Velocity
v))

msgNoteOff :: Channel -> Note -> LiveMsg
msgNoteOff :: Channel -> Note -> LiveMsg
msgNoteOff Channel
c Note
k = Channel -> Note -> Velocity -> LiveMsg
forall s c. HasChanData s c => Channel -> Note -> Velocity -> c
msgNoteOn Channel
c Note
k Velocity
0

data RecMsg
  = RecMsgChan !Channel !ChanData
  | RecMsgSysEx !SysExData
  | RecMsgMeta !MetaData
  deriving stock (RecMsg -> RecMsg -> Bool
(RecMsg -> RecMsg -> Bool)
-> (RecMsg -> RecMsg -> Bool) -> Eq RecMsg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecMsg -> RecMsg -> Bool
== :: RecMsg -> RecMsg -> Bool
$c/= :: RecMsg -> RecMsg -> Bool
/= :: RecMsg -> RecMsg -> Bool
Eq, Eq RecMsg
Eq RecMsg =>
(RecMsg -> RecMsg -> Ordering)
-> (RecMsg -> RecMsg -> Bool)
-> (RecMsg -> RecMsg -> Bool)
-> (RecMsg -> RecMsg -> Bool)
-> (RecMsg -> RecMsg -> Bool)
-> (RecMsg -> RecMsg -> RecMsg)
-> (RecMsg -> RecMsg -> RecMsg)
-> Ord RecMsg
RecMsg -> RecMsg -> Bool
RecMsg -> RecMsg -> Ordering
RecMsg -> RecMsg -> RecMsg
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
$ccompare :: RecMsg -> RecMsg -> Ordering
compare :: RecMsg -> RecMsg -> Ordering
$c< :: RecMsg -> RecMsg -> Bool
< :: RecMsg -> RecMsg -> Bool
$c<= :: RecMsg -> RecMsg -> Bool
<= :: RecMsg -> RecMsg -> Bool
$c> :: RecMsg -> RecMsg -> Bool
> :: RecMsg -> RecMsg -> Bool
$c>= :: RecMsg -> RecMsg -> Bool
>= :: RecMsg -> RecMsg -> Bool
$cmax :: RecMsg -> RecMsg -> RecMsg
max :: RecMsg -> RecMsg -> RecMsg
$cmin :: RecMsg -> RecMsg -> RecMsg
min :: RecMsg -> RecMsg -> RecMsg
Ord, Int -> RecMsg -> ShowS
[RecMsg] -> ShowS
RecMsg -> String
(Int -> RecMsg -> ShowS)
-> (RecMsg -> String) -> ([RecMsg] -> ShowS) -> Show RecMsg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecMsg -> ShowS
showsPrec :: Int -> RecMsg -> ShowS
$cshow :: RecMsg -> String
show :: RecMsg -> String
$cshowList :: [RecMsg] -> ShowS
showList :: [RecMsg] -> ShowS
Show, (forall x. RecMsg -> Rep RecMsg x)
-> (forall x. Rep RecMsg x -> RecMsg) -> Generic RecMsg
forall x. Rep RecMsg x -> RecMsg
forall x. RecMsg -> Rep RecMsg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RecMsg -> Rep RecMsg x
from :: forall x. RecMsg -> Rep RecMsg x
$cto :: forall x. Rep RecMsg x -> RecMsg
to :: forall x. Rep RecMsg x -> RecMsg
Generic)

recMsgStatus :: RecMsg -> RecStatus
recMsgStatus :: RecMsg -> RecStatus
recMsgStatus = \case
  RecMsgChan Channel
chan ChanData
cd -> ChanStatus -> RecStatus
RecStatusChan (Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
chan (ChanData -> ChanStatusType
chanDataType ChanData
cd))
  RecMsgSysEx SysExData
_ -> RecStatus
RecStatusSysEx
  RecMsgMeta MetaData
_ -> RecStatus
RecStatusMeta

instance HasChanData RecStatus RecMsg where
  extractStatus :: RecMsg -> RecStatus
extractStatus = RecMsg -> RecStatus
recMsgStatus
  embedChanData :: Channel -> ChanData -> RecMsg
embedChanData = Channel -> ChanData -> RecMsg
RecMsgChan

instance Binary RecMsg where
  byteSize :: RecMsg -> ByteCount
byteSize =
    ByteCount -> ByteCount
forall a. Enum a => a -> a
succ (ByteCount -> ByteCount)
-> (RecMsg -> ByteCount) -> RecMsg -> ByteCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
      RecMsgChan Channel
_ ChanData
cd -> ChanData -> ByteCount
byteSizeChanData ChanData
cd
      RecMsgSysEx SysExData
sed -> SysExData -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize SysExData
sed
      RecMsgMeta MetaData
md -> MetaData -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize MetaData
md
  get :: Get RecMsg
get = forall a. Binary a => Get a
get @RecStatus Get RecStatus -> (RecStatus -> Get RecMsg) -> Get RecMsg
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RecStatus -> Get RecMsg
getRecMsgWithStatus
  put :: RecMsg -> Put
put = PutM (Maybe ChanStatus) -> Put
forall (f :: * -> *) a. Functor f => f a -> f ()
void (PutM (Maybe ChanStatus) -> Put)
-> (RecMsg -> PutM (Maybe ChanStatus)) -> RecMsg -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RecMsg -> Put)
-> Maybe ChanStatus -> RecMsg -> PutM (Maybe ChanStatus)
forall s c.
(HasChanData s c, Binary s) =>
(c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning RecMsg -> Put
putRecMsgData Maybe ChanStatus
forall a. Maybe a
Nothing

getRecMsgWithStatus :: RecStatus -> Get RecMsg
getRecMsgWithStatus :: RecStatus -> Get RecMsg
getRecMsgWithStatus = \case
  RecStatusChan cs :: ChanStatus
cs@(ChanStatus Channel
chan ChanStatusType
_) -> (ChanData -> RecMsg) -> Get ChanData -> Get RecMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Channel -> ChanData -> RecMsg
RecMsgChan Channel
chan) (ChanStatus -> Get ChanData
getChanData ChanStatus
cs)
  RecStatus
RecStatusSysEx -> (SysExData -> RecMsg) -> Get SysExData -> Get RecMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SysExData -> RecMsg
RecMsgSysEx Get SysExData
forall a. Binary a => Get a
get
  RecStatus
RecStatusMeta -> (MetaData -> RecMsg) -> Get MetaData -> Get RecMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MetaData -> RecMsg
RecMsgMeta Get MetaData
forall a. Binary a => Get a
get

putRecMsgData :: RecMsg -> Put
putRecMsgData :: RecMsg -> Put
putRecMsgData = \case
  RecMsgChan Channel
_ ChanData
cd -> ChanData -> Put
putChanData ChanData
cd
  RecMsgSysEx SysExData
sed -> SysExData -> Put
forall a. Binary a => a -> Put
put SysExData
sed
  RecMsgMeta MetaData
md -> MetaData -> Put
forall a. Binary a => a -> Put
put MetaData
md

data ShortMsg
  = ShortMsgChan !Channel !ChanData
  | ShortMsgSysCommon !CommonData
  | ShortMsgSysRt !RtStatus
  deriving stock (ShortMsg -> ShortMsg -> Bool
(ShortMsg -> ShortMsg -> Bool)
-> (ShortMsg -> ShortMsg -> Bool) -> Eq ShortMsg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShortMsg -> ShortMsg -> Bool
== :: ShortMsg -> ShortMsg -> Bool
$c/= :: ShortMsg -> ShortMsg -> Bool
/= :: ShortMsg -> ShortMsg -> Bool
Eq, Eq ShortMsg
Eq ShortMsg =>
(ShortMsg -> ShortMsg -> Ordering)
-> (ShortMsg -> ShortMsg -> Bool)
-> (ShortMsg -> ShortMsg -> Bool)
-> (ShortMsg -> ShortMsg -> Bool)
-> (ShortMsg -> ShortMsg -> Bool)
-> (ShortMsg -> ShortMsg -> ShortMsg)
-> (ShortMsg -> ShortMsg -> ShortMsg)
-> Ord ShortMsg
ShortMsg -> ShortMsg -> Bool
ShortMsg -> ShortMsg -> Ordering
ShortMsg -> ShortMsg -> ShortMsg
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
$ccompare :: ShortMsg -> ShortMsg -> Ordering
compare :: ShortMsg -> ShortMsg -> Ordering
$c< :: ShortMsg -> ShortMsg -> Bool
< :: ShortMsg -> ShortMsg -> Bool
$c<= :: ShortMsg -> ShortMsg -> Bool
<= :: ShortMsg -> ShortMsg -> Bool
$c> :: ShortMsg -> ShortMsg -> Bool
> :: ShortMsg -> ShortMsg -> Bool
$c>= :: ShortMsg -> ShortMsg -> Bool
>= :: ShortMsg -> ShortMsg -> Bool
$cmax :: ShortMsg -> ShortMsg -> ShortMsg
max :: ShortMsg -> ShortMsg -> ShortMsg
$cmin :: ShortMsg -> ShortMsg -> ShortMsg
min :: ShortMsg -> ShortMsg -> ShortMsg
Ord, Int -> ShortMsg -> ShowS
[ShortMsg] -> ShowS
ShortMsg -> String
(Int -> ShortMsg -> ShowS)
-> (ShortMsg -> String) -> ([ShortMsg] -> ShowS) -> Show ShortMsg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShortMsg -> ShowS
showsPrec :: Int -> ShortMsg -> ShowS
$cshow :: ShortMsg -> String
show :: ShortMsg -> String
$cshowList :: [ShortMsg] -> ShowS
showList :: [ShortMsg] -> ShowS
Show, (forall x. ShortMsg -> Rep ShortMsg x)
-> (forall x. Rep ShortMsg x -> ShortMsg) -> Generic ShortMsg
forall x. Rep ShortMsg x -> ShortMsg
forall x. ShortMsg -> Rep ShortMsg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ShortMsg -> Rep ShortMsg x
from :: forall x. ShortMsg -> Rep ShortMsg x
$cto :: forall x. Rep ShortMsg x -> ShortMsg
to :: forall x. Rep ShortMsg x -> ShortMsg
Generic)

instance HasChanData ShortStatus ShortMsg where
  extractStatus :: ShortMsg -> ShortStatus
extractStatus = ShortMsg -> ShortStatus
shortMsgStatus
  embedChanData :: Channel -> ChanData -> ShortMsg
embedChanData = Channel -> ChanData -> ShortMsg
ShortMsgChan

instance Binary ShortMsg where
  byteSize :: ShortMsg -> ByteCount
byteSize =
    ByteCount -> ByteCount
forall a. Enum a => a -> a
succ (ByteCount -> ByteCount)
-> (ShortMsg -> ByteCount) -> ShortMsg -> ByteCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
      ShortMsgChan Channel
_ ChanData
cd -> ChanData -> ByteCount
byteSizeChanData ChanData
cd
      ShortMsgSysCommon CommonData
cd -> CommonData -> ByteCount
byteSizeCommonData CommonData
cd
      ShortMsgSysRt RtStatus
_ -> ByteCount
0
  get :: Get ShortMsg
get = forall a. Binary a => Get a
get @ShortStatus Get ShortStatus -> (ShortStatus -> Get ShortMsg) -> Get ShortMsg
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ShortStatus -> Get ShortMsg
getShortMsgWithStatus
  put :: ShortMsg -> Put
put = PutM (Maybe ChanStatus) -> Put
forall (f :: * -> *) a. Functor f => f a -> f ()
void (PutM (Maybe ChanStatus) -> Put)
-> (ShortMsg -> PutM (Maybe ChanStatus)) -> ShortMsg -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ShortMsg -> Put)
-> Maybe ChanStatus -> ShortMsg -> PutM (Maybe ChanStatus)
forall s c.
(HasChanData s c, Binary s) =>
(c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning ShortMsg -> Put
putShortMsgData Maybe ChanStatus
forall a. Maybe a
Nothing

-- private
shortMsgStatus :: ShortMsg -> ShortStatus
shortMsgStatus :: ShortMsg -> ShortStatus
shortMsgStatus = \case
  ShortMsgChan Channel
chan ChanData
cd -> ChanStatus -> ShortStatus
ShortStatusChan (Channel -> ChanStatusType -> ChanStatus
ChanStatus Channel
chan (ChanData -> ChanStatusType
chanDataType ChanData
cd))
  ShortMsgSysCommon CommonData
cd -> CommonStatus -> ShortStatus
ShortStatusSysCommon (CommonStatus -> ShortStatus) -> CommonStatus -> ShortStatus
forall a b. (a -> b) -> a -> b
$ case CommonData
cd of
    CommonDataTimeFrame QuarterTime
_ -> CommonStatus
CommonStatusTimeFrame
    CommonDataSongPointer Position
_ -> CommonStatus
CommonStatusSongPointer
    CommonDataSongSelect Song
_ -> CommonStatus
CommonStatusSongSelect
    CommonData
CommonDataTuneRequest -> CommonStatus
CommonStatusTuneRequest
  ShortMsgSysRt RtStatus
rs -> RtStatus -> ShortStatus
ShortStatusSysRt RtStatus
rs

-- private
getShortMsgWithStatus :: ShortStatus -> Get ShortMsg
getShortMsgWithStatus :: ShortStatus -> Get ShortMsg
getShortMsgWithStatus = \case
  ShortStatusChan cs :: ChanStatus
cs@(ChanStatus Channel
chan ChanStatusType
_) -> (ChanData -> ShortMsg) -> Get ChanData -> Get ShortMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Channel -> ChanData -> ShortMsg
ShortMsgChan Channel
chan) (ChanStatus -> Get ChanData
getChanData ChanStatus
cs)
  ShortStatusSysCommon CommonStatus
cs -> (CommonData -> ShortMsg) -> Get CommonData -> Get ShortMsg
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CommonData -> ShortMsg
ShortMsgSysCommon (CommonStatus -> Get CommonData
getCommonData CommonStatus
cs)
  ShortStatusSysRt RtStatus
rs -> ShortMsg -> Get ShortMsg
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RtStatus -> ShortMsg
ShortMsgSysRt RtStatus
rs)

-- private
putShortMsgData :: ShortMsg -> Put
putShortMsgData :: ShortMsg -> Put
putShortMsgData = \case
  ShortMsgChan Channel
_ ChanData
cd -> ChanData -> Put
putChanData ChanData
cd
  ShortMsgSysCommon CommonData
cd -> CommonData -> Put
putCommonData CommonData
cd
  ShortMsgSysRt RtStatus
_ -> () -> Put
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

-- | NOTE: Time delta is in number of ticks since previous message
data Event = Event
  { Event -> VarWord
evDelta :: !VarWord
  , Event -> RecMsg
evMsg :: !RecMsg
  }
  deriving stock (Event -> Event -> Bool
(Event -> Event -> Bool) -> (Event -> Event -> Bool) -> Eq Event
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Event -> Event -> Bool
== :: Event -> Event -> Bool
$c/= :: Event -> Event -> Bool
/= :: Event -> Event -> Bool
Eq, Eq Event
Eq Event =>
(Event -> Event -> Ordering)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Event)
-> (Event -> Event -> Event)
-> Ord Event
Event -> Event -> Bool
Event -> Event -> Ordering
Event -> Event -> Event
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
$ccompare :: Event -> Event -> Ordering
compare :: Event -> Event -> Ordering
$c< :: Event -> Event -> Bool
< :: Event -> Event -> Bool
$c<= :: Event -> Event -> Bool
<= :: Event -> Event -> Bool
$c> :: Event -> Event -> Bool
> :: Event -> Event -> Bool
$c>= :: Event -> Event -> Bool
>= :: Event -> Event -> Bool
$cmax :: Event -> Event -> Event
max :: Event -> Event -> Event
$cmin :: Event -> Event -> Event
min :: Event -> Event -> Event
Ord, Int -> Event -> ShowS
[Event] -> ShowS
Event -> String
(Int -> Event -> ShowS)
-> (Event -> String) -> ([Event] -> ShowS) -> Show Event
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Event -> ShowS
showsPrec :: Int -> Event -> ShowS
$cshow :: Event -> String
show :: Event -> String
$cshowList :: [Event] -> ShowS
showList :: [Event] -> ShowS
Show, (forall x. Event -> Rep Event x)
-> (forall x. Rep Event x -> Event) -> Generic Event
forall x. Rep Event x -> Event
forall x. Event -> Rep Event x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Event -> Rep Event x
from :: forall x. Event -> Rep Event x
$cto :: forall x. Rep Event x -> Event
to :: forall x. Rep Event x -> Event
Generic)

-- private
type TrackMagic = ExactBytes 4 "MTrk"

newtype Track = Track {Track -> Seq Event
unTrack :: Seq Event}
  deriving stock (Int -> Track -> ShowS
[Track] -> ShowS
Track -> String
(Int -> Track -> ShowS)
-> (Track -> String) -> ([Track] -> ShowS) -> Show Track
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Track -> ShowS
showsPrec :: Int -> Track -> ShowS
$cshow :: Track -> String
show :: Track -> String
$cshowList :: [Track] -> ShowS
showList :: [Track] -> ShowS
Show)
  deriving newtype (Track -> Track -> Bool
(Track -> Track -> Bool) -> (Track -> Track -> Bool) -> Eq Track
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Track -> Track -> Bool
== :: Track -> Track -> Bool
$c/= :: Track -> Track -> Bool
/= :: Track -> Track -> Bool
Eq, Eq Track
Eq Track =>
(Track -> Track -> Ordering)
-> (Track -> Track -> Bool)
-> (Track -> Track -> Bool)
-> (Track -> Track -> Bool)
-> (Track -> Track -> Bool)
-> (Track -> Track -> Track)
-> (Track -> Track -> Track)
-> Ord Track
Track -> Track -> Bool
Track -> Track -> Ordering
Track -> Track -> Track
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
$ccompare :: Track -> Track -> Ordering
compare :: Track -> Track -> Ordering
$c< :: Track -> Track -> Bool
< :: Track -> Track -> Bool
$c<= :: Track -> Track -> Bool
<= :: Track -> Track -> Bool
$c> :: Track -> Track -> Bool
> :: Track -> Track -> Bool
$c>= :: Track -> Track -> Bool
>= :: Track -> Track -> Bool
$cmax :: Track -> Track -> Track
max :: Track -> Track -> Track
$cmin :: Track -> Track -> Track
min :: Track -> Track -> Track
Ord)

-- private
byteSizeEventsLoop :: ByteCount -> Maybe ChanStatus -> Seq Event -> ByteCount
byteSizeEventsLoop :: ByteCount -> Maybe ChanStatus -> Seq Event -> ByteCount
byteSizeEventsLoop !ByteCount
bc !Maybe ChanStatus
mayLastStatus = \case
  Seq Event
Empty -> ByteCount
bc
  Event VarWord
td RecMsg
msg :<| Seq Event
mes ->
    let !tc :: ByteCount
tc = VarWord -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize VarWord
td
        !mayNextStatus :: Maybe ChanStatus
mayNextStatus = RecStatus -> Maybe ChanStatus
forall s. HasChanStatus s => s -> Maybe ChanStatus
statusAsChan (RecMsg -> RecStatus
forall s c. HasChanData s c => c -> s
extractStatus RecMsg
msg)
        !mc :: ByteCount
mc = RecMsg -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize RecMsg
msg
        !sc :: ByteCount
sc = case Maybe ChanStatus
mayNextStatus of
          Just ChanStatus
_ | Maybe ChanStatus
mayNextStatus Maybe ChanStatus -> Maybe ChanStatus -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe ChanStatus
mayLastStatus -> ByteCount
mc ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
- ByteCount
1
          Maybe ChanStatus
_ -> ByteCount
mc
    in  ByteCount -> Maybe ChanStatus -> Seq Event -> ByteCount
byteSizeEventsLoop (ByteCount
bc ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ ByteCount
tc ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ ByteCount
sc) Maybe ChanStatus
mayNextStatus Seq Event
mes

-- private
byteSizeEvents :: Seq Event -> ByteCount
byteSizeEvents :: Seq Event -> ByteCount
byteSizeEvents = ByteCount -> Maybe ChanStatus -> Seq Event -> ByteCount
byteSizeEventsLoop ByteCount
0 Maybe ChanStatus
forall a. Maybe a
Nothing

-- private
putEventsLoop :: Maybe ChanStatus -> Seq Event -> Put
putEventsLoop :: Maybe ChanStatus -> Seq Event -> Put
putEventsLoop !Maybe ChanStatus
mayLastStatus = \case
  Seq Event
Empty -> () -> Put
forall a. a -> PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  Event VarWord
td RecMsg
msg :<| Seq Event
mes -> do
    VarWord -> Put
forall a. Binary a => a -> Put
put VarWord
td
    Maybe ChanStatus
mayNextStatus <- (RecMsg -> Put)
-> Maybe ChanStatus -> RecMsg -> PutM (Maybe ChanStatus)
forall s c.
(HasChanData s c, Binary s) =>
(c -> Put) -> Maybe ChanStatus -> c -> PutM (Maybe ChanStatus)
putMsgRunning RecMsg -> Put
putRecMsgData Maybe ChanStatus
mayLastStatus RecMsg
msg
    Maybe ChanStatus -> Seq Event -> Put
putEventsLoop Maybe ChanStatus
mayNextStatus Seq Event
mes

-- private
putEvents :: Seq Event -> Put
putEvents :: Seq Event -> Put
putEvents = Maybe ChanStatus -> Seq Event -> Put
putEventsLoop Maybe ChanStatus
forall a. Maybe a
Nothing

getEventsScope :: ByteCount -> Get (Seq Event)
getEventsScope :: ByteCount -> Get (Seq Event)
getEventsScope ByteCount
bc = ByteCount -> Get (Seq Event) -> Get (Seq Event)
forall a. ByteCount -> Get a -> Get a
getExact ByteCount
bc (Seq Event -> Maybe ChanStatus -> Get (Seq Event)
go Seq Event
forall a. Seq a
Empty Maybe ChanStatus
forall a. Maybe a
Nothing)
 where
  go :: Seq Event -> Maybe ChanStatus -> Get (Seq Event)
go !Seq Event
acc !Maybe ChanStatus
mayLastStatus = do
    ByteCount
sz <- Get ByteCount
getRemainingSize
    -- traceM $ "SIZE LEFT : " ++ show sz
    if ByteCount
sz ByteCount -> ByteCount -> Bool
forall a. Eq a => a -> a -> Bool
== ByteCount
0
      then Seq Event -> Get (Seq Event)
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Seq Event
acc
      else do
        VarWord
td <- Get VarWord
forall a. Binary a => Get a
get
        RecMsg
msg <- (RecStatus -> Get RecMsg) -> Maybe ChanStatus -> Get RecMsg
forall s c.
(Binary s, HasChanStatus s) =>
(s -> Get c) -> Maybe ChanStatus -> Get c
getMsgRunning RecStatus -> Get RecMsg
getRecMsgWithStatus Maybe ChanStatus
mayLastStatus
        let !me :: Event
me = VarWord -> RecMsg -> Event
Event VarWord
td RecMsg
msg
            !mayNextStatus :: Maybe ChanStatus
mayNextStatus = RecStatus -> Maybe ChanStatus
forall s. HasChanStatus s => s -> Maybe ChanStatus
statusAsChan (RecMsg -> RecStatus
forall s c. HasChanData s c => c -> s
extractStatus RecMsg
msg)
        Seq Event -> Maybe ChanStatus -> Get (Seq Event)
go (Seq Event
acc Seq Event -> Event -> Seq Event
forall a. Seq a -> a -> Seq a
:|> Event
me) Maybe ChanStatus
mayNextStatus

instance Binary Track where
  byteSize :: Track -> ByteCount
byteSize (Track Seq Event
events) = ByteCount
8 ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Seq Event -> ByteCount
byteSizeEvents Seq Event
events

  get :: Get Track
get = do
    TrackMagic
_ <- forall a. Binary a => Get a
get @TrackMagic
    Word32BE
chunkSize <- forall a. Binary a => Get a
get @Word32BE
    (Seq Event -> Track) -> Get (Seq Event) -> Get Track
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Seq Event -> Track
Track (ByteCount -> Get (Seq Event)
getEventsScope (Word32BE -> ByteCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32BE
chunkSize))

  put :: Track -> Put
put t :: Track
t@(Track Seq Event
events) = do
    forall a. Binary a => a -> Put
put @TrackMagic (() -> TrackMagic
forall (n :: Natural) (s :: Symbol). () -> ExactBytes n s
ExactBytes ())
    forall a. Binary a => a -> Put
put @Word32BE (ByteCount -> Word32BE
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Track -> ByteCount
forall a. Binary a => a -> ByteCount
byteSize Track
t) Word32BE -> Word32BE -> Word32BE
forall a. Num a => a -> a -> a
- Word32BE
8)
    Seq Event -> Put
putEvents Seq Event
events

data MidFileType
  = MidFileTypeSingle
  | MidFileTypeMultiSync
  | MidFileTypeMultiAsync
  deriving stock (MidFileType -> MidFileType -> Bool
(MidFileType -> MidFileType -> Bool)
-> (MidFileType -> MidFileType -> Bool) -> Eq MidFileType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MidFileType -> MidFileType -> Bool
== :: MidFileType -> MidFileType -> Bool
$c/= :: MidFileType -> MidFileType -> Bool
/= :: MidFileType -> MidFileType -> Bool
Eq, Eq MidFileType
Eq MidFileType =>
(MidFileType -> MidFileType -> Ordering)
-> (MidFileType -> MidFileType -> Bool)
-> (MidFileType -> MidFileType -> Bool)
-> (MidFileType -> MidFileType -> Bool)
-> (MidFileType -> MidFileType -> Bool)
-> (MidFileType -> MidFileType -> MidFileType)
-> (MidFileType -> MidFileType -> MidFileType)
-> Ord MidFileType
MidFileType -> MidFileType -> Bool
MidFileType -> MidFileType -> Ordering
MidFileType -> MidFileType -> MidFileType
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
$ccompare :: MidFileType -> MidFileType -> Ordering
compare :: MidFileType -> MidFileType -> Ordering
$c< :: MidFileType -> MidFileType -> Bool
< :: MidFileType -> MidFileType -> Bool
$c<= :: MidFileType -> MidFileType -> Bool
<= :: MidFileType -> MidFileType -> Bool
$c> :: MidFileType -> MidFileType -> Bool
> :: MidFileType -> MidFileType -> Bool
$c>= :: MidFileType -> MidFileType -> Bool
>= :: MidFileType -> MidFileType -> Bool
$cmax :: MidFileType -> MidFileType -> MidFileType
max :: MidFileType -> MidFileType -> MidFileType
$cmin :: MidFileType -> MidFileType -> MidFileType
min :: MidFileType -> MidFileType -> MidFileType
Ord, Int -> MidFileType
MidFileType -> Int
MidFileType -> [MidFileType]
MidFileType -> MidFileType
MidFileType -> MidFileType -> [MidFileType]
MidFileType -> MidFileType -> MidFileType -> [MidFileType]
(MidFileType -> MidFileType)
-> (MidFileType -> MidFileType)
-> (Int -> MidFileType)
-> (MidFileType -> Int)
-> (MidFileType -> [MidFileType])
-> (MidFileType -> MidFileType -> [MidFileType])
-> (MidFileType -> MidFileType -> [MidFileType])
-> (MidFileType -> MidFileType -> MidFileType -> [MidFileType])
-> Enum MidFileType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MidFileType -> MidFileType
succ :: MidFileType -> MidFileType
$cpred :: MidFileType -> MidFileType
pred :: MidFileType -> MidFileType
$ctoEnum :: Int -> MidFileType
toEnum :: Int -> MidFileType
$cfromEnum :: MidFileType -> Int
fromEnum :: MidFileType -> Int
$cenumFrom :: MidFileType -> [MidFileType]
enumFrom :: MidFileType -> [MidFileType]
$cenumFromThen :: MidFileType -> MidFileType -> [MidFileType]
enumFromThen :: MidFileType -> MidFileType -> [MidFileType]
$cenumFromTo :: MidFileType -> MidFileType -> [MidFileType]
enumFromTo :: MidFileType -> MidFileType -> [MidFileType]
$cenumFromThenTo :: MidFileType -> MidFileType -> MidFileType -> [MidFileType]
enumFromThenTo :: MidFileType -> MidFileType -> MidFileType -> [MidFileType]
Enum, MidFileType
MidFileType -> MidFileType -> Bounded MidFileType
forall a. a -> a -> Bounded a
$cminBound :: MidFileType
minBound :: MidFileType
$cmaxBound :: MidFileType
maxBound :: MidFileType
Bounded, Int -> MidFileType -> ShowS
[MidFileType] -> ShowS
MidFileType -> String
(Int -> MidFileType -> ShowS)
-> (MidFileType -> String)
-> ([MidFileType] -> ShowS)
-> Show MidFileType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MidFileType -> ShowS
showsPrec :: Int -> MidFileType -> ShowS
$cshow :: MidFileType -> String
show :: MidFileType -> String
$cshowList :: [MidFileType] -> ShowS
showList :: [MidFileType] -> ShowS
Show)
  deriving (KnownNat (StaticSize MidFileType)
KnownNat (StaticSize MidFileType) =>
(Proxy MidFileType -> ByteCount) -> StaticByteSized MidFileType
Proxy MidFileType -> ByteCount
forall a.
KnownNat (StaticSize a) =>
(Proxy a -> ByteCount) -> StaticByteSized a
$cstaticByteSize :: Proxy MidFileType -> ByteCount
staticByteSize :: Proxy MidFileType -> ByteCount
StaticByteSized, Get MidFileType
MidFileType -> ByteCount
MidFileType -> Put
(MidFileType -> ByteCount)
-> Get MidFileType -> (MidFileType -> Put) -> Binary MidFileType
forall a. (a -> ByteCount) -> Get a -> (a -> Put) -> Binary a
$cbyteSize :: MidFileType -> ByteCount
byteSize :: MidFileType -> ByteCount
$cget :: Get MidFileType
get :: Get MidFileType
$cput :: MidFileType -> Put
put :: MidFileType -> Put
Binary) via (ViaBinaryRep Word16BE MidFileType)

instance BinaryRep Word16BE MidFileType where
  fromBinaryRep :: Word16BE -> Either String MidFileType
fromBinaryRep = \case
    Word16BE
0 -> MidFileType -> Either String MidFileType
forall a b. b -> Either a b
Right MidFileType
MidFileTypeSingle
    Word16BE
1 -> MidFileType -> Either String MidFileType
forall a b. b -> Either a b
Right MidFileType
MidFileTypeMultiSync
    Word16BE
2 -> MidFileType -> Either String MidFileType
forall a b. b -> Either a b
Right MidFileType
MidFileTypeMultiAsync
    Word16BE
other -> String -> Either String MidFileType
forall a b. a -> Either a b
Left (String
"invalid midi file type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word16BE -> String
forall a. Show a => a -> String
show Word16BE
other)
  toBinaryRep :: MidFileType -> Word16BE
toBinaryRep = \case
    MidFileType
MidFileTypeSingle -> Word16BE
0
    MidFileType
MidFileTypeMultiSync -> Word16BE
1
    MidFileType
MidFileTypeMultiAsync -> Word16BE
2

-- private
type MidFileMagic = ExactBytes 8 "MThd\NUL\NUL\NUL\ACK"

-- | NOTE: Ticks could also be SMTPE-related, but we don't support that here
data MidFile = MidFile
  { MidFile -> MidFileType
mfType :: !MidFileType
  , MidFile -> Word16
mfTicks :: !Word16
  , MidFile -> Seq Track
mfTracks :: !(Seq Track)
  }
  deriving stock (MidFile -> MidFile -> Bool
(MidFile -> MidFile -> Bool)
-> (MidFile -> MidFile -> Bool) -> Eq MidFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MidFile -> MidFile -> Bool
== :: MidFile -> MidFile -> Bool
$c/= :: MidFile -> MidFile -> Bool
/= :: MidFile -> MidFile -> Bool
Eq, Eq MidFile
Eq MidFile =>
(MidFile -> MidFile -> Ordering)
-> (MidFile -> MidFile -> Bool)
-> (MidFile -> MidFile -> Bool)
-> (MidFile -> MidFile -> Bool)
-> (MidFile -> MidFile -> Bool)
-> (MidFile -> MidFile -> MidFile)
-> (MidFile -> MidFile -> MidFile)
-> Ord MidFile
MidFile -> MidFile -> Bool
MidFile -> MidFile -> Ordering
MidFile -> MidFile -> MidFile
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
$ccompare :: MidFile -> MidFile -> Ordering
compare :: MidFile -> MidFile -> Ordering
$c< :: MidFile -> MidFile -> Bool
< :: MidFile -> MidFile -> Bool
$c<= :: MidFile -> MidFile -> Bool
<= :: MidFile -> MidFile -> Bool
$c> :: MidFile -> MidFile -> Bool
> :: MidFile -> MidFile -> Bool
$c>= :: MidFile -> MidFile -> Bool
>= :: MidFile -> MidFile -> Bool
$cmax :: MidFile -> MidFile -> MidFile
max :: MidFile -> MidFile -> MidFile
$cmin :: MidFile -> MidFile -> MidFile
min :: MidFile -> MidFile -> MidFile
Ord, Int -> MidFile -> ShowS
[MidFile] -> ShowS
MidFile -> String
(Int -> MidFile -> ShowS)
-> (MidFile -> String) -> ([MidFile] -> ShowS) -> Show MidFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MidFile -> ShowS
showsPrec :: Int -> MidFile -> ShowS
$cshow :: MidFile -> String
show :: MidFile -> String
$cshowList :: [MidFile] -> ShowS
showList :: [MidFile] -> ShowS
Show)

instance Binary MidFile where
  byteSize :: MidFile -> ByteCount
byteSize (MidFile MidFileType
_ Word16
_ Seq Track
tracks) = ByteCount
14 ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Seq Track -> ByteCount
forall (f :: * -> *) a. (Foldable f, Binary a) => f a -> ByteCount
byteSizeFoldable Seq Track
tracks
  get :: Get MidFile
get = do
    MidFileMagic
_ <- forall a. Binary a => Get a
get @MidFileMagic
    MidFileType
ty <- Get MidFileType
forall a. Binary a => Get a
get
    Word16BE Word16
numTracks <- Get Word16BE
forall a. Binary a => Get a
get
    Word16BE Word16
ticks <- Get Word16BE
forall a. Binary a => Get a
get
    -- traceM ("NUM TRACKS : " ++ show numTracks)
    Seq Track
tracks <- ElemCount -> Get Track -> Get (Seq Track)
forall a. ElemCount -> Get a -> Get (Seq a)
getSeq (Word16 -> ElemCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
numTracks) Get Track
forall a. Binary a => Get a
get
    MidFile -> Get MidFile
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MidFileType -> Word16 -> Seq Track -> MidFile
MidFile MidFileType
ty Word16
ticks Seq Track
tracks)
  put :: MidFile -> Put
put (MidFile MidFileType
ty Word16
ticks Seq Track
tracks) = do
    forall a. Binary a => a -> Put
put @MidFileMagic (() -> MidFileMagic
forall (n :: Natural) (s :: Symbol). () -> ExactBytes n s
ExactBytes ())
    MidFileType -> Put
forall a. Binary a => a -> Put
put MidFileType
ty
    Word16BE -> Put
forall a. Binary a => a -> Put
put (Word16 -> Word16BE
Word16BE (Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Seq Track -> Int
forall a. Seq a -> Int
Seq.length Seq Track
tracks)))
    Word16BE -> Put
forall a. Binary a => a -> Put
put (Word16 -> Word16BE
Word16BE Word16
ticks)
    (Track -> Put) -> Seq Track -> Put
forall a. (a -> Put) -> Seq a -> Put
putSeq Track -> Put
forall a. Binary a => a -> Put
put Seq Track
tracks

newtype SysExDump = SysExDump {SysExDump -> Seq SysExData
unSysExDump :: Seq SysExData}
  deriving stock (Int -> SysExDump -> ShowS
[SysExDump] -> ShowS
SysExDump -> String
(Int -> SysExDump -> ShowS)
-> (SysExDump -> String)
-> ([SysExDump] -> ShowS)
-> Show SysExDump
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SysExDump -> ShowS
showsPrec :: Int -> SysExDump -> ShowS
$cshow :: SysExDump -> String
show :: SysExDump -> String
$cshowList :: [SysExDump] -> ShowS
showList :: [SysExDump] -> ShowS
Show)
  deriving newtype (SysExDump -> SysExDump -> Bool
(SysExDump -> SysExDump -> Bool)
-> (SysExDump -> SysExDump -> Bool) -> Eq SysExDump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SysExDump -> SysExDump -> Bool
== :: SysExDump -> SysExDump -> Bool
$c/= :: SysExDump -> SysExDump -> Bool
/= :: SysExDump -> SysExDump -> Bool
Eq, Eq SysExDump
Eq SysExDump =>
(SysExDump -> SysExDump -> Ordering)
-> (SysExDump -> SysExDump -> Bool)
-> (SysExDump -> SysExDump -> Bool)
-> (SysExDump -> SysExDump -> Bool)
-> (SysExDump -> SysExDump -> Bool)
-> (SysExDump -> SysExDump -> SysExDump)
-> (SysExDump -> SysExDump -> SysExDump)
-> Ord SysExDump
SysExDump -> SysExDump -> Bool
SysExDump -> SysExDump -> Ordering
SysExDump -> SysExDump -> SysExDump
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
$ccompare :: SysExDump -> SysExDump -> Ordering
compare :: SysExDump -> SysExDump -> Ordering
$c< :: SysExDump -> SysExDump -> Bool
< :: SysExDump -> SysExDump -> Bool
$c<= :: SysExDump -> SysExDump -> Bool
<= :: SysExDump -> SysExDump -> Bool
$c> :: SysExDump -> SysExDump -> Bool
> :: SysExDump -> SysExDump -> Bool
$c>= :: SysExDump -> SysExDump -> Bool
>= :: SysExDump -> SysExDump -> Bool
$cmax :: SysExDump -> SysExDump -> SysExDump
max :: SysExDump -> SysExDump -> SysExDump
$cmin :: SysExDump -> SysExDump -> SysExDump
min :: SysExDump -> SysExDump -> SysExDump
Ord)

instance Binary SysExDump where
  byteSize :: SysExDump -> ByteCount
byteSize (SysExDump Seq SysExData
ds) = Int -> ByteCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Seq SysExData -> Int
forall a. Seq a -> Int
Seq.length Seq SysExData
ds) ByteCount -> ByteCount -> ByteCount
forall a. Num a => a -> a -> a
+ Seq SysExData -> ByteCount
forall (f :: * -> *) a. (Foldable f, Binary a) => f a -> ByteCount
byteSizeFoldable Seq SysExData
ds
  get :: Get SysExDump
get = (Seq SysExData -> SysExDump)
-> Get (Seq SysExData) -> Get SysExDump
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Seq SysExData -> SysExDump
SysExDump (Get (Seq SysExData) -> Get SysExDump)
-> Get (Seq SysExData) -> Get SysExDump
forall a b. (a -> b) -> a -> b
$ Get SysExData -> Get (Seq SysExData)
forall a. Get a -> Get (Seq a)
getRemainingSeq (Get SysExData -> Get (Seq SysExData))
-> Get SysExData -> Get (Seq SysExData)
forall a b. (a -> b) -> a -> b
$ do
    forall a. (Eq a, Show a) => String -> Get a -> a -> Get ()
getExpect @Word8 String
"sysex status byte" Get Word8
forall a. Binary a => Get a
get Word8
0xF0
    Get SysExData
forall a. Binary a => Get a
get
  put :: SysExDump -> Put
put = (SysExData -> Put) -> Seq SysExData -> Put
forall a. (a -> Put) -> Seq a -> Put
putSeq (\SysExData
d -> forall a. Binary a => a -> Put
put @Word8 Word8
0xF0 Put -> Put -> Put
forall a b. PutM a -> PutM b -> PutM b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> SysExData -> Put
forall a. Binary a => a -> Put
put SysExData
d) (Seq SysExData -> Put)
-> (SysExDump -> Seq SysExData) -> SysExDump -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SysExDump -> Seq SysExData
unSysExDump