anchor.diff:      
       type ModChange<'a>(m : pmod<'a>, value : 'a) =
           interface Op with
  +            member x.Target = m :> obj
               member x.Run() =
                   let old = m.Value
                   m.Ref.Value <- value
   
                   ModChange(m, old) :> Op
   
  -            member x.ConflictsWith o =
  -                false
  -
  +            member x.TryMerge o =
  +                match o with
  +                    | :? ModChange<'a> as o ->
  +                        None
  +                    | _ -> 
  +                        failwith "impossible"
  +
  +        override x.ToString() =
  +            sprintf "%s = %A" m.Name value
   
       let change (m : pmod<'a>) (value : 'a) =
           Single [ModChange(m, value) :> Op]
  
positive.code:         git.merge "a10"
          print()
  
          // and back to master
          git.checkout "master"
          print()
  
negative.code:                         ops |> List.iter (fun o -> w.Undo.[o] <- o.Run())
                      | _ -> ()
  
          let rec forwardMerge (w : WorkingCopy) (conflictTable : Dictionary<obj, Op>) (current : History) (target : History) =
              if current != target then
                  match target with
                      | Commit(b,{ ops = ops }) ->
                          let res, inner = forwardMerge w conflictTable current b
                          let rec tryMerge (ops : list<Op>) =
                              match ops with
                                  | [] -> [], []
                                  | o::ops ->
                                      let working, conflicts = tryMerge ops
  
                                      let op = 
                                          match conflictTable.TryGetValue o.Target with
                                              | (true, other) ->
                                                  match o.TryMerge(other) with
                                                      | Some res ->
                                                          Left res
                                                      | None -> Right (o, other)
                                              | _ -> Left o
  
                                      match op with
                                          | Left o ->
                                              o::working, conflicts
                                          | Right c ->
                                              working, c::conflicts
       
                          let working, conflicts = tryMerge ops
  
                          match res with
                              | Success ->
                                  if List.isEmpty conflicts then 
                                      working |> List.iter (fun o -> w.Undo.[o] <- o.Run())
                                      let result = Change.append inner (Change.ofList working)
  
                                      Success, result
                                  else
                                      backward w b current
                                      Conflicts conflicts, NoChange
  
  
                              | Conflicts inner ->
                                  Conflicts (inner @ conflicts), NoChange
  
                      | _ -> Success, NoChange
              else
                  Success,NoChange
  
          let rec changeFromTo (current : History) (target : History) =
              if current != target then
                  match target with
                      | Commit(b,{ ops = ops }) ->
                          let inner = changeFromTo current b
                          Change.append inner (Change.ofList ops)
                      | _ -> NoChange
              else
                  NoChange
  
      let init (folder : string) = WorkingCopy(folder)
  
  