Question

是否可以创建一个在编译时从模板haskell引号外部重写haskell代码的函数？

例如：

differentiate :: Floating a => (a -> a) -> a -> (a,a)
differentiate = -- what goes here?

f :: Num a => a -> a
f = sin

g :: Num a => a -> (a,a)
g = differentiate f

并在编译时将g转换为：

g x = (sin x, cos x)

我希望我的“区分”函数能够传递给“f”的AST并让我在编译之前重写它。据我所知，你不能在模板haskell中做到这一点而不传递函数的完整语法，即“g =区分罪”。

谢谢

Answer 1

您正在谈论计划中的宏。答案是不。 Haskell函数必须是“引用透明”，这意味着如果你给它两个指称相等的参数，结果必须在表示上相等。即，每个 f都必须

f (1 + 1) = f 2

如果f是宏，则不一定如此。然而，这个属性对于语言的“纯度”至关重要 - 是什么让Haskell很好地推理和重构。

然而，在Haskell中有automatic differentiation的大量工作，其中没有一个需要宏系统 - 抽象建模（以及使类看起来很好的类型类）都是必要的。

Answer 2

如果您愿意使用自己的一组数学函数和数字，理论上可以这样做。您需要做的是创建一个跟踪每个函数计算方式的类型系统。然后，这将反映在表达式的类型中。使用模板haskell和reify函数，或使用类型类代码，然后您可以在编译时生成正确的代码。

这是一个使用类型类的hacky示例实现。它适用于sin，cos，常量和加法。实施全套操作将需要做很多工作。此外，代码中存在相当多的重复，如果您计划使用此类方法，则应尝试解决该问题：

{-# LANGUAGE ScopedTypeVariables, UndecidableInstances, FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies #-}
module TrackedComputation where
import Prelude hiding (sin, cos, Num(..))
import Data.Function (on)
import qualified Prelude as P    

-- A tracked computation (TC for short).
-- It stores how a value is computed in the computation phantom variable
newtype TC newComp val = TC { getVal :: val }
    deriving (Eq)

instance (Show val) => Show (TC comp val) where
    show = show . getVal


data SinT comp = SinT
data CosT comp = CosT

data AddT comp1 comp2 = AddT

data ConstantT = ConstantT

data VariableT = VariableT

sin :: (P.Floating a) => TC comp1 a -> TC (SinT comp1) a
sin = TC . P.sin . getVal
cos :: (P.Floating a) => TC comp1 a -> TC (CosT comp1) a
cos = TC . P.cos . getVal

(+) :: (P.Num a) => TC comp1 a -> TC comp2 a -> TC (AddT comp1 comp2) a
(TC a) + (TC b) = TC $ (P.+) a b

toNum :: a -> TC ConstantT a
toNum = TC

class Differentiate comp compRIn compROut | comp compRIn -> compROut where
    differentiate :: P.Floating a => (TC VariableT a -> TC comp a) -> (TC compRIn a -> TC compROut a)


instance Differentiate ConstantT compIn ConstantT where
    differentiate _ = const $ toNum 0

instance Differentiate (SinT VariableT) compIn (CosT compIn) where
    differentiate _ = cos
instance Differentiate VariableT compIn (ConstantT) where
    differentiate _ = const $ toNum 1

instance (Differentiate add1 compIn add1Out, Differentiate add2 compIn add2Out) =>
    Differentiate (AddT add1 add2) compIn (AddT add1Out add2Out) where
    differentiate _ (val :: TC compROut a) = result where
        first = differentiate (undefined :: TC VariableT a -> TC add1 a) val :: TC add1Out a
        second = differentiate (undefined :: TC VariableT a -> TC add2 a) val :: TC add2Out a
        result = first + second

instance P.Num val => P.Num (TC ConstantT val) where
    (+) = (TC .) . ((P.+) `on` getVal)
    (*) = (TC .) . ((P.*) `on` getVal)
    abs = (TC) . ((P.abs) . getVal)
    signum = (TC) . ((P.signum) . getVal)
    fromInteger = TC . P.fromInteger

f x = sin x

g = differentiate f

h x = sin x + x + toNum 42 + x

test1 = f . toNum
test2 = g . toNum
test3 = differentiate h . toNum

在模板haskell范围之外编译时间代码重写？

2 个答案: