anchor.diff:                      if s.HasValue then
                           store.Remove s.Value |> ignore
                           let (_,s) = s.Value
  -                        s
  +                        Some s
                       else
  -                        failwith "[AList] removing unknown index"
  +                        None
  +                        //failwith "[AList] removing unknown index"
   
                   member x.Clear() =
                       store.Clear()
  
positive.code:             override x.Compute(token) =
                  reader.GetOperations token 
                      |> HDeltaSet.toSeq
                      |> Seq.map (fun d ->
                          match d with
                              | Add(1,v) -> 
                                  let k = mapping.Invoke v
                                  let i = indices.Invoke k
                                  i, Set v
                              | Rem(1,v) ->
                                  let k = mapping.Revoke v
                                  let i = indices.Revoke k
                                  i, Remove
                              | _ ->
                                  failwith ""
                      )
  
negative.code:             override x.Compute(token) =
                  reader.GetOperations token
                      |> HDeltaSet.toSeq
                      |> Seq.choose (fun d ->
                          match d with
                              | Add(1,v) -> 
                                  let i = indices.Invoke v
                                  Some (i, Set v)
                              | Rem(1,v) ->
                                  match indices.Revoke v with
                                      | Some i -> Some(i, Remove)
                                      | None -> None
                              | _ ->
                                  failwith ""
                      )
  