Come usare puri di D 2.0

Question

Durante la riproduzione in giro con D 2.0 Ho trovato il seguente problema:

Esempio 1:

pure string[] run1() 
{ 
    string[] msg; 
    msg ~= "Test"; 
    msg ~= "this."; 
    return msg; 
} 

Questo compila e funziona come previsto.

Quando provo ad avvolgere la matrice di stringhe in una classe che trovo non riesco a far funzionare tutto questo:

class TestPure 
{ 
    string[] msg; 
    void addMsg(string s) 
    { 
     msg ~= s; 
    } 
}; 

pure TestPure run2() 
{ 
    TestPure t = new TestPure(); 
    t.addMsg("Test"); 
    t.addMsg("this."); 
    return t; 
} 

Questo codice non verrà compilato perché la funzione addMsg è impuro. Non riesco a rendere tale funzione pura poiché altera l'oggetto TestPure. Mi manca qualcosa? O è una limitazione?

Di seguito si compila:

pure TestPure run3() 
{ 
    TestPure t = new TestPure(); 
    t.msg ~= "Test"; 
    t.msg ~= "this."; 
    return t; 
} 

Può la ~ = operatore non stata implementata in funzione impura della matrice msg? Come mai il compilatore non si lamenta di ciò nella funzione run1?

Answer 1

Dalla v2.050, D ha attenuato la definizione di pure per accettare anche le cosiddette funzioni "debolmente pure". Questo si riferisce alle funzioni "do not read or write any global mutable state". Le funzioni debolmente pure sono non le stesse come pure funzioni nel senso della lingua funzionale. L'unica relazione è che fanno vere e proprie funzioni pure, a.k.a. "Puramente" funzioni in grado di chiamare i deboli, come nell'esempio di OP.

Con questo, addMsgpuò contrassegnati come (debolmente) pure, poiché solo la variabile locale this.msg è modificato:

class TestPure 
{ 
    string[] msg; 
    pure void addMsg(string s) 
    { 
     msg ~= s; 
    } 
}; 

e, naturalmente, ora è possibile utilizzare il (forte) pure funzione run2 senza modifiche.

pure TestPure run2() 
{ 
    TestPure t = new TestPure(); 
    t.addMsg("Test"); 
    t.addMsg("this."); 
    return t; 
} 

Answer 2

Si prega di rivedere la definizione di funzioni pure:

• http://en.wikipedia.org/wiki/Pure_function
• http://www.digitalmars.com/d/2.0/function.html#pure-functions

funzioni pure sono funzioni che producono lo stesso risultato per gli stessi argomenti. A tal fine, una funzione di pura:

• ha dei parametri che sono tutti invarianti o che sono implicitamente convertibili in invariante
• non legge o scrivere qualsiasi stato mutevole globale

Uno degli effetti di usare le funzioni pure è che possono essere parallelizzate in sicurezza. Tuttavia, non è sicuro eseguire più istanze della funzione in parallelo, poiché potrebbero modificare contemporaneamente l'istanza della classe, causando un problema di sincronizzazione.

Answer 3

Solo un sospetto, ma questa funzione non restituisce sempre lo stesso risultato.

Vedere, restituisce un riferimento a qualche oggetto e mentre l'oggetto conterrà sempre gli stessi dati, gli oggetti restituiti da più chiamate alle stesse funzioni non sono identici; cioè, non hanno lo stesso indirizzo di memoria.

Quando si restituisce un riferimento all'oggetto, si restituisce essenzialmente un indirizzo di memoria, che sarà diverso tra più chiamate.

Un altro modo di pensarci, parte del valore di ritorno è l'indirizzo di memoria di un oggetto, che dipende da alcuni stati globali, e se l'output di una funzione dipende dallo stato globale, quindi non è puro. Diavolo, non deve nemmeno dipendere da ciò; finché una funzione legge uno stato globale, allora non è pura. Chiamando "nuovo", stai leggendo stato globale.

Answer 4

I pensare che il codice sia concettualmente corretto.Comunque potresti aver trovato casi in cui l'analisi semantica del compilatore non è buona come quella del tuo cervello.

Considerare il caso in cui la fonte della classe non è disponibile. In questi casi il compilatore non avrebbe modo di dire che addMsg modifica solo la variabile membro in modo che non possa permetterti di chiamarla da una funzione pura.

Per consentire nel tuo caso, dovrebbe avere una gestione caso speciale per questo tipo di utilizzo. Ogni regola di caso speciale aggiunta rende la lingua più complicata (o, se non documentata, la rende meno portabile)

Answer 5

Altri hanno già sottolineato che addMsg non è puro e non può essere puro perché muta lo stato dell'oggetto.

L'unico modo per renderlo puro è incapsulare le modifiche che stai apportando. Il modo più semplice per farlo è tramite la mutazione del ritorno e ci sono due modi per implementarlo.

In primo luogo, si potrebbe fare così:

class TestPure 
{ 
    string[] msg; 
    pure TestPure addMsg(string s) 
    { 
     auto r = new TestPure; 
     r.msg = this.msg.dup; 
     r.msg ~= s; 
     return r; 
    } 
} 

È necessario copiare la matrice precedente, perché all'interno di una funzione pura, il riferimento this è in realtà const. Nota che potresti fare meglio la copia allocando un nuovo array della dimensione finale e poi copiando gli elementi in te stesso. Si potrebbe utilizzare questa funzione in questo modo:

pure TestPure run3() 
{ 
    auto t = new TestPure; 
    t = t.addMsg("Test"); 
    t = t.addMsg("this."); 
    return t; 
} 

In questo modo, la mutazione si limita a ciascuna funzione pura con i cambiamenti passati tramite valori di ritorno.

Un modo alternativo di scrivere TestPure sarebbe quello di rendere i membri const e fare tutto la mutazione prima di passarlo al costruttore:

class TestPure 
{ 
    const(string[]) msg; 
    this() 
    { 
     msg = null; 
    } 
    this(const(string[]) msg) 
    { 
     this.msg = msg; 
    } 
    pure TestPure addMsg(string s) 
    { 
     return new TestPure(this.msg ~ s); 
    } 
} 

Speranza che aiuta.