module Harmonic.Interface.Tidal.Recall
( save
, recall
, recallE
, renderChart
, renderState
, parseState
, familyWord
) where
import Data.Char (toLower)
import Data.Foldable (toList)
import Data.List (intercalate, transpose, dropWhileEnd, isPrefixOf, isSuffixOf)
import Data.List.Split (splitOn)
import qualified Data.Sequence as Seq
import Data.Time (getZonedTime, formatTime, defaultTimeLocale)
import Text.Read (readMaybe)
import Harmonic.Rules.Types.Pitch (NoteName, PitchClass(..), pitchClass, mkPitchClass)
import qualified Harmonic.Rules.Types.Harmony as H
import qualified Harmonic.Rules.Types.Progression as Prog
import qualified Harmonic.Rules.Types.ProgressionContext as PC
import qualified Harmonic.Rules.Types.Scale as Sc
renderState :: H.CadenceState -> String
renderState :: CadenceState -> [Char]
renderState CadenceState
cs = [[Char]] -> [Char]
unwords ([[Char]]
base [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]]
mark)
where
root :: NoteName
root = CadenceState -> NoteName
H.stateCadenceRoot CadenceState
cs
rootPC :: PitchClass
rootPC = NoteName -> PitchClass
pitchClass NoteName
root
spell :: PitchClass -> NoteName
spell = EnharmonicSpelling -> PitchClass -> NoteName
H.enharmonicFunc (CadenceState -> EnharmonicSpelling
H.stateSpelling CadenceState
cs)
cad :: Cadence
cad = CadenceState -> Cadence
H.stateCadence CadenceState
cs
ivs :: [PitchClass]
ivs = case Cadence -> [PitchClass]
H.cadenceIntervals Cadence
cad of
(P Int
0 : [PitchClass]
rest) -> [PitchClass]
rest
[PitchClass]
other -> [PitchClass]
other
notes :: [[Char]]
notes = NoteName -> [Char]
forall a. Show a => a -> [Char]
show NoteName
root [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [ NoteName -> [Char]
forall a. Show a => a -> [Char]
show (PitchClass -> NoteName
spell (PitchClass
i PitchClass -> PitchClass -> PitchClass
forall a. Num a => a -> a -> a
+ PitchClass
rootPC)) | PitchClass
i <- [PitchClass]
ivs ]
name :: [Char]
name = case Cadence -> [Char]
H.cadenceFunctionality Cadence
cad of
[Char]
"" -> [Char]
"-"
[Char]
n -> [Char]
n
base :: [[Char]]
base = [[Char]]
notes [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
name, [Char]
"(" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Movement -> [Char]
forall a. Show a => a -> [Char]
show (Cadence -> Movement
H.cadenceMovement Cadence
cad) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
")"]
mark :: [[Char]]
mark | [Char] -> Either [Char] CadenceState
parseState ([[Char]] -> [Char]
unwords [[Char]]
base) Either [Char] CadenceState -> Either [Char] CadenceState -> Bool
forall a. Eq a => a -> a -> Bool
== CadenceState -> Either [Char] CadenceState
forall a b. b -> Either a b
Right CadenceState
cs = []
| Bool
otherwise = [EnharmonicSpelling -> [Char]
spellingWord (CadenceState -> EnharmonicSpelling
H.stateSpelling CadenceState
cs)]
spellingWord :: H.EnharmonicSpelling -> String
spellingWord :: EnharmonicSpelling -> [Char]
spellingWord EnharmonicSpelling
H.FlatSpelling = [Char]
"flat"
spellingWord EnharmonicSpelling
H.SharpSpelling = [Char]
"sharp"
parseState :: String -> Either String H.CadenceState
parseState :: [Char] -> Either [Char] CadenceState
parseState [Char]
s =
case ([Char] -> Bool) -> [[Char]] -> ([[Char]], [[Char]])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span [Char] -> Bool
isNoteTok ([Char] -> [[Char]]
tokens [Char]
s) of
([], [[Char]]
_) -> [Char] -> Either [Char] CadenceState
forall a b. a -> Either a b
Left ([Char]
"no notes in " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s)
([[Char]]
noteToks, [[Char]]
rest) -> do
let ([Char]
rootTok : [[Char]]
tailToks) = [[Char]]
noteToks
root :: NoteName
root = [Char] -> NoteName
noteFromTok [Char]
rootTok
rootPC :: PitchClass
rootPC = NoteName -> PitchClass
pitchClass NoteName
root
ivs :: [PitchClass]
ivs = Int -> PitchClass
P Int
0 PitchClass -> [PitchClass] -> [PitchClass]
forall a. a -> [a] -> [a]
: [ NoteName -> PitchClass
pitchClass ([Char] -> NoteName
noteFromTok [Char]
t) PitchClass -> PitchClass -> PitchClass
forall a. Num a => a -> a -> a
- PitchClass
rootPC | [Char]
t <- [[Char]]
tailToks ]
(mName, mMove, mSpell) <- [[Char]]
-> (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
classify [[Char]]
rest (Maybe [Char]
forall a. Maybe a
Nothing, Maybe Movement
forall a. Maybe a
Nothing, Maybe EnharmonicSpelling
forall a. Maybe a
Nothing)
let name = case Maybe [Char]
mName of
Maybe [Char]
Nothing -> [PitchClass] -> [Char]
H.corpusFunctionality [PitchClass]
ivs
Just [Char]
"-" -> [Char]
""
Just [Char]
n -> [Char]
n
move = Movement -> (Movement -> Movement) -> Maybe Movement -> Movement
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Movement
H.Unison Movement -> Movement
forall a. a -> a
id Maybe Movement
mMove
abs' = [ PitchClass -> Int
unPitchClass (PitchClass
i PitchClass -> PitchClass -> PitchClass
forall a. Num a => a -> a -> a
+ PitchClass
rootPC) | PitchClass
i <- [PitchClass]
ivs ]
lowered = ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower) [[Char]]
tailToks
spelling = case Maybe EnharmonicSpelling
mSpell of
Just EnharmonicSpelling
sp -> EnharmonicSpelling
sp
Maybe EnharmonicSpelling
Nothing -> case NoteName -> Maybe EnharmonicSpelling
H.noteNameImpliesSpelling NoteName
root of
Just EnharmonicSpelling
sp -> EnharmonicSpelling
sp
Maybe EnharmonicSpelling
Nothing
| ([Char] -> Bool) -> [[Char]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\[Char]
t -> Char
'b' Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
t) [[Char]]
lowered -> EnharmonicSpelling
H.FlatSpelling
| ([Char] -> Bool) -> [[Char]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Char
'#' Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem`) [[Char]]
lowered -> EnharmonicSpelling
H.SharpSpelling
| Bool
otherwise -> [Int] -> EnharmonicSpelling
H.inferSpelling [Int]
abs'
pure (H.CadenceState (H.Cadence name move ivs) root spelling)
where
tokens :: [Char] -> [[Char]]
tokens [Char]
str = case (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'(') [Char]
str of
([Char]
before, Char
'(' : [Char]
rest) | ([Char]
inner, Char
')' : [Char]
after) <- (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
')') [Char]
rest
-> [Char] -> [[Char]]
words [Char]
before [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
"(" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
inner [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
")"] [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]]
words [Char]
after
([Char], [Char])
_ -> [Char] -> [[Char]]
words [Char]
str
classify :: [[Char]]
-> (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
classify [] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
acc = (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
forall a b. b -> Either a b
Right (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
acc
classify ([Char]
t : [[Char]]
ts) (Maybe [Char]
n, Maybe Movement
m, Maybe EnharmonicSpelling
sp)
| Just EnharmonicSpelling
sp' <- [Char] -> Maybe EnharmonicSpelling
spellingFromWord [Char]
t =
if Maybe EnharmonicSpelling
sp Maybe EnharmonicSpelling -> Maybe EnharmonicSpelling -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe EnharmonicSpelling
forall a. Maybe a
Nothing then [[Char]]
-> (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
classify [[Char]]
ts (Maybe [Char]
n, Maybe Movement
m, EnharmonicSpelling -> Maybe EnharmonicSpelling
forall a. a -> Maybe a
Just EnharmonicSpelling
sp') else [Char]
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
forall a b. a -> Either a b
Left ([Char]
"two spellings in " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s)
| [Char]
"(" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` [Char]
t Bool -> Bool -> Bool
&& [Char]
")" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isSuffixOf` [Char]
t = do
mv <- [Char] -> Either [Char] Movement
parseMoveTok ([Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
init (Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
t))
if m == Nothing then classify ts (n, Just mv, sp) else Left ("two movements in " ++ show s)
| Bool
otherwise =
if Maybe [Char]
n Maybe [Char] -> Maybe [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe [Char]
forall a. Maybe a
Nothing then [[Char]]
-> (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
classify [[Char]]
ts ([Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
t, Maybe Movement
m, Maybe EnharmonicSpelling
sp) else [Char]
-> Either
[Char] (Maybe [Char], Maybe Movement, Maybe EnharmonicSpelling)
forall a b. a -> Either a b
Left ([Char]
"two chord names in " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s)
spellingFromWord :: [Char] -> Maybe EnharmonicSpelling
spellingFromWord [Char]
t = case (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
t of
[Char]
"flat" -> EnharmonicSpelling -> Maybe EnharmonicSpelling
forall a. a -> Maybe a
Just EnharmonicSpelling
H.FlatSpelling
[Char]
"sharp" -> EnharmonicSpelling -> Maybe EnharmonicSpelling
forall a. a -> Maybe a
Just EnharmonicSpelling
H.SharpSpelling
[Char]
_ -> Maybe EnharmonicSpelling
forall a. Maybe a
Nothing
parseMoveTok :: [Char] -> Either [Char] Movement
parseMoveTok [Char]
inner
| Just Int
n <- [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
inner :: Maybe Int = Movement -> Either [Char] Movement
forall a b. b -> Either a b
Right (PitchClass -> PitchClass -> Movement
H.toMovement (Int -> PitchClass
P Int
0) (Int -> PitchClass
mkPitchClass Int
n))
| [Char]
inner [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"empty" = Movement -> Either [Char] Movement
forall a b. b -> Either a b
Right Movement
H.Empty
| Bool
otherwise = case [Char] -> Movement
forall a. Read a => [Char] -> a
read [Char]
inner :: H.Movement of
Movement
H.Empty -> [Char] -> Either [Char] Movement
forall a b. a -> Either a b
Left ([Char]
"unknown movement " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
inner)
Movement
mv -> Movement -> Either [Char] Movement
forall a b. b -> Either a b
Right Movement
mv
noteTable :: [(String, NoteName)]
noteTable :: [([Char], NoteName)]
noteTable = [ ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower (NoteName -> [Char]
forall a. Show a => a -> [Char]
show NoteName
n), NoteName
n) | NoteName
n <- [NoteName
forall a. Bounded a => a
minBound .. NoteName
forall a. Bounded a => a
maxBound] ]
isNoteTok :: String -> Bool
isNoteTok :: [Char] -> Bool
isNoteTok [Char]
t = (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
t [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (([Char], NoteName) -> [Char]) -> [([Char], NoteName)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], NoteName) -> [Char]
forall a b. (a, b) -> a
fst [([Char], NoteName)]
noteTable
noteFromTok :: String -> NoteName
noteFromTok :: [Char] -> NoteName
noteFromTok [Char]
t = NoteName -> (NoteName -> NoteName) -> Maybe NoteName -> NoteName
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> NoteName
forall a. HasCallStack => [Char] -> a
error ([Char]
"not a note name: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
t)) NoteName -> NoteName
forall a. a -> a
id ([Char] -> [([Char], NoteName)] -> Maybe NoteName
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
t) [([Char], NoteName)]
noteTable)
familyWord :: PC.Family -> String
familyWord :: Family -> [Char]
familyWord Family
PC.FTriad = [Char]
"triad"
familyWord Family
PC.FExtended = [Char]
"extended"
familyWord Family
PC.FStrata = [Char]
"strata"
familyWord Family
PC.FJazz = [Char]
"jazz"
familyWord Family
PC.FPoly = [Char]
"poly"
familyFromWord :: String -> Either String PC.Family
familyFromWord :: [Char] -> Either [Char] Family
familyFromWord [Char]
w =
case [ Family
f | Family
f <- [Family
forall a. Bounded a => a
minBound .. Family
forall a. Bounded a => a
maxBound], Family -> [Char]
familyWord Family
f [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
w ] of
(Family
f : [Family]
_) -> Family -> Either [Char] Family
forall a b. b -> Either a b
Right Family
f
[] -> [Char] -> Either [Char] Family
forall a b. a -> Either a b
Left ([Char]
"unknown family " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
w [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"; one of triad extended strata jazz poly")
renderChart :: PC.ProgressionContext -> [String]
renderChart :: ProgressionContext -> [[Char]]
renderChart ProgressionContext
pc = ([[Char]] -> [Char]) -> [[[Char]]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ') ([Char] -> [Char]) -> ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
" | ") ([[[Char]]] -> [[[Char]]]
align [[[Char]]]
rows)
where
states :: [[[Char]]]
states = (Progression -> [[Char]]) -> [Progression] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map ((CadenceState -> [Char]) -> [CadenceState] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map CadenceState -> [Char]
renderState ([CadenceState] -> [[Char]])
-> (Progression -> [CadenceState]) -> Progression -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq CadenceState -> [CadenceState]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Seq CadenceState -> [CadenceState])
-> (Progression -> Seq CadenceState)
-> Progression
-> [CadenceState]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Progression -> Seq CadenceState
Prog.unProgression)
[ProgressionContext -> Progression
PC.triadLayer ProgressionContext
pc, ProgressionContext -> Progression
PC.strataLayer ProgressionContext
pc, ProgressionContext -> Progression
PC.modeLayer ProgressionContext
pc]
prov :: [[[Char]]]
prov = case ProgressionContext -> Maybe (Seq (Tristrata, StrataLabel))
PC.pcProvenance ProgressionContext
pc of
Maybe (Seq (Tristrata, StrataLabel))
Nothing -> []
Just Seq (Tristrata, StrataLabel)
sq -> [((Tristrata, StrataLabel) -> [Char])
-> [(Tristrata, StrataLabel)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (Tristrata, StrataLabel) -> [Char]
renderProv (Seq (Tristrata, StrataLabel) -> [(Tristrata, StrataLabel)]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Seq (Tristrata, StrataLabel)
sq)]
rows :: [[[Char]]]
rows = [[[Char]]] -> [[[Char]]]
forall a. [[a]] -> [[a]]
transpose ([[[Char]]]
states [[[Char]]] -> [[[Char]]] -> [[[Char]]]
forall a. [a] -> [a] -> [a]
++ [[[Char]]]
prov)
align :: [[[Char]]] -> [[[Char]]]
align [[[Char]]]
rs = let widths :: [Int]
widths = ([[Char]] -> Int) -> [[[Char]]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map ([Int] -> Int
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Int] -> Int) -> ([[Char]] -> [Int]) -> [[Char]] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:) ([Int] -> [Int]) -> ([[Char]] -> [Int]) -> [[Char]] -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Int) -> [[Char]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length) ([[[Char]]] -> [[[Char]]]
forall a. [[a]] -> [[a]]
transpose [[[Char]]]
rs)
in ([[Char]] -> [[Char]]) -> [[[Char]]] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map ((Int -> [Char] -> [Char]) -> [Int] -> [[Char]] -> [[Char]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Int -> [Char] -> [Char]
padTo [Int]
widths) [[[Char]]]
rs
padTo :: Int -> [Char] -> [Char]
padTo Int
n [Char]
str = [Char]
str [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
str) Char
' '
renderProv :: (Sc.Tristrata, Sc.StrataLabel) -> String
renderProv :: (Tristrata, StrataLabel) -> [Char]
renderProv (Tristrata
t, StrataLabel
s) =
[Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"-" ((StrataLabel -> [Char]) -> [StrataLabel] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map StrataLabel -> [Char]
forall a. Show a => a -> [Char]
show [Tristrata -> StrataLabel
Sc.ts1 Tristrata
t, Tristrata -> StrataLabel
Sc.ts2 Tristrata
t, Tristrata -> StrataLabel
Sc.ts3 Tristrata
t]) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ StrataLabel -> [Char]
forall a. Show a => a -> [Char]
show StrataLabel
s
parseProv :: String -> Either String (Sc.Tristrata, Sc.StrataLabel)
parseProv :: [Char] -> Either [Char] (Tristrata, StrataLabel)
parseProv [Char]
str = case [Char] -> [[Char]]
words [Char]
str of
[[Char]
tri, [Char]
lab] | [Just StrataLabel
a, Just StrataLabel
b, Just StrataLabel
c] <- ([Char] -> Maybe StrataLabel) -> [[Char]] -> [Maybe StrataLabel]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Maybe StrataLabel
forall a. Read a => [Char] -> Maybe a
readMaybe ([Char] -> [Char] -> [[Char]]
forall a. Eq a => [a] -> [a] -> [[a]]
splitOn [Char]
"-" [Char]
tri)
, Just StrataLabel
l <- [Char] -> Maybe StrataLabel
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
lab -> (Tristrata, StrataLabel) -> Either [Char] (Tristrata, StrataLabel)
forall a b. b -> Either a b
Right (StrataLabel -> StrataLabel -> StrataLabel -> Tristrata
Sc.Tristrata StrataLabel
a StrataLabel
b StrataLabel
c, StrataLabel
l)
[[Char]]
_ -> [Char] -> Either [Char] (Tristrata, StrataLabel)
forall a b. a -> Either a b
Left ([Char]
"bad provenance " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
str [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"; expected e.g. I-V-X V")
recallE :: String -> [String] -> Either String PC.ProgressionContext
recallE :: [Char] -> [[Char]] -> Either [Char] ProgressionContext
recallE [Char]
famWord [[Char]]
ls = do
fam <- [Char] -> Either [Char] Family
familyFromWord [Char]
famWord
bars <- mapM parseBar (zip [1 :: Int ..] ls)
let provs = [ Maybe (Tristrata, StrataLabel)
p | (CadenceState
_, CadenceState
_, CadenceState
_, Maybe (Tristrata, StrataLabel)
p) <- [(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))]
bars ]
prov <- case (all isJust' provs, any isJust' provs) of
(Bool
True, Bool
True) -> Maybe (Seq (Tristrata, StrataLabel))
-> Either [Char] (Maybe (Seq (Tristrata, StrataLabel)))
forall a b. b -> Either a b
Right (Seq (Tristrata, StrataLabel)
-> Maybe (Seq (Tristrata, StrataLabel))
forall a. a -> Maybe a
Just ([(Tristrata, StrataLabel)] -> Seq (Tristrata, StrataLabel)
forall a. [a] -> Seq a
Seq.fromList [ (Tristrata, StrataLabel)
p | Just (Tristrata, StrataLabel)
p <- [Maybe (Tristrata, StrataLabel)]
provs ]))
(Bool
_, Bool
False) -> Maybe (Seq (Tristrata, StrataLabel))
-> Either [Char] (Maybe (Seq (Tristrata, StrataLabel)))
forall a b. b -> Either a b
Right Maybe (Seq (Tristrata, StrataLabel))
forall a. Maybe a
Nothing
(Bool, Bool)
_ -> [Char] -> Either [Char] (Maybe (Seq (Tristrata, StrataLabel)))
forall a b. a -> Either a b
Left [Char]
"provenance must be on every bar or none"
let lyr (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
-> CadenceState
pick = [CadenceState] -> Progression
Prog.fromCadenceStates [ (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
-> CadenceState
pick (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
b | (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
b <- [(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))]
bars ]
pure . PC.normalizeFamily $ PC.ProgressionContext
{ PC.triadLayer = lyr (\(CadenceState
t, CadenceState
_, CadenceState
_, Maybe (Tristrata, StrataLabel)
_) -> CadenceState
t)
, PC.strataLayer = lyr (\(CadenceState
_, CadenceState
s, CadenceState
_, Maybe (Tristrata, StrataLabel)
_) -> CadenceState
s)
, PC.modeLayer = lyr (\(CadenceState
_, CadenceState
_, CadenceState
m, Maybe (Tristrata, StrataLabel)
_) -> CadenceState
m)
, PC.pcProvenance = prov
, PC.pcFamily = fam
}
where
isJust' :: Maybe a -> Bool
isJust' = Bool -> (a -> Bool) -> Maybe a -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Bool -> a -> Bool
forall a b. a -> b -> a
const Bool
True)
at :: a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
msg = ([Char] -> Either [Char] b)
-> (b -> Either [Char] b) -> Either [Char] b -> Either [Char] b
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> [Char] -> Either [Char] b
forall a b. a -> Either a b
Left ([Char]
"bar " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
msg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e)) b -> Either [Char] b
forall a b. b -> Either a b
Right
parseBar :: (a, [Char])
-> Either
[Char]
(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
parseBar (a
i, [Char]
line) = case ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> [Char]
trim ([Char] -> [Char] -> [[Char]]
forall a. Eq a => [a] -> [a] -> [[a]]
splitOn [Char]
"|" [Char]
line) of
[[Char]
t, [Char]
s, [Char]
m] -> (,,,) (CadenceState
-> CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"T " ([Char] -> Either [Char] CadenceState
parseState [Char]
t) Either
[Char]
(CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"S " ([Char] -> Either [Char] CadenceState
parseState [Char]
s)
Either
[Char]
(CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"M " ([Char] -> Either [Char] CadenceState
parseState [Char]
m) Either
[Char]
(Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] (Maybe (Tristrata, StrataLabel))
-> Either
[Char]
(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Tristrata, StrataLabel)
-> Either [Char] (Maybe (Tristrata, StrataLabel))
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Tristrata, StrataLabel)
forall a. Maybe a
Nothing
[[Char]
t, [Char]
s, [Char]
m, [Char]
p] -> (,,,) (CadenceState
-> CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"T " ([Char] -> Either [Char] CadenceState
parseState [Char]
t) Either
[Char]
(CadenceState
-> CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"S " ([Char] -> Either [Char] CadenceState
parseState [Char]
s)
Either
[Char]
(CadenceState
-> Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] CadenceState
-> Either
[Char]
(Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a
-> [Char]
-> Either [Char] CadenceState
-> Either [Char] CadenceState
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"M " ([Char] -> Either [Char] CadenceState
parseState [Char]
m) Either
[Char]
(Maybe (Tristrata, StrataLabel)
-> (CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel)))
-> Either [Char] (Maybe (Tristrata, StrataLabel))
-> Either
[Char]
(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
forall a b.
Either [Char] (a -> b) -> Either [Char] a -> Either [Char] b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Tristrata, StrataLabel) -> Maybe (Tristrata, StrataLabel)
forall a. a -> Maybe a
Just ((Tristrata, StrataLabel) -> Maybe (Tristrata, StrataLabel))
-> Either [Char] (Tristrata, StrataLabel)
-> Either [Char] (Maybe (Tristrata, StrataLabel))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a
-> [Char]
-> Either [Char] (Tristrata, StrataLabel)
-> Either [Char] (Tristrata, StrataLabel)
forall {a} {b}.
Show a =>
a -> [Char] -> Either [Char] b -> Either [Char] b
at a
i [Char]
"" ([Char] -> Either [Char] (Tristrata, StrataLabel)
parseProv [Char]
p))
[[Char]]
segs -> [Char]
-> Either
[Char]
(CadenceState, CadenceState, CadenceState,
Maybe (Tristrata, StrataLabel))
forall a b. a -> Either a b
Left ([Char]
"bar " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
": expected T | S | M [| provenance], got "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show ([[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
segs) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" segments")
trim :: [Char] -> [Char]
trim = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ') ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ')
recall :: String -> [String] -> PC.ProgressionContext
recall :: [Char] -> [[Char]] -> ProgressionContext
recall [Char]
famWord = ([Char] -> ProgressionContext)
-> (ProgressionContext -> ProgressionContext)
-> Either [Char] ProgressionContext
-> ProgressionContext
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> ProgressionContext
forall a. HasCallStack => [Char] -> a
error ProgressionContext -> ProgressionContext
forall a. a -> a
id (Either [Char] ProgressionContext -> ProgressionContext)
-> ([[Char]] -> Either [Char] ProgressionContext)
-> [[Char]]
-> ProgressionContext
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]] -> Either [Char] ProgressionContext
recallE [Char]
famWord
save :: String -> PC.ProgressionContext -> IO ()
save :: [Char] -> ProgressionContext -> IO ()
save [Char]
name ProgressionContext
pc = do
day <- TimeLocale -> [Char] -> ZonedTime -> [Char]
forall t. FormatTime t => TimeLocale -> [Char] -> t -> [Char]
formatTime TimeLocale
defaultTimeLocale [Char]
"%Y-%m-%d" (ZonedTime -> [Char]) -> IO ZonedTime -> IO [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO ZonedTime
getZonedTime
let fam = Family -> [Char]
familyWord (ProgressionContext -> Family
PC.pcFamily ProgressionContext
pc)
ls = ProgressionContext -> [[Char]]
renderChart ProgressionContext
pc
body = case [[Char]]
ls of
[] -> [[Char]
" []"]
([Char]
l : [[Char]]
rest) -> ([Char]
" [ " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
l) [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (([Char]
" , " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [[Char]]
rest [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
" ]"]
bars = ProgressionContext -> Int
PC.pcLength ProgressionContext
pc
case recallE fam ls of
Right ProgressionContext
pc' | ProgressionContext
pc' ProgressionContext -> ProgressionContext -> Bool
forall a. Eq a => a -> a -> Bool
== ProgressionContext
pc -> ([Char] -> IO ()) -> [[Char]] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ [Char] -> IO ()
putStrLn ([[Char]] -> IO ()) -> [[Char]] -> IO ()
forall a b. (a -> b) -> a -> b
$
([Char]
"-- saved " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
day [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" · " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
bars [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (if Int
bars Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then [Char]
" bar · " else [Char]
" bars · ") [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
fam)
[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ([Char]
name [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" = recall " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
fam)
[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
body
Right ProgressionContext
pc' -> [Char] -> IO ()
putStrLn ([Char]
"-- save: round-trip mismatch at bar " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show (ProgressionContext -> ProgressionContext -> Int
firstDiff ProgressionContext
pc ProgressionContext
pc') [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"; nothing emitted")
Left [Char]
err -> [Char] -> IO ()
putStrLn ([Char]
"-- save: own output failed to parse (" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
err [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"); nothing emitted")
where
firstDiff :: ProgressionContext -> ProgressionContext -> Int
firstDiff ProgressionContext
a ProgressionContext
b =
let bars' :: ProgressionContext -> [(CadenceState, CadenceState, CadenceState)]
bars' ProgressionContext
x = [CadenceState]
-> [CadenceState]
-> [CadenceState]
-> [(CadenceState, CadenceState, CadenceState)]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
zip3 (Progression -> [CadenceState]
states (ProgressionContext -> Progression
PC.triadLayer ProgressionContext
x)) (Progression -> [CadenceState]
states (ProgressionContext -> Progression
PC.strataLayer ProgressionContext
x)) (Progression -> [CadenceState]
states (ProgressionContext -> Progression
PC.modeLayer ProgressionContext
x))
states :: Progression -> [CadenceState]
states = Seq CadenceState -> [CadenceState]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Seq CadenceState -> [CadenceState])
-> (Progression -> Seq CadenceState)
-> Progression
-> [CadenceState]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Progression -> Seq CadenceState
Prog.unProgression
diffs :: [Int]
diffs = [ Int
i | (Int
i, (CadenceState, CadenceState, CadenceState)
x, (CadenceState, CadenceState, CadenceState)
y) <- [Int]
-> [(CadenceState, CadenceState, CadenceState)]
-> [(CadenceState, CadenceState, CadenceState)]
-> [(Int, (CadenceState, CadenceState, CadenceState),
(CadenceState, CadenceState, CadenceState))]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
zip3 [Int
1 :: Int ..] (ProgressionContext -> [(CadenceState, CadenceState, CadenceState)]
bars' ProgressionContext
a) (ProgressionContext -> [(CadenceState, CadenceState, CadenceState)]
bars' ProgressionContext
b), (CadenceState, CadenceState, CadenceState)
x (CadenceState, CadenceState, CadenceState)
-> (CadenceState, CadenceState, CadenceState) -> Bool
forall a. Eq a => a -> a -> Bool
/= (CadenceState, CadenceState, CadenceState)
y ]
in case [Int]
diffs of { (Int
i : [Int]
_) -> Int
i; [] -> Int
0 }