I’ve had quite some fun recently (re)learning Haskell. My learning project is to implement braille music notation parsing in Haskell. Given that i’ve already implemented most of this stuff in C++, it gives me a great opportunity to rethink my algorithms.

Not everything I’ve had to implement until now was actually pretty. I spent yesterday evening implementing accidentals handling, which turned out to be quite a mess. However, I wanted to share my definition of the circle of fifths, because I find it rather concise.

The problem

Given a key signature (often expressed as the number of sharp or flat accidentals), tell which pitch classes are actually raised/lowered.

While reading through music notation software, I have seen several implementations of this basic concept. However, I have never seen one which was so concise.

module Accidental where

import           Data.Map (Map)
import qualified Data.Map as Map (fromList)
import qualified Haskore.Basic.Pitch as Pitch

fifths n
  | n >  0    = let [a,b,c,d,e,f,g] = fifths (n-1) in  [d,e,f,g+1,a,b,c]
  | n <  0    = let [a,b,c,d,e,f,g] = fifths (n+1) in  [e,f,g,a,b,c,d-1]
  | otherwise = replicate 7 0

Given this, we can easily define a Map of pitches to currently active accidentals/alterations. List comprehension to the rescue!

accidentals :: Int -> Map Pitch.T Pitch.Relative
accidentals k = Map.fromList [ ((o, c), a)
                             | o <- [0..maxOctave]
                             , (c, a) <- zip diatonicSteps $ fifths k
                             , a /= 0
                             ] where
  maxOctave = 9
  diatonicSteps = [Pitch.C, Pitch.D, Pitch.E, Pitch.F, Pitch.G,
                   Pitch.A, Pitch.B]

The full source code for the haskore-braille (WIP) package can be found on GitHub.

If you have any comments regarding the implementation, please drop me a mail.