-- |
-- Module      : Harmonic.Interface.Tidal.Recall
-- Description : Progressions as paste-able text (save \/ recall)
--
-- A generated 'PC.ProgressionContext' lives only as long as the GHCi
-- session that bound it. 'save' prints it as a chart — one bar per line,
-- the three layers side by side — shaped as a complete @name = recall …@
-- statement. Paste that into the live file and evaluating it binds the
-- identical context in any later session. The format is lossless for every
-- family: each state carries its notes (root first, in the stored
-- spelling), its stored chord name (the graph key), its approach movement
-- and, where the notes alone cannot pin it, its enharmonic spelling; strata
-- contexts carry per-bar provenance as a fourth column.
--
-- 'recall' is pure, so the pasted binding can be re-evaluated at will, and
-- lenient enough to hand-write: @"C E G (pedal)"@ names itself through the
-- corpus namer, and a bar with no movement reads as a pedal.
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

-------------------------------------------------------------------------------
-- State  <->  "notes… name (movement) [flat|sharp]"
-------------------------------------------------------------------------------

-- |Render one state. Notes come root first; the remaining intervals are
-- spelled with the stored enharmonic function. The spelling word is appended
-- only when parsing the bare text would recover a different spelling (an
-- all-natural chord whose stored spelling is the non-default one), so the
-- common case stays a plain lead sheet.
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"

-- |Parse one state. Grammar: one or more note names (first = root), then in
-- any order an optional chord name (@-@ for an empty name; absent → the
-- corpus namer), an optional @(movement)@ in @show@ form or the integer
-- form of @lead'@ (absent → pedal), and an optional @flat@ \/ @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
    -- words, except that one parenthesised group ("(asc 5)") stays whole
    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

-- The seventeen note names, matched case-insensitively on their @show@ form.
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)

-------------------------------------------------------------------------------
-- Context  <->  chart lines
-------------------------------------------------------------------------------

-- |The family keyword 'save' prints and 'recall' expects.
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")

-- |One line per bar: @T | S | M@, plus @| tristrata strata@ when the context
-- carries provenance. Columns are padded so the separators line up.
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")

-- |Rebuild a context from its family keyword and chart lines; the total
-- form of 'recall' for callers that want the error rather than a crash.
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
' ')

-- |Bind a saved chart back to a context. The first argument is the family
-- keyword 'save' printed; each string is one bar, @T | S | M@ states
-- separated by bars, with an optional fourth @tristrata strata@ column.
-- Malformed text raises an error naming the bar and column.
--
-- @
-- verse = recall "triad"
--   [ "D F A min (pedal)  | D F G A C minadd11 (pedal) | …"
--   , "A C E min (desc 5) | …"
--   ]
-- @
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

-- |Print a context as a complete, paste-ready @name = recall …@ statement:
--
-- @
-- save "verse" s
-- -- saved 2026-10-17 · 4 bars · triad
-- verse = recall "triad"
--   [ "D F A min (pedal)  | … | …"
--   , …
--   ]
-- @
--
-- Copy the block into the live file; evaluating it next session binds
-- @verse@ equal to @s@ (every layer, name, movement, spelling and strata
-- provenance). The text is parsed back and compared before printing, so a
-- block that would not round-trip is reported instead of emitted.
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 }