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

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

 ジョンR. R.トールキン、 
                           「ロードオブザリング」-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) 

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

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

1. magic（aka prc [] ）はパラメーター1で呼び出されます。 機能的なコンテキストで使用されるため、インスタンスは機能します
   VarArgs（a-> r） 、最終的に返される...
2. ...再び機能する ここでも引数2があります。 機能コンテキスト
3. 「qwe」と[1,2,3]は同様に処理されます
4. 最後に、以前のパラメーターと現在のパラメーター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）
  

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

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

     A -> a -> A 

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

    class ArgProc a where prc :: A -> a 

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

    instance (ArgSrc a, ArgProc r) ArgProc (a -> r) where prc :: A -> (a -> r) 

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

    instance ArgProc R1 where prc :: A -> R1 instance ArgProc R2 where prc :: A -> R2 ... 

   
   逆ポーランド表記法の例では、結果のDouble型に対してそのようなインスタンスが1つだけあります。以前に蓄積されたパラメーターのリストの計算を開始するだけです。 printfの例では、Stringのインスタンスは、フォーマットされた文字列と残りのフォーマットを単純に連結します（そこにはフラットテキストが残っていると想定されます）。 IO（）のインスタンスはさらに結果を表示します。
   
   
6. 予備計算結果Aの初期状態の初期化子は、一般的な場合、固定パラメーターのセットの関数であり、例では、定数値[]および関数です。
   
   

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

 {-# 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 (*) 

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

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

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

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

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

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

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

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

1. 可変引数
2. 多変量関数
3. テンプレートhakell
4. 存在タイプ
5. Hlist