Bueno, llegué a comprender que F # es capaz de administrar referencias (algún tipo de referencias similares a C ++). Esto permite la posibilidad de cambiar el valor de los parámetros pasados en las funciones y también permite que el programador devuelva más de un solo valor. Sin embargo, esto es lo que necesito saber:

alabra clave @Ref: la palabra claveref se utiliza para crear, a partir de un valor, una referencia a ese valor del tipo inferido. Asi qu

let myref = ref 10

Esto significa que F # creará un objeto de tipoRef<int> poniendo allí (en el campo mutable) miint 10.

OKAY. Entonces supongo queref se usa para crear instancias deRef<'a> tipo. ¿Es correcto

Valor de acceso: para acceder a un valor almacenado en la referencia, puedo hacer esto:

let myref = ref 10
let myval = myref.Value
let myval2 = !myref

Mientras que la:= operator solo me permite editar el valor de esta manera:

let myref = ref 10
myref.Value <- 30
myref := 40

Asi que! (Bang) desreferencia mi referencia. Y:= editarlo. Supongo que esto también es correcto.

The & operator: ¿Qué hace este operador? ¿Se debe aplicar a un tipo de referencia? No, supongo que debe aplicarse a un valor mutable y esto devuelve ¿qué? ¿La referencia? ¿La dirección? Si usa interactivo:

let mutable mutvar = 10;;
&a;;

a última línea arroja un error, así que no entiendo lo que la& operador es para.

ByRef: ¿Qué pasa conbyref? Eso es muy importante para mí, pero me doy cuenta de que no lo entiendo. Entiendo que se usa en la función con respecto al paso de parámetros. Uno usa byref cuando quiere que el valor pasado se pueda editar (esto es un poco en contra de la filosofía de los lenguajes funcionales, pero f # es algo más que eso). Considera lo siguiente

let myfunc (x: int byref) =
    x <- x + 10

Esto es extraño. Sé que si tienes una referencialet myref = ref 10 y luego haga esto para editar el valor:myref <- 10 surge un error porque debería ser así:myref := 10. Sin embargo, el hecho de que en esa función puedo editarx utilizando la<- operador significa quex no es una referencia, ¿verdad?

Si supongo quex no es una referencia, entonces asumo también que, en funciones, cuando usobyref en un parámetro, a ese parámetro se le puede aplicar la sintaxis mutable. Por lo tanto, es solo una cuestión de sintaxis, si asumo esto, estoy bien y, de hecho, todo funciona (sin errores de compilación). Sin embargo, ¿qué esx?

Funciones de llamada: ¿Cómo puedo usar una función que utiliza parámetros byref?

Los& operador está involucrado pero ¿podría explicar esto mejor por favor? En este articulo: Parámetros y argumentos de MSDN se proporciona el siguiente ejemplo:

type Incrementor(z) =
    member this.Increment(i : int byref) =
       i <- i + z

let incrementor = new Incrementor(1)
let mutable x = 10
// A: Not recommended: Does not actually increment the variable. (Me: why?)
incrementor.Increment(ref x)
// Prints 10.
printfn "%d" x  

let mutable y = 10
incrementor.Increment(&y) (* Me: & what does it return? *)
// Prints 11.
printfn "%d" y 

let refInt = ref 10
incrementor.Increment(refInt) (* Why does it not work in A, but here it does? *)
// Prints 11.
printfn "%d" !refInt