小编Lea*_*ner的帖子

我有一个Scala 2.9编译器插件(源代码),在2.9中运行得很好但是甚至不用2.10编译.有许多(可能是100多个)错误都属于同一类,例如:

    [scalac] C:\***.scala:31: error: illegal cyclic reference involving class Global
    [scalac]   val fileSeparator = System.getProperty("file.separator");
    [scalac]                       ^

......最终终止于:

    [scalac] scala.reflect.internal.Types$TypeError: illegal cyclic reference involving class Global
    [scalac]     at scala.reflect.internal.Types$class.defineBaseClassesOfCompoundType(Types.scala:1731)
    [scalac]     at scala.reflect.internal.SymbolTable.defineBaseClassesOfCompoundType(SymbolTable.scala:12)
    [scalac]     at scala.reflect.internal.Types$CompoundType.baseClasses(Types.scala:1581)
    [scalac]     at scala.reflect.internal.Types$TypeRef.baseClasses(Types.scala:2369)
    [scalac]     at scala.reflect.internal.Types$SimpleTypeProxy$class.baseClasses(Types.scala:248)
    [scalac]     at scala.reflect.internal.Types$SingletonType.baseClasses(Types.scala:1292)
    [scalac]     at scala.reflect.internal.Types$Type.findMembers(Types.scala:1058)
    [scalac]     at scala.reflect.internal.Types$Type.membersBasedOnFlags(Types.scala:683)
    [scalac]     at scala.reflect.internal.Types$Type.implicitMembers(Types.scala:637)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.collect$1(Contexts.scala:630)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.collectImplicitImports(Contexts.scala:642)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:670)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:675)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:675)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:675)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:675)
    [scalac]     at scala.tools.nsc.typechecker.Contexts$Context.implicitss(Contexts.scala:675)
    [scalac]     at …

我有一个函数有两个参数列表,我试图部分应用和currying使用.第二个参数列表包含所有都具有默认值(但不是隐式)的参数.像这样的东西:

 def test(a: Int)(b: Int = 2, c: Int = 3) { println(a + ", " + b + ", " + c); }

现在,以下几点都很好:

 test(1)(2, 3);
 test(1)(2);
 test(1)(c=3);
 test(1)();

现在,如果我定义:

 def partial = test(1) _;

然后可以完成以下操作:

 partial(2, 3);

有人可以解释为什么我不能省略'部分'中的一些/所有参数,如下所示:

 partial(2);
 partial(c=3);
 partial();

不应该写"部分"的行为与"test(1)"的行为基本相同吗？有人可以帮我找出实现这个目标的方法吗？

请帮忙,我很绝望!

编辑 - 由于我无法在24小时内回答我自己的问题,我将在此发表自己的答案:

到目前为止,这是我能做的最好的事情:

class Test2(val a: Int) {
   def apply(b: Int = 2, c: Int = 3) { println(a + ", " + b + ", " + c); }
}

def test2(a: Int) …

我们需要将JavaDoc作为站点而不是存档发布到我们的maven存储库,以便可以直接从那里浏览它.我们基于maven的项目已经实现了这一点,但我们无法通过Gradle找到解决方法 - 我认为使用"站点部署".

搜索这一点非常复杂,因为"网站"是一个如此重载的术语,其他搜索不会产生任何结果.

我很困惑如何在Scala中解决这个问题.在Java中,我放弃了泛型或使用强制转换,但Scala比这更严格.这就是我所拥有的.

1. 一个抽象基类Factory[+F <: Factory[F]]和一些与此无关的具体实现.这是协变的.这个类有一个创建产品的方法 - 见下一点.
2. 一个抽象基类Product[+F <: Factory[F]],表示工厂的产品.这些也是协变和只读的.任何特定工厂只生产一种产品(即没有多种不同的子类型--FooFactory生产FooProduct,BarFactory生产BarProduct等)
3. 我必须有一个包含具体实例的工厂集合(Capt.明显在这里说).现在这是Iterable[Factory[_]].这是麻烦的第一部分.Scala似乎在_这里理解为Any,无视F <: Factory[F]对类型本身的约束.
4. 我有一个聚合工厂方法,要求每个工厂生产给出相同参数的产品.结果是工厂到他们的产品的地图,目前编码Map[Factory[_],Product[_]]和尝试Map[Factory[_],Product[Factory[_]]].这是我遇到麻烦的另一部分.第一个_与第二个没有联系_,两者似乎都暗示为Any.

我不能做的是创建该地图.它可能或不重要,但我通过使用另一种看起来像语法结构的方法来做(并且必须这样做).它来自一个特点:

1. 调用gather[B](fun: A => B): Map[A,B]获取工厂集合的声明方法(在此处调用,未在特征本身中实现并通常键入).实际的工厂类型是通用的和未知的.
2. 迭代该泛型集合并执行传递给它的函数.这个函数实际上是调用工厂方法的.
3. 返回MapF到P 的不可变量

编译器的问题不在于'gather'方法,而是在调用它的代码中.我无法将其结果转换为Map[Factory[_],Product[_]]因为_ F <: Factory[F]在任何一个地方都不符合...我会非常乐意使用基类型_,但那就是Factory[Factory[Factory[Factory......(infinitely many times)]]]]]]....并且我不知道该怎么做.

请帮忙!

学习者

以下Scala类:

class Foo[+T <: Bar] extends FooBase ...

有效地定义了一个以Foo [Bar]为根的类型层次结构 - 即任何有效的Foo [X]都可以赋值给Foo [Bar]值或变量:

val v1: Foo[Bar] = new Foo[SubBar1]();
val v2: Foo[Bar] = new Foo[SubBar2]();

FooBase更进一步,也可能暗示不是Foo的对象 - 以下显示了问题:

class Trouble extends FooBase ...
val iOnlyWantFooHere: FooBase = new Trouble();

...而且FooBase也不知道类型T,所以它的成员不能指定它,我必须在Foo中覆盖这些定义来专门化它们:

class FooBase {
  def ohNoIDontKnowTheType: Bar;
}

class Foo[+T <: Bar] extends FooBase {
  override def ohNoIDontKnowTheType: T = ...;
}

还有其他方法可以解决这个问题,但重点应该是明确的.

最后,我的实际问题是以下层次结构的根源:

class Foo[+T <: Foo[T]] extends FooBase ...

再说一遍,不要告诉我FooBase,因为事实并非如此.是的,我可以在专门用于此目的之间插入另一个类,但这仍然不是如上所述的真实答案.

Scala不喜欢just Foo(没有type参数),并且它不是Foo[_]因为然后访问返回类型参数类型的值的方法实际上Any不是Foo …

我正在尝试学习如何使用“平台”来对齐多项目设置中项目之间的依赖版本。到目前为止，我已经看到：

1. https://docs.gradle.org/6.2.1/userguide/platforms.html
2. https://docs.gradle.org/6.2.1/userguide/dependency_management_terminology.html#sub::terminology_platform
3. https://docs.gradle.org/6.2.1/userguide/dependency_version_alignment.html#sec:virtual_platform
4. https://docs.gradle.org/6.2.1/userguide/dependency_constraints.html#sec:adding-constraints-transitive-deps
5. https://docs.gradle.org/6.2.1/userguide/java_platform_plugin.html
6. ……以及更多试图寻找示例的外部站点，例如 https://dzone.com/articles/gradle-goodness-use-bill-of-materials-bom-as-depen

我了解如何在项目中声明约束。我想我也了解如何为此目的使用 BOM。但是，我想为此使用一个“强制平台项目”，这里有很多事情我不明白：

1. 我是否必须使用“java 平台”插件？我们有非 Java 项目。我们的配置不太适合“api”和“runtime”桶。
2. 即使我们都是 Java，对于任何一个项目，我们也不能为其“api”和“运行时”提供单独的版本。虽然我确实了解这在某些情况下可能提供的控制级别，但我不明白这些是如何协同工作的，以确保项目获得指定的依赖项。
3. Gradle 如何知道在使用平台的项目和平台规范之间匹配哪些配置的约束？我想我看到了平台中定义“api”和其他约束的示例，我“理解”项目将通过声明 api platform(project(':platform')) 来引用它。我希望 Gradle 不会试图通过简单的名称匹配来将“api”与“api”匹配。我需要多个不同的依赖配置，无论它被称为什么，都与同一个平台“配置”对齐。

总的来说，我没有找到足够的信息来对它的作用或工作方式充满信心。有人可以填写空白或指向一些显示比上述更多示例和详细信息的文档吗？目前我不明白我应该为那个平台项目（它的build.gradle）实际写什么和/或我将如何从我们拥有的当前项目中正确引用它。

谢谢！

更新 1：在https://discuss.gradle.org/t/can-someone-tell-me-what-i-am-doing-wrong-to- 上发布了一个最小的实验来测试我（缺乏）对此的理解align-dependency-versions-across-projects/35601 ...