🙇 💖 👨🏾‍⚕️ Haskell：可変数のパラメーターを持つ関数を実装する1つの方法について ➡️ 🚓 😻

-そして、あなたはタートル「ライク」を見ましたか？

「いいえ」とアリスは言った。 「それが誰なのかさえ知りません。」

「まあ」と女王は言った。 -これが「カメのスープのように」作られているものです。

 ルイス・キャロル 
                            「不思議の国のアリス」

「あなたのスピーチから判断すると、ファンゴーンをよく知っていますか？」 アラゴルンは返事を求めた。

-何があります！ -老人に答えた。 -これには100人の命だけでは十分ではありません。 しかし、時々ここに行きます。

 ジョンR. R.トールキン、 
                           「ロードオブザリング」-Haskellについての私の知識について

ホミネスダムドセント、ディスント。 （他の人に説明-あなたは理解します。）

 ラテン語のことわざ

Haskellの関数は本質的に1つのパラメーターの関数であることは誰もが知っています。いくつかのパラメータの「そのままの」関数は、単に最初の引数を受け入れ、（元の関数の）2番目の引数を取り、関数を返すなどの別の関数を返します。非関数型の値を既に返している最終関数（ currying ）へ。

この状況で議論できるパラメーターの可変数はどのように思えますか？ただし、 printfのソースを確認したり、wiki.haskellを読んだりすると、 FPがこの問題に対するやや「難解な」解決策ではなく、かなり美しい解決策への鍵を提供していることが明らかになります。

この出版物では、簡単な例を使用してこのようなメカニズムを実装する方法の1つを検討し、テンプレートHaskellに基づく一般化されたソリューションを提案して、リスト型の最後のパラメーターを持つ通常の関数のファミリーを「あたかも変数番号パラメーターを持つ」関数に変換します（以下、テキストは単に「可変数パラメーター付き」です）。

非常に簡単な例から始めて、ソリューションの本質を簡単に説明します。

{-# LANGUAGE FlexibleInstances, RankNTypes #-} -- (0) class VarArgs a where prc :: String -> a -- (1) instance VarArgs String where prc = id -- (2) instance (Show a, VarArgs r) => VarArgs (a -> r) where -- (3) prc acc = \x -> prc $ acc ++ " " ++ show x magic = prc [] useMagic :: (forall a. VarArgs a => a) -> IO () -- (4) useMagic f = do putStrLn $ f 1 putStrLn $ f 1 "qwe" putStrLn $ f 1 "qwe" [1, 2, 3] main :: IO () main = do putStrLn $ magic 1 2 "qwe" [1,2,3] 123.456 useMagic magic -- (5)

ここで何が起こっていますか？また、任意の数のパラメーターだけでなく、異なるタイプのパラメーターもマジック関数に渡すことができますか？

したがって、（1）では、文字列から特定の型の値を作成する方法を単に知っている単一のprcメソッドでVarArgsクラスを宣言します。さらに、（2）では、String型（[Char]とも呼ばれる）のこのクラスのインスタンスを実装します。 FlexibleInstances（0）拡張を使用する必要があることに注意してください。そうしないと、そのようなインスタンスは「違法」になります。

代替ソリューションがありますが、TypeFamilies拡張機能またはGADTも使用します。

 {-# LANGUAGE TypeFamilies #-} instance a ~ Char => VarArgs [a] where prc = id

VarArgs Stringインスタンスは、実際には可変数のパラメーターを持つ関数の「本体」です。この例では、単に蓄積されたパラメーターを返します。ここで最も興味深い部分に移りましょう。（3）では、関数型（ a- > r）のVarArgsのインスタンスを宣言しますが、引数型aが文字列にマップでき、結果型rがVarArgsクラスに再び属することを要求します。

これは、「犬が駆け抜ける」場所です。（特に）関数も許可する戻り型を持つ関数型でクラスをインスタンス化することにより、呼び出しのコンテキストに応じて、コンテキストが文字列を必要とする場合、 文字列型の最終値と関数の両方を返すprcメソッドを許可しますprc呼び出しの結果の型は、機能的としてコンテキストから推測されます。

次に、 VarArgs（a-> r）のインスタンスのprc定義を検討します。型prcを推定すると、次のようになります

 prc :: (Show a, VarArgs r) => String -> (a -> r)

つまり文字列として表される値で何かをする関数を返さなければなりません。 acc引数は、パラメーターの順次処理の結果の「ドライブ」の本質です。この場合、パラメータの文字列表現をスペースで追加します。

重要な点は、増分された「アキュムレータ」を返すだけでなく、（結果の関数の「本体」で） prcを再帰的に呼び出して、目的の結果型rを取得することです。どのprc実装が呼び出されるか（つまり、どのタイプが推論されるか）はコンテキストに依存します（Haskell関数は方程式であり、計算プロセスはパラメーターを更新する式の順次置換であることを忘れないでください）。

最も興味深いのは、「準合法」ステータスにもかかわらず、別の関数の引数として可変数のパラメーターを持つ関数を渡す（4）と使用する（5）ことです。確かに、このためには、呼び出し関数の定義（4）で別の拡張機能RankNTypes （0）とforall量指定子を使用する必要がありました。

少しわかりにくいので、（4）の$の右側の式がどのように計算されるかを見てみましょう。

magic（aka prc [] ）はパラメーター1で呼び出されます。機能的なコンテキストで使用されるため、インスタンスは機能します

VarArgs（a-> r） 、最終的に返される...
...再び機能するここでも引数2があります。機能コンテキスト
「qwe」と[1,2,3]は同様に処理されます
最後に、以前のパラメーターと現在のパラメーター123.456の蓄積された文字列表現を持つprc関数の最後の呼び出しの結果は、 putStrLn関数のパラメーターのような文字列コンテキストを既に必要とします-prcはVarArgs Stringインスタンスから起動されます

次に、もう少しやや複雑な例を考えてみましょう。逆ポーランド記法の式計算機です。次のようなもの：

 > calcRPN 5 8 (*) 2 (+) -- 5*8 + 2 42

最も原始的な実装は次のようになります。

 {-# LANGUAGE ExtendedDefaultRules, FlexibleInstances, GADTs #-} data Expr = Num Double | Op (Double -> Double -> Double) calcRPN' :: [Expr] -> Double calcRPN' = head . foldr rpnStep [] . reverse rpnStep :: Expr -> [Double] -> [Double] rpnStep (Num n) stack = n : stack rpnStep (Op f) (x:y:stack) = (fxy) : stack class ArgPrc a where prc :: [Expr] -> a class ArgSrc a where toArg :: a -> Expr instance ArgPrc Double where prc = calcRPN' . reverse instance (ArgSrc a, ArgPrc r) => ArgPrc (a -> r) where prc acc = prc . (: acc) . toArg -- (2) instance ArgSrc Expr where toArg = id instance a ~ Double => ArgSrc (a -> a -> a) where toArg = Op instance ArgSrc Integer where toArg = Num . fromIntegral instance ArgSrc String where toArg = Num . fst . head . (reads :: ReadS Double) instance ArgSrc [Double] where toArg = Num . sum calcRPN :: ArgPrc a => a calcRPN = prc [] main = do print $ calcRPN' [Num 5, Num 5, Op (*)] print $ calcRPN [1::Double,2,3] "5" (*) 7 (*)

可変数のパラメーターを実装するためのスキームは前の例と同じですが、ここでのみ：

結果をすぐに構築するのではなく、後続の処理のために（ Expr型の）引数をリストに蓄積します（2）。
「ラッパー」クラスArgSrcを使用して、「式」として機能できる型を宣言します（ Expr ）
いくつかの「トリック」（GADT拡張機能）を使用してインスタンスを実装する

インスタンスa〜Double => ArgSrc（a-> a-> a）

最後に、printf関数の回路図実装を見てみましょう。

 {-# LANGUAGE GADTs, FlexibleInstances, ExtendedDefaultRules #-} type FmtRes = (String, String) class PfVal a where doFmt :: (String, String) -> a -> FmtRes instance PfVal Integer where doFmt (fmt, res) x = let (b, s) = span (/= '%') fmt in (res ++ (tail . tail $ s), b ++ show x) instance PfVal String where doFmt (fmt, res) x = let (b, s) = span (/= '%') fmt in (res ++ (tail . tail $ s), b ++ x) class ArgProc a where prc :: FmtRes -> a instance ArgProc String where prc = uncurry (++) instance ArgProc (IO ()) where prc = putStrLn . uncurry (++) instance (PfVal a, ArgProc r) => ArgProc (a -> r) where prc st = prc . doFmt st printf fmt = prc (fmt, "") main :: IO() main = do putStrLn $ printf "%d %s" 1 "qwe" printf "%s %d" "This is" 123

コードに特別なコメントは必要ないと思います。パラメーターを蓄積する代わりに、結果を「オンザフライ」で再び生成し、 ArgProcクラスの2つのターミナルインスタンスを実装することに注意してください ： String型とIO（）型 。

図のスキームを一般化すると、次の要素を区別できます。

いくつかのタイプはバッテリーです（ Aを呼び出しましょう）。タイプaのパラメーターに基づいた予備計算結果です。「予備」の程度は、リストタイプのコンテナ内のパラメータの単純な累積（逆ポーランド表記の例のように）から、現在のパラメータセットのほぼ準備完了の結果（ printfの例のように）まで変化します。このタイプから必要なのは、タイプのオペレーションの存在だけです
```
  A -> a -> A
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```

メインクラス（ ArgProcを呼び出しましょう）。インスタンスを通じて、可変数のパラメーターのすべての「メカニクス」が実装されます。このクラスには、バッテリーAで何かを行う1つのメソッド（ prcを呼び出しましょう）があります。

 class ArgProc a where prc :: A -> a

値をパラメーター型に変換する機能をサポートするパラメーターとして機能できるタイプのクラス（ ArgSrcを呼び出しましょう）（一部のタイプaは操作:: A-> a- > Aを許可します）
パラメーターの処理と予備結果の蓄積を行うメインクラスのインスタンス：
```
 instance (ArgSrc a, ArgProc r) ArgProc (a -> r) where prc :: A -> (a -> r)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
printfを使用した例では、結果はすぐに累積され（ペアの2番目の要素）、状態は途中で処理されます（フォーマット文字列）。逆ポーランド記法を使用した例では、パラメータはリストに追加され、さらに処理されます。
予備結果の最終処理を担当するメインクラスのターミナルインスタンス：
```
 instance ArgProc R1 where prc :: A -> R1 instance ArgProc R2 where prc :: A -> R2 ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     
```
逆ポーランド表記法の例では、結果のDouble型に対してそのようなインスタンスが1つだけあります。以前に蓄積されたパラメーターのリストの計算を開始するだけです。 printfの例では、Stringのインスタンスは、フォーマットされた文字列と残りのフォーマットを単純に連結します（そこにはフラットテキストが残っていると想定されます）。 IO（）のインスタンスはさらに結果を表示します。

予備計算結果Aの初期状態の初期化子は、一般的な場合、固定パラメーターのセットの関数であり、例では、定数値[]および関数です。

  \x -> (x, "") :: String -> (String -> String)

このようなスキームは、「ブラックマジック」テンプレートHaskellの手段を使用して実装できることがわかります。これは、素材を統合するのに適した演習であり、テンプレートHaskellを試して~~タンバリン~~で~~踊るのに~~適したプラットフォームです。

現在の実装では、私は自分自身を一般的なスキームのサブセットに限定しました。ドライブはあるタイプの値のリストに過ぎず、初期化子はそれに応じて単純です[] 。このような制限には確かに不利な点がありますが、アイデアは、同じタイプのパラメーターを持つ最後のリストとさまざまな戻り値タイプを持つ通常の関数のファミリーを、可変数のパラメーター（リストに移動する固定パラメーターに加えて）を取る関数に変換することです。

途中で、指定された型からパラメーターリストの要素の型への「暗黙的なキャスト」（他のPLの用語では）のプロセスを自動化します。もう1つの制限は、「ドナー」関数には「単純な」型（量指定子と制限のない非多型型）が必要であることです。

繰り返しになりますが、すぐに使用例から始めますので、アイデアは明確になります。それから初めて実装を簡単に説明します。それでは、簡単なものから始めましょう。

 {-# LANGUAGE TemplateHaskell, FlexibleInstances, ExtendedDefaultRules #-} import Data.Function.Vargs -- (1) -- (2) tester' q (x : y : z) = putStrLn $ "Fixed parameter " ++ q ++ ", next x = " ++ x ++ " and y = " ++ y ++ " and rest = " ++ show z $( return [] ) -- (3) -- (4) defVargsFun "tester" ['tester'] (''Integer, [| ("Int " ++) . show |]) -- (5) (''(), [| const "NULL" |]) -- (6) ([t| [Int] |], [| ("[Int] " ++) . show |]) -- (7) ([t| [Double] |], [| ("[Double] " ++) . show |]) -- (8) main :: IO () main = do tester "<const>" "qwe" 100500 () [1::Int,2,3] [4::Double,5,6] -- (9)

この例では、次の型のテスター関数のテスターラッパー関数を作成します。

 tester' :: String -> [String] -> IO ()

テキストを見ていきましょう。

（1）-可変数のパラメーターを実装するモジュールを接続します
（2）-変換のための「実験的」機能を定義します
（3） -Reify操作を保証するためのトリック（詳細については、たとえば、こちら）
（4）-可変数のパラメーターを使用して関数を定義する

3番目から始まるパラメーター-いずれかのタイプの値：
- （名前、ExpQ）
- （TypeQ、ExpQ）
これらは、指定されたタイプ（整数、（）など）の値をパラメーターリスト内の要素のタイプ（String）の値に変換する方法を説明しています。タイプは、名前（（5）、（6））または式（（7）、（8））のいずれかで指定されます。要素自体も変数パラメーターとして渡されることに注意してください！
（9）-任意の順序でのさまざまなタイプの可変数のパラメーター（ストリングに縮小可能）を使用した実際の関数呼び出し

さらに進むか、逆ポーランド記法を使用して例に戻ります。

 {-# LANGUAGE TemplateHaskell, FlexibleInstances, ExtendedDefaultRules, GADTs #-} -- import Data.Function.Vargs data Expr = Num Double | Op (Double -> Double -> Double) calcRPN' :: [Expr] -> Double calcRPN' = head . foldr rpnStep [] . reverse rpnStep :: Expr -> [Double] -> [Double] rpnStep (Num n) stack = n : stack rpnStep (Op f) (x:y:stack) = (fxy) : stack $( return [] ) defVargsFun "calcRPN" ['calcRPN'] (''Integer, [| Num . fromIntegral |]) (''String, [| Num . fst . head . (reads :: ReadS Double) |]) (Genz [t| Double -> Double -> Double |], [| Op |]) -- (1) ([t| [Double] |], [| Num . sum |]) main = do print $ calcRPN' [Num 5, Num 5, Op (*)] print $ calcRPN [1::Double,2,3] "5" (+) 7 (*)

この例では、1つ興味深い点（1）を除いて、すべてが前の例と似ています。ここでは、TypeQだけでなく、GenQラッパーを使用しています。このラッパーは、ジェネレーターに次の形式のインスタンスを作成させます。

 instance a ~ Double => ArgSrc (a -> a -> a) where

標準の代わりに

 instance ArgSrc (Double -> Double -> Double) where

この場合、型チェックに合格しません。

さて、最後の例は、同じprintf関数、またはそれと類似した回路図です：

 {-# LANGUAGE TemplateHaskell, FlexibleInstances, ExtendedDefaultRules, ExistentialQuantification #-} import Data.Function.Vargs type FmtRes = (String, String) class PfVal a where doFmt :: FmtRes -> a -> FmtRes instance PfVal Integer where doFmt (fmt, res) x = let (b, s) = span (/= '%') fmt in (res ++ (tail . tail $ s), b ++ show x) instance PfVal Double where doFmt (fmt, res) x = let (b, s) = span (/= '%') fmt in (res ++ (tail . tail $ s), b ++ show x) instance PfVal String where doFmt (fmt, res) x = let (b, s) = span (/= '%') fmt in (res ++ (tail . tail $ s), b ++ x) data PfValWrap = forall a. PfVal a => Val a -- (1) printf_String :: String -> [PfValWrap] -> String -- (2) printf_String fmt vs = uncurry (flip (++)) $ foldl step (fmt, "") vs where step fmt (Val f) = doFmt fmt f printf_IO :: String -> [PfValWrap] -> IO () -- (3) printf_IO fmt = putStrLn . printf_String fmt $( return [] ) defVargsFun "printf" ['printf_String, 'printf_IO] -- (4) [''Integer, ''Double, ''String] main :: IO () main = do let fmt = "Number one is %d, number two is %f and string is \"%s\"" printf_IO fmt [Val 100, Val 123.456, Val "ok"] putStrLn $ printf fmt 100 123.456 "ok" printf fmt 100 123.456 "ok"

注目に値する3つの新しいポイントがあります。

ラッパータイプ（1）を使用して、 PfValクラスのコントラクトをサポートする任意のタイプの値を処理する（指定された形式で文字列に出力できる）
2つのパラメーターハンドラーの存在（2）-（3）異なるタイプの結果（ StringおよびIO（） ）
指定された型の値をPfValWrapラッパー型に変換するための自動コード生成（実際、唯一の型コンストラクターはリフレクションreifyを介してプルされます-Val ）

ここで、それがすべてどのように機能するかについてのいくつかの言葉実際、 defVargsFunが行うことは、 reifyから受け取った情報と、可変数のパラメーターを持つ関数自体の宣言と定義に基づいて、いくつかのクラスとインスタンスを作成することだけです。この「キッチン」はすべて、以前に例で検討された一般的なスキームに対応しています。繰り返しますが、正確に生成されたものを例で示すことは、より明確で簡単です。呼び出しによって生成されたコードを検討してください。

 defVargsFun "printf" ['printf_String, 'printf_IO] [''Integer, ''Double, ''String]

-ddump-splicesスイッチを使用してghcを実行すると、このコードが表示されます。明確にするために、フォーマットを修正し、余分な括弧を削除しました。

 class ArgPrc_printf_aa3M a where -- (1) prc_printf_aa3O :: String -> [PfValWrap] -> a -- (2) class ArgSrc_printf_aa3N a where -- (3) toArg_printf_aa3Q :: a -> PfValWrap -- (4) instance ArgPrc_printf_aa3M String where -- (5) prc_printf_aa3O a1 = printf_String a1 . reverse instance ArgPrc_printf_aa3M (IO ()) where -- (6) prc_printf_aa3O a1 = printf_IO a1 . reverse -- (7) instance (ArgSrc_printf_aa3N a, ArgPrc_printf_aa3M r) => ArgPrc_printf_aa3M (a -> r) where prc_printf_aa3O a1 acc_printf_aa3P = prc_printf_aa3O a1 . (: acc_printf_aa3P) . toArg_printf_aa3Q -- (8) instance ArgSrc_printf_aa3N PfValWrap where toArg_printf_aa3Q = id instance ArgSrc_printf_aa3N Integer where toArg_printf_aa3Q = Val instance ArgSrc_printf_aa3N Double where toArg_printf_aa3Q = Val instance ArgSrc_printf_aa3N String where toArg_printf_aa3Q = Val -- (9) printf :: forall a. ArgPrc_printf_aa3M a => String -> a printf a1 = prc_printf_aa3O a1 []

Monad Qは、ユニークな名前の生成を提供します-そのため、名前の「キャッチーな」エンディングです。テキストを見ていきましょう。

可変数のパラメーターのメインプロセッサクラス（1）とそのキーメソッド（2）が宣言されている
クラス（3）は、単一のメソッド（4）を使用して、指定された型の値をパラメーターリスト（ PfValWrap ）の要素の型に「暗黙的に変換」するために宣言されます
メインクラス（1）の「ターミナル」インスタンスは、String（5）およびIO（）（6）タイプに対して定義されます。メソッドの実装は、すべての固定パラメーターと蓄積された「変数」パラメーターのリストを指定した関数の呼び出しです。なぜならパラメータの蓄積はリストの「先頭から」実行され、「ネイティブ」関数を呼び出す前に、 リバースが呼び出されます
メインクラス（1）のインスタンス（7）は機能タイプ（ a- > r）で決定されます-ここでは、特別に作成されたクラス（3）に属するタイプの値は、メソッド（4）をパラメーターリスト要素のタイプ（ PfValWrap ）に呼び出すことで変換されます、そしてこの値をリストに入れる
さらに（8）、クラス（3）のインスタンスは、示されたすべての型+ PfValWrap型自体のインスタンスに対して決定されます（変換にはメソッド（4）が呼び出されるため、「トートロジー」が必要です）
そして最後に、ラッパー関数自体が可変数のパラメーターで宣言および定義されます

コメント付きのData.Function.Vargsモジュールのソースコードとその使用例はここにあります; haddoc形式のドキュメントはこことパッケージの一部として入手できます。現時点では、パッケージは「完全」という言葉から実験段階にあります;）

おそらく、時間の経過とともにそれを思い起こさせます-少なくとも、エラー状態（無効または互換性のないタイプ）を最大で分析および処理する必要があります。

一般化されたスキームを実装し、「親」関数で多態型をサポートします。
特に、ラッピング関数をパラメーターとして他の関数に渡す可能性のために、作成されたクラスおよびメソッドに意味のある名前を付けます。
代替の実装スキームを検討することは可能です。

それから、ハッカーに投稿するのは恥ずかしいことではないと思います（同様のトピックに関するHListのような適切なパッケージは既にありますが）。

トピックに関する役立つリンク：

Haskell：可変数のパラメーターを持つ関数を実装する1つの方法について

More articles: