Valore di incremento in F #

Question

Forse è una cosa troppo semplice da fare, ma non riesco a trovare nessuna risposta nel web
Sto provando a incrementare il valore in F # (come count++ in C#).
Non voglio usare l'opzione "mutabile", Voglio solo vedere un esempio, come dovrebbe essere la funzione di incremento in F #.
E come lo uso.

Answer 1

L'idea di "incrementare un valore" nello stesso senso di C++ ha senso solo quando si lavora con valori mutabili o quando si utilizza una cella di riferimento mutabile (essenzialmente un oggetto semplice che memorizza un valore mutabile). Se si dispone di una cella di riferimento mutevole, è possibile utilizzare incr funzione:

let count = ref 0 
incr count 

Se si utilizza una variabile mutabile, allora non c'è alcuna funzione built-in per questo ed è necessario scrivere count + 1:

let mutable count = 0 
count <- count + 1 

Se si sta scrivendo il codice utilizzando valori immutabili, in genere si scrive solo count + 1 e quindi si passa il risultato a una funzione (o altrove, a seconda del caso specifico). Ad esempio, per calcolare la lunghezza di una lista F #, si può scrivere:

let rec length list = 
    match list with 
    | [] -> 0 
    | _::tail -> 1 + (length tail) 

In questo esempio, l'espressione 1 + (...) è il codice corrispondente alla i++ in un codice C++ che itera su una lista e calcola la sua lunghezza. Il risultato dell'espressione non viene assegnato a una nuova variabile, perché viene restituito direttamente come risultato della funzione length.

EDIT I parametri delle funzioni sono immutabili, ovvero non è possibile modificarne i valori. Come accennato da Lee, è possibile utilizzare lo shadowing variabile per nascondere il vecchio valore con uno nuovo, ma si noti che questo ha solo un effetto locale (è come definire una nuova variabile con un nome diverso per memorizzare il nuovo valore). Ad esempio:

let rec length list count = 
    match list with 
    | [] -> count 
    | _::tail -> 
    let count = count + 1 // Variable shadowing used here 
    length tail count 

Non si può scrivere una funzione per semplificare la linea let count = count + 1 e come menzionato sopra, questo è equivalente a scrivere let newCount = count + 1 e quindi utilizzando newCount nell'ultima riga.

Answer 2

Se non si desidera utilizzare il mutabile, non è possibile eseguire un aggiornamento distruttivo come ++ in C#. Puoi ombreggiare una variabile con una nuova con lo stesso nome, ad es.

let x = 4; 
let x = x + 1 in (x+4) //returns 8 

sebbene non sia possibile scrivere questo come una funzione.

EDIT: Se si vuole utilizzare le variabili mutabili quindi è possibile creare una funzione che modifica una ref:

let increment (ir: int ref) = ir := !ir + 1 

è quindi possibile utilizzare come

let i = ref 1 
increment i 
let iv = !i //iv contains 2 

Come Tomas sottolinea nel suo risposta, questa funzione esiste già e si chiama incr.

Answer 3

Non si può simulare un operatore di post-incremento, ma si può fare preincremento

let inline (+=) (x : byref<_>) y = x <- x + y 

let mutable a = 0 
&a += 1 

o

let inline incv (x : byref<_>) = x <- x + LanguagePrimitives.GenericOne; x 

let mutable b = 0 
incv &b