F #: comportement d'inférence de type impair

Question

Tout d'abord, j'ai une meilleure méthode de traitement de ce problème, donc ce n'est pas un problème.

Cependant, c'est quelque chose que je ne comprends pas. Quelqu'un peut-il expliquer cela?

Quand je définit la fonction d'échange comme:

namespace Utilities 
module Misc 

let Swap (left : 'a byref) (right : 'a byref) = 
    let temp = left 
    left <- right 
    right <- temp 

Je suis en mesure d'utiliser la fonction de swap comme celui-ci très bien.

Misc.Swap (&s.[i]) (&s.[j]) 

Mais quand je définis le module comme:

namespace Utilities 

type Misc = 
    static member Swap (left : 'a byref) (right : 'a byref) = 
     let temp = left 
     left <- right 
     right <- temp 

Je reçois l'erreur suivante sur les deux arguments:

This expression has type 'b byref but is here used with type 'a ref 

Comment l'inférence de type pour les arguments de l'appelant changement en déplaçant la fonction dans un type?

Answer 1

Cela peut être une interaction avec la transformation de tuple que le compilateur F # effectue sur les méthodes de classe.

réflecteur indique le type de Misc.Swap que:

public static void Swap<a>(ref a left, ref a right); 

afin que nous puissions voir ici que le compilateur a transformé les arguments cari en forme uplées.

Définition de la méthode avec des arguments uplées évite ce problème:

type Misc = 
    static member Swap(left : 'a byref, right : 'a byref) = 
     let temp = left 
     left <- right 
     right <- temp  

> let s = Array.init 3 (fun i -> i) 
> val s : int array = [|0; 1; 2|] 
> Misc.Swap (&s.[2], &s.[0]) 
> s;; 
> val s : int array = [|2; 1; 0|]