Music.Pitch.Common.Pitch

Provides a standard pitch representation.

Accidentals

data Accidental

An accidental is either flat, natural or sharp.

This representation allows for an arbitrary number of flats or sharps rather than just single and double.

The Num and Enum instances treat Accidental as the number of altered semitones, i.e. a double flat is -2, natural 0 and so on.

Instances

Enum Accidental

Eq Accidental

Integral Accidental

Num Accidental

Ord Accidental

Real Accidental

Show Accidental

Alterable Accidental

(IsPitch a, Alterable a) => IsPitch (Accidental -> a)

  Magic instance that allow us to write c sharp instead of sharpen c.

natural :: Accidental

The natural accidental.

flat :: Accidental

The flat accidental.

sharp :: Accidental

The sharp accidental.

doubleFlat :: Accidental

The double flat accidental.

doubleSharp :: Accidental

The double sharp accidental.

Inspecting accidentals

isNatural :: Accidental -> Bool

 Returns whether this is a natural accidental.

isFlattened :: Accidental -> Bool

 Returns whether this is a flat, double flat etc.

isSharpened :: Accidental -> Bool

 Returns whether this is a sharp, double sharp etc.

isStandard :: Accidental -> Bool

 Returns whether this is a standard accidental, i.e. either a double flat, flat, natural, sharp or double sharp.

Name

data Name

A pitch name.

Constructors

C

D

E

F

G

A

B

Instances

Enum Name

Eq Name

Ord Name

Show Name

Pitch

data Pitch

Common pitch representation.

Intervals and pitches can be added using .+^. To get the interval between two pitches, use .-..

Pitches are normally entered using the following literals.

 c d e f g a b

Notes with accidentals can be written by adding the s or b suffices (or two for double sharps and flats).

 cs, ds, es ...    -- sharp
 cb, db, eb ...    -- flat
 css, dss, ess ... -- double sharp
 cbb, dbb, ebb ... -- double flat

There is also a convenience syntax for entering pitches one octave up or down, using ' and _ respectively.

 g a b c'
 d c b_ c

Because of some overloading magic, we can actually write sharp and flat as postfix functions. This gives a better read:

 cs == c sharp
 db == c flat

You can of course use typical functional transformation of pitch as well. For example sharpen and flatten are the ordinary (prefix) versions of sharp and flat

 sharpen c             == c sharp       == cs
 flatten d             == d flat        == ds
 (sharpen . sharpen) c == c doubleSharp == css
 (flatten . flatten) d == d doubleFlat  == dss

Note that there is no guarantee that your pitch representation use enharmonic equivalence, so cs == db may or may not hold.

 c .+^ minor third == eb
 f .-. c           == perfect fourth

Pitches are described by name, accidental and octave number.

 c   == fromIntegral 0
 _P4 == perfect fourth   == interval Perfect 5
 d5  == diminished fifth == diminish (perfect fifth)

Instances

Enum Pitch

Eq Pitch

Num Pitch

Ord Pitch

Show Pitch

Typeable Pitch

IsPitch Pitch

Alterable Pitch

AffineSpace Pitch

mkPitch :: Name -> Accidental -> Pitch

Creates a pitch from name accidental.

name :: Pitch -> Name

Returns the name of a pitch.

To convert a pitch to a numeric type, use octaves, steps or semitones on the relevant interval type, for example:

 semitones ('a\'' .-. c)

accidental :: Pitch -> Accidental

Returns the accidental of a pitch.

See also octaves, and steps and semitones.

asPitch :: Pitch -> Pitch

This is just the identity function, but is useful to fix the type of Pitch.