Scala 单例工厂和类常量

Question

好的，在关于“类变量作为常量”的问题中，我事实是，这些常量只有在“官方”构造函数运行之后才可用（即直到您有一个实例）。但是，如果我需要伴随单例来调用该类怎么办：

object thing {
    val someConst = 42
    def apply(x: Int) = new thing(x)
}

class thing(x: Int) {
    import thing.someConst
    val field = x * someConst
    override def toString = "val: " + field
}

如果我首先创建伴随对象，则“new thing(x)”（在伴随对象中）会导致错误。但是，如果我首先定义类，则“x * someConst”（在类定义中）会导致错误。

我还尝试将类定义放在单例中。

object thing {
    var someConst = 42

    def apply(x: Int) = new thing(x)

    class thing(x: Int) {
        val field = x * someConst
        override def toString = "val: " + field
    }
}

然而，这样做会给我一个“thing.thing”类型的对象

val t = thing(2)

结果，

t: thing.thing = val: 84

我想出的唯一有用的解决方案是创建一个抽象类，一个同伴和一个内部类（它扩展了抽象类）：

abstract class thing

object thing {
    val someConst = 42
    def apply(x: Int) = new privThing(x)

    class privThing(x: Int) extends thing {
        val field = x * someConst
        override def toString = "val: " + field
    }
}

val t1 = thing(2)
val tArr: Array[thing] = Array(t1)

好的，' t1' 仍然具有“thing.privThing”类型，但现在可以将其视为“事物”。

然而，这仍然不是一个优雅的解决方案，有人能告诉我更好的方法吗？

附言。我应该提到，我在 Windows 7 上使用 Scala 2.8.1

Answer 1

首先，您看到的错误（您没有告诉我它是什么）不是运行时错误。当 thing 单例初始化时，不会调用 thing 构造函数 - 它会在稍后调用 thing.apply 时调用，因此不存在循环运行时参考。

其次，在编译时确实存在循环引用，但是当您编译保存在磁盘上的 scala 文件时，这不会导致问题 - 编译器甚至可以解决不同文件之间的循环引用。 （我测试过。我把你的原始代码放在一个文件中并编译它，它工作得很好。）

你真正的问题来自于尝试在 Scala REPL 中运行这段代码。 这是 REPL 的作用以及为什么这是 REPL 中的问题。您正在输入对象事物，一旦完成，REPL 就会尝试编译它，因为它已经到达了一个连贯的代码块的末尾。 （分号推断能够推断出对象末尾的分号，这意味着编译器可以开始处理该代码块。）但是由于您还没有定义 class thing 它可以不编译它。当你颠倒类事物和对象事物的定义时，你也会遇到同样的问题。

解决方案是将类事物和对象事物嵌套在某个外部对象内。这将推迟编译，直到外部对象完成，此时编译器将同时看到class thing和object thing的定义。您可以在此之后立即运行 import thingwrapper._ 以使 class thing 和 object thing 在 REPL 的全局范围内可用。 当您准备好将代码集成到某个文件中时，只需放弃外部类 thingwrapper 即可。

object thingwrapper{
   //you only need a wrapper object in the REPL
   object thing {
       val someConst = 42
       def apply(x: Int) = new thing(x)
   }   

   class thing(x: Int) {
       import thing.someConst
       val field = x * someConst
       override def toString = "val: " + field
   }   
}

Answer 2

Scala 2.12 或更高版本可能会受益于 sip 23< /a> 刚刚（2016 年 8 月）传递到下一个迭代（被认为是一个“好主意”，但仍在进行中）

基于文字的单例类型

单例类型弥合了值级别和类型级别之间的差距，因此允许在 Scala 中探索通常仅在支持全谱依赖类型的语言中可用的技术。

Scala 的类型系统可以对常量建模（例如 42、"foo"、classOf[String]）。
这些是在 object O { Final val x = 42 } 等情况下推断出来的。它们用于表示和传播编译时常量（请参阅 6.24 常量表达式以及4.1 值声明和定义)。
但是，没有表面语法来表达此类类型。这使得需要它们的人创建宏来提供解决方法来做到这一点（例如 无形状）。
这可以通过相对简单的方式进行更改，因为实现此功能的整个机制已经存在于 scala 编译器中。

type _42 = 42.type
type Unt = ().type
type _1 = 1 // .type is optional for literals
final val x = 1
type one = x.type // … but mandatory for identifiers