Как смоделировать переменную «назначить один раз» в Scala?

Вы можете сделать это с неявными, сделав неявные доступными только в методе, который должен иметь возможность переназначения. Просмотр значения не требует неявного, поэтому «переменная» видна другим методам:

sealed trait Access                                                                                                                                                                                            

trait Base {                                                                                                                                                                                                  

  object mgr {                                                                                                                                                                                                 
    private var i: Int = 0                                                                                                                                                                                     
    def apply() = i                                                                                                                                                                                            
    def :=(nv: Int)(implicit access: Access) = i = nv                                                                                                                                                          
  }                                                                                                                                                                                                            

  val init = {                                                                                                                                                                                                 
    implicit val access = new Access {}                                                                                                                                                                        

    () => {                                                                                                                                                                                                    
      mgr := 5                                                                                                                                                                                                 
    }                                                                                                                                                                                                          
  }                                                                                                                                                                                                            

}

object Main extends Base {

  def main(args: Array[String]) {                                                                                                                                                                              
    println(mgr())                                                                                                                                                                                             
    init()                                                                                                                                                                                                     
    println(mgr())                                                                                                                                                                                             
  }                                                                                                                                                                                                            

}

Итак, вот мое предложение, непосредственно вдохновленное axel22, Рекс Керр и Debilski ответы:

class SetOnce[T] {
  private[this] var value: Option[T] = None
  def isSet = value.isDefined
  def ensureSet { if (value.isEmpty) throwISE("uninitialized value") }
  def apply() = { ensureSet; value.get }
  def :=(finalValue: T)(implicit credential: SetOnceCredential) {
    value = Some(finalValue)
  }
  def allowAssignment = {
    if (value.isDefined) throwISE("final value already set")
    else new SetOnceCredential
  }
  private def throwISE(msg: String) = throw new IllegalStateException(msg)

  @implicitNotFound(msg = "This value cannot be assigned without the proper credential token.")
  class SetOnceCredential private[SetOnce]
}

object SetOnce {
  implicit def unwrap[A](wrapped: SetOnce[A]): A = wrapped()
}

Мы получаем безопасность во время компиляции, поскольку := не вызывается случайно, поскольку нам нужен SetOnceCredential объекта, который возвращается только один раз. Тем не менее, переменная может быть переназначена при условии, что у вызывающего объекта есть исходные учетные данные. Это работает с AnyVals и AnyRefs. Неявное преобразование позволяет мне напрямую использовать имя переменной во многих случаях, и если это не сработает, я могу преобразовать его явно, добавив ().

Типичное использование будет следующим:

object AppProperties {

  private val mgr = new SetOnce[FileManager]
  private val mgr2 = new SetOnce[FileManager]

  val init /*(config: Config)*/ = {
    var inited = false

    (config: Config) => {
      if (inited)
        throw new IllegalStateException("AppProperties already initialized")

      implicit val mgrCredential = mgr.allowAssignment
      mgr := makeFileManager(config)
      mgr2 := makeFileManager(config) // does not compile

      inited = true
    }
  }

  def calledAfterInit {
    mgr2 := makeFileManager(config) // does not compile
    implicit val mgrCredential = mgr.allowAssignment // throws exception
    mgr := makeFileManager(config) // never reached
}

Это не приводит к ошибке времени компиляции, если в какой-то другой точке того же файла я пытаюсь получить другие учетные данные и переназначить переменную (как в calledAfterInit), но терпит неудачу во время выполнения.

Я предполагаю, что вам не нужно делать это эффективно с примитивами, и для простоты вам также не нужно хранить null (но вы, конечно, можете изменить идею, если эти предположения ложны):

class SetOnce[A >: Null <: AnyRef] {
  private[this] var _a = null: A
  def set(a: A) { if (_a eq null) _a = a else throw new IllegalStateException }
  def get = if (_a eq null) throw new IllegalStateException else _a
}

и просто используйте этот класс везде, где вам нужна эта функциональность. (Может быть, вы бы предпочли apply() get?)

Если вы действительно хотите, чтобы это выглядело как доступ к переменной (или методу) без каких-либо дополнительных трюков, сделайте SetOnce закрытым и

private val unsetHolder = new SetOnce[String]
def unsetVar = unsetHolder.get
// Fill in unsetHolder somewhere private....

Не самый лучший способ и не совсем то, о чем вы просили, но он дает вам некоторую инкапсуляцию доступа:

object AppProperties {
  def mgr = _init.mgr
  def init(config: Config) = _init.apply(config)

  private object _init {
    var mgr: FileManager = _
    def apply(config: Config) = {   
      mgr = makeFileMaker(config)
    }
  }
}

Глядя на сообщение JPP, у меня есть сделал еще один вариант:

class SetOnce[T] {
  private[this] var value: Option[T] = None
  private[this] var key: Option[SetOnceCredential] = None
  def isSet = value.isDefined
  def ensureSet { if (value.isEmpty) throwISE("precondition violated: uninitialized value") }
  def apply() = value getOrElse throwISE("uninitialized value")

  def :=(finalValue: T)(implicit credential: SetOnceCredential = null): SetOnceCredential = {
    if (key != Option(credential)) throwISE("Wrong credential")
    else key = Some(new SetOnceCredential)

    value = Some(finalValue)
    key get
  }
  private def throwISE(msg: String) = throw new IllegalStateException(msg)

  class SetOnceCredential private[SetOnce]
}

private val mgr1 = new SetOnce[FileManager]
private val mgr2 = new SetOnce[FileManager]

val init /*(config: Config)*/ = {
    var inited = false

    (config: Config) => {
      if (inited)
        throw new IllegalStateException("AppProperties already initialized")


      implicit val credential1 = mgr1 := new FileManager(config)
      mgr1 := new FileManager(config) // works

      implicit val credential2 = mgr2 := new FileManager(config) // We get a new credential for this one
      mgr2 := new FileManager(config) // works

      inited = true
    }
}

init(new Config)
mgr1 := new FileManager(new Config) // forbidden

На этот раз нам вполне разрешено назначать переменную несколько раз, но нам нужно иметь правильные учетные данные в области видимости. Учетные данные создаются и возвращаются при первом назначении, поэтому нам нужно немедленно сохранить их в implicit val credential = mgr := new FileManager(config). Если учетные данные неверны, он не будет работать.

(Обратите внимание, что неявные учетные данные не работают, если в области действия больше учетных данных, поскольку они будут иметь один и тот же тип. Возможно, это можно обойти, но я не уверен в данный момент.)

Я думал что-то вроде:

object AppProperties {                                        
  var p : Int => Unit = { v : Int => p = { _ => throw new IllegalStateException } ; hiddenx = v  }
  def x_=(v : Int) = p(v)
  def x = hiddenx                                                     
  private var hiddenx = 0                                             
}

X можно установить ровно один раз.

Это не совсем то же самое, но во многих случаях решение для «установить переменную один раз, а затем продолжать ее использовать» — это простое создание подклассов со специальным фабричным методом или без него.

abstract class AppPropertyBase {
  def mgr: FileManager
}

//.. somewhere else, early in the initialisation
// but of course the assigning scope is no different from the accessing scope

val AppProperties = new AppPropertyBase {
  def mgr = makeFileMaker(...)
}

Вы всегда можете переместить это значение в другой объект, инициализировать его только один раз и получить к нему доступ при необходимости.

object FileManager { 

    private var fileManager : String = null
    def makeManager(initialValue : String ) : String  = { 
        if( fileManager  == null ) { 
            fileManager  = initialValue;
        }
        return fileManager  
    }
    def manager() : String  = fileManager 
}

object AppProperties { 

    def init( config : String ) { 
        val y = FileManager.makeManager( config )
        // do something with ... 
    }

    def other()  { 
        FileManager.makeManager( "x" )
        FileManager.makeManager( "y" )
        val y =  FileManager.manager()
        // use initilized y
        print( y )
        // the manager can't be modified
    }
}
object Main { 
    def main( args : Array[String] ) {

        AppProperties.init("Hello")
        AppProperties.other
    }
}