小编Owe*_*wen的帖子

根据Scala语言规范:

...允许局部类型推断限制[类型参数]的推断边界的复杂性.必须相对于可接受复杂性的类型集来理解类型的最小性和最大性.

在实践中有什么限制？

此外,是否有不同的限制适用于推断的表达式类型而不是参数类型边界,这些限制是什么？

我听说过(而且我知道我也见过一些例子,只要我能记得哪里)sbt可以从git repo获得依赖.

我希望从github 获得harrah/up的依赖.存储库不提供任何工件JAR文件,只提供设置为使用构建的源树sbt.我想象的过程是sbt下载源代码,构建它,然后将其用作依赖项工件.

我可能想象sbt事实上可以做这样的事情.它可以？如果是这样,怎么样？

例如,在2010年7月5日,我想计算字符串

 July 5, 2010

该怎么做？

我想知道D是多么成熟和稳定,如果它可能是C/C++的一个很好的替代品.

我知道目前有两个标准库(Phobos和Tango).是否仍然没有统一的标准库？

另外我前段时间听说语言在GCed /非GCed代码的边界上存在问题.我在D网站上找不到任何关于它的参考,这个问题仍然是正确的吗？

编译器或库中更"本机"的部分(IO或能够访问黑魔法和实现的函数)是否对这些定律做出假设？打破它们会导致不可能发生的事吗？

或者他们只是表达一种编程模式 - 也就是说,你唯一能够惹恼他们的人就是那些使用你的代码并且不希望你如此粗心的人？

我发现自己编写如下代码:

val b = a map (entry =>
    entry match {
        case ((x,y), u) => ((y,x), u)
    }
)

我想以不同的方式写它,如果只有这个工作:

val c = a map (((x,y) -> u) =>
    (y,x) -> u
)

有什么方法可以让我接近这个吗？

如果我分叉存储库joe/foo,它有一个Wiki,我将不会得到维基.现在,我只是想让wiki添加页面.

1. 这可能没有分配存储库吗？

2. 如果没有,是否可能？

我可以,

{
    "type": "record",
    "name": "Foo",
    "fields": [
        {"name": "bar", "type": {
            "type": "record",
            "name": "Bar",
            "fields": [ ]
        }}
    ]
}

并且工作正常,但假设我想将模式拆分为两个文件,例如:

{
    "type": "record",
    "name": "Foo",
    "fields": [
        {"name": "bar", "type": "Bar"}
    ]
}

{
    "type": "record",
    "name": "Bar",
    "fields": [ ]
}

Avro有能力这样做吗？

我偶尔在代码中遇到一个类似于monad的模式,但不会保持一致的类型>>=.

这是我能提出的最简单的例子:

(首先是一些类型级的布尔值:

data TyT = TyT
data TyF = TyF

class TyOr a b c | a b -> c

instance TyOr TyF TyF TyF
-- rest similarly

)

现在这里是我们的"monad"类型构造函数:

data Marked p a = Marked a
    deriving (Show)

对于给定的p,Marked p是一个* -> *非常像mmonad中的行为,但是当我们定义"bind"时,就像接下来发生的那样:

(>>%) :: (TyOr p q r) => Marked p a -> (a -> Marked q b) -> Marked r b
(Marked x) >>% f = Marked …

像这样的定义

def foo(x: Int) = x + 1

很好,很短,看起来很漂亮,但当签名本身变得不舒服时,

def foo[T <: Token[T]](x: ArrayBuffer[T], y: T => ArrayBuffer[() => T]): (T, T, BigDecimal) = {
    // ...
}

我不知道在哪里拆分它.我发现以下所有内容看起来很尴尬:

def foo(
    x: Int,
    y: Int
): Int = {
    // ...
}

def foo(
        x: Int,
        y: Int
    ): Int =
{
    // ...
}

def foo(
        x: Int,
        y: Int
    ): Int
= {
    // ...
}

def foo(
        x: Int,
        y: Int
    ):
Int = {
    // ... …