标签: multiple-dispatch

我想了解多次发送是什么.我阅读了很多不同的文本,但我仍然不知道多重发送是什么以及它有什么好处.也许我缺少的是使用多个调度的代码片段.请问,您是否可以使用多个调度在C++中编写一小段代码,以便我可以看到它无法正确编译/运行,因为C++只有单个调度？我需要看到差异.谢谢.

我是朱莉娅的新手,鉴于我的Matlab起源,我在确定如何编写利用多个调度和Julia的类型系统的"好"Julia代码时遇到了一些困难.

考虑我有一个提供a的平方的函数的情况Float64.我可以这样写:

function mysquare(x::Float64)
    return(x^2);
end

有时,我想Float64在一维数组中对所有s 进行平方,但不想mysquare每次都写出一个循环,所以我使用多次调度并添加以下内容:

function mysquare(x::Array{Float64, 1})
    y = Array(Float64, length(x));
    for k = 1:length(x)
        y[k] = x[k]^2;
    end
    return(y);
end

但是现在我有时正在使用Int64,所以我写了两个利用多个调度的函数:

function mysquare(x::Int64)
    return(x^2);
end
function mysquare(x::Array{Int64, 1})
    y = Array(Float64, length(x));
    for k = 1:length(x)
        y[k] = x[k]^2;
    end
    return(y);
end

这是正确的吗？或者是否有更具思想性的方法来应对这种情况？我应该使用这样的类型参数吗？

function mysquare{T<:Number}(x::T)
    return(x^2);
end
function mysquare{T<:Number}(x::Array{T, 1})
    y = Array(Float64, length(x));
    for k = 1:length(x)
        y[k] = x[k]^2;
    end
    return(y);
end

这感觉很合理,但我的代码运行速度会与避免参数类型的情况一样快吗？

总之,我的问题分为两部分:

1. 如果快速代码对我很重要,我应该如上所述使用参数类型,还是应该为不同的具体类型写出多个版本？或者我应该完全做其他事情？ …

......还是他们一样的东西？我注意到每个都有自己的维基百科条目:多态,多重调度,但我很难看到概念的不同之处.

编辑:重载如何适应这一切？

我正在努力理解单个和多个调度是什么.

我刚刚读到这个:http:
//en.wikipedia.org/wiki/Multiple_dispatch

从这个定义来看,我认为C#和VB.Net是多分派的,即使在编译时选择要调用的重载也是如此.

我在这里是正确的,还是我错过了什么？谢谢!

我一直在阅读http://c2.com/cgi/wiki?ImplementingMultipleDispatch

我一直在寻找关于Julia如何实现多方法的参考.调度的运行时复杂性是什么,它是如何实现的？

我想在Python中使用重载。我知道这在设计上是不可能的（Python 是动态类型语言），这里有关于这个主题的很好的帖子。这就是为什么我可以使用诸如多重调度（多方法）之类的东西。我正在考虑最好的解决方案，即为任何函数或类方法实现多重分派。Python 中是否有原生包含的解决方案？

在我的例子中，使用 singledispatch （在 3.4 中添加到 Python 中）是不够的（因为只考虑第一个参数的类型，而我需要multiple）。

我还知道我可以使用关键字参数（即具有单个函数并通过检查所有参数来驱动行为），但是当您有很多参数和组合时，它会变得复杂。

到目前为止，我能够找到这两个库（不包含在Python标准库中）：

• multimethod - 提供一个装饰器，用于向函数添加多个参数分派，可以使用与functools.singledispatch相同的注册风格，与注释配合良好，甚至可以与带注释的谓词配合使用，或者multimeta为类提供特殊的命名空间
• multipledispatch - 还提供用于多参数分派的装饰器，不适用于注释，并且与以前的库相比，对我来说看起来不太强大

基本用法如下：

from multimethod import multimethod

@multimethod
def add(x: int, y: int):
    ...

@multimethod
def add(x: str, y: str):
    ...

或者

from multipledispatch import dispatch

@dispatch(int, int)
def add(x, y):
    ...

@dispatch(str, str)
def add(x, y):
    ...

这个功能看起来非常相似。

我主要有两个问题：

• 这些多重调度实现中的一种是否比另一种带来任何（不利）优势？（例如支持的类型，速度，性能，限制，...）它似乎具有可比性，但我对此不确定，因为后者（multipledispatch）似乎更受欢迎（检查 GitHub 星星）但维护较少（我什至会说不成熟）。
• 是否还有其他解决方案（即使是包含在 Python 标准库中的解决方案）？

首先：raku (perl6) 很棒。克罗也是。只用了一个周末就坠入爱河。但是现在我偶然发现了一些必须非常简单的东西。

如果我在多分派 MAIN 中使用 slurpy 参数，则可以识别并完美运行：

multi MAIN( 'config', 'add', *@hostnames ) {

但是，如果我将其设为非 slurpy 数组，则要么无法识别，要么我不知道如何从命令行提供它：

multi MAIN( 'config', 'add', @hostnames ) {

我希望这些调用之一能够工作：

$ cli.raku config add www.example.com example.com
$ cli.raku config add www.example.com,example.com
$ cli.raku config add www.example.com, example.com

Cro CLI 中使用了类似的构造，但是没有示例说明如何使用文档中的数组调用其中一个命令。

我也用一个数组作为命名参数尝试了这个：

my %*SUB-MAIN-OPTS = :named-anywhere;
multi MAIN( 'config', 'add', :@hostnames) {

鉴于raku 文档中的示例，我希望它可以工作：

$ cli.raku config add --hostnames=www.example.com example.com

但它没有，也没有逗号或空格逗号分隔的变体。在所有情况下，我都会获得使用信息。

我想知道是否有可能在OCaml中构建类似于多个调度的东西.为此,我尝试为多方法的输入签名创建一个显式类型.例如,我定义了一个数字类型

type _ num =
| I : int -> int num
| F : float -> float num

现在我想要一个函数add来求和a 'a num和a 'b num并返回一个int numif 'a和'bare int,并且float num如果它们中至少有一个是a float.此外,类型系统应该知道输出将使用哪个构造函数.也就是说,在函数调用中应该静态地知道输出是类型int num的.

那可能吗？到目前为止,我只能管理签名函数type a b. a num * b num -> a num,因此总是必须提供(更一般的)float作为第一个参数.int num * float num必须不允许这种情况,导致非穷举模式匹配和运行时异常.

似乎需要一个签名,例如type a b. a num * b num -> c(a,b) numwhere c类型函数包含类型提升规则.我不认为OCaml有这个.打开的类型或对象能够捕获这个吗？我不是在寻找类型之间最常用的函数,如果我可以明确地列出少数输入类型组合和相应的输出类型就足够了.

我想知道Java7的新invokedynamic字节码指令是否可用于实现Java语言的多个调度.java.lang.invoke下的新API是否有助于执行此类操作？

我正在思考的场景如下所示.(这看起来像访问者设计模式的应用案例,但可能有理由认为这不是一个可行的选择.)

class A {} 
class A1 extends A {}
class A2 extends A {}

class SomeHandler {
    private void doHandle(A1 a1) { ... }
    private void doHandle(A2 a2) { ... }
    private void doHandle(A a) { ... }

    public void handle(A a) {
        MultipleDispatch.call(this, "doHandle", a);
    }
}

然后库类MultipleDispatch会做类似的事情:

class MultipleDispatch {

    public static Object call(Object receiver, String method, Object...arg) {
        // something like that in byte code
        #invokeDynamic "doHandle" "someBootstrap"
    }

    static …

您将如何实现这样的功能：

function foo(a,b...,c)
    println(a,b,c)
end

foo(2,3,3,"last")

=> a = 2 , b = (3,3) , c = "最后一个"

我不能使用类似的东西：

function foo(a,b...) 
    c = b[end]
    println(a,b,c)
end

因为我想在 c 上调度，即我想要有方法：

foo(a,b...,c::Foo)

和

foo(a,b...,c::Bar)

我也不能有这样的东西：

foo_wrapper(a,b...) = foo(a,b[1:end-1],b[end])

因为我也想在 foo 上调度。

这有可能吗？