Apakah ada kesempatan untuk menulis "C mayor" daripada "mayor C"?

Saya mengalami masalah estetika kecil dalam proyek musik saya dan itu telah mengganggu saya selama beberapa waktu.

Saya memiliki tipe data Key = C | D | ...dan saya dapat membangun Scaledari Keydan Mode. Yang Modemembedakan antara skala mayor dan minor.

Saya dapat mendefinisikan Modetipe sebagai fungsi dari Keyhingga Scale. Dalam hal ini mode akan memiliki nama huruf kecil (yang baik-baik saja) dan saya bisa mendapatkan Skala seperti ini

aScale = major C

Tetapi musisi tidak berbicara seperti ini. Mereka menyebut skala ini sebagai skala C mayor , bukan skala C mayor .

Apa yang saya inginkan

Idealnya saya ingin menulis

aScale = C major

Apakah ini mungkin?

Apa yang saya coba

Saya dapat membuat Keyfungsi yang membangun a Scaledari Mode, jadi saya bisa menulis

aScale = c Major

Tapi saya tidak bisa membatasi Kunci untuk membangun Timbangan. Mereka diperlukan untuk hal-hal lain juga (misalnya membangun akord ). Juga Keyharus menjadi contoh dari Show.

Saya bisa meletakkan Modesetelah Keyketika saya menggunakan fungsi tambahan (atau konstruktor nilai):

aScale = scale C major dengan scale :: Key -> Mode -> Scale

Tetapi skala kata tambahan terlihat berisik dan bertentangan dengan namanya, scaletidak terlalu peduli dengan skala. Bagian yang cerdas adalah major, scalebenar-benar adil flip ($).

Menggunakan a newtype Mode = Major | Minor ...tidak terlalu banyak berubah, kecuali scaleharus lebih pintar:

aScale = scale C Major

Solusi 1:

Gunakan ini

data Mode  = Major | Minor
data Scale = C Mode | D Mode | E Mode | F Mode | G Mode | A Mode | B Mode 

Sekarang Anda bisa menulis (dengan modal C dan modal M)

aScale = C Major

Solusi 2a:

Ini juga mungkin

data Mode  = Major | Minor
data Key   = C | D | E | F | G | A | B 

data Scale = Scale Key Mode  

Sekarang kamu menulis

aScale = Scale C Major

Solusi 2b:

Ini juga mungkin

data Mode  = Major | Minor
data Key   = C | D | E | F | G | A | B 

type Scale = (Key, Mode)  

Sekarang kamu menulis

aScale = (C, Major)

Inilah salah satu solusi aneh yang tidak saya rekomendasikan, tetapi terlihat sangat "musikal":

infix 8 ♮
(♮) :: Key -> Mode -> Scale
(♮) = (Data.Function.&)
 -- ≡ flip ($)

Maka Anda bisa menulis

> C♮ major :: Scale

Tentu saja, di mana ini benar-benar ditujukan adalah bahwa Anda juga akan memiliki F♯ minordan B♭ majorlain - lain.

Jika Anda tidak keberatan dengan operator tambahan, Anda dapat menggunakan &dari Data.Function. Dengan asumsi itu majoradalah fungsi Key -> Scale, Anda bisa menulis C & major. Itu menghasilkan Scalenilai:

Prelude Data.Function> :t C & major
C & major :: Scale

Sudah ada beberapa jawaban yang baik, tetapi inilah solusi gaya kelanjutan lewat yang mungkin membantu (mungkin bukan untuk contoh khusus ini, tetapi dalam konteks lain di mana semacam sintaks aplikasi balik diinginkan).

Dengan definisi standar untuk beberapa jenis domain masalah:

data Mode = Major | Minor                 deriving (Show)
data Key = C | D | E | F | G | A | B      deriving (Show)
data Semitone = Flat | Natural | Sharp    deriving (Show)

data Note = Note Key Semitone             deriving (Show)
data Scale = Scale Note Mode              deriving (Show)
data Chord = Chord [Note]                 deriving (Show)

Anda dapat memperkenalkan jenis kelanjutan-lewat:

type Cont a r = (a -> r) -> r

dan tulis tipe-tipe primitif untuk membangun Conttipe-tipe seperti:

a, b, c :: Cont Note r
a = mkNote A
b = mkNote B
c = mkNote C
-- etc.
mkNote a f = f $ Note a Natural

flat, natural, sharp :: Note -> Cont Note r
flat    = mkSemi Flat
natural = mkSemi Natural
sharp   = mkSemi Sharp
mkSemi semi (Note k _) f = f $ Note k semi

Kemudian, fungsi pembangunan skala, note, dan chord dapat menyelesaikan Conts ke tipe plain dalam bentuk postfix (yaitu, sebagai kelanjutan yang akan diteruskan ke Cont):

major, minor :: Note -> Scale
major n = Scale n Major
minor n = Scale n Minor

note :: Note -> Note
note = id

atau bentuk awalan (yaitu, mengambil Conts sebagai argumen):

chord :: [Cont Note [Note]] -> Chord
chord = Chord . foldr step []
  where step f acc = f (:acc)

Sekarang, Anda dapat menulis:

> c sharp note
Note C Sharp
> c note
Note C Natural
> c major
Scale (Note C Natural) Major
> b flat note
Note B Flat
> c sharp major
Scale (Note C Sharp) Major
> chord [a sharp, c]
Chord [Note A Sharp,Note C Natural]

Perhatikan bahwa citu sendiri tidak memiliki Showinstance, tetapi c notetidak.

Dengan modifikasi pada Notejenisnya, Anda dapat dengan mudah mendukung kecelakaan ganda (mis. c sharp sharp, Berbeda dari d), dll.

Tapi saya tidak bisa membatasi Kunci untuk membangun Timbangan. Mereka diperlukan untuk hal-hal lain juga (misalnya membangun akord). Juga Key harus merupakan instance dari Show.

Anda dapat menggunakan kacamata ketik untuk secara cerdik mengatasinya:

{-# LANGUAGE FlexibleInstances #-}

data Key = C | D | E | F | G | A | B deriving(Show)

data Mode = Major | Minor

data Scale = Scale Key Mode

class UsesKey t where
  c, d, e, f, g, a, b :: t

instance UsesKey Key where
  c = C
  d = D
  e = E
  f = F
  g = G
  a = A
  b = B

instance UsesKey (Mode -> Scale) where
  c = Scale C
  d = Scale D
  e = Scale E
  f = Scale F
  g = Scale G
  a = Scale A
  b = Scale B

aScale :: Scale
aScale = c Major

Sekarang, Anda juga dapat menggunakan huruf kecil untuk jenis lain dengan mendefinisikan instance yang sesuai.