C#如何以函数式风格实现多态性？

Question

我有一些 OOP 代码，我想将其转换为函数式风格，仅使用不可变类型并且仅使用独立 (static) 无副作用函数。

这是一个场景的非常简化的版本：

abstract class Thing { }

class Sphere : Thing {
    public readonly double Radius;
     public Sphere(double r) { Radius = r; }
}

class Cube : Thing {
     public readonly double Side;
     public Cube(double s) { Side = s; }
}

之前，Thing 定义了一个抽象方法 void Grow(double ratio)。我已将这两个具体实现转换为独立的静态函数：

Sphere Grow(Sphere s, double ratio) => new Sphere(s.Radius*ratio);
Cube Grow(Cube c, double ratio) => new Cube(c.Side * ratio);

在 OOP 版本中，我可以使用多态性来枚举类型为 Thing 的集合并导致每个集合增长，例如：

things.foreach(x => x.Grow(r));

但是我怎样才能在函数式方法中做到这一点？我知道我可以写例如这个：

Thing Grow(Thing t, double ratio) => t switch
{
     Sphere s => Grow(s, ratio),
     Cube c => Grow(c, ratio),
     _ => throw new Exception()
};

和

things.Select(t => Grow(t, r))

但我不喜欢必须为我添加的每个新的 Thing 实现扩展 switch 表达式的想法。

我可以看到一种方法（我认为）使用反射来做到这一点，但出于其他原因我并不热衷于此。

有没有更简单的方法来使用函数模式来实现等效的 OOP 多态性？ （在 C# 中，即 - 我知道它可以在例如 Haskell 中完成）。

Answer 1

尝试像这样为Grow方法定义和使用通用接口。

interface IGrowable<T> where T: Thing { 
    T Grow(T t, double ratio);
}

class Sphere : Thing, IGrowable<Sphere> {
    public readonly double Radius;
    public Sphere(double r) { Radius = r; }
    public Sphere Grow(Sphere s, double ratio) => new Sphere(s.Radius*ratio);

}

class Cube : Thing, IGrowable<Cube> {
     public readonly double Side;
     public Cube(double s) { Side = s; }
     public Cube Grow(Cube c, double ratio) => new Cube(c.Side * ratio);
}

IEnumerable<IGrowable<T>> GrowOwn<T>(IEnumerable<IGrowable<T>> grows, double ratio){
    return grows.Select(x => x.Grow(x,ratio));
}

编辑

如果你想使用反射，定义这些类

public abstract class Thing {}

public class Sphere : Thing {
    public readonly double Radius;
    public Sphere(double r) { Radius = r; }
    public Sphere(Sphere s, double ratio){ Radius = s.Radius * ratio; }
}

public class Cube : Thing {
     public readonly double Side;
     public Cube(double s) { Side = s; }
     public Cube(Cube c, double ratio){ Side = c.Side * ratio; }
}

还有这个。

T Grow<T>(T thing, double ratio) where T: Thing => (T)Activator.CreateInstance(typeof(T) , thing,  ratio);

你可以通过这个函数获得Thing对象。
但是有MissingMethodException的风险。而且反射并不快。
（see .NET's design goal，使用表达式树可能有助于提高处理速度）