実行時に型付き関数を部分的に適用する（任意の時間型が一致する）

Question

ジェネリックプログラミング時間！

私が機能している場合：

f :: a1 -> a2 -> a3 -> ... -> an 

と値vがための右のタイプがあるfの引数のコンパイル時に知らず値

v :: aX -- where 1 <= x < n 

を（もしあれば） 、部分的にfをvに適用できますか？

実行時に関数g（下）を少し強固に構築できますか？それは実際に多形である必要はありません、私のすべての型は単形です！

g :: (a1 -> a2 -> a3 -> a4 -> a5) -> a3 -> (a1 -> a2 -> a4 -> a5) 
g f v = \x y z -> f x y v z 

私はTypeable（特にtypeRepArgs）、vはfの第三引数であるが、それは私が部分的にfを適用する方法が意味するものではありませんを使用して、ことを知っています。

私のコードは、おそらく次のようになります。

import Data.Typeable 

data Box = forall a. Box (TyRep, a) 

mkBox :: Typeable a => a -> Box 
mkBox = (typeOf a, a) 

g :: Box -> Box -> [Box] 
g (Box (ft,f)) (Box (vt,v)) = 
    let argNums = [n | n <- [1..nrArgs], isNthArg n vt ft] 
    in map (mkBox . magicApplyFunction f v) argNums 

isNthArg :: Int -> TyRep -> TyRep -> Bool 
isNthArg n arg func = Just arg == lookup n (zip [1..] (typeRepArgs func)) 

nrArgs :: TyRep -> Int 
nrArgs = (\x -> x - 1) . length . typeRepArgs 

はmagicApplyFunctionを実装できることはありますか？

編集：私はついにこれを再生しました。私は今のところ、ここで全体のソリューションを書くつもりはない

buildFunc :: f -> x -> Int -> g 
buildFunc f x 0 = unsafeCoerce f x 
buildFunc f x i = 
     let !res = \y -> (buildFunc (unsafeCoerce f y) x (i-1)) 
     in unsafeCoerce res 

Answer 1

、私はこれはData.DynamicとTypeableで純粋に行うことができると確信している：魔法適用関数です。 dynApplyとfunResultTyのソースは重要な要素を提供する必要があります：

dynApply :: Dynamic -> Dynamic -> Maybe Dynamic 
dynApply (Dynamic t1 f) (Dynamic t2 x) = 
    case funResultTy t1 t2 of 
    Just t3 -> Just (Dynamic t3 ((unsafeCoerce f) x)) 
    Nothing -> Nothing 


funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep 
funResultTy trFun trArg 
    = case splitTyConApp trFun of 
     (tc, [t1,t2]) | tc == funTc && t1 == trArg -> Just t2 
     _ -> Nothing 

物事をシンプルに保つために、私はtype Box = (Dynamic, [Either TypeRep Dynamic])を持っていると思います。後者は、引数のtyperepsのリストとして始まります。 magicApplyは、ボックス内で最初に一致するTypeRepを探し、値のDynamicを代入します。次にBoxにすべての引数がmagicappliedされているextractを持つことができます。実際にはdynApply呼び出しを実行して結果の動的結果を生成します。

Answer 2

hm ..のみ入力できますか？良い古いOverlappingInstancesはどうですか？

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies, 
UndecidableInstances, IncoherentInstances, ScopedTypeVariables #-} 

class Magical a b c where 
    apply :: a -> b -> c 

instance (AreEqual a c e, Magical' e (a -> b) c r) => Magical (a -> b) c r where 
    apply f a = apply' (undefined :: e) f a 


class Magical' e a b c where 
    apply' :: e -> a -> b -> c 

instance (r ~ b) => Magical' True (a -> b) a r where 
    apply' _ f a = f a 

instance (Magical b c d, r ~ (a -> d)) => Magical' False (a -> b) c r where 
    apply' _ f c = \a -> apply (f a) c 


data True 
data False 

class AreEqual a b r 
instance (r ~ True) => AreEqual a a r 
instance (r ~ False) => AreEqual a b r 


test :: Int -> Char -> Bool 
test i c = True 

t1 = apply test (5::Int) 
t2 = apply test 'c'