Compreendendo byref, ref e &

Bem, eu entendi que o F # é capaz de gerenciar referências (algum tipo de referência em C ++). Isso permite a possibilidade de alterar o valor dos parâmetros passados nas funções e também permite que o programador retorne mais de um valor único. No entanto, aqui está o que eu preciso saber:

Palavra-chave de referência: a palavra-chaveref é usado para criar, a partir de um valor, uma referência a esse valor do tipo inferido. assim

let myref = ref 10

Isso significa que o F # criará um objeto do tipoRef<int> colocando lá (no campo mutável) meuint 10.

ESTÁ BEM. Então eu assumo queref é usado para criar instâncias doRef<'a> tipo. Está correto?

Valor de acesso: para acessar um valor armazenado na referência, posso fazer o seguinte:

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

Enquanto o:= O operador apenas permite editar o valor assim:

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

assim! (Bang) desreferencia minha referência. E:= Edite-o. Suponho que isso também esteja correto.

O operador &: O que esse operador faz? É para ser aplicado a um tipo de referência? Não, acho que deve ser aplicado a um valor mutável e isso retorna o quê? A referência? O endereço? Se estiver usando o interativo:

let mutable mutvar = 10;;
&a;;

A última linha gera um erro, então eu não entendo o que o& operador é para.

ByRef: Que talbyref? Isso é muito importante para mim, mas sei que não entendo. Eu entendo que é usado na função referente à passagem de parâmetros. Utilizamos byref quando ele quer que o valor passado possa ser editado (isso é um pouco contra a filosofia das linguagens funcionais, mas f # é algo mais que isso). Considere o seguinte:

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

Isto é estranho. Eu sei que se você tem uma referêncialet myref = ref 10 e faça isso para editar o valor:myref <- 10 surge um erro porque deve ser assim:myref := 10. No entanto, o fato de que nessa função eu posso editarx usando o<- operador significa quex não é uma referência, certo?

Se eu assumir quex não é uma referência, então eu assumo também que, nas funções, ao usarbyref em um parâmetro, esse parâmetro pode ter a sintaxe mutável aplicada. Portanto, é apenas uma questão de sintaxe, se eu assumir isso, estou bem e, de fato, tudo funciona (sem erros de compilador). No entanto, o que éx?

Chamando funções: Como posso usar uma função utilizando parâmetros byref?

o& operador está envolvido, mas você poderia explicar melhor isso, por favor? Neste artigo:Parâmetros e argumentos do MSDN o seguinte exemplo é fornecido:

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