Принуждение вывода типа F # на дженериках и интерфейсах оставаться свободным

Мы получаем здесь волосатый. Я протестировал кучу дерева-синхронизирующего кода для конкретных представлений данных, и теперь мне нужно отвлечь его, чтобы он мог работать с любым источником и целью, которые поддерживают правильные методы. [На практике это будут такие источники, как Documentum, иерархии SQL и файловые системы; с такими местами, как Solr и специализированное хранилище перекрестных ссылок SQL.]

Сложная часть заключается в том, что когда я возвращаю дерево типа T и синхронизируюсь с деревом типа U, в определенных файлах мне нужно выполнить "подсинхронизацию" второго типа V к этому типу U в текущем node. (V представляет иерархическую структуру внутри файла...) И механизм ввода типа в F # меня крутит вокруг, как только я пытаюсь добавить субсинхронизацию к V.

Я представляю это в TreeComparison<'a,'b>, поэтому приведенный выше результат приводит к TreeComparison<T,U> и суб-сравнению TreeComparison<V,U>.

Проблема заключается в том, что, как только я поставлю конкретный TreeComparison<V,'b> в одном из методов класса, тип V распространяется через весь вывод, когда я хочу, чтобы этот параметр первого типа оставался общим (when 'a :> ITree). Возможно, есть некоторая типизация, которую я могу сделать в значении TreeComparison<V,'b>? Или, скорее, вывод на самом деле говорит мне, что что-то по своей сути нарушается в том, как я думаю об этой проблеме.

Это было очень сложно сжать, но я хочу дать рабочий код, который вы можете вставить в script, и поэкспериментировать с ним, поэтому в начале есть тонна типов... основной материал находится прямо в конце if вы хотите пропустить. Большая часть фактического сравнения и рекурсии по типам через 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. Если вы закомментируете либо:

• Строка docTree.Compare()
• tree.UpdateITree вызывает

и замените их на (), тогда вывод останется общим, и все будет прекрасно.

Это была довольно загадка. Я попытался переместить функции сравнения во втором фрагменте из типа и определить их как рекурсивные функции; Я пробовал миллион способов аннотации или принуждения ввода. Я просто не понимаю!

Последнее решение, которое я рассматриваю, представляет собой полностью отдельную (и дублированную) реализацию типа сравнения и функций для синхронизации. Но это уродливое и страшное.

Спасибо, если вы прочтете это! Sheesh!

Ответы

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