anchor.diff:              let dict = new ConcurrentDictionary<'Key, List<'T>>()
               stream |> Internals.iterCont 
                   (fun cts -> nocurry(); fun value -> 
  -                                        let mutable grouping = Unchecked.defaultof<List<'T>>
  -                                        let key = projection value
  -                                        if dict.TryGetValue(key, &grouping) then
  -                                            let list = grouping
  -                                            lock grouping (fun () -> list.Add(value))
  -                                        else
  -                                            grouping <- new List<'T>()
  -                                            if not <| dict.TryAdd(key, grouping) then
  -                                                dict.TryGetValue(key, &grouping) |> ignore
  -                                            let list = grouping
  -                                            lock grouping (fun () -> list.Add(value)))
  +                                let mutable grouping = Unchecked.defaultof<List<'T>>
  +                                let key = projection value
  +                                if dict.TryGetValue(key, &grouping) then
  +                                    let list = grouping
  +                                    lock grouping (fun () -> list.Add(value))
  +                                else
  +                                    grouping <- new List<'T>()
  +                                    if not <| dict.TryAdd(key, grouping) then
  +                                        dict.TryGetValue(key, &grouping) |> ignore
  +                                    let list = grouping
  +                                    lock grouping (fun () -> list.Add(value)))
                    (fun () -> 
  -                                        let stream' = dict |> ofSeq |> map (fun keyValue -> (keyValue.Key, keyValue.Value :> seq<'T>))   
  -                                        stream' |> Internals.looksLike stream))
  +                                let stream' = dict |> ofSeq |> map (fun keyValue -> (keyValue.Key, keyValue.Value :> seq<'T>))   
  +                                stream' |> Internals.looksLike stream))
           
   
       /// <summary>Returns the first element for which the given function returns true. Returns None if no such element exists.</summary>
  
positive.code:                     state
                  | _ -> state) 
                (fun left right -> 
                  match left, right with
                  | Some (_, key), Some (_, key') ->
                      if !key' > !key then right else left
                  | None, _ -> right
                  | _, None -> left) 
                (fun () -> None) 
  
          match result with
  
negative.code:                     state 
                  | _ -> state) 
                (fun left right -> 
                                      match left, right with
                                      | Some (_, key), Some (_, key') ->
                                          if !key' > !key then left else right
                                      | None, _ -> right
                                      | _, None -> left) 
                (fun () -> None) 
  
          match result with
  