Composition.Notes

This module contains some data structures for describing note sequences and time signatures, and a QuasiQuoter for note sequences.

Documentation

data Accidental

Accidentals.

Constructors

Flat

Natural

Sharp

Instances

Eq Accidental

Defined in Composition.Notes

Methods

(==) :: Accidental -> Accidental -> Bool

(/=) :: Accidental -> Accidental -> Bool

Show Accidental

Defined in Composition.Notes

Methods

showsPrec :: Int -> Accidental -> ShowS

show :: Accidental -> String

showList :: [Accidental] -> ShowS

data Natural_note_name

Natural note names for algorithmic convenience.

Constructors

C_natural

D_natural

E_natural

F_natural

G_natural

A_natural

B_natural

Instances

Enum Natural_note_name

Defined in Composition.Notes

Methods

succ :: Natural_note_name -> Natural_note_name

pred :: Natural_note_name -> Natural_note_name

toEnum :: Int -> Natural_note_name

fromEnum :: Natural_note_name -> Int

enumFrom :: Natural_note_name -> [Natural_note_name]

enumFromThen :: Natural_note_name -> Natural_note_name -> [Natural_note_name]

enumFromTo :: Natural_note_name -> Natural_note_name -> [Natural_note_name]

enumFromThenTo :: Natural_note_name -> Natural_note_name -> Natural_note_name -> [Natural_note_name]

Eq Natural_note_name

Defined in Composition.Notes

Methods

(==) :: Natural_note_name -> Natural_note_name -> Bool

(/=) :: Natural_note_name -> Natural_note_name -> Bool

Show Natural_note_name

Defined in Composition.Notes

Methods

showsPrec :: Int -> Natural_note_name -> ShowS

show :: Natural_note_name -> String

showList :: [Natural_note_name] -> ShowS

data Note

Note. The first argument is the octave.

Constructors

Note Int Note_name

Instances

Enum Note

Defined in Composition.Notes

Methods

succ :: Note -> Note

pred :: Note -> Note

toEnum :: Int -> Note

fromEnum :: Note -> Int

enumFrom :: Note -> [Note]

enumFromThen :: Note -> Note -> [Note]

enumFromTo :: Note -> Note -> [Note]

enumFromThenTo :: Note -> Note -> Note -> [Note]

Eq Note

Defined in Composition.Notes

Methods

(==) :: Note -> Note -> Bool

(/=) :: Note -> Note -> Bool

Ord Note

Defined in Composition.Notes

Methods

compare :: Note -> Note -> Ordering

(<) :: Note -> Note -> Bool

(<=) :: Note -> Note -> Bool

(>) :: Note -> Note -> Bool

(>=) :: Note -> Note -> Bool

max :: Note -> Note -> Note

min :: Note -> Note -> Note

Show Note

Defined in Composition.Notes

Methods

showsPrec :: Int -> Note -> ShowS

show :: Note -> String

showList :: [Note] -> ShowS

Lift Note

Defined in Composition.Notes

Methods

lift :: Note -> Q Exp

data Note_name

Note names. Double accidentals are not supported.

Constructors

C_flat

C

C_sharp

D_flat

D

D_sharp

E_flat

E

F_flat

E_sharp

F

F_sharp

G_flat

G

G_sharp

A_flat

A

A_sharp

B_flat

B

B_sharp

Instances

Enum Note_name

Defined in Composition.Notes

Methods

succ :: Note_name -> Note_name

pred :: Note_name -> Note_name

toEnum :: Int -> Note_name

fromEnum :: Note_name -> Int

enumFrom :: Note_name -> [Note_name]

enumFromThen :: Note_name -> Note_name -> [Note_name]

enumFromTo :: Note_name -> Note_name -> [Note_name]

enumFromThenTo :: Note_name -> Note_name -> Note_name -> [Note_name]

Eq Note_name

Defined in Composition.Notes

Methods

(==) :: Note_name -> Note_name -> Bool

(/=) :: Note_name -> Note_name -> Bool

Ord Note_name

Defined in Composition.Notes

Methods

compare :: Note_name -> Note_name -> Ordering

(<) :: Note_name -> Note_name -> Bool

(<=) :: Note_name -> Note_name -> Bool

(>) :: Note_name -> Note_name -> Bool

(>=) :: Note_name -> Note_name -> Bool

max :: Note_name -> Note_name -> Note_name

min :: Note_name -> Note_name -> Note_name

Show Note_name

Defined in Composition.Notes

Methods

showsPrec :: Int -> Note_name -> ShowS

show :: Note_name -> String

showList :: [Note_name] -> ShowS

Lift Note_name

Defined in Composition.Notes

Methods

lift :: Note_name -> Q Exp

data Note_name'

An alternative representation of note names that is more convenient for algorithms.

Constructors

Note_name' Natural_note_name Accidental

Instances

Eq Note_name'

Defined in Composition.Notes

Methods

(==) :: Note_name' -> Note_name' -> Bool

(/=) :: Note_name' -> Note_name' -> Bool

Show Note_name'

Defined in Composition.Notes

Methods

showsPrec :: Int -> Note_name' -> ShowS

show :: Note_name' -> String

showList :: [Note_name'] -> ShowS

type Rat = Ratio Int

Rationals with limited numerators and denominators for representing note lengths.

data Simultaneous

A collection of notes of same length that sound simultaneously. Non-positive length will result in runtime errors when attempting to generate Lilypond and MIDI files.

Constructors

Simultaneous [Note] Rat

Instances

Show Simultaneous

Defined in Composition.Notes

Methods

showsPrec :: Int -> Simultaneous -> ShowS

show :: Simultaneous -> String

showList :: [Simultaneous] -> ShowS

Lift Simultaneous

Defined in Composition.Notes

Methods

lift :: Simultaneous -> Q Exp

data Time

Time signature. The first argument describes the subdivisions of the bar. For example, 2 beats per bar is encoded as [2], 3 as [3], 4 as [2, 2], 6 as [2, 3], 9 as [3, 3]. The second argument is the inverse of the length of the beat. Note that non-positive numbers in either numerator or denominator will result in errors, and Lilypond does not accept denominators that are not a power of two.

Constructors

Time [Int] Int

Instances

Show Time

Defined in Composition.Notes

Methods

showsPrec :: Int -> Time -> ShowS

show :: Time -> String

showList :: [Time] -> ShowS

data Time_and_position

Time signature and the starting position of the first bar. For example, if the piece starts with a full bar, the initial position is 0. If the piece is in 34 and starts with a 14-note bar, the initial position is 1/2.

Constructors

Time_and_position Time Rat

Instances

Show Time_and_position

Defined in Composition.Notes

Methods

showsPrec :: Int -> Time_and_position -> ShowS

show :: Time_and_position -> String

showList :: [Time_and_position] -> ShowS

construct_note_name :: Note_name' -> Note_name

Construct the note name from a natural note name and an accidental.

deconstruct_note_name :: Note_name -> Note_name'

Deconstruct a note name into the natural note name and the accidental.

ly :: QuasiQuoter

A QuasiQuoter for compile-time parsing of note sequences. The syntax is loosely based on Lilypond. Some example of use:

• An empty note sequence: [ly||].
• A single note: [ly|<C0>1|].
• Two consecutive notes: [ly|<C0>1 <C0>1|].
• A rest, a single note and two simultaneous notes: [ly|<>1 <C0>1 <C0 D0>1|].
• All natural notes from C to B: [ly|<C0 D0 E0 F0 G0 A0 B0>1|].
• Accidentals: [ly|<Cb0 C0 C#0>1|].
• Different octaves: [ly|<C-1 C0 C1>1|].
• Rests of length 1/3, 1/2, 2/3, 1, 3/2, 2 and 3: [ly|<>3 <>2 <>3~3 <>1 <>1. <>1~1 <>1~1~1|].

measure_length :: Time -> Rat

The length of one measure.

sequential_length :: [Simultaneous] -> Rat

The length of a note sequence.

simultaneous_length :: Simultaneous -> Rat

The length of a collection of notes.

subdivision :: Time -> Time

Discards the topmost division of the bar. For example, 1/1 is transformed into 1/2, 2/2 into 1/2, 3/4 into 1/4, 4/4 into 2/4, 6/8 into 3/8, 9/16 into 3/16.