功能上相当于重载

Question

在函数式编程中我应该采取什么方法来重载方法（提供一个或多个具有相同函数名称的不同签名）。

我是函数式编程的新手，所以目前我还没有真正理解这一点。

例如，在 C# 中，我有以下内容：

public int LowestCommonMultiple(int a, int b)
{
    return (a * b) / GreatestCommonFactor(a, b); // details ommited
}

public int LowestCommonMultiple(List<int> integers)
{
    int commonMultiple = integers[0];
    foreach(var integer in integers)
    {
        commonMultiple = LowestCommonMultiple(commonMultiple, i);
    }
    return commonMultiple;
}

谢谢，

编辑：我不需要 C# 中的答案，我的问题更多的是函数式 pargadim 问题，例如，在 Haskell 中考虑它。我认为重载方法不是一种选择。

Answer 1

在 Haskell 中，重载是使用类型类完成的。这与 C# 中的重载有很大不同，因为类型类与 C# 中的接口更相似，尽管它们也更强大*。

例如，要拥有一个能够接受 Integer 或 Bool 的函数，您可以编写如下内容：

class Foo a where
    foo :: a -> String

instance Foo Integer where
    foo n = show (n+42)

instance Foo Bool where
    foo b = if b then "Hello" else "Goodbye"

在解释器中测试它，我们看到函数 foo 具有带有约束的类型。

*Main> :t foo
foo :: Foo a => a -> String

这意味着该函数适用于我们为其定义了 Foo 实例的类型 a。

*Main> foo 1295
"1337"
*Main> foo False
"Goodbye"

如果我们尝试在没有此类实例的类型上使用它，我们会收到错误。

*Main> foo "Hello"

<interactive>:1:1:
    No instance for (Foo [Char])
      arising from a use of `foo'
    Possible fix: add an instance declaration for (Foo [Char])
    In the expression: foo "Hello"
    In an equation for `it': it = foo "Hello"

对于你的例子，我认为在 Haskell 中以这种方式重载这个函数不是很有用。事实上，标准库中的lcm函数已经被重载了。

*Main> :t lcm
lcm :: Integral a => a -> a -> a

这意味着它适用于任何有 Integral 实例的类型。在本例中，这就是所有类似整数的类型，包括机器大小的 Int、任意大小的 Integer 以及其他类型，例如 Int32 、Int64 等等。

列表版本可以写为 foldl1' lcm，因此可能不需要首先提供这样的重载。

_{* 一方面，类型类实例与它们所应用的对象分开传递。这使得多重调度之类的事情变得更加清晰。这也意味着您可以重载函数的返回类型，这在 C# 中是不可能的。类型类也可以与类型构造函数一起使用； Monad 也许是此类类型中最著名的示例。}

Answer 2

我不确定你所说的函​​数式编程语言是什么意思，这似乎与任何编程语言的特定功能（例如，支持重载）有关，而不是它是函数式的还是面向对象的。例如，在 Javascript 中，它不受支持，但很容易模拟，因为 javascript 不需要传递参数并且不是强类型的。

// a: array or integer
// b: optional integer when a is integer
function LowestCommonMultiple(a, b)
{
    // could also test for presence of b, other validation checking probably good
    if (a instanceof Array) {
       // array code
    } else {
       return (a * b) / GreatestCommonFactor(a, b); // details ommited
    }
}

答案将取决于所讨论语言的具体功能。

Answer 3

我认为你的问题与函数式编程与过程式/面向对象编程没有太大关系，而是与静态变量类型与动态变量类型有关。

以SML（ML的一种方言）和Scheme/Lisp为例。两种函数式语言，但是在 SML 中重载函数是理所当然的，而在Scheme 中则不可能（至少在我还在使用它时是这样）。
SML 是静态类型的（如 C/C++/JAVA 等），因此编译器使用变量类型作为签名的一部分并创建重载不是问题，就像任何 C 编译器为 C 代码创建它们一样。另一方面，Scheme 是动态类型的，因此编译器/解释器无法在编译时（在大多数情况下）根据其参数找出方法的签名。

你的问题是非常跨语言的（我什至不认为所有静态类型语言都支持函数/方法重载），所以它总是取决于你使用的语言（有时是实现）。

Answer 4

您可以通过一次重构编写任意数量的签名 - 不能有 2 个具有相同参数类型的签名。每个签名都可以有它自己的返回类型

void SomeMethor(){...}
string SomeMethod(string s){...}
object SomeMethod(string s, int i){...}