let transform xs =
        xs
        |> Seq.groupBy ^ fun x -> x.ParentId
        |> Seq.map ^ fun (id, items) ->
            let children = items
                           |> Seq.map ^ fun x -> { Id = x.Id; Children = [] }
                           |> Seq.toList
            
            { Id = id; Children = children }

let updateObservableCollection
      (create: 's -> 'id -> 't)
      update
      (target: ObservableCollection<'t>, getTargetId: 't -> 'id)
      (source: 's array, getSourceId: 's -> 'id) =

  let kvp (k, v) = KeyValuePair<_,_>(k, v)

  let targetIds = target |> Seq.map getTargetId |> Seq.toFlatList
  let sourceIds = source |> Seq.map getSourceId |> Seq.toFlatList

  let targetIdsSet = targetIds |> HashSet.ofSeq
  let sourceIdsSet = sourceIds |> HashSet.ofSeq

  let targetIdsMap = targetIds |> Seq.mapi (fun i id -> kvp(id, i)) |> Seq.toHashMap

  let removes =
    targetIdsSet.Except sourceIdsSet
    |> Seq.map (fun id -> targetIdsMap.[id])
    |> Seq.sortDescending
    |> Seq.toFlatList

  removes |> Seq.iter target.RemoveAt

  let sourceIdsMap = sourceIds |> Seq.mapi (fun i id -> kvp(id, i)) |> Seq.toHashMap
  let adds =
    sourceIdsSet.Except targetIdsSet
    |> Seq.map (fun id -> id, sourceIdsMap.[id])
    |> Seq.sortBy (fun (_, idx) -> idx)
    |> Seq.toFlatList

  adds |> Seq.iter (fun (id, index) -> target.Insert(index, create (source.[index]) id))

  sourceIds
  |> Seq.iter (fun id ->
    let newIdx = sourceIdsMap.[id]
    let oldIdx = target |> Seq.mapi (fun i t -> i, getTargetId t) |> Seq.where (fun (_, tId) -> id = tId) |> Seq.map fst |> Seq.head
    target.Move(oldIdx, newIdx)
    update newIdx
  )