小编jon*_*son的帖子

为什么这个F#类没有编译(使用VS2010):

type Base =
    abstract func : (int * int) -> int

    default this.func (x : int, y : int) : int =
        x + y

func的默认实现导致此编译错误:

Error   9   This override takes a different number of arguments to the corresponding abstract member

如果我改变它是一个成员:

type Base =
    abstract func : (int * int) -> int

    member this.func (x : int, y : int) : int =
        x + y

然后它编译(虽然我相信现在抽象函数缺少一个实现),并且第二个函数的类型匹配第一个.

在相关的说明中,为什么编译器不要求Base的第二个定义具有AbstractClass属性？

在Play 1.4.x下,如果我想反向生成一个URL,我可能会使用以下内容:

Map<String, Object> map = new TreeMap();
map.put("myParam", myParam);
ActionDefinition ad = Router.reverse("MyAction.query", map);
String url = ad.url;

根据可靠的简洁的Play 2.x 文档,在Play 2下使用Scala,我应该使用重定向:

val action = Action {Redirect(routes.MyAction.query(myParam))}

但是我如何处理获取实际URL的操作？

可能重复:
使用scala中的重载构造函数定义自己的异常

我想编写一个Scala异常类,它对Java Exception类进行子类化,并提供类似的构造函数(每个构造函数都会调用相应的Exception ctor.即,我将如何编写此Java类的Scala等价物:

public class MyException extends java.lang.Exception {
    public MyException () {
    }

    public MyException (String msg) {
        super(msg);
    }

    public MyException (Throwable e) {
        super(e);
    }

    public MyException (String msg, Throwable cause) {
        super(msg, cause);
    }
}

这似乎与这个问题有关,但其中的答案并不令人满意(因为实际上没有定义子类).

表达式和函数之间的形式区别是什么？我通过观察就知道其中的区别，但我正在寻求对其的彻底理解。例如，显示来自Scheme或Python的一些示例：

; scheme
(display "hello")                          # expression
((lambda () (display "hello")))            # unnamed lambda
(define hi (lambda () (display "hello")))  # named lambda

# python
>>> print ('hello')          
>>> lambda: print ('hello')
>>> hi = lambda: print ('hello')

在我的初步思考中，我认为差异是：

1. 函数有一个名称并且可以被引用（尽管表达式可以分配给变量？）
2. 函数可以带参数（表达式可以吗？）
3. 函数可以具有作用域/封装并包含多个语句。

命名静态构造函数方法的首选约定是什么？例如，假设我有一个Error类，它有一个构造函数，它简单地初始化字段，然后是一些静态构造函数方法：

class Error {
    static Error xxxx(String msg) {
        return new Error(msg, -1);
    }

    static Error xxxx(String msg, int line) {
        return new Error(msg, line);
    }

    final String msg;
    final int line;

    private Error(String msg, int line) {
        this.msg = msg;
        this.line = line
    }
}

我应该如何命名这些xxxx方法。可能性包括：

1. valueOf- 一些 Java 类遵循此，例如Integer.valueOf，但这仅用于装箱原语吗？
2. of- 更简洁。Error.of(msg, i)似乎可读。
3. error - 一些优点和缺点 - 见下文。
4. create- 过分强调机制（创造一些东西）而不是意图（给我一个价值）。例如，某些实现可能会缓存和重用值，这意味着实际上并不总是这样创建。
5. createError- 罗嗦，和相同的问题create。

我倾向于以函数式风格进行编码，并且可能因此，我的偏好是 #3，部分原因是如果我静态导入，Error …

如果我有一个java.util.Stream需要关闭的（一旦完成），我如何才能既关闭它（通过调用close）又调用一个终端操作，如countor collect？

例如：

java.nio.file.Files.lines(FileSystems.getDefault().getPath("myfile.txt"))
        .collect(Collectors.toSet());
        //.close(); ???

（在此示例中，调用close并不重要，但可以说我有一个Stream对象，该对象通过onClose在流中注册了关键的close操作）。

我猜您可以将流存储在temp var中并关闭它，如下所示：

Stream<String> ss = java.nio.file.Files.lines(FileSystems.getDefault().getPath("myfile.txt"));
Set<String> lines = ss.collect(Collectors.toSet());
ss.close();
return lines;

但似乎有点笨拙。以这种方式关闭流是否总是安全的？