{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
module Csound.Catalog.Wave.Sharc(
    -- * Oscillators
    sharcOsc, sigSharcOsc, rndSharcOsc, rndSigSharcOsc,
    soloSharcOsc, orcSharcOsc, purePadSharcOsc, padSharcOsc,

    -- * Padsynth
    PadSharcSpec(..), padsynthSharcOsc, padsynthSharcOsc2,
    padsynthSharcOsc', padsynthSharcOsc2',

    -- * Padsynth and granular
    morphsynthSharcOsc, morphsynthSharcOsc', quadMorphsynthSharcOsc, quadMorphsynthSharcOsc',

    -- * Instriments
    SharcInstr(..),
    shViolin, shViolinPizzicato, shViolinMuted, shViolinMarteleBowing, shViolinsEnsemble, shViola, shViolaPizzicato, shViolaMuted,
    shViolaMarteleBowing, shTuba, shTromboneMuted, shTrombone, shPiccolo, shOboe, shFrenchHornMuted, shFrenchHorn, shFlute,
    shEnglishHorn, shClarinetEflat, shTrumpetMutedC, shTrumpetC, shContrabassClarinet, shContrabassoon, shCello, shCelloPizzicato,
    shCelloMuted, shCelloMarteleBowing, shContrabassPizzicato, shContrabassMuted, shContrabassMarteleBowing, shContrabass,
    shClarinet, shBassTrombone, shBassClarinet, shBassoon, shBassFlute, shTrumpetBach, shAltoTrombone, shAltoFlute,

    -- * Low-level getters
    getInstrTab, note2sig, note2tab
) where

import qualified Sharc.Types as Sh
import qualified Sharc.Data as Sh
import Csound.Base

note2sig :: Sh.Note -> Sig
note2sig :: Note -> Sig
note2sig Note
n = Tab -> Sig -> Sig
oscBy ([Harmonic] -> Tab
harmonics2tab ([Harmonic] -> Tab) -> [Harmonic] -> Tab
forall a b. (a -> b) -> a -> b
$ Note -> [Harmonic]
Sh.noteHarmonics Note
n) (D -> Sig
sig (D -> Sig) -> D -> Sig
forall a b. (a -> b) -> a -> b
$ Double -> D
double (Double -> D) -> Double -> D
forall a b. (a -> b) -> a -> b
$ Pitch -> Double
Sh.pitchFund (Pitch -> Double) -> Pitch -> Double
forall a b. (a -> b) -> a -> b
$ Note -> Pitch
Sh.notePitch Note
n)

note2tab :: Sh.Note -> Tab
note2tab :: Note -> Tab
note2tab Note
n = ([Harmonic] -> Tab
harmonics2tab ([Harmonic] -> Tab) -> [Harmonic] -> Tab
forall a b. (a -> b) -> a -> b
$ Note -> [Harmonic]
Sh.noteHarmonics Note
n)

deg :: a -> a
deg a
x = a
180 a -> a -> a
forall a. Num a => a -> a -> a
* a
x a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
forall a. Floating a => a
pi

harmonics2tab :: [Harmonic] -> Tab
harmonics2tab [Harmonic]
harmonics = [(Double, Double, Double)] -> Tab
sines3 ([(Double, Double, Double)] -> Tab)
-> [(Double, Double, Double)] -> Tab
forall a b. (a -> b) -> a -> b
$ (Harmonic -> (Double, Double, Double))
-> [Harmonic] -> [(Double, Double, Double)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Harmonic
h -> (Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Int -> Double
forall a b. (a -> b) -> a -> b
$ Harmonic -> Int
Sh.harmonicId Harmonic
h, Harmonic -> Double
Sh.harmonicAmplitude Harmonic
h, Double -> Double
forall a. Floating a => a -> a
deg (Double -> Double) -> Double -> Double
forall a b. (a -> b) -> a -> b
$ Harmonic -> Double
Sh.harmonicPhase Harmonic
h)) [Harmonic]
harmonics

-- | Get instrument wave table by midi pitch number.
getInstrTab :: SharcInstr -> Int -> Tab
getInstrTab :: SharcInstr -> Int -> Tab
getInstrTab (SharcInstr Instr
instr) Int
n = Note -> Tab
note2tab (Note -> Tab) -> Note -> Tab
forall a b. (a -> b) -> a -> b
$ Instr -> [Note]
Sh.instrNotes Instr
instr [Note] -> Int -> Note
forall a. [a] -> Int -> a
!! Int
idx
    where
        ns :: [Note]
ns = Instr -> [Note]
Sh.instrNotes Instr
instr
        keys :: [Int]
keys = (Note -> Int) -> [Note] -> [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Pitch -> Int
Sh.pitchKeyNum (Pitch -> Int) -> (Note -> Pitch) -> Note -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Note -> Pitch
Sh.notePitch) [Note]
ns
        keyMin :: Int
keyMin = [Int] -> Int
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [Int]
keys
        keyMax :: Int
keyMax = [Int] -> Int
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum [Int]
keys
        idx :: Int
idx = (Int -> Int -> Int
forall a. Ord a => a -> a -> a
min (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
keyMin Int
n) Int
keyMax Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
keyMin)

---------------------------------------------------------------------------
-- oscilliators

-- | Sharc oscillator
sharcOsc :: SharcInstr -> D -> Sig
sharcOsc :: SharcInstr -> D -> Sig
sharcOsc SharcInstr
instr D
cpsTab = SharcInstr -> D -> Sig -> Sig
sigSharcOsc SharcInstr
instr D
cpsTab (D -> Sig
sig D
cpsTab)

-- | Sharc oscillator with continuous pitch.
-- The second argument picks upth table by frequency
-- and the third supplies the frequency.
sigSharcOsc :: SharcInstr -> D -> Sig -> Sig
sigSharcOsc :: SharcInstr -> D -> Sig -> Sig
sigSharcOsc = (Tab -> Sig -> Sig) -> SharcInstr -> D -> Sig -> Sig
forall a. (Tab -> Sig -> a) -> SharcInstr -> D -> Sig -> a
genSharcOsc' Tab -> Sig -> Sig
oscBy

-- | Sharc oscillator with randomized phase.
rndSharcOsc :: SharcInstr -> D -> SE Sig
rndSharcOsc :: SharcInstr -> D -> SE Sig
rndSharcOsc SharcInstr
instr D
cpsTab = SharcInstr -> D -> Sig -> SE Sig
rndSigSharcOsc SharcInstr
instr D
cpsTab (D -> Sig
sig D
cpsTab)

-- | Sharc oscillator with continuous pitch and randomized phase.
rndSigSharcOsc :: SharcInstr -> D -> Sig -> SE Sig
rndSigSharcOsc :: SharcInstr -> D -> Sig -> SE Sig
rndSigSharcOsc = (Tab -> Sig -> SE Sig) -> SharcInstr -> D -> Sig -> SE Sig
forall a. (Tab -> Sig -> a) -> SharcInstr -> D -> Sig -> a
genSharcOsc' Tab -> Sig -> SE Sig
rndOscBy

genSharcOsc' :: (Tab -> Sig -> a) -> SharcInstr -> D -> Sig -> a
genSharcOsc' :: (Tab -> Sig -> a) -> SharcInstr -> D -> Sig -> a
genSharcOsc' Tab -> Sig -> a
wave (SharcInstr Instr
instr) D
cps Sig
cpsSig = Tab -> Sig -> a
wave Tab
t Sig
cpsSig
    where
        t :: Tab
t = TabList -> D -> Tab
fromTabListD TabList
tabs (D -> D
forall a. Floating a => a -> a
cps2pitch D
cps D -> D -> D
forall a. Num a => a -> a -> a
- Int -> D
int Int
keyMin)

        tabs :: TabList
tabs = [Tab] -> TabList
tabList ([Tab] -> TabList) -> [Tab] -> TabList
forall a b. (a -> b) -> a -> b
$ (Note -> Tab) -> [Note] -> [Tab]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Note -> Tab
note2tab [Note]
ns

        ns :: [Note]
ns = Instr -> [Note]
Sh.instrNotes Instr
instr
        keys :: [Int]
keys = (Note -> Int) -> [Note] -> [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Pitch -> Int
Sh.pitchKeyNum (Pitch -> Int) -> (Note -> Pitch) -> Note -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Note -> Pitch
Sh.notePitch) [Note]
ns
        keyMin :: Int
keyMin = [Int] -> Int
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [Int]
keys

cps2pitch :: Floating a => a -> a
cps2pitch :: a -> a
cps2pitch a
x =  a
69 a -> a -> a
forall a. Num a => a -> a -> a
+ a
12 a -> a -> a
forall a. Num a => a -> a -> a
* a -> a -> a
forall a. Floating a => a -> a -> a
logBase a
2 (a
x a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
440)

---------------------------------------------------------------------------
-- patches

uni :: (Sig -> SE Sig) -> Sig -> SE Sig
uni = Int -> Sig -> (Sig -> SE Sig) -> Sig -> SE Sig
forall a. Fractional a => Int -> Sig -> (Sig -> a) -> Sig -> a
multiHz Int
4 (Sig -> Sig
forall a. SigOrD a => a -> a
cent Sig
40)

-- | Plays a solo instrument
soloSharcOsc :: SharcInstr -> D -> SE Sig
soloSharcOsc :: SharcInstr -> D -> SE Sig
soloSharcOsc SharcInstr
instr D
cps = Sig -> SE Sig -> SE Sig
forall a. SigSpace a => Sig -> a -> a
mul (D -> D -> Sig
fades D
0.001 D
0.05) (SE Sig -> SE Sig) -> SE Sig -> SE Sig
forall a b. (a -> b) -> a -> b
$ SharcInstr -> D -> SE Sig
rndSharcOsc SharcInstr
instr D
cps

-- | Plays a orchestrated instrument (with pitch chorus)
orcSharcOsc :: SharcInstr -> D -> SE Sig
orcSharcOsc :: SharcInstr -> D -> SE Sig
orcSharcOsc SharcInstr
instr D
cps = Sig -> SE Sig -> SE Sig
forall a. SigSpace a => Sig -> a -> a
mul (D -> D -> Sig
fades D
0.01 D
0.42) (SE Sig -> SE Sig) -> SE Sig -> SE Sig
forall a b. (a -> b) -> a -> b
$ (Sig -> SE Sig) -> Sig -> SE Sig
uni (SharcInstr -> D -> Sig -> SE Sig
rndSigSharcOsc SharcInstr
instr D
cps) (D -> Sig
sig D
cps)

-- | Plays a solo instrument with pad-like envelope
purePadSharcOsc :: SharcInstr -> D -> SE Sig
purePadSharcOsc :: SharcInstr -> D -> SE Sig
purePadSharcOsc SharcInstr
instr D
cps = Sig -> SE Sig -> SE Sig
forall a. SigSpace a => Sig -> a -> a
mul (D -> D -> Sig
fades D
0.65 D
0.75) (SE Sig -> SE Sig) -> SE Sig -> SE Sig
forall a b. (a -> b) -> a -> b
$ SharcInstr -> D -> SE Sig
rndSharcOsc SharcInstr
instr D
cps

-- | Plays orchestrated instrument with pad-like envelope
padSharcOsc :: SharcInstr -> D -> SE Sig
padSharcOsc :: SharcInstr -> D -> SE Sig
padSharcOsc SharcInstr
instr D
cps = Sig -> SE Sig -> SE Sig
forall a. SigSpace a => Sig -> a -> a
mul (D -> D -> Sig
fades D
0.65 D
0.75) (SE Sig -> SE Sig) -> SE Sig -> SE Sig
forall a b. (a -> b) -> a -> b
$ (Sig -> SE Sig) -> Sig -> SE Sig
uni (SharcInstr -> D -> Sig -> SE Sig
rndSigSharcOsc SharcInstr
instr D
cps) (D -> Sig
sig D
cps)

---------------------------------------------------------------------------
-- padsynth

data PadSharcSpec = PadSharcSpec {
        PadSharcSpec -> Double
padSharcBandwidth :: Double,
        PadSharcSpec -> Int
padSharcSize      :: Int
    }

instance Default PadSharcSpec where
    def :: PadSharcSpec
def = Double -> Int -> PadSharcSpec
PadSharcSpec Double
15 Int
8

padsynthSharcOsc :: SharcInstr -> D -> SE Sig
padsynthSharcOsc :: SharcInstr -> D -> SE Sig
padsynthSharcOsc = PadSharcSpec -> SharcInstr -> D -> SE Sig
padsynthSharcOsc' PadSharcSpec
forall a. Default a => a
def

padsynthSharcOsc2 :: SharcInstr -> D -> SE Sig2
padsynthSharcOsc2 :: SharcInstr -> D -> SE Sig2
padsynthSharcOsc2 = PadSharcSpec -> SharcInstr -> D -> SE Sig2
padsynthSharcOsc2' PadSharcSpec
forall a. Default a => a
def

padsynthSharcOsc2' :: PadSharcSpec -> SharcInstr -> D -> SE Sig2
padsynthSharcOsc2' :: PadSharcSpec -> SharcInstr -> D -> SE Sig2
padsynthSharcOsc2' PadSharcSpec
spec SharcInstr
instr D
freq = [(Double, PadsynthSpec)] -> D -> SE Sig2
padsynthOscMultiCps2 (PadSharcSpec -> SharcInstr -> [(Double, PadsynthSpec)]
getSpecIntervals PadSharcSpec
spec SharcInstr
instr) D
freq

padsynthSharcOsc' :: PadSharcSpec -> SharcInstr -> D -> SE Sig
padsynthSharcOsc' :: PadSharcSpec -> SharcInstr -> D -> SE Sig
padsynthSharcOsc' PadSharcSpec
spec SharcInstr
instr D
freq = [(Double, PadsynthSpec)] -> D -> SE Sig
padsynthOscMultiCps (PadSharcSpec -> SharcInstr -> [(Double, PadsynthSpec)]
getSpecIntervals PadSharcSpec
spec SharcInstr
instr) D
freq

morphsynthSharcOsc :: MorphSpec -> SharcInstr -> D -> SE Sig2
morphsynthSharcOsc :: MorphSpec -> SharcInstr -> D -> SE Sig2
morphsynthSharcOsc = PadSharcSpec -> MorphSpec -> SharcInstr -> D -> SE Sig2
morphsynthSharcOsc' PadSharcSpec
forall a. Default a => a
def

morphsynthSharcOsc' :: PadSharcSpec -> MorphSpec -> SharcInstr -> D -> SE Sig2
morphsynthSharcOsc' :: PadSharcSpec -> MorphSpec -> SharcInstr -> D -> SE Sig2
morphsynthSharcOsc' PadSharcSpec
spec MorphSpec
morphSpec SharcInstr
instr D
freq = MorphSpec -> [(Double, PadsynthSpec)] -> D -> SE Sig2
morphsynthOscMultiCps MorphSpec
morphSpec (PadSharcSpec -> SharcInstr -> [(Double, PadsynthSpec)]
getSpecIntervals PadSharcSpec
spec SharcInstr
instr) D
freq

quadMorphsynthSharcOsc :: MorphSpec -> [SharcInstr] -> (Sig, Sig) -> D -> SE Sig2
quadMorphsynthSharcOsc :: MorphSpec -> [SharcInstr] -> Sig2 -> D -> SE Sig2
quadMorphsynthSharcOsc = PadSharcSpec -> MorphSpec -> [SharcInstr] -> Sig2 -> D -> SE Sig2
quadMorphsynthSharcOsc' PadSharcSpec
forall a. Default a => a
def

quadMorphsynthSharcOsc' :: PadSharcSpec -> MorphSpec -> [SharcInstr] -> (Sig, Sig) -> D -> SE Sig2
quadMorphsynthSharcOsc' :: PadSharcSpec -> MorphSpec -> [SharcInstr] -> Sig2 -> D -> SE Sig2
quadMorphsynthSharcOsc' PadSharcSpec
spec MorphSpec
morphSpec [SharcInstr]
instr (Sig
x, Sig
y) D
freq = MorphSpec -> [[(Double, PadsynthSpec)]] -> Sig2 -> D -> SE Sig2
quadMorphsynthOscMultiCps MorphSpec
morphSpec ((SharcInstr -> [(Double, PadsynthSpec)])
-> [SharcInstr] -> [[(Double, PadsynthSpec)]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PadSharcSpec -> SharcInstr -> [(Double, PadsynthSpec)]
getSpecIntervals PadSharcSpec
spec) [SharcInstr]
instr) (Sig
x, Sig
y) D
freq

getSpecIntervals :: PadSharcSpec -> SharcInstr -> [(Double, PadsynthSpec)]
getSpecIntervals PadSharcSpec
spec (SharcInstr Instr
instr) = [Double] -> [PadsynthSpec] -> [(Double, PadsynthSpec)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Double]
borderFreqs [PadsynthSpec]
specs
    where
        groups :: [[Note]]
groups = Int -> [Note] -> [[Note]]
forall a. Int -> [a] -> [[a]]
splitTo (PadSharcSpec -> Int
padSharcSize PadSharcSpec
spec) (Instr -> [Note]
Sh.instrNotes Instr
instr)
        medians :: [Note]
medians = ([Note] -> Note) -> [[Note]] -> [Note]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Note] -> Note
forall a. [a] -> a
getMedian [[Note]]
groups
        borders :: [Note]
borders = ([Note] -> Note) -> [[Note]] -> [Note]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Note] -> Note
forall a. [a] -> a
getBorder [[Note]]
groups

        specs :: [PadsynthSpec]
specs   = (Note -> PadsynthSpec) -> [Note] -> [PadsynthSpec]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Double -> Note -> PadsynthSpec
note2padsynth (Double -> Note -> PadsynthSpec) -> Double -> Note -> PadsynthSpec
forall a b. (a -> b) -> a -> b
$ PadSharcSpec -> Double
padSharcBandwidth PadSharcSpec
spec) [Note]
medians
        borderFreqs :: [Double]
borderFreqs = (Note -> Double) -> [Note] -> [Double]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Pitch -> Double
Sh.pitchFund (Pitch -> Double) -> (Note -> Pitch) -> Note -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Note -> Pitch
Sh.notePitch) [Note]
borders


splitTo :: Int -> [a] -> [[a]]
splitTo :: Int -> [a] -> [[a]]
splitTo Int
m [a]
as = Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
go Int
size [a]
as
    where
        size :: Int
size = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 ([a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
as Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
m)

        go :: Int -> [a] -> [[a]]
        go :: Int -> [a] -> [[a]]
go Int
n [a]
bs
            | [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
ys   = [[a]
xs]
            | Bool
otherwise = [a]
xs [a] -> [[a]] -> [[a]]
forall a. a -> [a] -> [a]
: Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
go Int
n [a]
ys
            where
                ([a]
xs, [a]
ys) = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n [a]
bs

getMedian :: [a] -> a
getMedian :: [a] -> a
getMedian [a]
as
    | [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
as   = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"getMedian: Csound.Catalog.Wave.Sharc.hs empty list"
    | Bool
otherwise = [a]
as [a] -> Int -> a
forall a. [a] -> Int -> a
!! ([a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
as Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2)

getBorder :: [a] -> a
getBorder :: [a] -> a
getBorder [a]
as
    | [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
as   = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"getMedian: Csound.Catalog.Wave.Sharc.hs empty list"
    | Bool
otherwise = [a] -> a
forall a. [a] -> a
last [a]
as

note2padsynth :: Double -> Sh.Note -> PadsynthSpec
note2padsynth :: Double -> Note -> PadsynthSpec
note2padsynth Double
bandwidth Note
note = (Double -> [Double] -> PadsynthSpec
defPadsynthSpec Double
bandwidth [Double]
normAmps) { padsynthFundamental :: Double
padsynthFundamental = Pitch -> Double
Sh.pitchFund (Note -> Pitch
Sh.notePitch Note
note) }
    where
        normAmps :: [Double]
normAmps = (Double -> Double) -> [Double] -> [Double]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ( Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
maxAmp) [Double]
amps
        amps :: [Double]
amps = (Harmonic -> Double) -> [Harmonic] -> [Double]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Harmonic -> Double
Sh.harmonicAmplitude ([Harmonic] -> [Double]) -> [Harmonic] -> [Double]
forall a b. (a -> b) -> a -> b
$ Note -> [Harmonic]
Sh.noteHarmonics Note
note
        maxAmp :: Double
maxAmp = [Double] -> Double
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum [Double]
amps


---------------------------------------------------------------------------
-- sharc instr

newtype SharcInstr = SharcInstr { SharcInstr -> Instr
unSharcInstr :: Sh.Instr }

shViolin :: SharcInstr
shViolin :: SharcInstr
shViolin = Instr -> SharcInstr
SharcInstr Instr
Sh.violin

shViolinPizzicato :: SharcInstr
shViolinPizzicato :: SharcInstr
shViolinPizzicato = Instr -> SharcInstr
SharcInstr Instr
Sh.violinPizzicato

shViolinMuted :: SharcInstr
shViolinMuted :: SharcInstr
shViolinMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.violinMuted

shViolinMarteleBowing :: SharcInstr
shViolinMarteleBowing :: SharcInstr
shViolinMarteleBowing = Instr -> SharcInstr
SharcInstr Instr
Sh.violinMarteleBowing

shViolinsEnsemble :: SharcInstr
shViolinsEnsemble :: SharcInstr
shViolinsEnsemble = Instr -> SharcInstr
SharcInstr Instr
Sh.violinsEnsemble

shViola :: SharcInstr
shViola :: SharcInstr
shViola = Instr -> SharcInstr
SharcInstr Instr
Sh.viola

shViolaPizzicato :: SharcInstr
shViolaPizzicato :: SharcInstr
shViolaPizzicato = Instr -> SharcInstr
SharcInstr Instr
Sh.violaPizzicato

shViolaMuted :: SharcInstr
shViolaMuted :: SharcInstr
shViolaMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.violaMuted

shViolaMarteleBowing :: SharcInstr
shViolaMarteleBowing :: SharcInstr
shViolaMarteleBowing = Instr -> SharcInstr
SharcInstr Instr
Sh.violaMarteleBowing

shTuba :: SharcInstr
shTuba :: SharcInstr
shTuba = Instr -> SharcInstr
SharcInstr Instr
Sh.tuba

shTromboneMuted :: SharcInstr
shTromboneMuted :: SharcInstr
shTromboneMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.tromboneMuted

shTrombone :: SharcInstr
shTrombone :: SharcInstr
shTrombone = Instr -> SharcInstr
SharcInstr Instr
Sh.trombone

shPiccolo :: SharcInstr
shPiccolo :: SharcInstr
shPiccolo = Instr -> SharcInstr
SharcInstr Instr
Sh.piccolo

shOboe :: SharcInstr
shOboe :: SharcInstr
shOboe = Instr -> SharcInstr
SharcInstr Instr
Sh.oboe

shFrenchHornMuted :: SharcInstr
shFrenchHornMuted :: SharcInstr
shFrenchHornMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.frenchHornMuted

shFrenchHorn :: SharcInstr
shFrenchHorn :: SharcInstr
shFrenchHorn = Instr -> SharcInstr
SharcInstr Instr
Sh.frenchHorn

shFlute :: SharcInstr
shFlute :: SharcInstr
shFlute = Instr -> SharcInstr
SharcInstr Instr
Sh.flute

shEnglishHorn :: SharcInstr
shEnglishHorn :: SharcInstr
shEnglishHorn = Instr -> SharcInstr
SharcInstr Instr
Sh.englishHorn

shClarinetEflat :: SharcInstr
shClarinetEflat :: SharcInstr
shClarinetEflat = Instr -> SharcInstr
SharcInstr Instr
Sh.clarinetEflat

shTrumpetMutedC :: SharcInstr
shTrumpetMutedC :: SharcInstr
shTrumpetMutedC = Instr -> SharcInstr
SharcInstr Instr
Sh.trumpetMutedC

shTrumpetC :: SharcInstr
shTrumpetC :: SharcInstr
shTrumpetC = Instr -> SharcInstr
SharcInstr Instr
Sh.trumpetC

shContrabassClarinet :: SharcInstr
shContrabassClarinet :: SharcInstr
shContrabassClarinet = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabassClarinet

shContrabassoon :: SharcInstr
shContrabassoon :: SharcInstr
shContrabassoon = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabassoon

shCello :: SharcInstr
shCello :: SharcInstr
shCello = Instr -> SharcInstr
SharcInstr Instr
Sh.cello

shCelloPizzicato :: SharcInstr
shCelloPizzicato :: SharcInstr
shCelloPizzicato = Instr -> SharcInstr
SharcInstr Instr
Sh.celloPizzicato

shCelloMuted :: SharcInstr
shCelloMuted :: SharcInstr
shCelloMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.celloMuted

shCelloMarteleBowing :: SharcInstr
shCelloMarteleBowing :: SharcInstr
shCelloMarteleBowing = Instr -> SharcInstr
SharcInstr Instr
Sh.celloMarteleBowing

shContrabassPizzicato :: SharcInstr
shContrabassPizzicato :: SharcInstr
shContrabassPizzicato = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabassPizzicato

shContrabassMuted :: SharcInstr
shContrabassMuted :: SharcInstr
shContrabassMuted = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabassMuted

shContrabassMarteleBowing :: SharcInstr
shContrabassMarteleBowing :: SharcInstr
shContrabassMarteleBowing = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabassMarteleBowing

shContrabass :: SharcInstr
shContrabass :: SharcInstr
shContrabass = Instr -> SharcInstr
SharcInstr Instr
Sh.contrabass

shClarinet :: SharcInstr
shClarinet :: SharcInstr
shClarinet = Instr -> SharcInstr
SharcInstr Instr
Sh.clarinet

shBassTrombone :: SharcInstr
shBassTrombone :: SharcInstr
shBassTrombone = Instr -> SharcInstr
SharcInstr Instr
Sh.bassTrombone

shBassClarinet :: SharcInstr
shBassClarinet :: SharcInstr
shBassClarinet = Instr -> SharcInstr
SharcInstr Instr
Sh.bassClarinet

shBassoon :: SharcInstr
shBassoon :: SharcInstr
shBassoon = Instr -> SharcInstr
SharcInstr Instr
Sh.bassoon

shBassFlute :: SharcInstr
shBassFlute :: SharcInstr
shBassFlute = Instr -> SharcInstr
SharcInstr Instr
Sh.bassFlute

shTrumpetBach :: SharcInstr
shTrumpetBach :: SharcInstr
shTrumpetBach = Instr -> SharcInstr
SharcInstr Instr
Sh.trumpetBach

shAltoTrombone :: SharcInstr
shAltoTrombone :: SharcInstr
shAltoTrombone = Instr -> SharcInstr
SharcInstr Instr
Sh.altoTrombone

shAltoFlute :: SharcInstr
shAltoFlute :: SharcInstr
shAltoFlute = Instr -> SharcInstr
SharcInstr Instr
Sh.altoFlute