「メジャーC」ではなく「Cメジャー」と書く機会はありますか？

音楽プロジェクトで小さな美的問題に遭遇し、しばらくの間悩まされてきました。

タイプがdata Key = C | D | ...ありScale、a Keyとa からを構築できModeます。Mode例えば、Aメジャーとマイナースケールを区別します。

Modeタイプを関数Keyto からとして定義できますScale。その場合、モードには小文字の名前が付き（これで問題ありません）、次のようなスケールを取得できます。

aScale = major C

しかし、ミュージシャンはこのように話しません。彼らはこのスケールをメジャーCスケールではなく、Cメジャースケールと呼びます。

私が欲しいもの

理想的には書きたい

aScale = C major

これはまったく可能ですか？

私が試したもの

からa Keyを作成する関数を作成できるので、ScaleMode

aScale = c Major

しかし、キーをスケールの構築に限定することはできません。それらは他のものにも必要です（例えば、コードの構築）。またKey、のインスタンスである必要がありますShow。

追加の関数（または値コンストラクター）を使用する場合、Modeその後に置くことができKeyます。

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

しかし、余分な単語スケールは、その名前に反して騒々しく見え、scale実際にはスケールとは関係ありません。インテリジェントな部分はにありmajor、scale本当にただflip ($)です。

よりインテリジェントである必要があることnewtype Mode = Major | Minor ...を除いて、aを使用してもそれほど大きな変化はありませんscale。

aScale = scale C Major

解決策1：

これを使って

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

今、あなたは書くことができます（大文字Cと大文字Mで）

aScale = C Major

ソリューション2a：

これも可能です

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

data Scale = Scale Key Mode  

今あなたは書く

aScale = Scale C Major

ソリューション2b：

これも可能です

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

type Scale = (Key, Mode)  

今あなたは書く

aScale = (C, Major)

これは私があまりお勧めしない奇抜な解決策ですが、非常に「音楽的」に見えます。

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

その後、あなたは書くことができます

> C♮ major :: Scale

もちろん、これが本当に目的としているのは、あなたが持っているF♯ minorであろうことB♭ majorなどです。

余分な演算子を気にしなければ、&fromを使用できますData.Function。それmajorが関数Key -> Scaleであると仮定して、あなたは書くことができますC & major。それはScale値を生成します：

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

すでにいくつかの良い答えがありますが、これは役立つかもしれない継続渡しスタイルソリューションです（この特定の例ではないかもしれませんが、逆アプリケーション構文のようなものが必要な他のコンテキストでは）。

一部の問題ドメインタイプの標準的な定義を使用すると、次のようになります。

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)

継続渡しタイプを導入できます。

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

プリミティブなノート作成Contタイプを記述して、次のようにタイプを作成します。

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

次に、スケール、ノート、およびコード構築関数は、Contsをどちらかの接尾辞形式（つまり、に渡される継続として）のプレーンタイプに解決できますCont。

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

note :: Note -> Note
note = id

またはプレフィックス形式（つまり、Cont引数としてsを取る）：

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

今、あなたは書くことができます：

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

それc自体にはShowインスタンスがないことに注意してくださいc note。

Noteタイプを変更することで、二重の偶発c sharp sharp的なもの（たとえば、とは異なるd）などを簡単にサポートできます。

しかし、キーをスケールの構築に限定することはできません。それらは他のものにも必要です（例えば、コードの作成）。また、KeyはShowのインスタンスである必要があります。

タイプクラスを使用して、それを巧みに回避できます。

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

これで、適切なインスタンスを定義することで、他のタイプにも小文字を使用できます。