标签: multiple-dispatch

我正在编写一个一次性脚本来计算我正在运行的一些模拟的一些分析解决方案。

我想以一种基于其输入计算正确答案的方式实现一个函数。举例来说，假设我有以下数学方程：

tmax = (s1 - s2) / 2 = q * (a^2 / (a^2 - b^2))

对我来说，我应该能够做类似的事情，这似乎很简单：

tmax = (s1 - s2) / 2 = q * (a^2 / (a^2 - b^2))

我可能已经习惯了用 编写julia，但我真的不想让这个脚本变得比我需要的更复杂。

这是程序：

my %SUB-COUNTS;

say "Start";

multi sub trait_mod:<is>(Sub $s where .name().contains("-logged"), :$AOP) {
    $s.wrap({
        say "Entering { $s.name }";
        callsame;
    });
}

multi sub trait_mod:<is>(Sub $s where .name().contains("-counted"), :$AOP) {
    $s.wrap({
        say "Counting { $s.name }";
        %SUB-COUNTS{$s.name}++;
    });
}

sub water-logged() is AOP {
    return "Water";
}

sub out-logged() is AOP {
    return "Out";
}

sub we're-counted() is AOP {
    state $count = 0;
    return $count++;
}

sub we're-counted-and-logged() is AOP {
    state $alpha = 'a';
    return $alpha++;
}

say …

假设我有一堆水果:

class Fruit { ... };
class Apple : public Fruit { ... };
class Orange: public Fruit { ... };

以及在所述水果上运行的一些多态函数:

void Eat(Fruit* f, Pesticide* p)   { ... }
void Eat(Apple* f, Pesticide* p)   { ingest(f,p); }
void Eat(Orange* f, Pesticide* p)   { peel(f,p); ingest(f,p); }

好,等一下.停在那儿.请注意,任何理智的人都会使Eat()成为Fruit类的虚拟成员函数.但这不是一种选择,因为我不是一个理智的人.另外,我不想在我的水果类的头文件中使用Pesticide*.

遗憾的是,我希望接下来要做的就是成员函数和动态绑定允许的内容:

typedef list<Fruit*> Fruits;
Fruits fs;
...
for(Fruits::iterator i=fs.begin(), e=fs.end(); i!=e; ++i)
    Eat(*i);

显然,这里的问题是我们传递给Eat()的指针将是Fruit*,而不是Apple*或Orange*,因此什么都不会被吃掉,我们都会非常饥饿.

所以我真的希望能够做到而不是这样:

Eat(*i);

这是:

Eat(MAGIC_CAST_TO_MOST_DERIVED_CLASS(*i));

但是根据我有限的知识,这种魔法并不存在,除非可能是一个充满调用dynamic_cast的大讨厌if语句.

那么有一些我不知道的运行时魔法吗？或者我应该实现并维护一个充满dynamic_casts的令人讨厌的if语句？或者我应该把它搞砸,不要再考虑如何在Ruby中实现它,并允许一点Pesticide进入我的水果标题？

更新:而不是使用裸饮食功能和农药的人为设计,而是假设我只是不想把吃水果放在水果中,因为它毫无意义.知道怎么吃的水果？算了吧.相反,我需要一个带有Eat功能的Eater类,使用不同的代码来吃每种水果,以及一些默认代码,以防它是食者无法识别的水果:

class Eater
{
public:
  void Eat(Apple* f) { wash(); nom(); …

我在应用程序架构中遇到了障碍.我刚刚开始使用访问者模式在抽象对象上执行特定的算法,这些抽象对象在运行时我不知道.我的问题是我的算法也取决于嵌套抽象类型的类型.

让我说明一下我的意思:

我有一个抽象的DataSource类.从这里我实现了concerete DataSourceReference和DataSourceExplicit类.我还有一个抽象的Report类(反序列化的元数据),我从中实现具体的Report类ReportTypeA和ReportTypeB.创建这些对象时,它们的DataSource可以是任何扩展的DataSource类.

我需要两者,实际的Report类型和DataSource类型,所以我可以相应地执行.我可以使用访问者模式获取协同报告类型,但不知道如何在之后/也为DataSource执行相同操作.

访问报告后我无法访问DataSource,因为我将失去报告的具体类型(因为您必须让它接受基本报告类型:Accept(SomeDataSourceVisitor d,MetaReport m) - 或者为每个可能的报告类型重载,这违背了访客模式的目的.看到我的问题？

有任何想法吗？我不想使用动态,因为它不需要新报表类型的开发人员确保调度程序(访问者)支持新报表.

现行代码:

public abstract class DataSource
{
}

public class DataSourceReference : DataSource
{
    // reference thing(s)
}

public class DataSourceExplicit : DataSource
{
    // explicit thing(s)
}

public abstract class Report
{
    // some shared Report attribute(s)
    // ...

    public DataSource DataSource { get; set; }

    public abstract FinalReport Execute(IReportExecutionDispatcher d);
}

public class ReportA : Report
{
    // ReportA specific attribute(s)
    // ... …

假设我有以下类结构:

页

的Page,StaticPage并且DynamicPage接口是由客户来实现.它们根据页面类型(静态或动态)提供各种数据,用于通过页面呈现页面Renderer.这些接口可能有很多实现.

渲染

该Renderer的render页面.此外,此接口可能有多个实现(针对不同的呈现技术).

RenderManager

这只是一个简单的外观,它应该根据给定的页面类型在提供的渲染器上调用相应的渲染方法.这就是谎言

问题

如何Renderer根据提供的页面类型确定在对象上调用哪个方法？

目前(不满意)的解决方案

目前我正在使用条件派遣:

void render(Page page, Renderer renderer) {
    if (page is StaticPage) {
        renderer.renderStaticPage(page);
    } else if (page is DynamicPage) {
        renderer.renderDynamicPage(page);
    } else {
        throw new Exception("page type not supported");
    }
}

怎么了

这个解决方案的问题是每当我想添加另一个页面类型(即扩展Page界面)时,我也需要调整这个方法.实际上,这是应该使用面向对象语言中的多态(虚拟)方法,但在这种情况下,这不起作用(见下面的原因).

我考虑但拒绝的其他解决方案

1. 抽象类而不是接口.这将在实现者的类型层次结构上放置一个不必要的约束:它们将不再能够扩展他们想要的任何类,而是强制扩展抽象StaticPage或DynamicPage类,这很糟糕.

2. dispatch(Renderer render)向接口添加方法并强制实现者根据页面类型调用渲染器对象上的相应方法.这显然很糟糕,因为实现者不应该关心渲染:他们只需要提供要渲染的数据.

那么,也许有一些模式或一些替代设计可能有助于这种情况？欢迎任何想法.:)

在Julia中,我想将函数参数的类型指定为数组数组.所以我有

function foo{T <: Any}(x::Array{Array{T}})

但是如果我x在REPL中设置参数,例如:

x = Array[[0,1],[1,2,3],[0,1,2,4]]

然后它会自动获取以下类型赋值(例如),其中包括其尺寸:

x::Array{Array{T,N},1}

所以我得到了错误

ERROR: `foo` has no method matching foo(::Array{Array{T,N},1}).

我根本不想限制数组维度,因此我们认为解决方案可能就是这样

function foo{T <: Any, N <: Number}(x::Array{Array{T,N},N})

但这也不起作用.

如何将参数类型指定为数组数组？

我的问题是我怎么可以重载某些方法中的朱莉娅一定的阶级？

换句话说,假设我有一个类的以下定义:

type Sometype
    prop::String

    setValue::Function

    # constructor
    function Sometype()
        this = new ()

        this.prop = ""

####### v1 #######
        this.setValue = function(v::Real)
            println("Scalar Version was Invoked!")
            # operations on scalar...
            # ...
        end

####### v2 #######
        this.setValue = function(v::Vector{Real})
            println("Vector Version was Invoked!")
            # operations on vector...
            # ...
        end

####### v3 #######
        this.setValue = function(v::Matrix{Real})
            println("Matrix Version was Invoked!")
            # operations on Matrix...
            # ...
        end

        return this
    end
end

所以当我在我的主要代码中说:

st = Sometype()
st.setValue(val)

根据是否 …

我已经定义了以下变量

julia> X = (1:10) * ones(1,10)

它定义了一个矩阵,每行等于相同的数字,列中的数字从1增加到10.我想知道哪个方法使用Julia作为函数*.我怎么能问朱莉娅？

我要救的对象Arc,并Line在一个ArrayList中,然后利用这两者的交集.问题是如何演员i和j原作.我知道这instanceof有效,但这将是最脏的方法.

public class Intersection {
    public static boolean intersect(ArrayList<Curve> list1, ArrayList<Curve> list2) {
        for (Curve i : list1) {
            for (Curve j : list2) {
                if (i.intersection(j).length > 0) 
                    return true;
            }
        }
        return false;
    }
}

public abstract class Curve {
    public Point[] intersection(Curve c) {
        return new Point[] {};
    }
}

public class Line extends Curve {
    public Point[] intersection(Line l) {
        // returns intersection Point of this …

为了简化，我尝试编写一个带有两个参数的函数，其中：

1. 基本方法接受两个整数作为参数

   func(x::Int, y::Int) = 某事

2. 其他方法接受一个或两个参数作为任意类型，将这些参数映射到整数，然后调用基本方法

3. 其他方法接受一个或两个参数作为数组（或 ::Colon 类型），并通过按元素应用适当的先前方法 (1) 或 (2) 来生成数组。

毫不奇怪（事后看来），这种方法会产生方法模糊性。鉴于提供给函数的参数类型，Julia 选择具有最具体类型的有效方法。但如果 x 是一个数组并且 y 是一个 Int，则以下方法同样具体，而 Julia 不知道该调用哪一个：

• func(x::任意，y::整数)
• func(x::数组，y::任意)

我想做类似的事情

• func(x::T, y::Int) T <: any_so_long_as_not_array = func(map_x_to_Int(x), y)
• func(x::Array, y::Any) = (el -> func(el, y)).(x)

是否存在诸如“非类型”之类的东西？我是否以错误的方式思考这个问题？是否有解决此类问题的规范方法？

对于上下文，我试图为我编写的结构实现 Base.getindex，并且当结构的内容可能有所不同时，我希望 getindex 支持许多不同的方法来索引结构。在幕后，结构中的元素由整数索引，但用户可能使用几乎任意的非整数类型来索引结构中的元素（我不想强迫用户使用特定类型来索引元素）。