如何上限自我指涉类型？

Question

我有可以对自己的类型执行操作的东西(比如上下文,数字):

interface Number<N> {
    N add(N to);
}
class Int implements Number<Int> {
    Int add(Int to) {...}
}

和作用于某个上限的所有子类型的actor:

interface Actor<U> {
    <E extends U> E act(Iterable<? extends E> items);
}

我想创建一个在任何数字类型上多态化的actor:

class Sum implements Actor<Number> {
    <N extends Number<N>> N act(Iterable<? extends N> items) {...}
}

现在,显然这不起作用,因为Number并且Number<N>不一样.实际上,由于Number不将实现者的类型参数约束为其自己的类型,因此这样的actor无法工作.但是我一般不关心Numbers 操作- 我对我的功能只对某些类型的数字工作感到满意N extends Number<N>

作为替代方案,我可以声明:

interface Actor<E> {
    E act(Iterable<? extends E> items);
}

class Sum<N extends Number<N>> implements Actor<N> {
    N act(Iterable<? extends N> items) {...}
}

但这对我不起作用,因为它迫使我知道N我何时构建我的Sum,我的用例不方便.它还<N extends Number<N>>会对多态使用a的每个类或方法Sum造成丑陋,导致类型杂乱的扩散.

有什么优雅的方式来做我想要的吗？

例:

这是一些示例代码,表达了我想要做的事情.

interface Folder<U> {
    <E extends U> E fold(Iterable<? extends E> items);
}

class Sum implements Folder<Number> {
    <N extends Number<N>> N fold(Iterable<? extends N> items) {
        Iterator<? extends N> iter = items.iterator();
        N item = iter.next();
        while (iter.hasNext())
            item = item.add(iter.next());
        return item;
    }
}

class Concat implements Folder<String> {
    <S extends String> fold(Iterable<? extends S> items) {
        StringBuilder concatenation = new StringBuilder();
        for (S item : items)
            concatenation.append(item);
        return concatenation.toString();
    }
}

class FoldUtils {
    static <U, E extends U> E foldDeep(Folder<U> folder, Iterable<? extends Iterable<? extends E>> itemses) {
        Collection<E> partialResults = new ArrayList<E>();
        for (Iterable<? extends E> items : itemses)
            partialResults.add(folder.fold(items));
        return folder.fold(partialResults);
    }
}

Answer 1

看看你的例子，我不确定让通用方法提供具体参数与在演员中提供具体参数相比你会得到什么：

class Sum<T extends Number<T>> implements Actor<T> {
    T act(Iterable<? extends T> items) {...}
}

Sum<any-self-referential-Number>拥有 a与仅拥有 a Sum<Int>、 a等相比有什么好处Sum<Float>？

如果您担心创建不同实例的微小内存开销，您可以每次使用未经检查的强制转换返回相同的实例，这在安全的情况下很常见（参见例如 GuavaOptional.absent()或Collections.emptyList()）。

在你的例子中，有人最终必须这样做：

List<List<Int>> list;
foldDeep(new Sum(), list)

那么为什么不只需要类型参数呢？

foldDeep(new Sum<Int>(), list)

或者如果封装在工厂后面，

foldDeep(Sum.instance(), list)
foldDeep(NumberFolders.sum(), list)

简而言之，我不清楚为什么这不起作用：

interface Folder<U> {
    U fold(Iterable<? extends U> items);
}

class Sum<T extends Number<T>> implements Folder<T> {
    public T fold(Iterable<? extends T> items) {
        //...
    }
}

class FoldUtils {
    static <E> E foldDeep(Folder<E> folder, Iterable<? extends Iterable<? extends E>> itemses) {
        Collection<E> partialResults = new ArrayList<>();
        for (Iterable<? extends E> items : itemses)
            partialResults.add(folder.fold(items));
        return folder.fold(partialResults);
    }
}

//...
FoldUtils.foldDeep(new Sum<>(), list);