{-# LANGUAGE TupleSections #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Fadno.Notation where

import GHC.Generics
import Data.Semigroup
import Data.String
import Data.Default
import Fadno.Note
import Control.Lens hiding (pre)
import Data.Typeable
import Data.Ratio
import Data.Sequence (Seq,fromList)
import Data.Foldable
import Test.HUnit
import Data.List
import Data.Maybe


-- valid time sig denoms
data Quanta = Q2|Q4|Q8|Q16|Q32|Q64
               deriving (Quanta -> Quanta -> Bool
(Quanta -> Quanta -> Bool)
-> (Quanta -> Quanta -> Bool) -> Eq Quanta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Quanta -> Quanta -> Bool
$c/= :: Quanta -> Quanta -> Bool
== :: Quanta -> Quanta -> Bool
$c== :: Quanta -> Quanta -> Bool
Eq,Int -> Quanta -> ShowS
[Quanta] -> ShowS
Quanta -> String
(Int -> Quanta -> ShowS)
-> (Quanta -> String) -> ([Quanta] -> ShowS) -> Show Quanta
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Quanta] -> ShowS
$cshowList :: [Quanta] -> ShowS
show :: Quanta -> String
$cshow :: Quanta -> String
showsPrec :: Int -> Quanta -> ShowS
$cshowsPrec :: Int -> Quanta -> ShowS
Show,Eq Quanta
Eq Quanta
-> (Quanta -> Quanta -> Ordering)
-> (Quanta -> Quanta -> Bool)
-> (Quanta -> Quanta -> Bool)
-> (Quanta -> Quanta -> Bool)
-> (Quanta -> Quanta -> Bool)
-> (Quanta -> Quanta -> Quanta)
-> (Quanta -> Quanta -> Quanta)
-> Ord Quanta
Quanta -> Quanta -> Bool
Quanta -> Quanta -> Ordering
Quanta -> Quanta -> Quanta
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Quanta -> Quanta -> Quanta
$cmin :: Quanta -> Quanta -> Quanta
max :: Quanta -> Quanta -> Quanta
$cmax :: Quanta -> Quanta -> Quanta
>= :: Quanta -> Quanta -> Bool
$c>= :: Quanta -> Quanta -> Bool
> :: Quanta -> Quanta -> Bool
$c> :: Quanta -> Quanta -> Bool
<= :: Quanta -> Quanta -> Bool
$c<= :: Quanta -> Quanta -> Bool
< :: Quanta -> Quanta -> Bool
$c< :: Quanta -> Quanta -> Bool
compare :: Quanta -> Quanta -> Ordering
$ccompare :: Quanta -> Quanta -> Ordering
$cp1Ord :: Eq Quanta
Ord,Int -> Quanta
Quanta -> Int
Quanta -> [Quanta]
Quanta -> Quanta
Quanta -> Quanta -> [Quanta]
Quanta -> Quanta -> Quanta -> [Quanta]
(Quanta -> Quanta)
-> (Quanta -> Quanta)
-> (Int -> Quanta)
-> (Quanta -> Int)
-> (Quanta -> [Quanta])
-> (Quanta -> Quanta -> [Quanta])
-> (Quanta -> Quanta -> [Quanta])
-> (Quanta -> Quanta -> Quanta -> [Quanta])
-> Enum Quanta
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Quanta -> Quanta -> Quanta -> [Quanta]
$cenumFromThenTo :: Quanta -> Quanta -> Quanta -> [Quanta]
enumFromTo :: Quanta -> Quanta -> [Quanta]
$cenumFromTo :: Quanta -> Quanta -> [Quanta]
enumFromThen :: Quanta -> Quanta -> [Quanta]
$cenumFromThen :: Quanta -> Quanta -> [Quanta]
enumFrom :: Quanta -> [Quanta]
$cenumFrom :: Quanta -> [Quanta]
fromEnum :: Quanta -> Int
$cfromEnum :: Quanta -> Int
toEnum :: Int -> Quanta
$ctoEnum :: Int -> Quanta
pred :: Quanta -> Quanta
$cpred :: Quanta -> Quanta
succ :: Quanta -> Quanta
$csucc :: Quanta -> Quanta
Enum,Quanta
Quanta -> Quanta -> Bounded Quanta
forall a. a -> a -> Bounded a
maxBound :: Quanta
$cmaxBound :: Quanta
minBound :: Quanta
$cminBound :: Quanta
Bounded,Typeable)

qToInt :: Quanta -> Int
qToInt :: Quanta -> Int
qToInt = (Int
2Int -> Int -> Int
forall a b. (Num a, Integral b) => a -> b -> a
^) (Int -> Int) -> (Quanta -> Int) -> Quanta -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int
forall a. Enum a => a -> a
succ (Int -> Int) -> (Quanta -> Int) -> Quanta -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Quanta -> Int
forall a. Enum a => a -> Int
fromEnum
qFromInt :: Integral i => i -> Maybe Quanta
qFromInt :: i -> Maybe Quanta
qFromInt = (Int -> Quanta) -> Maybe Int -> Maybe Quanta
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Quanta
forall a. Enum a => Int -> a
toEnum (Maybe Int -> Maybe Quanta)
-> (i -> Maybe Int) -> i -> Maybe Quanta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> [i] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
`elemIndex` [i
2,i
4,i
8,i
16,i
32,i
64])


data TimeSignature = TimeSignature { TimeSignature -> Int
_tsLength :: Int, TimeSignature -> Quanta
_tsUnit :: Quanta }
   deriving (TimeSignature -> TimeSignature -> Bool
(TimeSignature -> TimeSignature -> Bool)
-> (TimeSignature -> TimeSignature -> Bool) -> Eq TimeSignature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TimeSignature -> TimeSignature -> Bool
$c/= :: TimeSignature -> TimeSignature -> Bool
== :: TimeSignature -> TimeSignature -> Bool
$c== :: TimeSignature -> TimeSignature -> Bool
Eq,Eq TimeSignature
Eq TimeSignature
-> (TimeSignature -> TimeSignature -> Ordering)
-> (TimeSignature -> TimeSignature -> Bool)
-> (TimeSignature -> TimeSignature -> Bool)
-> (TimeSignature -> TimeSignature -> Bool)
-> (TimeSignature -> TimeSignature -> Bool)
-> (TimeSignature -> TimeSignature -> TimeSignature)
-> (TimeSignature -> TimeSignature -> TimeSignature)
-> Ord TimeSignature
TimeSignature -> TimeSignature -> Bool
TimeSignature -> TimeSignature -> Ordering
TimeSignature -> TimeSignature -> TimeSignature
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TimeSignature -> TimeSignature -> TimeSignature
$cmin :: TimeSignature -> TimeSignature -> TimeSignature
max :: TimeSignature -> TimeSignature -> TimeSignature
$cmax :: TimeSignature -> TimeSignature -> TimeSignature
>= :: TimeSignature -> TimeSignature -> Bool
$c>= :: TimeSignature -> TimeSignature -> Bool
> :: TimeSignature -> TimeSignature -> Bool
$c> :: TimeSignature -> TimeSignature -> Bool
<= :: TimeSignature -> TimeSignature -> Bool
$c<= :: TimeSignature -> TimeSignature -> Bool
< :: TimeSignature -> TimeSignature -> Bool
$c< :: TimeSignature -> TimeSignature -> Bool
compare :: TimeSignature -> TimeSignature -> Ordering
$ccompare :: TimeSignature -> TimeSignature -> Ordering
$cp1Ord :: Eq TimeSignature
Ord)
instance Show TimeSignature where
    show :: TimeSignature -> String
show (TimeSignature Int
l Quanta
u) = Int -> String
forall a. Show a => a -> String
show Int
l String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"/:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Quanta -> String
forall a. Show a => a -> String
show Quanta
u
makeLenses ''TimeSignature
class HasTimeSignature a where timeSignature :: Lens' a (Maybe TimeSignature)

(/:) :: Int -> Quanta -> TimeSignature
/: :: Int -> Quanta -> TimeSignature
(/:) = Int -> Quanta -> TimeSignature
TimeSignature

-- PPQ: valid midi divisions, named after equivalent Quantum
-- as in, "1 means ..."; PQ4 is "1 means quarter note"
data PPQ = PQ4|PQ8|PQ16|PQ32|PQ64|PQ128|PQ256
         deriving (PPQ -> PPQ -> Bool
(PPQ -> PPQ -> Bool) -> (PPQ -> PPQ -> Bool) -> Eq PPQ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PPQ -> PPQ -> Bool
$c/= :: PPQ -> PPQ -> Bool
== :: PPQ -> PPQ -> Bool
$c== :: PPQ -> PPQ -> Bool
Eq,Int -> PPQ -> ShowS
[PPQ] -> ShowS
PPQ -> String
(Int -> PPQ -> ShowS)
-> (PPQ -> String) -> ([PPQ] -> ShowS) -> Show PPQ
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PPQ] -> ShowS
$cshowList :: [PPQ] -> ShowS
show :: PPQ -> String
$cshow :: PPQ -> String
showsPrec :: Int -> PPQ -> ShowS
$cshowsPrec :: Int -> PPQ -> ShowS
Show,Eq PPQ
Eq PPQ
-> (PPQ -> PPQ -> Ordering)
-> (PPQ -> PPQ -> Bool)
-> (PPQ -> PPQ -> Bool)
-> (PPQ -> PPQ -> Bool)
-> (PPQ -> PPQ -> Bool)
-> (PPQ -> PPQ -> PPQ)
-> (PPQ -> PPQ -> PPQ)
-> Ord PPQ
PPQ -> PPQ -> Bool
PPQ -> PPQ -> Ordering
PPQ -> PPQ -> PPQ
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PPQ -> PPQ -> PPQ
$cmin :: PPQ -> PPQ -> PPQ
max :: PPQ -> PPQ -> PPQ
$cmax :: PPQ -> PPQ -> PPQ
>= :: PPQ -> PPQ -> Bool
$c>= :: PPQ -> PPQ -> Bool
> :: PPQ -> PPQ -> Bool
$c> :: PPQ -> PPQ -> Bool
<= :: PPQ -> PPQ -> Bool
$c<= :: PPQ -> PPQ -> Bool
< :: PPQ -> PPQ -> Bool
$c< :: PPQ -> PPQ -> Bool
compare :: PPQ -> PPQ -> Ordering
$ccompare :: PPQ -> PPQ -> Ordering
$cp1Ord :: Eq PPQ
Ord,Int -> PPQ
PPQ -> Int
PPQ -> [PPQ]
PPQ -> PPQ
PPQ -> PPQ -> [PPQ]
PPQ -> PPQ -> PPQ -> [PPQ]
(PPQ -> PPQ)
-> (PPQ -> PPQ)
-> (Int -> PPQ)
-> (PPQ -> Int)
-> (PPQ -> [PPQ])
-> (PPQ -> PPQ -> [PPQ])
-> (PPQ -> PPQ -> [PPQ])
-> (PPQ -> PPQ -> PPQ -> [PPQ])
-> Enum PPQ
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: PPQ -> PPQ -> PPQ -> [PPQ]
$cenumFromThenTo :: PPQ -> PPQ -> PPQ -> [PPQ]
enumFromTo :: PPQ -> PPQ -> [PPQ]
$cenumFromTo :: PPQ -> PPQ -> [PPQ]
enumFromThen :: PPQ -> PPQ -> [PPQ]
$cenumFromThen :: PPQ -> PPQ -> [PPQ]
enumFrom :: PPQ -> [PPQ]
$cenumFrom :: PPQ -> [PPQ]
fromEnum :: PPQ -> Int
$cfromEnum :: PPQ -> Int
toEnum :: Int -> PPQ
$ctoEnum :: Int -> PPQ
pred :: PPQ -> PPQ
$cpred :: PPQ -> PPQ
succ :: PPQ -> PPQ
$csucc :: PPQ -> PPQ
Enum,PPQ
PPQ -> PPQ -> Bounded PPQ
forall a. a -> a -> Bounded a
maxBound :: PPQ
$cmaxBound :: PPQ
minBound :: PPQ
$cminBound :: PPQ
Bounded)


-- convert to midi division value
ppqDiv :: Integral a => PPQ -> a
ppqDiv :: PPQ -> a
ppqDiv = (a
2a -> Int -> a
forall a b. (Num a, Integral b) => a -> b -> a
^) (Int -> a) -> (PPQ -> Int) -> PPQ -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PPQ -> Int
forall a. Enum a => a -> Int
fromEnum


-- Compute duration of TS
tsToRatio :: TimeSignature -> Rational
tsToRatio :: TimeSignature -> Rational
tsToRatio (TimeSignature Int
n Quanta
d) = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Quanta -> Int
qToInt Quanta
d)

-- Derive TS from duration, with 1 denominator implying Q4
tsFromRatio :: Rational -> Maybe TimeSignature
tsFromRatio :: Rational -> Maybe TimeSignature
tsFromRatio Rational
r = Integer -> Maybe TimeSignature
toTs (if Integer
d Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1 then Integer
4 else (if Integer
n Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1 then Integer
2 else Integer
1))
    where toTs :: Integer -> Maybe TimeSignature
toTs Integer
m = (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
m) Int -> Quanta -> TimeSignature
/:) (Quanta -> TimeSignature) -> Maybe Quanta -> Maybe TimeSignature
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> Maybe Quanta
forall i. Integral i => i -> Maybe Quanta
qFromInt (Integer
d Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
m)
          d :: Integer
d = Rational -> Integer
forall a. Ratio a -> a
denominator Rational
r
          n :: Integer
n = Rational -> Integer
forall a. Ratio a -> a
numerator Rational
r


tsFromRatio' :: TimeSignature -> Rational -> Maybe TimeSignature
tsFromRatio' :: TimeSignature -> Rational -> Maybe TimeSignature
tsFromRatio' (TimeSignature Int
_ Quanta
src) = (TimeSignature -> TimeSignature)
-> Maybe TimeSignature -> Maybe TimeSignature
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TimeSignature -> TimeSignature
adjust (Maybe TimeSignature -> Maybe TimeSignature)
-> (Rational -> Maybe TimeSignature)
-> Rational
-> Maybe TimeSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Maybe TimeSignature
tsFromRatio where
    adjust :: TimeSignature -> TimeSignature
adjust t :: TimeSignature
t@(TimeSignature Int
n Quanta
d) | Quanta
src Quanta -> Quanta -> Bool
forall a. Ord a => a -> a -> Bool
<= Quanta
d = TimeSignature
t
                                 | Bool
otherwise = (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
m) Int -> Quanta -> TimeSignature
/: Quanta
src
                                 where qd :: Int
qd = Quanta -> Int
qToInt Quanta
d
                                       qs :: Int
qs = Quanta -> Int
qToInt Quanta
src
                                       m :: Int
m = Int
qs Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
qd


-- | Duration iso, from Integral to Rational, given PPQ
ratioPPQ :: Integral a => PPQ -> Iso' a Rational
ratioPPQ :: PPQ -> Iso' a Rational
ratioPPQ PPQ
p = (a -> Rational) -> (Rational -> a) -> Iso' a Rational
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso a -> Rational
forall a a. (Integral a, Integral a) => a -> Ratio a
toRat Rational -> a
forall b. Integral b => Rational -> b
toInt where
    ppq4 :: Integer
ppq4 = PPQ -> Integer
forall a. Integral a => PPQ -> a
ppqDiv PPQ
p Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
4
    toRat :: a -> Ratio a
toRat a
i = a -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
% Integer -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
ppq4
    toInt :: Rational -> b
toInt Rational
r = Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Rational
r Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Integer -> Rational
forall a. Real a => a -> Rational
toRational Integer
ppq4)

-- | Adapt a type to its HasXXX "Maybe Lens'"
adaptHas :: Lens' a (Maybe a)
adaptHas :: (Maybe a -> f (Maybe a)) -> a -> f a
adaptHas Maybe a -> f (Maybe a)
f a
s = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe a
s (Maybe a -> a) -> f (Maybe a) -> f a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a -> f (Maybe a)
f (a -> Maybe a
forall a. a -> Maybe a
Just a
s)

-- | Adapt a non-Maybe lens to the HasXXX "Maybe Lens'"
adaptHasLens :: Lens' s a -> Lens' s (Maybe a)
adaptHasLens :: Lens' s a -> Lens' s (Maybe a)
adaptHasLens Lens' s a
l Maybe a -> f (Maybe a)
f s
s = (Maybe a -> s) -> f (Maybe a) -> f s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (s -> (a -> s) -> Maybe a -> s
forall b a. b -> (a -> b) -> Maybe a -> b
maybe s
s (\a
a -> ASetter s s a a -> a -> s -> s
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter s s a a
Lens' s a
l a
a s
s)) (Maybe a -> f (Maybe a)
f (a -> Maybe a
forall a. a -> Maybe a
Just (Getting a s a -> s -> a
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting a s a
Lens' s a
l s
s)))

-- | Adapt a type that does NOT support the HasXXX feature.
adaptHasNot :: Lens' s (Maybe a)
adaptHasNot :: (Maybe a -> f (Maybe a)) -> s -> f s
adaptHasNot Maybe a -> f (Maybe a)
f s
s = (Maybe a -> s) -> f (Maybe a) -> f s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (s -> Maybe a -> s
forall a b. a -> b -> a
const s
s) (Maybe a -> f (Maybe a)
f Maybe a
forall a. Maybe a
Nothing)


-- | Tied notes.
data Tie = TStart | TStop | TBoth
    deriving (Tie -> Tie -> Bool
(Tie -> Tie -> Bool) -> (Tie -> Tie -> Bool) -> Eq Tie
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tie -> Tie -> Bool
$c/= :: Tie -> Tie -> Bool
== :: Tie -> Tie -> Bool
$c== :: Tie -> Tie -> Bool
Eq,Tie
Tie -> Tie -> Bounded Tie
forall a. a -> a -> Bounded a
maxBound :: Tie
$cmaxBound :: Tie
minBound :: Tie
$cminBound :: Tie
Bounded,Int -> Tie
Tie -> Int
Tie -> [Tie]
Tie -> Tie
Tie -> Tie -> [Tie]
Tie -> Tie -> Tie -> [Tie]
(Tie -> Tie)
-> (Tie -> Tie)
-> (Int -> Tie)
-> (Tie -> Int)
-> (Tie -> [Tie])
-> (Tie -> Tie -> [Tie])
-> (Tie -> Tie -> [Tie])
-> (Tie -> Tie -> Tie -> [Tie])
-> Enum Tie
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Tie -> Tie -> Tie -> [Tie]
$cenumFromThenTo :: Tie -> Tie -> Tie -> [Tie]
enumFromTo :: Tie -> Tie -> [Tie]
$cenumFromTo :: Tie -> Tie -> [Tie]
enumFromThen :: Tie -> Tie -> [Tie]
$cenumFromThen :: Tie -> Tie -> [Tie]
enumFrom :: Tie -> [Tie]
$cenumFrom :: Tie -> [Tie]
fromEnum :: Tie -> Int
$cfromEnum :: Tie -> Int
toEnum :: Int -> Tie
$ctoEnum :: Int -> Tie
pred :: Tie -> Tie
$cpred :: Tie -> Tie
succ :: Tie -> Tie
$csucc :: Tie -> Tie
Enum,Eq Tie
Eq Tie
-> (Tie -> Tie -> Ordering)
-> (Tie -> Tie -> Bool)
-> (Tie -> Tie -> Bool)
-> (Tie -> Tie -> Bool)
-> (Tie -> Tie -> Bool)
-> (Tie -> Tie -> Tie)
-> (Tie -> Tie -> Tie)
-> Ord Tie
Tie -> Tie -> Bool
Tie -> Tie -> Ordering
Tie -> Tie -> Tie
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tie -> Tie -> Tie
$cmin :: Tie -> Tie -> Tie
max :: Tie -> Tie -> Tie
$cmax :: Tie -> Tie -> Tie
>= :: Tie -> Tie -> Bool
$c>= :: Tie -> Tie -> Bool
> :: Tie -> Tie -> Bool
$c> :: Tie -> Tie -> Bool
<= :: Tie -> Tie -> Bool
$c<= :: Tie -> Tie -> Bool
< :: Tie -> Tie -> Bool
$c< :: Tie -> Tie -> Bool
compare :: Tie -> Tie -> Ordering
$ccompare :: Tie -> Tie -> Ordering
$cp1Ord :: Eq Tie
Ord,Int -> Tie -> ShowS
[Tie] -> ShowS
Tie -> String
(Int -> Tie -> ShowS)
-> (Tie -> String) -> ([Tie] -> ShowS) -> Show Tie
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tie] -> ShowS
$cshowList :: [Tie] -> ShowS
show :: Tie -> String
$cshow :: Tie -> String
showsPrec :: Int -> Tie -> ShowS
$cshowsPrec :: Int -> Tie -> ShowS
Show)
makeLenses ''Tie
class HasTie a where tie :: Lens' a (Maybe Tie)
instance HasTie Tie where tie :: (Maybe Tie -> f (Maybe Tie)) -> Tie -> f Tie
tie = (Maybe Tie -> f (Maybe Tie)) -> Tie -> f Tie
forall a. Lens' a (Maybe a)
adaptHas
instance HasTie (Note p d) where tie :: (Maybe Tie -> f (Maybe Tie)) -> Note p d -> f (Note p d)
tie = (Maybe Tie -> f (Maybe Tie)) -> Note p d -> f (Note p d)
forall s a. Lens' s (Maybe a)
adaptHasNot


-- | Slurred notes.
data Slur = SStart | SStop
    deriving (Slur -> Slur -> Bool
(Slur -> Slur -> Bool) -> (Slur -> Slur -> Bool) -> Eq Slur
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Slur -> Slur -> Bool
$c/= :: Slur -> Slur -> Bool
== :: Slur -> Slur -> Bool
$c== :: Slur -> Slur -> Bool
Eq,Slur
Slur -> Slur -> Bounded Slur
forall a. a -> a -> Bounded a
maxBound :: Slur
$cmaxBound :: Slur
minBound :: Slur
$cminBound :: Slur
Bounded,Int -> Slur
Slur -> Int
Slur -> [Slur]
Slur -> Slur
Slur -> Slur -> [Slur]
Slur -> Slur -> Slur -> [Slur]
(Slur -> Slur)
-> (Slur -> Slur)
-> (Int -> Slur)
-> (Slur -> Int)
-> (Slur -> [Slur])
-> (Slur -> Slur -> [Slur])
-> (Slur -> Slur -> [Slur])
-> (Slur -> Slur -> Slur -> [Slur])
-> Enum Slur
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Slur -> Slur -> Slur -> [Slur]
$cenumFromThenTo :: Slur -> Slur -> Slur -> [Slur]
enumFromTo :: Slur -> Slur -> [Slur]
$cenumFromTo :: Slur -> Slur -> [Slur]
enumFromThen :: Slur -> Slur -> [Slur]
$cenumFromThen :: Slur -> Slur -> [Slur]
enumFrom :: Slur -> [Slur]
$cenumFrom :: Slur -> [Slur]
fromEnum :: Slur -> Int
$cfromEnum :: Slur -> Int
toEnum :: Int -> Slur
$ctoEnum :: Int -> Slur
pred :: Slur -> Slur
$cpred :: Slur -> Slur
succ :: Slur -> Slur
$csucc :: Slur -> Slur
Enum,Eq Slur
Eq Slur
-> (Slur -> Slur -> Ordering)
-> (Slur -> Slur -> Bool)
-> (Slur -> Slur -> Bool)
-> (Slur -> Slur -> Bool)
-> (Slur -> Slur -> Bool)
-> (Slur -> Slur -> Slur)
-> (Slur -> Slur -> Slur)
-> Ord Slur
Slur -> Slur -> Bool
Slur -> Slur -> Ordering
Slur -> Slur -> Slur
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Slur -> Slur -> Slur
$cmin :: Slur -> Slur -> Slur
max :: Slur -> Slur -> Slur
$cmax :: Slur -> Slur -> Slur
>= :: Slur -> Slur -> Bool
$c>= :: Slur -> Slur -> Bool
> :: Slur -> Slur -> Bool
$c> :: Slur -> Slur -> Bool
<= :: Slur -> Slur -> Bool
$c<= :: Slur -> Slur -> Bool
< :: Slur -> Slur -> Bool
$c< :: Slur -> Slur -> Bool
compare :: Slur -> Slur -> Ordering
$ccompare :: Slur -> Slur -> Ordering
$cp1Ord :: Eq Slur
Ord,Int -> Slur -> ShowS
[Slur] -> ShowS
Slur -> String
(Int -> Slur -> ShowS)
-> (Slur -> String) -> ([Slur] -> ShowS) -> Show Slur
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Slur] -> ShowS
$cshowList :: [Slur] -> ShowS
show :: Slur -> String
$cshow :: Slur -> String
showsPrec :: Int -> Slur -> ShowS
$cshowsPrec :: Int -> Slur -> ShowS
Show)
makeLenses ''Slur
class HasSlur a where slur :: Lens' a (Maybe Slur)
instance HasSlur Slur where slur :: (Maybe Slur -> f (Maybe Slur)) -> Slur -> f Slur
slur = (Maybe Slur -> f (Maybe Slur)) -> Slur -> f Slur
forall a. Lens' a (Maybe a)
adaptHas

-- | Note articulations.
data Articulation = Staccato | Accent
    deriving (Articulation -> Articulation -> Bool
(Articulation -> Articulation -> Bool)
-> (Articulation -> Articulation -> Bool) -> Eq Articulation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Articulation -> Articulation -> Bool
$c/= :: Articulation -> Articulation -> Bool
== :: Articulation -> Articulation -> Bool
$c== :: Articulation -> Articulation -> Bool
Eq,Int -> Articulation -> ShowS
[Articulation] -> ShowS
Articulation -> String
(Int -> Articulation -> ShowS)
-> (Articulation -> String)
-> ([Articulation] -> ShowS)
-> Show Articulation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Articulation] -> ShowS
$cshowList :: [Articulation] -> ShowS
show :: Articulation -> String
$cshow :: Articulation -> String
showsPrec :: Int -> Articulation -> ShowS
$cshowsPrec :: Int -> Articulation -> ShowS
Show,Articulation
Articulation -> Articulation -> Bounded Articulation
forall a. a -> a -> Bounded a
maxBound :: Articulation
$cmaxBound :: Articulation
minBound :: Articulation
$cminBound :: Articulation
Bounded,Int -> Articulation
Articulation -> Int
Articulation -> [Articulation]
Articulation -> Articulation
Articulation -> Articulation -> [Articulation]
Articulation -> Articulation -> Articulation -> [Articulation]
(Articulation -> Articulation)
-> (Articulation -> Articulation)
-> (Int -> Articulation)
-> (Articulation -> Int)
-> (Articulation -> [Articulation])
-> (Articulation -> Articulation -> [Articulation])
-> (Articulation -> Articulation -> [Articulation])
-> (Articulation -> Articulation -> Articulation -> [Articulation])
-> Enum Articulation
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Articulation -> Articulation -> Articulation -> [Articulation]
$cenumFromThenTo :: Articulation -> Articulation -> Articulation -> [Articulation]
enumFromTo :: Articulation -> Articulation -> [Articulation]
$cenumFromTo :: Articulation -> Articulation -> [Articulation]
enumFromThen :: Articulation -> Articulation -> [Articulation]
$cenumFromThen :: Articulation -> Articulation -> [Articulation]
enumFrom :: Articulation -> [Articulation]
$cenumFrom :: Articulation -> [Articulation]
fromEnum :: Articulation -> Int
$cfromEnum :: Articulation -> Int
toEnum :: Int -> Articulation
$ctoEnum :: Int -> Articulation
pred :: Articulation -> Articulation
$cpred :: Articulation -> Articulation
succ :: Articulation -> Articulation
$csucc :: Articulation -> Articulation
Enum,Eq Articulation
Eq Articulation
-> (Articulation -> Articulation -> Ordering)
-> (Articulation -> Articulation -> Bool)
-> (Articulation -> Articulation -> Bool)
-> (Articulation -> Articulation -> Bool)
-> (Articulation -> Articulation -> Bool)
-> (Articulation -> Articulation -> Articulation)
-> (Articulation -> Articulation -> Articulation)
-> Ord Articulation
Articulation -> Articulation -> Bool
Articulation -> Articulation -> Ordering
Articulation -> Articulation -> Articulation
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Articulation -> Articulation -> Articulation
$cmin :: Articulation -> Articulation -> Articulation
max :: Articulation -> Articulation -> Articulation
$cmax :: Articulation -> Articulation -> Articulation
>= :: Articulation -> Articulation -> Bool
$c>= :: Articulation -> Articulation -> Bool
> :: Articulation -> Articulation -> Bool
$c> :: Articulation -> Articulation -> Bool
<= :: Articulation -> Articulation -> Bool
$c<= :: Articulation -> Articulation -> Bool
< :: Articulation -> Articulation -> Bool
$c< :: Articulation -> Articulation -> Bool
compare :: Articulation -> Articulation -> Ordering
$ccompare :: Articulation -> Articulation -> Ordering
$cp1Ord :: Eq Articulation
Ord)
class HasArticulation a where articulation :: Lens' a (Maybe Articulation)
instance HasArticulation Articulation where articulation :: (Maybe Articulation -> f (Maybe Articulation))
-> Articulation -> f Articulation
articulation = (Maybe Articulation -> f (Maybe Articulation))
-> Articulation -> f Articulation
forall a. Lens' a (Maybe a)
adaptHas


-- | Bar rehearsal mark.
newtype RehearsalMark = RehearsalMark { RehearsalMark -> String
_rehearsalText :: String }
    deriving (RehearsalMark -> RehearsalMark -> Bool
(RehearsalMark -> RehearsalMark -> Bool)
-> (RehearsalMark -> RehearsalMark -> Bool) -> Eq RehearsalMark
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RehearsalMark -> RehearsalMark -> Bool
$c/= :: RehearsalMark -> RehearsalMark -> Bool
== :: RehearsalMark -> RehearsalMark -> Bool
$c== :: RehearsalMark -> RehearsalMark -> Bool
Eq,Eq RehearsalMark
Eq RehearsalMark
-> (RehearsalMark -> RehearsalMark -> Ordering)
-> (RehearsalMark -> RehearsalMark -> Bool)
-> (RehearsalMark -> RehearsalMark -> Bool)
-> (RehearsalMark -> RehearsalMark -> Bool)
-> (RehearsalMark -> RehearsalMark -> Bool)
-> (RehearsalMark -> RehearsalMark -> RehearsalMark)
-> (RehearsalMark -> RehearsalMark -> RehearsalMark)
-> Ord RehearsalMark
RehearsalMark -> RehearsalMark -> Bool
RehearsalMark -> RehearsalMark -> Ordering
RehearsalMark -> RehearsalMark -> RehearsalMark
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RehearsalMark -> RehearsalMark -> RehearsalMark
$cmin :: RehearsalMark -> RehearsalMark -> RehearsalMark
max :: RehearsalMark -> RehearsalMark -> RehearsalMark
$cmax :: RehearsalMark -> RehearsalMark -> RehearsalMark
>= :: RehearsalMark -> RehearsalMark -> Bool
$c>= :: RehearsalMark -> RehearsalMark -> Bool
> :: RehearsalMark -> RehearsalMark -> Bool
$c> :: RehearsalMark -> RehearsalMark -> Bool
<= :: RehearsalMark -> RehearsalMark -> Bool
$c<= :: RehearsalMark -> RehearsalMark -> Bool
< :: RehearsalMark -> RehearsalMark -> Bool
$c< :: RehearsalMark -> RehearsalMark -> Bool
compare :: RehearsalMark -> RehearsalMark -> Ordering
$ccompare :: RehearsalMark -> RehearsalMark -> Ordering
$cp1Ord :: Eq RehearsalMark
Ord,String -> RehearsalMark
(String -> RehearsalMark) -> IsString RehearsalMark
forall a. (String -> a) -> IsString a
fromString :: String -> RehearsalMark
$cfromString :: String -> RehearsalMark
IsString,(forall x. RehearsalMark -> Rep RehearsalMark x)
-> (forall x. Rep RehearsalMark x -> RehearsalMark)
-> Generic RehearsalMark
forall x. Rep RehearsalMark x -> RehearsalMark
forall x. RehearsalMark -> Rep RehearsalMark x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RehearsalMark x -> RehearsalMark
$cfrom :: forall x. RehearsalMark -> Rep RehearsalMark x
Generic,b -> RehearsalMark -> RehearsalMark
NonEmpty RehearsalMark -> RehearsalMark
RehearsalMark -> RehearsalMark -> RehearsalMark
(RehearsalMark -> RehearsalMark -> RehearsalMark)
-> (NonEmpty RehearsalMark -> RehearsalMark)
-> (forall b. Integral b => b -> RehearsalMark -> RehearsalMark)
-> Semigroup RehearsalMark
forall b. Integral b => b -> RehearsalMark -> RehearsalMark
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> RehearsalMark -> RehearsalMark
$cstimes :: forall b. Integral b => b -> RehearsalMark -> RehearsalMark
sconcat :: NonEmpty RehearsalMark -> RehearsalMark
$csconcat :: NonEmpty RehearsalMark -> RehearsalMark
<> :: RehearsalMark -> RehearsalMark -> RehearsalMark
$c<> :: RehearsalMark -> RehearsalMark -> RehearsalMark
Semigroup,Semigroup RehearsalMark
RehearsalMark
Semigroup RehearsalMark
-> RehearsalMark
-> (RehearsalMark -> RehearsalMark -> RehearsalMark)
-> ([RehearsalMark] -> RehearsalMark)
-> Monoid RehearsalMark
[RehearsalMark] -> RehearsalMark
RehearsalMark -> RehearsalMark -> RehearsalMark
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [RehearsalMark] -> RehearsalMark
$cmconcat :: [RehearsalMark] -> RehearsalMark
mappend :: RehearsalMark -> RehearsalMark -> RehearsalMark
$cmappend :: RehearsalMark -> RehearsalMark -> RehearsalMark
mempty :: RehearsalMark
$cmempty :: RehearsalMark
$cp1Monoid :: Semigroup RehearsalMark
Monoid,RehearsalMark
RehearsalMark -> Default RehearsalMark
forall a. a -> Default a
def :: RehearsalMark
$cdef :: RehearsalMark
Default)
makeLenses ''RehearsalMark
instance Show RehearsalMark where show :: RehearsalMark -> String
show = ShowS
forall a. Show a => a -> String
show ShowS -> (RehearsalMark -> String) -> RehearsalMark -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RehearsalMark -> String
_rehearsalText
class HasRehearsalMark a where rehearsalMark :: Lens' a (Maybe RehearsalMark)
instance HasRehearsalMark RehearsalMark where rehearsalMark :: (Maybe RehearsalMark -> f (Maybe RehearsalMark))
-> RehearsalMark -> f RehearsalMark
rehearsalMark = (Maybe RehearsalMark -> f (Maybe RehearsalMark))
-> RehearsalMark -> f RehearsalMark
forall a. Lens' a (Maybe a)
adaptHas

-- | Musical direction.
newtype Direction = Direction { Direction -> String
_directionText :: String }
    deriving (Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: Direction -> Direction -> Bool
Eq,Eq Direction
Eq Direction
-> (Direction -> Direction -> Ordering)
-> (Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool)
-> (Direction -> Direction -> Direction)
-> (Direction -> Direction -> Direction)
-> Ord Direction
Direction -> Direction -> Bool
Direction -> Direction -> Ordering
Direction -> Direction -> Direction
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Direction -> Direction -> Direction
$cmin :: Direction -> Direction -> Direction
max :: Direction -> Direction -> Direction
$cmax :: Direction -> Direction -> Direction
>= :: Direction -> Direction -> Bool
$c>= :: Direction -> Direction -> Bool
> :: Direction -> Direction -> Bool
$c> :: Direction -> Direction -> Bool
<= :: Direction -> Direction -> Bool
$c<= :: Direction -> Direction -> Bool
< :: Direction -> Direction -> Bool
$c< :: Direction -> Direction -> Bool
compare :: Direction -> Direction -> Ordering
$ccompare :: Direction -> Direction -> Ordering
$cp1Ord :: Eq Direction
Ord,String -> Direction
(String -> Direction) -> IsString Direction
forall a. (String -> a) -> IsString a
fromString :: String -> Direction
$cfromString :: String -> Direction
IsString,(forall x. Direction -> Rep Direction x)
-> (forall x. Rep Direction x -> Direction) -> Generic Direction
forall x. Rep Direction x -> Direction
forall x. Direction -> Rep Direction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Direction x -> Direction
$cfrom :: forall x. Direction -> Rep Direction x
Generic,b -> Direction -> Direction
NonEmpty Direction -> Direction
Direction -> Direction -> Direction
(Direction -> Direction -> Direction)
-> (NonEmpty Direction -> Direction)
-> (forall b. Integral b => b -> Direction -> Direction)
-> Semigroup Direction
forall b. Integral b => b -> Direction -> Direction
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Direction -> Direction
$cstimes :: forall b. Integral b => b -> Direction -> Direction
sconcat :: NonEmpty Direction -> Direction
$csconcat :: NonEmpty Direction -> Direction
<> :: Direction -> Direction -> Direction
$c<> :: Direction -> Direction -> Direction
Semigroup,Semigroup Direction
Direction
Semigroup Direction
-> Direction
-> (Direction -> Direction -> Direction)
-> ([Direction] -> Direction)
-> Monoid Direction
[Direction] -> Direction
Direction -> Direction -> Direction
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [Direction] -> Direction
$cmconcat :: [Direction] -> Direction
mappend :: Direction -> Direction -> Direction
$cmappend :: Direction -> Direction -> Direction
mempty :: Direction
$cmempty :: Direction
$cp1Monoid :: Semigroup Direction
Monoid,Direction
Direction -> Default Direction
forall a. a -> Default a
def :: Direction
$cdef :: Direction
Default)
makeLenses ''Direction
instance Show Direction where show :: Direction -> String
show = ShowS
forall a. Show a => a -> String
show ShowS -> (Direction -> String) -> Direction -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Direction -> String
_directionText
class HasDirection a where direction :: Lens' a (Maybe Direction)
instance HasDirection Direction where direction :: (Maybe Direction -> f (Maybe Direction))
-> Direction -> f Direction
direction = (Maybe Direction -> f (Maybe Direction))
-> Direction -> f Direction
forall a. Lens' a (Maybe a)
adaptHas

-- | Barline.
data Barline = Double | Final
    deriving (Barline -> Barline -> Bool
(Barline -> Barline -> Bool)
-> (Barline -> Barline -> Bool) -> Eq Barline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Barline -> Barline -> Bool
$c/= :: Barline -> Barline -> Bool
== :: Barline -> Barline -> Bool
$c== :: Barline -> Barline -> Bool
Eq,Int -> Barline -> ShowS
[Barline] -> ShowS
Barline -> String
(Int -> Barline -> ShowS)
-> (Barline -> String) -> ([Barline] -> ShowS) -> Show Barline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Barline] -> ShowS
$cshowList :: [Barline] -> ShowS
show :: Barline -> String
$cshow :: Barline -> String
showsPrec :: Int -> Barline -> ShowS
$cshowsPrec :: Int -> Barline -> ShowS
Show,Eq Barline
Eq Barline
-> (Barline -> Barline -> Ordering)
-> (Barline -> Barline -> Bool)
-> (Barline -> Barline -> Bool)
-> (Barline -> Barline -> Bool)
-> (Barline -> Barline -> Bool)
-> (Barline -> Barline -> Barline)
-> (Barline -> Barline -> Barline)
-> Ord Barline
Barline -> Barline -> Bool
Barline -> Barline -> Ordering
Barline -> Barline -> Barline
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Barline -> Barline -> Barline
$cmin :: Barline -> Barline -> Barline
max :: Barline -> Barline -> Barline
$cmax :: Barline -> Barline -> Barline
>= :: Barline -> Barline -> Bool
$c>= :: Barline -> Barline -> Bool
> :: Barline -> Barline -> Bool
$c> :: Barline -> Barline -> Bool
<= :: Barline -> Barline -> Bool
$c<= :: Barline -> Barline -> Bool
< :: Barline -> Barline -> Bool
$c< :: Barline -> Barline -> Bool
compare :: Barline -> Barline -> Ordering
$ccompare :: Barline -> Barline -> Ordering
$cp1Ord :: Eq Barline
Ord,(forall x. Barline -> Rep Barline x)
-> (forall x. Rep Barline x -> Barline) -> Generic Barline
forall x. Rep Barline x -> Barline
forall x. Barline -> Rep Barline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Barline x -> Barline
$cfrom :: forall x. Barline -> Rep Barline x
Generic)
class HasBarline a where barline :: Lens' a (Maybe Barline)
instance HasBarline Barline where barline :: (Maybe Barline -> f (Maybe Barline)) -> Barline -> f Barline
barline = (Maybe Barline -> f (Maybe Barline)) -> Barline -> f Barline
forall a. Lens' a (Maybe a)
adaptHas

data Repeats = RStart | REnd | RBoth
    deriving (Repeats -> Repeats -> Bool
(Repeats -> Repeats -> Bool)
-> (Repeats -> Repeats -> Bool) -> Eq Repeats
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Repeats -> Repeats -> Bool
$c/= :: Repeats -> Repeats -> Bool
== :: Repeats -> Repeats -> Bool
$c== :: Repeats -> Repeats -> Bool
Eq,Int -> Repeats -> ShowS
[Repeats] -> ShowS
Repeats -> String
(Int -> Repeats -> ShowS)
-> (Repeats -> String) -> ([Repeats] -> ShowS) -> Show Repeats
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Repeats] -> ShowS
$cshowList :: [Repeats] -> ShowS
show :: Repeats -> String
$cshow :: Repeats -> String
showsPrec :: Int -> Repeats -> ShowS
$cshowsPrec :: Int -> Repeats -> ShowS
Show,Eq Repeats
Eq Repeats
-> (Repeats -> Repeats -> Ordering)
-> (Repeats -> Repeats -> Bool)
-> (Repeats -> Repeats -> Bool)
-> (Repeats -> Repeats -> Bool)
-> (Repeats -> Repeats -> Bool)
-> (Repeats -> Repeats -> Repeats)
-> (Repeats -> Repeats -> Repeats)
-> Ord Repeats
Repeats -> Repeats -> Bool
Repeats -> Repeats -> Ordering
Repeats -> Repeats -> Repeats
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Repeats -> Repeats -> Repeats
$cmin :: Repeats -> Repeats -> Repeats
max :: Repeats -> Repeats -> Repeats
$cmax :: Repeats -> Repeats -> Repeats
>= :: Repeats -> Repeats -> Bool
$c>= :: Repeats -> Repeats -> Bool
> :: Repeats -> Repeats -> Bool
$c> :: Repeats -> Repeats -> Bool
<= :: Repeats -> Repeats -> Bool
$c<= :: Repeats -> Repeats -> Bool
< :: Repeats -> Repeats -> Bool
$c< :: Repeats -> Repeats -> Bool
compare :: Repeats -> Repeats -> Ordering
$ccompare :: Repeats -> Repeats -> Ordering
$cp1Ord :: Eq Repeats
Ord,(forall x. Repeats -> Rep Repeats x)
-> (forall x. Rep Repeats x -> Repeats) -> Generic Repeats
forall x. Rep Repeats x -> Repeats
forall x. Repeats -> Rep Repeats x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Repeats x -> Repeats
$cfrom :: forall x. Repeats -> Rep Repeats x
Generic)
class HasRepeats a where repeats :: Lens' a (Maybe Repeats)
instance HasRepeats Repeats where repeats :: (Maybe Repeats -> f (Maybe Repeats)) -> Repeats -> f Repeats
repeats = (Maybe Repeats -> f (Maybe Repeats)) -> Repeats -> f Repeats
forall a. Lens' a (Maybe a)
adaptHas

data Clef = TrebleClef | BassClef | AltoClef | PercClef
    deriving (Clef -> Clef -> Bool
(Clef -> Clef -> Bool) -> (Clef -> Clef -> Bool) -> Eq Clef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Clef -> Clef -> Bool
$c/= :: Clef -> Clef -> Bool
== :: Clef -> Clef -> Bool
$c== :: Clef -> Clef -> Bool
Eq,Int -> Clef -> ShowS
[Clef] -> ShowS
Clef -> String
(Int -> Clef -> ShowS)
-> (Clef -> String) -> ([Clef] -> ShowS) -> Show Clef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Clef] -> ShowS
$cshowList :: [Clef] -> ShowS
show :: Clef -> String
$cshow :: Clef -> String
showsPrec :: Int -> Clef -> ShowS
$cshowsPrec :: Int -> Clef -> ShowS
Show,Eq Clef
Eq Clef
-> (Clef -> Clef -> Ordering)
-> (Clef -> Clef -> Bool)
-> (Clef -> Clef -> Bool)
-> (Clef -> Clef -> Bool)
-> (Clef -> Clef -> Bool)
-> (Clef -> Clef -> Clef)
-> (Clef -> Clef -> Clef)
-> Ord Clef
Clef -> Clef -> Bool
Clef -> Clef -> Ordering
Clef -> Clef -> Clef
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Clef -> Clef -> Clef
$cmin :: Clef -> Clef -> Clef
max :: Clef -> Clef -> Clef
$cmax :: Clef -> Clef -> Clef
>= :: Clef -> Clef -> Bool
$c>= :: Clef -> Clef -> Bool
> :: Clef -> Clef -> Bool
$c> :: Clef -> Clef -> Bool
<= :: Clef -> Clef -> Bool
$c<= :: Clef -> Clef -> Bool
< :: Clef -> Clef -> Bool
$c< :: Clef -> Clef -> Bool
compare :: Clef -> Clef -> Ordering
$ccompare :: Clef -> Clef -> Ordering
$cp1Ord :: Eq Clef
Ord,(forall x. Clef -> Rep Clef x)
-> (forall x. Rep Clef x -> Clef) -> Generic Clef
forall x. Rep Clef x -> Clef
forall x. Clef -> Rep Clef x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Clef x -> Clef
$cfrom :: forall x. Clef -> Rep Clef x
Generic)
makeLenses ''Clef
class HasClef a where clef :: Lens' a (Maybe Clef)
instance HasClef Clef where clef :: (Maybe Clef -> f (Maybe Clef)) -> Clef -> f Clef
clef = (Maybe Clef -> f (Maybe Clef)) -> Clef -> f Clef
forall a. Lens' a (Maybe a)
adaptHas


-- | Part identifier, prefers 'Num' or 'IsString' values.
newtype Part a = Part { Part a -> a
_partIdx :: a }
    deriving (Part a -> Part a -> Bool
(Part a -> Part a -> Bool)
-> (Part a -> Part a -> Bool) -> Eq (Part a)
forall a. Eq a => Part a -> Part a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Part a -> Part a -> Bool
$c/= :: forall a. Eq a => Part a -> Part a -> Bool
== :: Part a -> Part a -> Bool
$c== :: forall a. Eq a => Part a -> Part a -> Bool
Eq,(forall x. Part a -> Rep (Part a) x)
-> (forall x. Rep (Part a) x -> Part a) -> Generic (Part a)
forall x. Rep (Part a) x -> Part a
forall x. Part a -> Rep (Part a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Part a) x -> Part a
forall a x. Part a -> Rep (Part a) x
$cto :: forall a x. Rep (Part a) x -> Part a
$cfrom :: forall a x. Part a -> Rep (Part a) x
Generic,Eq (Part a)
Eq (Part a)
-> (Part a -> Part a -> Ordering)
-> (Part a -> Part a -> Bool)
-> (Part a -> Part a -> Bool)
-> (Part a -> Part a -> Bool)
-> (Part a -> Part a -> Bool)
-> (Part a -> Part a -> Part a)
-> (Part a -> Part a -> Part a)
-> Ord (Part a)
Part a -> Part a -> Bool
Part a -> Part a -> Ordering
Part a -> Part a -> Part a
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
forall a. Ord a => Eq (Part a)
forall a. Ord a => Part a -> Part a -> Bool
forall a. Ord a => Part a -> Part a -> Ordering
forall a. Ord a => Part a -> Part a -> Part a
min :: Part a -> Part a -> Part a
$cmin :: forall a. Ord a => Part a -> Part a -> Part a
max :: Part a -> Part a -> Part a
$cmax :: forall a. Ord a => Part a -> Part a -> Part a
>= :: Part a -> Part a -> Bool
$c>= :: forall a. Ord a => Part a -> Part a -> Bool
> :: Part a -> Part a -> Bool
$c> :: forall a. Ord a => Part a -> Part a -> Bool
<= :: Part a -> Part a -> Bool
$c<= :: forall a. Ord a => Part a -> Part a -> Bool
< :: Part a -> Part a -> Bool
$c< :: forall a. Ord a => Part a -> Part a -> Bool
compare :: Part a -> Part a -> Ordering
$ccompare :: forall a. Ord a => Part a -> Part a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Part a)
Ord,a -> Part b -> Part a
(a -> b) -> Part a -> Part b
(forall a b. (a -> b) -> Part a -> Part b)
-> (forall a b. a -> Part b -> Part a) -> Functor Part
forall a b. a -> Part b -> Part a
forall a b. (a -> b) -> Part a -> Part b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Part b -> Part a
$c<$ :: forall a b. a -> Part b -> Part a
fmap :: (a -> b) -> Part a -> Part b
$cfmap :: forall a b. (a -> b) -> Part a -> Part b
Functor,Part a
Part a -> Part a -> Bounded (Part a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Part a
maxBound :: Part a
$cmaxBound :: forall a. Bounded a => Part a
minBound :: Part a
$cminBound :: forall a. Bounded a => Part a
Bounded,Part a -> Bool
(a -> m) -> Part a -> m
(a -> b -> b) -> b -> Part a -> b
(forall m. Monoid m => Part m -> m)
-> (forall m a. Monoid m => (a -> m) -> Part a -> m)
-> (forall m a. Monoid m => (a -> m) -> Part a -> m)
-> (forall a b. (a -> b -> b) -> b -> Part a -> b)
-> (forall a b. (a -> b -> b) -> b -> Part a -> b)
-> (forall b a. (b -> a -> b) -> b -> Part a -> b)
-> (forall b a. (b -> a -> b) -> b -> Part a -> b)
-> (forall a. (a -> a -> a) -> Part a -> a)
-> (forall a. (a -> a -> a) -> Part a -> a)
-> (forall a. Part a -> [a])
-> (forall a. Part a -> Bool)
-> (forall a. Part a -> Int)
-> (forall a. Eq a => a -> Part a -> Bool)
-> (forall a. Ord a => Part a -> a)
-> (forall a. Ord a => Part a -> a)
-> (forall a. Num a => Part a -> a)
-> (forall a. Num a => Part a -> a)
-> Foldable Part
forall a. Eq a => a -> Part a -> Bool
forall a. Num a => Part a -> a
forall a. Ord a => Part a -> a
forall m. Monoid m => Part m -> m
forall a. Part a -> Bool
forall a. Part a -> Int
forall a. Part a -> [a]
forall a. (a -> a -> a) -> Part a -> a
forall m a. Monoid m => (a -> m) -> Part a -> m
forall b a. (b -> a -> b) -> b -> Part a -> b
forall a b. (a -> b -> b) -> b -> Part a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Part a -> a
$cproduct :: forall a. Num a => Part a -> a
sum :: Part a -> a
$csum :: forall a. Num a => Part a -> a
minimum :: Part a -> a
$cminimum :: forall a. Ord a => Part a -> a
maximum :: Part a -> a
$cmaximum :: forall a. Ord a => Part a -> a
elem :: a -> Part a -> Bool
$celem :: forall a. Eq a => a -> Part a -> Bool
length :: Part a -> Int
$clength :: forall a. Part a -> Int
null :: Part a -> Bool
$cnull :: forall a. Part a -> Bool
toList :: Part a -> [a]
$ctoList :: forall a. Part a -> [a]
foldl1 :: (a -> a -> a) -> Part a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Part a -> a
foldr1 :: (a -> a -> a) -> Part a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Part a -> a
foldl' :: (b -> a -> b) -> b -> Part a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Part a -> b
foldl :: (b -> a -> b) -> b -> Part a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Part a -> b
foldr' :: (a -> b -> b) -> b -> Part a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Part a -> b
foldr :: (a -> b -> b) -> b -> Part a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Part a -> b
foldMap' :: (a -> m) -> Part a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Part a -> m
foldMap :: (a -> m) -> Part a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Part a -> m
fold :: Part m -> m
$cfold :: forall m. Monoid m => Part m -> m
Foldable,Functor Part
Foldable Part
Functor Part
-> Foldable Part
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Part a -> f (Part b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Part (f a) -> f (Part a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Part a -> m (Part b))
-> (forall (m :: * -> *) a. Monad m => Part (m a) -> m (Part a))
-> Traversable Part
(a -> f b) -> Part a -> f (Part b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Part (m a) -> m (Part a)
forall (f :: * -> *) a. Applicative f => Part (f a) -> f (Part a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Part a -> m (Part b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Part a -> f (Part b)
sequence :: Part (m a) -> m (Part a)
$csequence :: forall (m :: * -> *) a. Monad m => Part (m a) -> m (Part a)
mapM :: (a -> m b) -> Part a -> m (Part b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Part a -> m (Part b)
sequenceA :: Part (f a) -> f (Part a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Part (f a) -> f (Part a)
traverse :: (a -> f b) -> Part a -> f (Part b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Part a -> f (Part b)
$cp2Traversable :: Foldable Part
$cp1Traversable :: Functor Part
Traversable,Num (Part a)
Ord (Part a)
Num (Part a)
-> Ord (Part a) -> (Part a -> Rational) -> Real (Part a)
Part a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. Real a => Num (Part a)
forall a. Real a => Ord (Part a)
forall a. Real a => Part a -> Rational
toRational :: Part a -> Rational
$ctoRational :: forall a. Real a => Part a -> Rational
$cp2Real :: forall a. Real a => Ord (Part a)
$cp1Real :: forall a. Real a => Num (Part a)
Real,Integer -> Part a
Part a -> Part a
Part a -> Part a -> Part a
(Part a -> Part a -> Part a)
-> (Part a -> Part a -> Part a)
-> (Part a -> Part a -> Part a)
-> (Part a -> Part a)
-> (Part a -> Part a)
-> (Part a -> Part a)
-> (Integer -> Part a)
-> Num (Part a)
forall a. Num a => Integer -> Part a
forall a. Num a => Part a -> Part a
forall a. Num a => Part a -> Part a -> Part a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Part a
$cfromInteger :: forall a. Num a => Integer -> Part a
signum :: Part a -> Part a
$csignum :: forall a. Num a => Part a -> Part a
abs :: Part a -> Part a
$cabs :: forall a. Num a => Part a -> Part a
negate :: Part a -> Part a
$cnegate :: forall a. Num a => Part a -> Part a
* :: Part a -> Part a -> Part a
$c* :: forall a. Num a => Part a -> Part a -> Part a
- :: Part a -> Part a -> Part a
$c- :: forall a. Num a => Part a -> Part a -> Part a
+ :: Part a -> Part a -> Part a
$c+ :: forall a. Num a => Part a -> Part a -> Part a
Num,String -> Part a
(String -> Part a) -> IsString (Part a)
forall a. IsString a => String -> Part a
forall a. (String -> a) -> IsString a
fromString :: String -> Part a
$cfromString :: forall a. IsString a => String -> Part a
IsString)
makeLenses ''Part
instance (Show a) => Show (Part a) where show :: Part a -> String
show = a -> String
forall a. Show a => a -> String
show(a -> String) -> (Part a -> a) -> Part a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Part a -> a
forall a. Part a -> a
_partIdx
class HasPart a b | a -> b where part :: Lens' a (Maybe (Part b))

-- | Lensy show of a Maybe field, given a 'Getter' and its name.
mshow :: (Show a) => Getter s (Maybe a) -> String -> s -> String
mshow :: Getter s (Maybe a) -> String -> s -> String
mshow Getter s (Maybe a)
l String
n = String -> (a -> String) -> Maybe a -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" (\a
v -> String
" & " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
n String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" ?~ " String -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
v) (Maybe a -> String) -> (s -> Maybe a) -> s -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Maybe a) s (Maybe a) -> s -> Maybe a
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe a) s (Maybe a)
Getter s (Maybe a)
l

-- | 'concatMap' show functions with a prelude.
mshows :: s -> String -> [s -> String] -> String
mshows :: s -> String -> [s -> String] -> String
mshows s
s String
pre = (String
pre String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ([s -> String] -> String) -> [s -> String] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((s -> String) -> String) -> [s -> String] -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((s -> String) -> s -> String
forall a b. (a -> b) -> a -> b
$ s
s)

-- Example types.

-- | Note with notations.
data Note' p d = Note' {
      Note' p d -> Note p d
_nNote :: Note p d
    , Note' p d -> Maybe Tie
_nTie :: Maybe Tie
    , Note' p d -> Maybe Slur
_nSlur :: Maybe Slur
    , Note' p d -> Maybe Articulation
_nArticulation :: Maybe Articulation
    } deriving (Note' p d -> Note' p d -> Bool
(Note' p d -> Note' p d -> Bool)
-> (Note' p d -> Note' p d -> Bool) -> Eq (Note' p d)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall p d. (Eq p, Eq d) => Note' p d -> Note' p d -> Bool
/= :: Note' p d -> Note' p d -> Bool
$c/= :: forall p d. (Eq p, Eq d) => Note' p d -> Note' p d -> Bool
== :: Note' p d -> Note' p d -> Bool
$c== :: forall p d. (Eq p, Eq d) => Note' p d -> Note' p d -> Bool
Eq,(forall x. Note' p d -> Rep (Note' p d) x)
-> (forall x. Rep (Note' p d) x -> Note' p d)
-> Generic (Note' p d)
forall x. Rep (Note' p d) x -> Note' p d
forall x. Note' p d -> Rep (Note' p d) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall p d x. Rep (Note' p d) x -> Note' p d
forall p d x. Note' p d -> Rep (Note' p d) x
$cto :: forall p d x. Rep (Note' p d) x -> Note' p d
$cfrom :: forall p d x. Note' p d -> Rep (Note' p d) x
Generic)

makeLenses ''Note'
instance HasNote (Note' p d) p d where
    note :: (Note p d -> f (Note p d)) -> Note' p d -> f (Note' p d)
note = (Note p d -> f (Note p d)) -> Note' p d -> f (Note' p d)
forall p d p d. Lens (Note' p d) (Note' p d) (Note p d) (Note p d)
nNote
    fromNote :: n -> Note' p d
fromNote = Note p d -> Note' p d
forall p d. Note p d -> Note' p d
note' (Note p d -> Note' p d) -> (n -> Note p d) -> n -> Note' p d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Note p d) n (Note p d) -> n -> Note p d
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Note p d) n (Note p d)
forall s p d. HasNote s p d => Lens' s (Note p d)
note
instance HasTie (Note' p d) where tie :: (Maybe Tie -> f (Maybe Tie)) -> Note' p d -> f (Note' p d)
tie = (Maybe Tie -> f (Maybe Tie)) -> Note' p d -> f (Note' p d)
forall p d. Lens' (Note' p d) (Maybe Tie)
nTie
instance HasSlur (Note' p d) where slur :: (Maybe Slur -> f (Maybe Slur)) -> Note' p d -> f (Note' p d)
slur = (Maybe Slur -> f (Maybe Slur)) -> Note' p d -> f (Note' p d)
forall p d. Lens' (Note' p d) (Maybe Slur)
nSlur
instance HasArticulation (Note' p d) where articulation :: (Maybe Articulation -> f (Maybe Articulation))
-> Note' p d -> f (Note' p d)
articulation = (Maybe Articulation -> f (Maybe Articulation))
-> Note' p d -> f (Note' p d)
forall p d. Lens' (Note' p d) (Maybe Articulation)
nArticulation
instance (Show p, Show d) => Show (Note' p d) where
    show :: Note' p d -> String
show Note' p d
n = Note' p d -> String -> [Note' p d -> String] -> String
forall s. s -> String -> [s -> String] -> String
mshows Note' p d
n (String
"note' (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Note p d -> String
forall a. Show a => a -> String
show (Getting (Note p d) (Note' p d) (Note p d) -> Note' p d -> Note p d
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Note p d) (Note' p d) (Note p d)
forall p d p d. Lens (Note' p d) (Note' p d) (Note p d) (Note p d)
nNote Note' p d
n) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")")
             [Getter (Note' p d) (Maybe Tie) -> String -> Note' p d -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasTie a => Lens' a (Maybe Tie)
Getter (Note' p d) (Maybe Tie)
tie String
"tie"
             ,Getter (Note' p d) (Maybe Slur) -> String -> Note' p d -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasSlur a => Lens' a (Maybe Slur)
Getter (Note' p d) (Maybe Slur)
slur String
"slur"
             ,Getter (Note' p d) (Maybe Articulation)
-> String -> Note' p d -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasArticulation a => Lens' a (Maybe Articulation)
Getter (Note' p d) (Maybe Articulation)
articulation String
"articulation"
             ]


-- | Note smart ctor, used in 'Show'.
note' :: Note p d -> Note' p d
note' :: Note p d -> Note' p d
note' Note p d
n = Note p d
-> Maybe Tie -> Maybe Slur -> Maybe Articulation -> Note' p d
forall p d.
Note p d
-> Maybe Tie -> Maybe Slur -> Maybe Articulation -> Note' p d
Note' Note p d
n Maybe Tie
forall a. Maybe a
Nothing Maybe Slur
forall a. Maybe a
Nothing Maybe Articulation
forall a. Maybe a
Nothing

testNote :: Note' [Int] Int
testNote :: Note' [Int] Int
testNote = Note [Int] Int -> Note' [Int] Int
forall p d. Note p d -> Note' p d
note' ([Int
60][Int] -> Int -> Note [Int] Int
forall p d. p -> d -> Note p d
|:Int
2) Note' [Int] Int
-> (Note' [Int] Int -> Note' [Int] Int) -> Note' [Int] Int
forall a b. a -> (a -> b) -> b
& (Maybe Tie -> Identity (Maybe Tie))
-> Note' [Int] Int -> Identity (Note' [Int] Int)
forall a. HasTie a => Lens' a (Maybe Tie)
tie ((Maybe Tie -> Identity (Maybe Tie))
 -> Note' [Int] Int -> Identity (Note' [Int] Int))
-> Tie -> Note' [Int] Int -> Note' [Int] Int
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Tie
TStart Note' [Int] Int
-> (Note' [Int] Int -> Note' [Int] Int) -> Note' [Int] Int
forall a b. a -> (a -> b) -> b
& (Maybe Articulation -> Identity (Maybe Articulation))
-> Note' [Int] Int -> Identity (Note' [Int] Int)
forall a. HasArticulation a => Lens' a (Maybe Articulation)
articulation ((Maybe Articulation -> Identity (Maybe Articulation))
 -> Note' [Int] Int -> Identity (Note' [Int] Int))
-> Articulation -> Note' [Int] Int -> Note' [Int] Int
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Articulation
Accent

-- | Bar as list of notes, with notations.
data Bar n = Bar {
      Bar n -> Seq n
_bNotes :: Seq n
    , Bar n -> Maybe RehearsalMark
_bRehearsalMark :: Maybe RehearsalMark
    , Bar n -> Maybe Direction
_bDirection :: Maybe Direction
    , Bar n -> Maybe Barline
_bBarline :: Maybe Barline
    , Bar n -> Maybe Repeats
_bRepeats :: Maybe Repeats
    , Bar n -> Maybe TimeSignature
_bTimeSignature :: Maybe TimeSignature
    , Bar n -> Maybe Clef
_bClef :: Maybe Clef
    } deriving (Bar n -> Bar n -> Bool
(Bar n -> Bar n -> Bool) -> (Bar n -> Bar n -> Bool) -> Eq (Bar n)
forall n. Eq n => Bar n -> Bar n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bar n -> Bar n -> Bool
$c/= :: forall n. Eq n => Bar n -> Bar n -> Bool
== :: Bar n -> Bar n -> Bool
$c== :: forall n. Eq n => Bar n -> Bar n -> Bool
Eq,(forall x. Bar n -> Rep (Bar n) x)
-> (forall x. Rep (Bar n) x -> Bar n) -> Generic (Bar n)
forall x. Rep (Bar n) x -> Bar n
forall x. Bar n -> Rep (Bar n) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall n x. Rep (Bar n) x -> Bar n
forall n x. Bar n -> Rep (Bar n) x
$cto :: forall n x. Rep (Bar n) x -> Bar n
$cfrom :: forall n x. Bar n -> Rep (Bar n) x
Generic,a -> Bar b -> Bar a
(a -> b) -> Bar a -> Bar b
(forall a b. (a -> b) -> Bar a -> Bar b)
-> (forall a b. a -> Bar b -> Bar a) -> Functor Bar
forall a b. a -> Bar b -> Bar a
forall a b. (a -> b) -> Bar a -> Bar b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Bar b -> Bar a
$c<$ :: forall a b. a -> Bar b -> Bar a
fmap :: (a -> b) -> Bar a -> Bar b
$cfmap :: forall a b. (a -> b) -> Bar a -> Bar b
Functor,Bar a -> Bool
(a -> m) -> Bar a -> m
(a -> b -> b) -> b -> Bar a -> b
(forall m. Monoid m => Bar m -> m)
-> (forall m a. Monoid m => (a -> m) -> Bar a -> m)
-> (forall m a. Monoid m => (a -> m) -> Bar a -> m)
-> (forall a b. (a -> b -> b) -> b -> Bar a -> b)
-> (forall a b. (a -> b -> b) -> b -> Bar a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bar a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bar a -> b)
-> (forall a. (a -> a -> a) -> Bar a -> a)
-> (forall a. (a -> a -> a) -> Bar a -> a)
-> (forall a. Bar a -> [a])
-> (forall a. Bar a -> Bool)
-> (forall a. Bar a -> Int)
-> (forall a. Eq a => a -> Bar a -> Bool)
-> (forall a. Ord a => Bar a -> a)
-> (forall a. Ord a => Bar a -> a)
-> (forall a. Num a => Bar a -> a)
-> (forall a. Num a => Bar a -> a)
-> Foldable Bar
forall a. Eq a => a -> Bar a -> Bool
forall a. Num a => Bar a -> a
forall a. Ord a => Bar a -> a
forall m. Monoid m => Bar m -> m
forall a. Bar a -> Bool
forall a. Bar a -> Int
forall a. Bar a -> [a]
forall a. (a -> a -> a) -> Bar a -> a
forall m a. Monoid m => (a -> m) -> Bar a -> m
forall b a. (b -> a -> b) -> b -> Bar a -> b
forall a b. (a -> b -> b) -> b -> Bar a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Bar a -> a
$cproduct :: forall a. Num a => Bar a -> a
sum :: Bar a -> a
$csum :: forall a. Num a => Bar a -> a
minimum :: Bar a -> a
$cminimum :: forall a. Ord a => Bar a -> a
maximum :: Bar a -> a
$cmaximum :: forall a. Ord a => Bar a -> a
elem :: a -> Bar a -> Bool
$celem :: forall a. Eq a => a -> Bar a -> Bool
length :: Bar a -> Int
$clength :: forall a. Bar a -> Int
null :: Bar a -> Bool
$cnull :: forall a. Bar a -> Bool
toList :: Bar a -> [a]
$ctoList :: forall a. Bar a -> [a]
foldl1 :: (a -> a -> a) -> Bar a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Bar a -> a
foldr1 :: (a -> a -> a) -> Bar a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Bar a -> a
foldl' :: (b -> a -> b) -> b -> Bar a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Bar a -> b
foldl :: (b -> a -> b) -> b -> Bar a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Bar a -> b
foldr' :: (a -> b -> b) -> b -> Bar a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Bar a -> b
foldr :: (a -> b -> b) -> b -> Bar a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Bar a -> b
foldMap' :: (a -> m) -> Bar a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Bar a -> m
foldMap :: (a -> m) -> Bar a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Bar a -> m
fold :: Bar m -> m
$cfold :: forall m. Monoid m => Bar m -> m
Foldable,Functor Bar
Foldable Bar
Functor Bar
-> Foldable Bar
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Bar a -> f (Bar b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Bar (f a) -> f (Bar a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bar a -> m (Bar b))
-> (forall (m :: * -> *) a. Monad m => Bar (m a) -> m (Bar a))
-> Traversable Bar
(a -> f b) -> Bar a -> f (Bar b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Bar (m a) -> m (Bar a)
forall (f :: * -> *) a. Applicative f => Bar (f a) -> f (Bar a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bar a -> m (Bar b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bar a -> f (Bar b)
sequence :: Bar (m a) -> m (Bar a)
$csequence :: forall (m :: * -> *) a. Monad m => Bar (m a) -> m (Bar a)
mapM :: (a -> m b) -> Bar a -> m (Bar b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bar a -> m (Bar b)
sequenceA :: Bar (f a) -> f (Bar a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Bar (f a) -> f (Bar a)
traverse :: (a -> f b) -> Bar a -> f (Bar b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bar a -> f (Bar b)
$cp2Traversable :: Foldable Bar
$cp1Traversable :: Functor Bar
Traversable)
makeLenses ''Bar
instance Default (Bar n) where def :: Bar n
def = [n] -> Bar n
forall n. [n] -> Bar n
bar []
instance Snoc (Bar n) (Bar n) n n where
    _Snoc :: p (Bar n, n) (f (Bar n, n)) -> p (Bar n) (f (Bar n))
_Snoc = ((Bar n, n) -> Bar n)
-> (Bar n -> Either (Bar n) (Bar n, n))
-> Prism (Bar n) (Bar n) (Bar n, n) (Bar n, n)
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism (\(Bar n
b,n
n) -> ASetter (Bar n) (Bar n) (Seq n) (Seq n)
-> (Seq n -> Seq n) -> Bar n -> Bar n
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter (Bar n) (Bar n) (Seq n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes (AReview (Seq n) (Seq n, n) -> (Seq n, n) -> Seq n
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview (Seq n) (Seq n, n)
forall s t a b. Snoc s t a b => Prism s t (s, a) (t, b)
_Snoc ((Seq n, n) -> Seq n) -> (Seq n -> (Seq n, n)) -> Seq n -> Seq n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,n
n)) Bar n
b) ((Bar n -> Either (Bar n) (Bar n, n))
 -> Prism (Bar n) (Bar n) (Bar n, n) (Bar n, n))
-> (Bar n -> Either (Bar n) (Bar n, n))
-> Prism (Bar n) (Bar n) (Bar n, n) (Bar n, n)
forall a b. (a -> b) -> a -> b
$
            \Bar n
b -> case Getting (Leftmost (Seq n, n)) (Seq n) (Seq n, n)
-> Seq n -> Maybe (Seq n, n)
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf Getting (Leftmost (Seq n, n)) (Seq n) (Seq n, n)
forall s t a b. Snoc s t a b => Prism s t (s, a) (t, b)
_Snoc (Getting (Seq n) (Bar n) (Seq n) -> Bar n -> Seq n
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Seq n) (Bar n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Bar n
b) of
                    Maybe (Seq n, n)
Nothing -> Bar n -> Either (Bar n) (Bar n, n)
forall a b. a -> Either a b
Left (Bar n
forall a. Default a => a
def :: Bar n)
                    (Just (Seq n
as,n
a)) -> (Bar n, n) -> Either (Bar n) (Bar n, n)
forall a b. b -> Either a b
Right (ASetter (Bar n) (Bar n) (Seq n) (Seq n) -> Seq n -> Bar n -> Bar n
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter (Bar n) (Bar n) (Seq n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Seq n
as Bar n
b,n
a)
instance Cons (Bar n) (Bar n) n n where
    _Cons :: p (n, Bar n) (f (n, Bar n)) -> p (Bar n) (f (Bar n))
_Cons = ((n, Bar n) -> Bar n)
-> (Bar n -> Either (Bar n) (n, Bar n))
-> Prism (Bar n) (Bar n) (n, Bar n) (n, Bar n)
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism (\(n
n,Bar n
b) -> ASetter (Bar n) (Bar n) (Seq n) (Seq n)
-> (Seq n -> Seq n) -> Bar n -> Bar n
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter (Bar n) (Bar n) (Seq n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes (AReview (Seq n) (n, Seq n) -> (n, Seq n) -> Seq n
forall b (m :: * -> *) t. MonadReader b m => AReview t b -> m t
review AReview (Seq n) (n, Seq n)
forall s t a b. Cons s t a b => Prism s t (a, s) (b, t)
_Cons ((n, Seq n) -> Seq n) -> (Seq n -> (n, Seq n)) -> Seq n -> Seq n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (n
n,)) Bar n
b) ((Bar n -> Either (Bar n) (n, Bar n))
 -> Prism (Bar n) (Bar n) (n, Bar n) (n, Bar n))
-> (Bar n -> Either (Bar n) (n, Bar n))
-> Prism (Bar n) (Bar n) (n, Bar n) (n, Bar n)
forall a b. (a -> b) -> a -> b
$
            \Bar n
b -> case Getting (Leftmost (n, Seq n)) (Seq n) (n, Seq n)
-> Seq n -> Maybe (n, Seq n)
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf Getting (Leftmost (n, Seq n)) (Seq n) (n, Seq n)
forall s t a b. Cons s t a b => Prism s t (a, s) (b, t)
_Cons (Getting (Seq n) (Bar n) (Seq n) -> Bar n -> Seq n
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Seq n) (Bar n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Bar n
b) of
                    Maybe (n, Seq n)
Nothing -> Bar n -> Either (Bar n) (n, Bar n)
forall a b. a -> Either a b
Left (Bar n
forall a. Default a => a
def :: Bar n)
                    (Just (n
a,Seq n
as)) -> (n, Bar n) -> Either (Bar n) (n, Bar n)
forall a b. b -> Either a b
Right (n
a,ASetter (Bar n) (Bar n) (Seq n) (Seq n) -> Seq n -> Bar n -> Bar n
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter (Bar n) (Bar n) (Seq n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Seq n
as Bar n
b)
instance HasRehearsalMark (Bar n) where rehearsalMark :: (Maybe RehearsalMark -> f (Maybe RehearsalMark))
-> Bar n -> f (Bar n)
rehearsalMark = (Maybe RehearsalMark -> f (Maybe RehearsalMark))
-> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe RehearsalMark)
bRehearsalMark
instance HasDirection (Bar n) where direction :: (Maybe Direction -> f (Maybe Direction)) -> Bar n -> f (Bar n)
direction = (Maybe Direction -> f (Maybe Direction)) -> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe Direction)
bDirection
instance HasBarline (Bar n) where barline :: (Maybe Barline -> f (Maybe Barline)) -> Bar n -> f (Bar n)
barline = (Maybe Barline -> f (Maybe Barline)) -> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe Barline)
bBarline
instance HasTimeSignature (Bar n) where timeSignature :: (Maybe TimeSignature -> f (Maybe TimeSignature))
-> Bar n -> f (Bar n)
timeSignature = (Maybe TimeSignature -> f (Maybe TimeSignature))
-> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe TimeSignature)
bTimeSignature
instance HasClef (Bar n) where clef :: (Maybe Clef -> f (Maybe Clef)) -> Bar n -> f (Bar n)
clef = (Maybe Clef -> f (Maybe Clef)) -> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe Clef)
bClef
instance HasRepeats (Bar n) where repeats :: (Maybe Repeats -> f (Maybe Repeats)) -> Bar n -> f (Bar n)
repeats = (Maybe Repeats -> f (Maybe Repeats)) -> Bar n -> f (Bar n)
forall n. Lens' (Bar n) (Maybe Repeats)
bRepeats
instance (Show n) => Show (Bar n) where
    show :: Bar n -> String
show Bar n
b = Bar n -> String -> [Bar n -> String] -> String
forall s. s -> String -> [s -> String] -> String
mshows Bar n
b (String
"bar " String -> ShowS
forall a. [a] -> [a] -> [a]
++ [n] -> String
forall a. Show a => a -> String
show (Seq n -> [n]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Seq n -> [n]) -> Seq n -> [n]
forall a b. (a -> b) -> a -> b
$ Getting (Seq n) (Bar n) (Seq n) -> Bar n -> Seq n
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Seq n) (Bar n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Bar n
b))
             [Getter (Bar n) (Maybe RehearsalMark) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasRehearsalMark a => Lens' a (Maybe RehearsalMark)
Getter (Bar n) (Maybe RehearsalMark)
rehearsalMark String
"rehearsalMark"
             ,Getter (Bar n) (Maybe Direction) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasDirection a => Lens' a (Maybe Direction)
Getter (Bar n) (Maybe Direction)
direction String
"direction"
             ,Getter (Bar n) (Maybe Barline) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasBarline a => Lens' a (Maybe Barline)
Getter (Bar n) (Maybe Barline)
barline String
"barline"
             ,Getter (Bar n) (Maybe Repeats) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasRepeats a => Lens' a (Maybe Repeats)
Getter (Bar n) (Maybe Repeats)
repeats String
"repeat"
             ,Getter (Bar n) (Maybe TimeSignature) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasTimeSignature a => Lens' a (Maybe TimeSignature)
Getter (Bar n) (Maybe TimeSignature)
timeSignature String
"timeSignature"
             ,Getter (Bar n) (Maybe Clef) -> String -> Bar n -> String
forall a s. Show a => Getter s (Maybe a) -> String -> s -> String
mshow forall a. HasClef a => Lens' a (Maybe Clef)
Getter (Bar n) (Maybe Clef)
clef String
"clef"
             ]
instance Semigroup (Bar n) where
    Bar n
a <> :: Bar n -> Bar n -> Bar n
<> Bar n
b = ASetter (Bar n) (Bar n) (Seq n) (Seq n)
-> (Seq n -> Seq n) -> Bar n -> Bar n
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter (Bar n) (Bar n) (Seq n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes (Seq n -> Seq n -> Seq n
forall a. Semigroup a => a -> a -> a
<> Getting (Seq n) (Bar n) (Seq n) -> Bar n -> Seq n
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Seq n) (Bar n) (Seq n)
forall n n. Lens (Bar n) (Bar n) (Seq n) (Seq n)
bNotes Bar n
b) Bar n
a
instance Monoid (Bar n) where
    mempty :: Bar n
mempty = Bar n
forall a. Default a => a
def
    mappend :: Bar n -> Bar n -> Bar n
mappend = Bar n -> Bar n -> Bar n
forall a. Semigroup a => a -> a -> a
(<>)

-- | Bar smart ctor, used in 'Show'.
bar :: [n] -> Bar n
bar :: [n] -> Bar n
bar [n]
ns = Seq n
-> Maybe RehearsalMark
-> Maybe Direction
-> Maybe Barline
-> Maybe Repeats
-> Maybe TimeSignature
-> Maybe Clef
-> Bar n
forall n.
Seq n
-> Maybe RehearsalMark
-> Maybe Direction
-> Maybe Barline
-> Maybe Repeats
-> Maybe TimeSignature
-> Maybe Clef
-> Bar n
Bar ([n] -> Seq n
forall a. [a] -> Seq a
fromList [n]
ns) Maybe RehearsalMark
forall a. Maybe a
Nothing Maybe Direction
forall a. Maybe a
Nothing Maybe Barline
forall a. Maybe a
Nothing Maybe Repeats
forall a. Maybe a
Nothing Maybe TimeSignature
forall a. Maybe a
Nothing Maybe Clef
forall a. Maybe a
Nothing

testBar :: Bar (Note [Int] Int)
testBar :: Bar (Note [Int] Int)
testBar = [Note [Int] Int] -> Bar (Note [Int] Int)
forall n. [n] -> Bar n
bar [[Int
60][Int] -> Int -> Note [Int] Int
forall p d. p -> d -> Note p d
|:Int
2,[Int
62][Int] -> Int -> Note [Int] Int
forall p d. p -> d -> Note p d
|:Int
1] Bar (Note [Int] Int)
-> (Bar (Note [Int] Int) -> Bar (Note [Int] Int))
-> Bar (Note [Int] Int)
forall a b. a -> (a -> b) -> b
& (Maybe TimeSignature -> Identity (Maybe TimeSignature))
-> Bar (Note [Int] Int) -> Identity (Bar (Note [Int] Int))
forall a. HasTimeSignature a => Lens' a (Maybe TimeSignature)
timeSignature ((Maybe TimeSignature -> Identity (Maybe TimeSignature))
 -> Bar (Note [Int] Int) -> Identity (Bar (Note [Int] Int)))
-> TimeSignature -> Bar (Note [Int] Int) -> Bar (Note [Int] Int)
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Int -> Quanta -> TimeSignature
TimeSignature Int
4 Quanta
Q4 Bar (Note [Int] Int)
-> (Bar (Note [Int] Int) -> Bar (Note [Int] Int))
-> Bar (Note [Int] Int)
forall a b. a -> (a -> b) -> b
& (Maybe Direction -> Identity (Maybe Direction))
-> Bar (Note [Int] Int) -> Identity (Bar (Note [Int] Int))
forall a. HasDirection a => Lens' a (Maybe Direction)
direction ((Maybe Direction -> Identity (Maybe Direction))
 -> Bar (Note [Int] Int) -> Identity (Bar (Note [Int] Int)))
-> Direction -> Bar (Note [Int] Int) -> Bar (Note [Int] Int)
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Direction
"Softly"