强制泛型和接口上的F#类型推断保持松散

Question

我们这里真的很开心.我已经在数据的具体表示上测试了一堆树同步代码,现在我需要对它进行抽象,以便它可以运行任何支持正确方法的源和目标.[实际上,这将是Documentum,SQL层次结构和文件系统等来源; 使用Solr和自定义SQL交叉引用存储等目标.

棘手的部分是,当我递归一个类型的树T并同步到一个类型的树时U,在某些文件中,我需要在当前节点处对该类型V执行第二种类型的"子同步" U.(V代表阶层结构的内部文件......),并在F#的类型推理引擎将立即围绕推动我在圈子里就这一点,因为我尝试添加子同步到V.

我在一个代表这个TreeComparison<'a,'b>,所以上面的东西导致a TreeComparison<T,U>和子比较TreeComparison<V,U>.

问题是,只要我TreeComparison<V,'b>在其中一个类方法中提供具体V,当我希望第一个类型参数保持泛型(when 'a :> ITree)时,类型会传播所有推断.也许我可以对TreeComparison<V,'b>价值做一些打字？或者,更有可能的是,推断实际上告诉我,在我思考这个问题的方式中,某些东西本来就被打破了.

这对于压缩来说真的很棘手,但是我想给你可以粘贴到脚本中的工作代码并进行实验,所以一开始就有很多类型......如果你想跳过,核心内容就在最后.通过ITree对大多数类型的实际比较和递归进行了切割,因为没有必要看到我正在敲打的推理问题.

open System

type TreeState<'a,'b> = //'
  | TreeNew of 'a
  | TreeDeleted of 'b
  | TreeBoth of 'a * 'b

type TreeNodeType = TreeFolder | TreeFile | TreeSection

type ITree =
  abstract NodeType: TreeNodeType
  abstract Path: string
      with get, set

type ITreeProvider<'a when 'a :> ITree> = //'
  abstract Children : 'a -> 'a seq
  abstract StateForPath : string -> 'a

type ITreeWriterProvider<'a when 'a :> ITree> = //'
  inherit ITreeProvider<'a> //'
  abstract Create: ITree -> 'a //'
  // In the real implementation, this supports:
  // abstract AddChild : 'a -> unit
  // abstract ModifyChild : 'a -> unit
  // abstract DeleteChild : 'a -> unit
  // abstract Commit : unit -> unit

/// Comparison varies on two types and takes a provider for the first and a writer provider for the second.
/// Then it synchronizes them. The sync code is added later because some of it is dependent on the concrete types.
type TreeComparison<'a,'b when 'a :> ITree and 'b :> ITree> =
  {
    State: TreeState<'a,'b> //'
    ATree: ITreeProvider<'a> //'
    BTree: ITreeWriterProvider<'b> //'
  }

  static member Create(
                        atree: ITreeProvider<'a>,
                        apath: string,
                        btree: ITreeWriterProvider<'b>,
                        bpath: string) =
      { 
        State = TreeBoth (atree.StateForPath apath, btree.StateForPath bpath)
        ATree = atree
        BTree = btree
      }

  member tree.CreateSubtree<'c when 'c :> ITree>
    (atree: ITreeProvider<'c>, apath: string, bpath: string)
      : TreeComparison<'c,'b> = //'
        TreeComparison.Create(atree, apath, tree.BTree, bpath)

/// Some hyper-simplified state types: imagine each is for a different kind of heirarchal database structure or filesystem
type T( data, path: string ) = class
  let mutable path = path
  let rand = (new Random()).NextDouble
  member x.Data = data
  // In the real implementations, these would fetch the child nodes for this state instance
  member x.Children() = Seq.empty<T>

  interface ITree with
    member tree.NodeType = 
      if rand() > 0.5 then TreeFolder
      else TreeFile
    member tree.Path
      with get() = path
      and set v = path <- v
end

type U(data, path: string) = class
  inherit T(data, path)
  member x.Children() = Seq.empty<U>
end

type V(data, path: string) = class
  inherit T(data, path)
  member x.Children() = Seq.empty<V>
  interface ITree with
    member tree.NodeType = TreeSection
end


// Now some classes to spin up and query for those state types [gross simplification makes these look pretty stupid]
type TProvider() = class
  interface ITreeProvider<T> with
    member this.Children x = x.Children()
    member this.StateForPath path = 
      new T("documentum", path)
end

type UProvider() = class
  interface ITreeProvider<U> with
    member this.Children x = x.Children()
    member this.StateForPath path = 
      new U("solr", path)
  interface ITreeWriterProvider<U> with
    member this.Create t =
      new U("whee", t.Path)
end

type VProvider(startTree: ITree, data: string) = class
  interface ITreeProvider<V> with
    member this.Children x = x.Children()
    member this.StateForPath path = 
      new V(data, path)
end


type TreeComparison<'a,'b when 'a :> ITree and 'b :> ITree> with
  member x.UpdateState (a:'a option) (b:'b option) = 
      { x with State = match a, b with
                        | None, None -> failwith "No state found in either A and B"
                        | Some a, None -> TreeNew a
                        | None, Some b -> TreeDeleted b
                        | Some a, Some b -> TreeBoth(a,b) }

  member x.ACurrent = match x.State with TreeNew a | TreeBoth (a,_) -> Some a | _ -> None
  member x.BCurrent = match x.State with TreeDeleted b | TreeBoth (_,b) -> Some b | _ -> None

  member x.CreateBFromA = 
    match x.ACurrent with
      | Some a -> x.BTree.Create a
      | _ -> failwith "Cannot create B from null A node"

  member x.Compare() =
    // Actual implementation does a bunch of mumbo-jumbo to compare with a custom IComparable wrapper
    //if not (x.ACurrent.Value = x.BCurrent.Value) then
      x.SyncStep()
    // And then some stuff to move the right way in the tree


  member internal tree.UpdateRenditions (source: ITree) (target: ITree) =
    let vp = new VProvider(source, source.Path) :> ITreeProvider<V>
    let docTree = tree.CreateSubtree(vp, source.Path, target.Path)
    docTree.Compare()

  member internal tree.UpdateITree (source: ITree) (target: ITree) =
    if not (source.NodeType = target.NodeType) then failwith "Nodes are incompatible types"
    if not (target.Path = source.Path) then target.Path <- source.Path
    if source.NodeType = TreeFile then tree.UpdateRenditions source target

  member internal tree.SyncStep() =
    match tree.State with
    | TreeNew a     -> 
        let target = tree.CreateBFromA
        tree.UpdateITree a target
        //tree.BTree.AddChild target
    | TreeBoth(a,b) ->
        let target = b
        tree.UpdateITree a target
        //tree.BTree.ModifyChild target
    | TreeDeleted b -> 
        ()
        //tree.BTree.DeleteChild b

  member t.Sync() =
    t.Compare()
    //t.BTree.Commit()


// Now I want to synchronize between a tree of type T and a tree of type U

let pt = new TProvider()
let ut = new UProvider()

let c = TreeComparison.Create(pt, "/start", ut , "/path")
c.Sync()

问题可能围绕CreateSubtree.如果您注释掉:

1. 这docTree.Compare()条线
2. 该tree.UpdateITree呼叫

并替换它们(),然后推断保持通用,一切都很可爱.

这真是一个难题.我已经尝试将第二个块中的"比较"函数移出类型并将它们定义为递归函数; 我尝试了一百万种注释或强制打字方式.我只是不明白!

我正在考虑的最后一个解决方案是为子同步进行比较类型和函数的完全独立(和重复)实现.但那是丑陋而可怕的.

谢谢,如果你读到这么远!啧!

Answer 1

我没有分析足够的代码来弄清楚原因,但补充说

  member internal tree.SyncStep() : unit =
                             //   ^^^^^^

似乎解决了这个问题.

编辑

也可以看看

为什么F#推断这种类型？

了解F#值限制错误

未知需要类型注释或强制转换

获得对F#类型推理算法的功能和限制的深入理解需要经验.但是这个例子似乎是人们在做非常高级的事情时遇到的一类问题.对于类的成员,F#推理算法就像这样

1. 查看所有成员显式签名,为所有成员设置初始类型环境
2. 对于具有完全显式签名的任何成员,请将其类型修复为显式签名
3. 开始从上到下,从左到右开始阅读方法体(在执行此操作时,您会遇到一些可能涉及未解决的类型变量的"前向引用",这可能会导致麻烦,因为...)
4. 同时解决所有成员团体(......但是我们还没有做过任何'概括',那个'推断类型参数'而不是'修复'的部分在理论上可以是'a'的任何具体类型的函数它的第一个呼叫站点使用)
5. Generalize(任何剩余未解决的类型变量成为泛型方法的实际推断类型变量)

这可能不完全正确; 我不太清楚它描述算法,我只是对它有所了解.你总是可以去阅读语言规范.

经常发生的是你得到子弹3并迫使推理器开始尝试同时解决/约束所有方法体,而实际上它是不必要的,因为,例如,某些函数可能具有简单的具体固定类型.就像SyncStep是unit-> unit一样,但是F#在步骤3中还不知道它,因为签名不是明确的,它只是说好了SyncStep对于某些尚未解决的类型'a'而言类型为"unit - >'a"那么现在SyncStep现在通过引入一个不必要的变量而不必要地使所有解决方案复杂化.

我发现这个的方式是,第一个警告(这个构造导致代码不如类型注释所指示的那样通用.类型变量'a被约束为类型'V')位于体的最后一行调用docTree.Compare()时的UpdateRenditions.现在我知道Compare()应该是unit - > unit.所以,我怎么可能会得到一个有关通用岬警告存在？啊,好吧,编译器不知道返回类型是那个时候的单位,所以它必须是通用的东西不是.事实上,我可以将返回类型注释添加到Compare而不是SyncStep - 任何一个都可以.

无论如何,我很啰嗦.总结一下

• 如果你有一个良好的类型的程序,它应该'工作'
• 有时推理算法的细节需要一些"额外"注释......在最坏的情况下,你可以"全部添加",然后"减去不必要的"
• 通过使用编译器警告和推理算法的一些心理模型,您可以快速转向缺少注释的经验
• 通常情况下,"修复"只是将一个完整类型的签名(包括返回类型)添加到某个关键方法中,该关键方法是"声明延迟"但"早期调用"(在成员集中引入前向引用)

希望有所帮助!