Existe alguma chance de escrever "Dó maior" em vez de "Dó maior"?

Eu encontrei um pequeno problema estético no meu projeto musical e ele está me incomodando há algum tempo.

Eu tenho um tipo data Key = C | D | ...e posso construir a Scalepartir de a Keye a Mode. Os Modedistingue entre, por exemplo, um grande e um menor escala.

Eu posso definir o Modetipo como uma função de Keypara Scale. Nesse caso, os modos terão nomes em minúsculas (o que é bom) e posso obter uma escala como esta

aScale = major C

Mas músicos não falam assim. Eles se referem a essa escala como a escala C maior , não a escala C maior.

O que eu quero

Idealmente, eu gostaria de escrever

aScale = C major

Isso é possível em tudo?

O que eu tentei

Eu posso criar Keyuma função que construa a Scalede a Mode, para que eu possa escrever

aScale = c Major

Mas não posso limitar as chaves à construção de escalas. Eles são necessários para outras coisas também (por exemplo, construção de acordes ). Também Keydeve ser uma instância de Show.

Eu posso colocar o Modedepois do Keyquando eu uso uma função extra (ou construtor de valor):

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

Mas a escala extra de palavras parece barulhenta e, ao contrário do nome, scalenão está realmente preocupada com escalas. A parte inteligente está dentro major, scaleé realmente justa flip ($).

Usar um newtype Mode = Major | Minor ...realmente não muda muito, exceto que scaleprecisa ser mais inteligente:

aScale = scale C Major

Solução 1:

Usa isto

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

Agora você pode escrever (com maiúsculas C e maiúsculas M)

aScale = C Major

Solução 2a:

Isso também é possível

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

data Scale = Scale Key Mode  

Agora você escreve

aScale = Scale C Major

Solução 2b:

Isso também é possível

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

type Scale = (Key, Mode)  

Agora você escreve

aScale = (C, Major)

Aqui está uma solução extravagante que eu realmente não recomendo, mas parece muito "musical":

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

Então você pode escrever

> C♮ major :: Scale

Claro, onde isso é realmente direcionado é que você também teria F♯ minore B♭ majoretc.

Se você não se importa com um operador extra, pode usar a &partir de Data.Function. Supondo que majorseja uma função Key -> Scale, você poderia escrever C & major. Isso produz um Scalevalor:

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

Já existem várias respostas boas, mas aqui está uma solução de estilo de passagem contínua que pode ser útil (talvez não para este exemplo específico, mas em outros contextos em que é necessária uma espécie de sintaxe de aplicativo reverso).

Com definições padrão para alguns tipos de domínio com problemas:

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)

você pode introduzir um tipo de passagem de continuação:

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

e escreva os tipos primitivos de criação de notas para criar Conttipos assim:

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

Em seguida, as funções de escala, nota e construção de acordes podem resolver os Conttipos simples de s em qualquer forma de postfix (ou seja, como continuações a serem passadas para o Cont):

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

note :: Note -> Note
note = id

ou forma de prefixo (ou seja, usando Conts como argumentos):

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

Agora, você pode escrever:

> 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]

Observe que cele próprio não possui uma Showinstância, mas c notepossui.

Com uma modificação no Notetipo, você pode facilmente suportar acidentes duplos (por exemplo c sharp sharp, distintos de d), etc.

Mas não posso limitar as chaves à construção de escalas. Eles são necessários para outras coisas também (por exemplo, construção de acordes). Também Key deve ser uma instância de Show.

Você pode usar classes tipográficas para solucionar isso de maneira inteligente:

{-# 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

Agora, você também pode usar as letras minúsculas para outros tipos, definindo instâncias apropriadas.