{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}

module Language.Notes
  ( Note (..)
  , Octave (..)
  , Pitch (..)
  , Tone (..)
  , getIntFromOctave
  , getIntFromTone
  , getOctaveFromInt
  , getToneFromInt
  , noteStrike
  , octaves
  , pitches
  , tones
  ) where

import Prelude                         hiding ((^))
import Synthesizer.Modifiers.Envelopes (AttackLength, DecayLength,
                                        Envelope (Envelope), ReleaseLength,
                                        SustainLevel)
import Synthesizer.Structure           (Frequency)

data Tone = C | D | E | F | G | A | B
  deriving (Int -> Tone -> ShowS
[Tone] -> ShowS
Tone -> String
(Int -> Tone -> ShowS)
-> (Tone -> String) -> ([Tone] -> ShowS) -> Show Tone
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tone] -> ShowS
$cshowList :: [Tone] -> ShowS
show :: Tone -> String
$cshow :: Tone -> String
showsPrec :: Int -> Tone -> ShowS
$cshowsPrec :: Int -> Tone -> ShowS
Show, Int -> Tone
Tone -> Int
Tone -> [Tone]
Tone -> Tone
Tone -> Tone -> [Tone]
Tone -> Tone -> Tone -> [Tone]
(Tone -> Tone)
-> (Tone -> Tone)
-> (Int -> Tone)
-> (Tone -> Int)
-> (Tone -> [Tone])
-> (Tone -> Tone -> [Tone])
-> (Tone -> Tone -> [Tone])
-> (Tone -> Tone -> Tone -> [Tone])
-> Enum Tone
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 :: Tone -> Tone -> Tone -> [Tone]
$cenumFromThenTo :: Tone -> Tone -> Tone -> [Tone]
enumFromTo :: Tone -> Tone -> [Tone]
$cenumFromTo :: Tone -> Tone -> [Tone]
enumFromThen :: Tone -> Tone -> [Tone]
$cenumFromThen :: Tone -> Tone -> [Tone]
enumFrom :: Tone -> [Tone]
$cenumFrom :: Tone -> [Tone]
fromEnum :: Tone -> Int
$cfromEnum :: Tone -> Int
toEnum :: Int -> Tone
$ctoEnum :: Int -> Tone
pred :: Tone -> Tone
$cpred :: Tone -> Tone
succ :: Tone -> Tone
$csucc :: Tone -> Tone
Enum, Eq Tone
Eq Tone
-> (Tone -> Tone -> Ordering)
-> (Tone -> Tone -> Bool)
-> (Tone -> Tone -> Bool)
-> (Tone -> Tone -> Bool)
-> (Tone -> Tone -> Bool)
-> (Tone -> Tone -> Tone)
-> (Tone -> Tone -> Tone)
-> Ord Tone
Tone -> Tone -> Bool
Tone -> Tone -> Ordering
Tone -> Tone -> Tone
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 :: Tone -> Tone -> Tone
$cmin :: Tone -> Tone -> Tone
max :: Tone -> Tone -> Tone
$cmax :: Tone -> Tone -> Tone
>= :: Tone -> Tone -> Bool
$c>= :: Tone -> Tone -> Bool
> :: Tone -> Tone -> Bool
$c> :: Tone -> Tone -> Bool
<= :: Tone -> Tone -> Bool
$c<= :: Tone -> Tone -> Bool
< :: Tone -> Tone -> Bool
$c< :: Tone -> Tone -> Bool
compare :: Tone -> Tone -> Ordering
$ccompare :: Tone -> Tone -> Ordering
$cp1Ord :: Eq Tone
Ord, Tone -> Tone -> Bool
(Tone -> Tone -> Bool) -> (Tone -> Tone -> Bool) -> Eq Tone
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tone -> Tone -> Bool
$c/= :: Tone -> Tone -> Bool
== :: Tone -> Tone -> Bool
$c== :: Tone -> Tone -> Bool
Eq)

tones :: [Tone]
tones :: [Tone]
tones = [Tone
C ..]

data Pitch = Flat | Sharp
  deriving (Int -> Pitch -> ShowS
[Pitch] -> ShowS
Pitch -> String
(Int -> Pitch -> ShowS)
-> (Pitch -> String) -> ([Pitch] -> ShowS) -> Show Pitch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pitch] -> ShowS
$cshowList :: [Pitch] -> ShowS
show :: Pitch -> String
$cshow :: Pitch -> String
showsPrec :: Int -> Pitch -> ShowS
$cshowsPrec :: Int -> Pitch -> ShowS
Show, Int -> Pitch
Pitch -> Int
Pitch -> [Pitch]
Pitch -> Pitch
Pitch -> Pitch -> [Pitch]
Pitch -> Pitch -> Pitch -> [Pitch]
(Pitch -> Pitch)
-> (Pitch -> Pitch)
-> (Int -> Pitch)
-> (Pitch -> Int)
-> (Pitch -> [Pitch])
-> (Pitch -> Pitch -> [Pitch])
-> (Pitch -> Pitch -> [Pitch])
-> (Pitch -> Pitch -> Pitch -> [Pitch])
-> Enum Pitch
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 :: Pitch -> Pitch -> Pitch -> [Pitch]
$cenumFromThenTo :: Pitch -> Pitch -> Pitch -> [Pitch]
enumFromTo :: Pitch -> Pitch -> [Pitch]
$cenumFromTo :: Pitch -> Pitch -> [Pitch]
enumFromThen :: Pitch -> Pitch -> [Pitch]
$cenumFromThen :: Pitch -> Pitch -> [Pitch]
enumFrom :: Pitch -> [Pitch]
$cenumFrom :: Pitch -> [Pitch]
fromEnum :: Pitch -> Int
$cfromEnum :: Pitch -> Int
toEnum :: Int -> Pitch
$ctoEnum :: Int -> Pitch
pred :: Pitch -> Pitch
$cpred :: Pitch -> Pitch
succ :: Pitch -> Pitch
$csucc :: Pitch -> Pitch
Enum, Eq Pitch
Eq Pitch
-> (Pitch -> Pitch -> Ordering)
-> (Pitch -> Pitch -> Bool)
-> (Pitch -> Pitch -> Bool)
-> (Pitch -> Pitch -> Bool)
-> (Pitch -> Pitch -> Bool)
-> (Pitch -> Pitch -> Pitch)
-> (Pitch -> Pitch -> Pitch)
-> Ord Pitch
Pitch -> Pitch -> Bool
Pitch -> Pitch -> Ordering
Pitch -> Pitch -> Pitch
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 :: Pitch -> Pitch -> Pitch
$cmin :: Pitch -> Pitch -> Pitch
max :: Pitch -> Pitch -> Pitch
$cmax :: Pitch -> Pitch -> Pitch
>= :: Pitch -> Pitch -> Bool
$c>= :: Pitch -> Pitch -> Bool
> :: Pitch -> Pitch -> Bool
$c> :: Pitch -> Pitch -> Bool
<= :: Pitch -> Pitch -> Bool
$c<= :: Pitch -> Pitch -> Bool
< :: Pitch -> Pitch -> Bool
$c< :: Pitch -> Pitch -> Bool
compare :: Pitch -> Pitch -> Ordering
$ccompare :: Pitch -> Pitch -> Ordering
$cp1Ord :: Eq Pitch
Ord, Pitch -> Pitch -> Bool
(Pitch -> Pitch -> Bool) -> (Pitch -> Pitch -> Bool) -> Eq Pitch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pitch -> Pitch -> Bool
$c/= :: Pitch -> Pitch -> Bool
== :: Pitch -> Pitch -> Bool
$c== :: Pitch -> Pitch -> Bool
Eq)

pitches :: [Pitch]
pitches :: [Pitch]
pitches = [Pitch
Flat ..]

data Octave = Zero | One | Two | Three | Four | Five | Six | Seven | Eight
  deriving (Int -> Octave -> ShowS
[Octave] -> ShowS
Octave -> String
(Int -> Octave -> ShowS)
-> (Octave -> String) -> ([Octave] -> ShowS) -> Show Octave
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Octave] -> ShowS
$cshowList :: [Octave] -> ShowS
show :: Octave -> String
$cshow :: Octave -> String
showsPrec :: Int -> Octave -> ShowS
$cshowsPrec :: Int -> Octave -> ShowS
Show, Int -> Octave
Octave -> Int
Octave -> [Octave]
Octave -> Octave
Octave -> Octave -> [Octave]
Octave -> Octave -> Octave -> [Octave]
(Octave -> Octave)
-> (Octave -> Octave)
-> (Int -> Octave)
-> (Octave -> Int)
-> (Octave -> [Octave])
-> (Octave -> Octave -> [Octave])
-> (Octave -> Octave -> [Octave])
-> (Octave -> Octave -> Octave -> [Octave])
-> Enum Octave
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 :: Octave -> Octave -> Octave -> [Octave]
$cenumFromThenTo :: Octave -> Octave -> Octave -> [Octave]
enumFromTo :: Octave -> Octave -> [Octave]
$cenumFromTo :: Octave -> Octave -> [Octave]
enumFromThen :: Octave -> Octave -> [Octave]
$cenumFromThen :: Octave -> Octave -> [Octave]
enumFrom :: Octave -> [Octave]
$cenumFrom :: Octave -> [Octave]
fromEnum :: Octave -> Int
$cfromEnum :: Octave -> Int
toEnum :: Int -> Octave
$ctoEnum :: Int -> Octave
pred :: Octave -> Octave
$cpred :: Octave -> Octave
succ :: Octave -> Octave
$csucc :: Octave -> Octave
Enum, Eq Octave
Eq Octave
-> (Octave -> Octave -> Ordering)
-> (Octave -> Octave -> Bool)
-> (Octave -> Octave -> Bool)
-> (Octave -> Octave -> Bool)
-> (Octave -> Octave -> Bool)
-> (Octave -> Octave -> Octave)
-> (Octave -> Octave -> Octave)
-> Ord Octave
Octave -> Octave -> Bool
Octave -> Octave -> Ordering
Octave -> Octave -> Octave
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 :: Octave -> Octave -> Octave
$cmin :: Octave -> Octave -> Octave
max :: Octave -> Octave -> Octave
$cmax :: Octave -> Octave -> Octave
>= :: Octave -> Octave -> Bool
$c>= :: Octave -> Octave -> Bool
> :: Octave -> Octave -> Bool
$c> :: Octave -> Octave -> Bool
<= :: Octave -> Octave -> Bool
$c<= :: Octave -> Octave -> Bool
< :: Octave -> Octave -> Bool
$c< :: Octave -> Octave -> Bool
compare :: Octave -> Octave -> Ordering
$ccompare :: Octave -> Octave -> Ordering
$cp1Ord :: Eq Octave
Ord, Octave -> Octave -> Bool
(Octave -> Octave -> Bool)
-> (Octave -> Octave -> Bool) -> Eq Octave
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Octave -> Octave -> Bool
$c/= :: Octave -> Octave -> Bool
== :: Octave -> Octave -> Bool
$c== :: Octave -> Octave -> Bool
Eq)

octaves :: [Octave]
octaves :: [Octave]
octaves = [Octave
Zero ..]

data Note = Note
  { Note -> Tone
getTone   :: Tone
  , Note -> Pitch
getPitch  :: Pitch
  , Note -> Octave
getOctave :: Octave
  }
  deriving (Int -> Note -> ShowS
[Note] -> ShowS
Note -> String
(Int -> Note -> ShowS)
-> (Note -> String) -> ([Note] -> ShowS) -> Show Note
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Note] -> ShowS
$cshowList :: [Note] -> ShowS
show :: Note -> String
$cshow :: Note -> String
showsPrec :: Int -> Note -> ShowS
$cshowsPrec :: Int -> Note -> ShowS
Show, Eq Note
Eq Note
-> (Note -> Note -> Ordering)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Bool)
-> (Note -> Note -> Note)
-> (Note -> Note -> Note)
-> Ord Note
Note -> Note -> Bool
Note -> Note -> Ordering
Note -> Note -> Note
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Note -> Note -> Note
$cmin :: Note -> Note -> Note
max :: Note -> Note -> Note
$cmax :: Note -> Note -> Note
>= :: Note -> Note -> Bool
$c>= :: Note -> Note -> Bool
> :: Note -> Note -> Bool
$c> :: Note -> Note -> Bool
<= :: Note -> Note -> Bool
$c<= :: Note -> Note -> Bool
< :: Note -> Note -> Bool
$c< :: Note -> Note -> Bool
compare :: Note -> Note -> Ordering
$ccompare :: Note -> Note -> Ordering
$cp1Ord :: Eq Note
Ord, Note -> Note -> Bool
(Note -> Note -> Bool) -> (Note -> Note -> Bool) -> Eq Note
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Note -> Note -> Bool
$c/= :: Note -> Note -> Bool
== :: Note -> Note -> Bool
$c== :: Note -> Note -> Bool
Eq)

noteStrike :: AttackLength -> DecayLength -> SustainLevel -> ReleaseLength -> Envelope
noteStrike :: AttackLength
-> AttackLength -> AttackLength -> AttackLength -> Envelope
noteStrike = AttackLength
-> AttackLength -> AttackLength -> AttackLength -> Envelope
Envelope

getOctaveFromInt :: Int -> Octave
getOctaveFromInt :: Int -> Octave
getOctaveFromInt = Int -> Octave
forall a. Enum a => Int -> a
toEnum

getIntFromOctave :: Octave -> Int
getIntFromOctave :: Octave -> Int
getIntFromOctave = Octave -> Int
forall a. Enum a => a -> Int
fromEnum

getToneFromInt :: Int -> Tone
getToneFromInt :: Int -> Tone
getToneFromInt = Int -> Tone
forall a. Enum a => Int -> a
toEnum

getIntFromTone :: Tone -> Int
getIntFromTone :: Tone -> Int
getIntFromTone = Tone -> Int
forall a. Enum a => a -> Int
fromEnum