Generics 向量运算的F#型约束

我想用F#编写一些通用函数和类型来处理向量。我使用静态

（+）

和

（*）

运算符有多种不同的数据类型，因此我可以将它们相加，然后用标量相乘（

float

s）

例如，我成功地构建了一个

Vec2

类，可以在其中编写代码

let v = 3.0 * Vec2(1.,1.) + Vec2(3.,4.)

假设我还有一个

Vec3

或任何其他类型的向量。下面是我想写的两个示例（伪代码）：

向量上的泛型函数 我认为这是可能的，静态解析类型约束断言

'V

有

（+）

和

（*）

，但我无法让它工作。如果我能按如下方式命名我的类型约束，那就太好了

let average<'V when 'V : vector> (v1:'V) (v2:'V) =
    0.5 * (v1 + v2)

举个简单的例子，

f:VecFunc

可以存储一个函数，该函数取

int

x

并返回一个

Vec2

，两个分量都等于

float x

。也许我们可以通过调用

Eval

方法来评估底层函数：

f.Eval(3) // would return Vec2(3.,3.)

我想把

VecFunc

当作一个向量类型，给它

（+）

和

（*）

运算，这样我就可以计算了

(-2.0 * f + f).Eval(2) // returns Vec2(-4., -4.)

或者将其与第一个示例相结合：

(average f g).Eval(1) // ...

---

有没有办法使用F#接口或类型参数来实现这些结果？

您可以通过要求向量类型（以及向量上的函数）实现某些运算符来实现这些结果。基于您的示例，我假设您已经有了

+

用于

Vec2

和

*

用于向量与标量的乘法。您可以根据这些运算符编写

average

函数，然后它将在具有这些运算符的任何类型上工作

唯一的问题是F#以某种特殊的方式处理

*

，因此如果您的

*

类型为

float*vector->vector

，您就无法轻松做到这一点。如果您使用

*

进行矢量标量乘法（类似地，您可以将

*.

添加到另一个方向），它似乎可以正常工作

以下是我对这些运算符的

Vec2

和

Vec3

的定义：

type Vec2(a:float, b:float) = 
  member x.A = a
  member x.B = b
  static member (.*) (a:float, v:Vec2) = 
    Vec2(a*v.A, a*v.B)
  static member (+) (v1:Vec2, v2:Vec2) = 
    Vec2(v1.A+v2.A, v1.B+v2.B)

type Vec3(a:float, b:float, c:float) = 
  member x.A = a
  member x.B = b
  member x.C = c
  static member (.*) (a:float, v:Vec3) = 
    Vec3(a*v.A, a*v.B, a*v.C)
  static member (+) (v1:Vec3, v2:Vec3) = 
    Vec3(v1.A+v2.A, v1.B+v2.B, v1.C+v2.C)

现在，您可以将

average

编写为使用静态成员约束的内联函数：

let inline average (v1:^V) (v2:^V) =
  (^V : (static member (.*) : float * ^V -> ^V) (0.5, v1 + v2))

average (Vec2(1.,1.)) (Vec2(3.,4.))
average (Vec3(1.,1.,1.)) (Vec3(3.,4.,5.))

如果使用

+

操作符，F#会自动添加一个约束，因此我可以只编写

v1+v2

。

*

操作符是非标准的，因此我必须显式地调用它

对于问题的第二部分，正如您所指出的，F#类型不能由具有静态类型约束的其他类型参数化，因此这样做需要更多技巧。您可以选择添加所需的操作作为类型的参数，然后使用

inline

函数捕获操作并将其作为常规函数传递给

VecFunc

类型。以下是一个例子：

type VecFunc<'T1, 'T2>(f:'T1 -> 'T2, mult:float * 'T1 -> 'T1, add:'T2 * 'T2 -> 'T2) = 
  member x.F = f
  member x.Mult = mult
  member x.Add = add
  static member (.*) (a:float, f:VecFunc<_, _>) = 
    VecFunc((fun v -> f.F (f.Mult(a, v))), f.Mult, f.Add)
  static member (+) (f1:VecFunc<_, _>, f2:VecFunc<_, _>) = 
    VecFunc((fun v -> f1.Add(f1.F v, f2.F v)), f1.Mult, f1.Add)

let inline vfunc (f:^V -> ^T) = 
    VecFunc< ^V, ^T>(f, 
      (fun (a, b) -> (^V : (static member (.*) : float * ^V -> ^V) (a, b))),
      (fun (a, b) -> a + b))

let vf = vfunc (fun (v:Vec2) -> v + v)
average vf vf 

type VecFunc（f:'T1->'T2，mult:float*'T1->'T1，add:'T2*'T2->'T2）=
成员x.F=F
成员x.Mult=Mult
成员x.添加=添加
静态成员（.*）（a:float，f:VecFunc）=
VecFunc（（乐趣v->f.f（f.Mult（a，v））），f.Mult，f.Add）
静态成员（+）（f1:VecFunc，f2:VecFunc）=
VecFunc（（fun v->f1.Add（f1.F v，f2.F v）），f1.Mult，f1.Add）
让内联vfunc（f:^V->^T）=
VecFunc<^V，^T>（f，
（fun（a，b）->（^V：（静态成员（.*）：float*^V->^V）（a，b）），
（乐趣（a，b）->a+b）
让vf=vfunc（乐趣（v:Vec2）->v+v）
平均心室颤动

---

这种类型会检查，但我不确定它是否正确（我不确定向量函数的加法和乘法应该做什么！）-但无论如何，它可能会帮助您找到正确的方向。

谢谢！经过进一步研究，F#类型似乎不接受类型参数上的静态解析约束，因此我并不乐观。不，它们不接受-但您可以在inde

inline

函数中捕获操作，然后将它们作为常规函数传递给泛型类型。我对答案进行了编辑，添加了一个示例（可能是错误的，但应该说明这个想法）。

type VecFunc<'T1, 'T2>(f:'T1 -> 'T2, mult:float * 'T1 -> 'T1, add:'T2 * 'T2 -> 'T2) = 
  member x.F = f
  member x.Mult = mult
  member x.Add = add
  static member (.*) (a:float, f:VecFunc<_, _>) = 
    VecFunc((fun v -> f.F (f.Mult(a, v))), f.Mult, f.Add)
  static member (+) (f1:VecFunc<_, _>, f2:VecFunc<_, _>) = 
    VecFunc((fun v -> f1.Add(f1.F v, f2.F v)), f1.Mult, f1.Add)

let inline vfunc (f:^V -> ^T) = 
    VecFunc< ^V, ^T>(f, 
      (fun (a, b) -> (^V : (static member (.*) : float * ^V -> ^V) (a, b))),
      (fun (a, b) -> a + b))

let vf = vfunc (fun (v:Vec2) -> v + v)
average vf vf