Scala: eine Variable einmal ohne val Zuordnung

Question

Dies ist, was ich tun will -

class A(some args) { 
    var v: SomeType = null 
    def method1(args) = { 
    v = something1 
    ... 
    method3 
    } 

    def method2(args) = { 
    v = something2 
    ... 
    method3 
    } 
    def method3 = { 
    // uses v 
    } 
} 

In diesem speziellen Fall method1 und 2 sich gegenseitig aus und einer von ihnen wird genau einmal in der Lebensdauer eines genannt Instanz von A. Außerdem wird v einmal zugewiesen. Ich würde es lieber ein val machen. Aber da ich den Kontext von method2 oder method3 benötige, um v zu initialisieren, kann ich das im Konstruktor nicht tun.

Wie kann dieses "val" Verhalten erreicht werden? Ich kann daran denken, Methode1 und Methode2 zu ändern, um Methoden anzuwenden, aber ich mag die Idee nicht. Darüber hinaus haben Methode 1 und 2 dieselbe Argumentsignatur (daher würden für die Unterscheidung der zwei Arten von Anrufen einige weitere Informationen benötigt).

Answer 1

Eine wichtige Frage ist: Was genau nennen Sie "Val-Verhalten"? Für mich ist "val behaviour" das wird sofort bei der Deklaration zugewiesen, was statisch erzwungen werden kann. Sie scheinen zu erzwingen, dass v nicht doppelt vergeben wird. Sie möchten möglicherweise auch erzwingen ist nie lesen, bevor es zugewiesen ist.

final class OnceBox[A] { 
    private[this] var value: Option[A] = None 

    def update(v: A): Unit = { 
    if (value.isDefined) 
     throw new IllegalStateException("Value assigned twice") 
    value = Some(v) 
    } 

    def apply(): A = { 
    value.getOrElse { 
     throw new IllegalStateException("Value not yet assigned") 
    } 
    } 
} 

und jetzt Ihr Snippet:

class A(some args) { 
    val v = new OnceBox[SomeType] 
    def method1(args) = { 
    v() = something1 
    ... 
    method3 
    } 

    def method2(args) = { 
    v() = something2 
    ... 
    method3 
    } 
    def method3 = { 
    // uses v 
    v() 
    } 
} 

Oh, und nur ein Scherz, aber Ozma hat Single-Zuordnung vals Einbau-:-P

Sie könnten eine sehr kleine Helfer-Box für das erstellen

Answer 2

So etwas wie dieses vielleicht:

class A private (mtdType: Int, ...) { 
     val v = mdtType match { 
     case 1 => method1(...) 
     case 2 => method2(...) 
     } 
    } 


    object A { 
    def withMethod1(...) = new A(1, ...) 
    def withMethod2(...) = new A(2, ...) 
    } 

Oder eine andere Möglichkeit:

sealed trait A { 
    val v 
    def method3 = println(v) 
    } 

    class Method1(...) extends A { 
     val v = method1(...) 
    } 

    class Method2(...) extends A { 
     val v = method2(...) 
    } 

Answer 3

Ähnliche Idee zu der anderen Antwort, aber statt Subtypen, ein Feld.

scala> :pa 
// Entering paste mode (ctrl-D to finish) 

class A { 
    private[this] var context: Int = _ 
    lazy val v: String = 
    context match { 
     case 1 => "one" 
     case 2 => "two" 
     case _ => ??? 
    } 
    def m1() = { context = 1 ; v } 
    def m2() = { context = 2 ; v } 
} 

// Exiting paste mode, now interpreting. 

defined class A 

scala> val a = new A 
a: A = A@62ce72ff 

scala> a.m2 
res0: String = two 

scala> a.m1 
res1: String = two