具有灵活类型参数和返回值的函数？

Question

我正在尝试编写一个函数，该函数接受某种类型或其任何子类型作为其参数之一，然后返回该类型或其任何子类型的值。

[<AbstractClass>]
type Spreader () =
    abstract Fn : unit -> unit

type Fire () =
    inherit Spreader ()
    override self.Fn () = ()

type Disease () =
    inherit Spreader ()
    override self.Fn () = ()

let spread (spr:#Spreader) : #Spreader =
    match spr with
    | :? Fire -> Fire ()
    | :? Disease -> Disease ()
    | _ -> failwith "I don't get it"

显然，这行不通，但你明白我想要做什么。

首先，我在 Spreader 类型中实现了一个抽象函数，并在子类型中覆盖（覆盖？）它，但这需要向上转换，这是我试图避免的。

这可行吗？我正在研究泛型，但我还不太了解它们的 F# 实现。

编辑 2010.07.08 1730 PST

关于我使用受歧视工会的建议，我以前尝试过。我遇到的问题是，我定义为基本类型成员的任何函数都必须处理联合的每个分支。例如：

type strength = float32

type Spreader =
    | Fire of strength
    | Disease of strength

    member self.Spread () =
        match self with
        | Fire str -> Fire str
        | Disease str -> Disease str

    member self.Burn () =
        match self with
        | Fire str -> Fire str
        | _ -> failwith "Only fire burns"

Spread 函数在这里工作得很好，但如果我想要火燃烧，那么我也必须提供疾病，这是没有意义的。

我希望允许用户可能尝试做一些非法的事情，例如尝试Disease.Burn，但我不想必须在整个地方返回一堆选项类型，例如：

member self.Burn () =
    match self with
    | Fire str -> Some(Fire str)
    | _ -> None

我宁愿只留下燃烧功能严格针对火焰传播者，甚至没有为疾病传播者定义。

此外，这也适用于财产；我希望火拥有一些对疾病没有意义的成员，反之亦然。另外，我希望能够使用点表示法访问 Spreader 的强度值，因为无论如何我都会以这种方式访问​​其他成员，并且在已经定义 member.strength 后必须定义 member.strength 似乎是多余的封装在对象中。 （例如|Disease str -> ...）

当然，另一种选择是简单地将Spread和Burn函数与Spreader类型分开，但是我必须（1）为函数提供丑陋的向上转换或泛型代码（正如其他人所描述的），或者（2）对于火灾和疾病具有完全独立的功能，这在传播的情况下会很糟糕，因为我必须将它们命名为 SpreadFire 和 SpreadDisease （因为奇怪的是不允许函数重载外部类型） 。

作为一个 F# 菜鸟，我欢迎所有批评和建议。 :)

编辑 2010.07.09 0845 PST

Jon Harrop：“为什么要使用增强和成员？”

因为我的实际代码中的类型是数学密集型的，所以我' m 在初始化时预先计算某些值并将它们存储为成员。

Jon Harrop：“为什么你希望burn应用于Speader类型，而它只适用于一种类型？”

正如我所写，我不希望Burn应用于吊具。我希望它仅适用于火。然而，我在作为 Spreader 成员实现该函数和将其与 Spreader 类型分离之间左右为难。 （不一致的味道。）

Jon Harrop：“你的 Fn 成员的目的是什么？”

抱歉，那只是无关的代码，请忽略它。

Jon Harrop：“为什么使用抽象类而不是接口？”

主要是代码的可读性和效率。我讨厌仅仅为了使用其中一种方法就必须向上转型为接口。

Jon Harrop：“为什么你将 Strength 定义为 float32 的别名？”

代码可读性。

Jon Harrop：“您想要解决的实际具体问题是什么？！”

相关类型的代码共享，同时保持可读性。

有趣的是，您提供的解决方案正是我第一次尝试的解决方案（我在这个 F# 事情上只花了一周左右的时间），但我放弃了它，因为我对必须包装我的基本类型的想法感到不舒服在 DU 中作为无法重载类型定义之外定义的函数的解决方法。我只是非常担心在基本类型方面表现不佳（部分原因是 VS2010 中缺乏 F# 重构）。函数式编程现在是我非常感兴趣的一个主题，我几乎只是在寻找理解。

编辑 2010.07.09 2230 PST

实际上，我开始不喜欢函数式编程（非常同意作者的观点 http://briancarper.net/blog/315/function-programming-hurts-me -- 如果我在一个例子中看到另一个斐波那契或阶乘编码示例F# 教程或教科书，我要刺伤我找到的下一个书呆子）。

我希望这里有人会以乔恩所表现出的那种蔑视（如下）来回击我最新的回应（解释我为什么要做某些事情）。我想向傲慢的精英们学习 FP，那些自以为自己的东西不臭的程序员。

Answer 1

您可能需要显式向上转换您的返回值：

let spread (spr: Spreader) =
  match spr with
  | :? Fire -> (Fire() :> Spreader)
  | :? Disease -> (Disease() :> Spreader)

不过，这是一种非常不寻常的编程风格。你到底想做什么？

编辑

我仍然不明白你想要完成什么。为什么要使用增强和成员？为什么您希望 burn 应用于 Speader 类型，而它仅适用于一种类型？您的 Fn 会员的目的是什么？为什么使用抽象类而不是接口？为什么将 strength 定义为 float32 的别名？您想要解决的实际具体问题是什么？

怎么样：

type fire = ...

let burn fire = ...

type spreader = Disease | Fire of fire

let spread = function
  | Disease -> ...
  | Fire fire -> ...

基本上，如果您的功能仅适用于传播者的子集，那么您需要以某种方式分离关注点。要么通过新类型间接（如上所述），要么使用 OOP 并使类的子集实现接口。

Answer 2

在 F# 中，人们不经常使用实现继承（基类），因此了解您想要做什么会很有用（例如，更现实的示例会很棒）。

如果我理解正确的话，函数 spread 应该采用 Spreader 类型的子类型并返回相同类型的值。您可以这样编写函数的签名：

let foo< 'T when 'T :> Spreader >(arg:'T) : 'T =
  // some implementation here

类型参数 'T 将是 Spreader 的某个继承类，如类型签名所示，函数 foo 返回与参数相同的类型。

实现有点难看，因为您需要添加大量动态类型转换：

let foo< 'T when 'T :> Spreader >(arg:'T) : 'T =
  match box arg with 
  | :? Fire -> (box (Fire())) :?> 'T
  | :? Disease -> (box (Disease())) :?> 'T

无论如何，我同意 Brian 的观点，这似乎是一个场景，其中受歧视的联合将是更好的选择。如果您能更详细地描述您的问题，那就太好了。

---

与 Jon 和 Brian 的 spread2 的解决方案不同，上面的版本返回与作为参数获得的子类型相同的子类型，这意味着以下内容应该有效：

let fire = new Fire()
let fire2 = foo fire       // 'fire2' has type 'Fire'
fire2.FireSpecificThing()

Answer 3

您可以执行下面的 spread1 或 spread2 操作，但我想知道您是否想使用有区别的联合而不是类层次结构。

[<AbstractClass>] 
type Spreader () = 
    abstract Fn : unit -> unit 

type Fire () = 
    inherit Spreader () 
    override self.Fn () = () 

type Disease () = 
    inherit Spreader () 
    override self.Fn () = () 

let fire = new Fire()
let disease = new Disease()

let spread1<'t when 't :> Spreader>(spr:'t) : 't = 
    spr

printfn "%A" (spread1 fire)
printfn "%A" (spread1 disease)

let spread2(spr:Spreader) : Spreader = 
    match spr with
    | :? Fire -> upcast disease
    | :? Disease -> upcast fire
    | _ -> failwith "hmmm"

printfn "%A" (spread2 fire)
printfn "%A" (spread2 disease)

编辑

更新后，听起来您确实想要一个类层次结构，并且您只需执行与在 C# 中执行的操作完全相同的操作即可。所以我会这么做。顺便说一句，这

let spread (spr:Spreader) : Spreader = 
    match spr with 
    | :? Fire -> upcast Fire () 
    | :? Disease -> upcast Disease () 
    | _ -> failwith "I don't get it" 

工作正常，并且接近您的原始版本。不过，我会在基类上创建一个抽象方法 Spread 。

顺便说一句，在 F# 中您几乎从不需要“灵活类型”(#type)，如果您认为需要使用它们，通常会产生代码味道。