小编Aar*_*erg的帖子

对于我正在编写的Java程序,我特别需要按Unicode代码点按字典顺序对字符串进行排序.这是不一样的String.compareTo(),当你开始处理基本多文种平面以外的值.String.compareTo()按字典顺序比较16位char值的字符串.要知道这不等同,请注意U + FD00 ARABIC LIGATURE HAH WITH YEH ISOLATED FORM小于U + 1D11E MUSICAL SYMBOL G CLEF,但阿拉伯字符的Java String对象"\uFD00"比"\uD834\uDD1E"谱号的代理对要大.

我可以使用String.codePointAt()和Character.charCount()手动循环代码点,并在必要时自己进行比较.是否有API函数或其他更"规范"的方法？

枚举任意图中两个顶点之间的所有简单路径通常需要指数时间,因为顶点之间可能存在指数个简单路径.但是,如果我们只对两个端点之间的至少一条简单路径上的顶点感兴趣呢？

那就是:给定一个无向图和两个不同的顶点,是否有一个多项式时间算法,它找到位于两个顶点之间的至少一条简单路径上的每个顶点？这与连接不同; 死胡同和死胡同被排除在外.但是,分支和连接路径是允许的.

我发现编写一个看起来像是解决了这个问题的算法非常容易,但在某些情况下要么失败,要么在病态情况下需要指数运行时间.

更一般地说:给定图中两个不相交的顶点集,是否存在多项式时间算法,该算法找到位于从一个集合中的顶点到另一个集合中的顶点的简单路径上的所有顶点？

(请原谅我,如果有一个非常明显的解决方案.当然感觉应该有.)

Haskell报告在布局规则中包含了一个名为" parse-error(t) "的臭名昭着的子句.此规则的目的是避免强制程序员在单行let表达式和类似情况下编写大括号.相关的句子是:

副条件解析错误(t)将被解释如下:如果到目前为止L生成的令牌与下一个令牌t一起表示Haskell语法的无效前缀,并且到目前为止生成的令牌由L后跟token"}"表示Haskell语法的有效前缀,然后parse-error(t)为true.

这会产生一种不寻常的依赖关系,其中词法分析器必然都会为解析器生成令牌,并通过插入额外的令牌来解析解析器中产生的错误.这与任何其他语言定义中的任何内容都不同,如果100%字面解释,则会严重地使实现复杂化.

不出所料,我所知道的Haskell编译器没有像编写的那样实现整个规则.例如,GHC无法解析以下表达式,根据报告,这是合法的:

let x = 42 in x == 42 == True

还有各种其他类似的奇怪案例.这篇文章列出了一些特别困难的例子.其中一些GHC正常工作,但它(从7.10.1开始)也失败了:

e = case 1 of 1 -> 1 :: Int + 1

此外,似乎GHC有一个未记录的语言扩展名称,它用词法AlternativeLayoutRule分析器中的一堆令牌上下文替换parse-error(t)子句,在大多数情况下给出类似的结果; 但是,这不是默认行为.

现实世界的Haskell编译器(特别是GHC)在lexing期间做什么来近似解析错误(t)规则？我很好奇,因为我正在尝试实现一个简单的Haskell编译器,这个规则真的让我感到沮丧.(另见相关问题.)

我在Eclipse中开发了一些代码，对其进行了成功的测试，将其推送到我们的Jenkins CI服务器上，并收到了一封电子邮件，指出Maven由于Java编译错误而感到窒息。随后，我隔离了该问题，并创建了以下显示该问题的最小示例：

import java.util.List;
import java.util.function.Function;

class MinimalTypeFailureExample {
    public static void main(String[] args) {
        List<String> originalList = null;  // irrelevant
        List<IntToByteFunction> resultList = transform(originalList,
                outer -> inner -> doStuff(inner, outer));
        System.out.println(resultList);
    }

    static <F, T> List<T> transform(List<F> originalList,
            MyFunction<? super F, ? extends T> function) {
        return null;  // irrelevant
    }

    static Byte doStuff(Integer inner, String outer) {
        return null;  // irrelevant
    }
}

@FunctionalInterface
interface MyFunction<F, T> extends Function<F, T> {
    @Override
    T apply(F input);
}

@FunctionalInterface
interface …

将私有字段访问与Java中的CRTP相结合似乎在可见性规则中发现了一个奇怪的边缘情况:

public abstract class Test<O extends Test<O>> implements Cloneable {
    private int x = 0;

    @SuppressWarnings("unchecked")
    @Override
    protected final O clone() {
        try {
            return (O) super.clone();
        } catch (CloneNotSupportedException ex) {
            throw new AssertionError(ex);
        }
    }

    public final int getX() {
        return x;
    }

    public final O withX(int x) {
        O created = clone();
        created.x = x;  // Compiler error: The field Test<O>.x is not visible
        return created;
    }
}

只需将withX()方法更改为此...

    public final O withX(int …