Scala equivalente della variabile statica C++ in una funzione

Question

Sono abbastanza nuovo a Scala e ci siamo imbattuti seguente problema:

ciò che è Scala equivalente della variabile statica della funzione?

void foo() 
{ 
    static int x = 5; 
    x++; 
    printf("%d", x); 
} 

EDIT:

Quello che voglio ottenere è una sorta di contatore chiamata di funzione - Voglio verificare quante volte è stata eseguita la mia funzione e nello stesso tempo limitare il visibilità di questo contatore in modo che non possa essere modificato dall'esterno.

Answer 1

Ecco un blocco di codice che ha effetto simile:

scala> object f extends Function0[Unit] { 
    | var x = 0; 
    | def apply = { 
    |  x = x + 1; 
    |  println(x); 
    | } 
    | } 
defined module f 

scala> f() 
1 

scala> f() 
2 

Anche se devo sottolineare che questa è una pessima pratica dal momento che uccide referential transparency.

Se davvero bisogno di questo comportamento considerare questo:

type State = Int 

def f(state: State) = { 
val newState = state + 1 
println(state); 
newState; 
} 

Answer 2

Scala non ha equivalenti alle variabili statiche locali di C++. In Scala, le regole di scoping sono più coerenti rispetto a C++ o Java - ciò che viene definito all'interno di un blocco, esce dall'ambito di applicazione quando il blocco viene chiuso. Come altri hanno notato, una variabile statica locale sarebbe un effetto collaterale , che non è auspicabile nella programmazione funzionale.

Scala, essendo un linguaggio OO/funzionale ibrido, consente di scrivere in stile imperativo, ma preferisce e incoraggia lo stile funzionale (ad esempio rendendo le raccolte immutabili la scelta predefinita). Le variabili statiche locali, oltre a rappresentare un effetto collaterale di per sé, sono assenti anche in Java, che è un motivo in più per non fornirle in Scala.

Answer 3

Per ottenere l'equivalente di un C++ variabile statica locale a Scala:

import scala.collection.parallel.mutable 
import scala.reflect._ 
import scala.reflect.runtime.universe._ 

object StaticLocal { 
    private val classes = new mutable.ParHashSet[String] 
    private val variables = new mutable.ParHashMap[String, AnyVal] 
} 

import Numeric._ 

class StaticLocal[T <: AnyVal](value:T)(implicit tag: TypeTag[T], num: Numeric[T]){ 
    val name = this.getClass + "." + tag.toString() ; 
    private var inited = false 
    if (!inited) { 
    inited = true 

    if (!StaticLocal.classes.contains(name)) { 
     StaticLocal.classes += name 
     StaticLocal.variables += name -> value.asInstanceOf[AnyVal] 
    } 
    } 
    def get():T = {StaticLocal.variables.get(name) match { case x:Some[Int] => (x.get).asInstanceOf[T] ; case None => throw new Exception("Not found:" + name) }} 
    def set(value:AnyVal) { StaticLocal.variables.put(name, value)} 
    def +(v:StaticLocal[T]):T = { num.plus(this.get, v.get) } 
    def +(v:T):T = { num.plus(this.get, v) } 
    def +=(v:T):Unit = { set(num.plus(this.get, v)) } 
    def +=(v:StaticLocal[T]):Unit = { set(num.plus(this.get, v.get)) } 

    override def toString() = { get.toString} 
    implicit def StaticLocalWrapper(s: StaticLocal[T]):T = s.get 
} 

Poi nel metodo:

def foo():Unit 
{ 
    object x extends StaticLocal(5) 
    x += 1 
    println(x) 
}   

Funzionerà esattamente come in C++, anche quando il metodo o proprietario dell'istanza di classe non rientra nello scope (anche se w con una penalità di prestazioni). Non protetto da thread così com'è.