Pourquoi F # infère-t-il ce type?

Question

Ceci est mon code:

type Cell<'t>(initial : 't) = 
    let mutable v = initial 
    let callbacks = new List<'t -> unit>() 
    member x.register c = callbacks.Add(c) 
    member x.get() = v 
    member x.set v' = 
     if v' <> v 
     then v <- v' 
      for callback in callbacks do callback v' 
    member x.map f = 
     let c = new Cell<_>(f v) 
     x.register(fun v' -> c.set (f v')) ; c 

Mon problème est avec le membre map. F # infère le type

map : ('t -> 't) -> Cell<'t> 

Je pense qu'il devrait en déduire ce type plus général (comme la carte de Seq):

map : ('t -> 'a) -> Cell<'a> 

Et en fait, si je déclare le type comme ça, Visual Studio me dit que le type 'a a été contraint de t' à cause de l'expression (f v') dans c.set (f v'). Est-ce le problème que la nouvelle cellule est obligée d'avoir? Cellule < 't> parce que nous sommes dans la définition de la classe?

Je suis sûr que ce problème parce que si je définis la carte en fonction séparée puis F # n'infère le type que je veux:

let map f (c : Cell<_>) = 
    let c' = new Cell<_>(f (c.get())) 
    c.register(fun v' -> c'.set (f v')) ; c' 

A savoir

map : ('a -> 'b) -> Cell<'a> -> Cell<'b> 

Je voudrais utiliser un membre, mais ce type moins général rend mon type de cellule inutile ... Comment résoudre ce problème?

Merci! Jules

Answer 1

Je n'ai pas de boîte avec Beta1 à portée de main en ce moment (dans nos bits internes cela semble maintenant indiquer le type correct, donc j'espère que cela sera corrigé dans Beta2).

Je pense que vous pouvez spécifier une signature de type complet:

member x.map<'a> (f:'t -> 'a) : Cell<'a> = 

et cela fonctionnera.

MISE À JOUR

J'ai essayé sur Beta1, et en fait la 'solution' est

member x.set (v':'t) : unit = 

Je suis pas clair pourquoi l'ajout de cette signature de type aide.