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无法工作。但是我并不关心在Number上操作 - 我对我的功能只对某些类型的数字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>>的类或方法施加一个丑陋的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

看看你的例子，我不确定你从泛型方法提供具体参数vs在演员中获得它会带来什么：

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

拥有Sum<any-self-referential-Number>与仅拥有Sum<Int>和Sum<Float>等的优点是什么？

如果你担心创建不同实例的微小内存开销，你可以每次使用未经检查的强制转换返回相同的实例，这在安全的地方很常见（参见例如Guava的Optional.absent()或{{1 }}）。

在你的例子中，有人最终必须要做的事情：

Collections.emptyList()

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

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

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

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

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

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

如何上限自我指涉类型？

实施例

1 个答案: