anchor.diff:          | _ -> None
   
       let hashSets (com: ICompiler) (i: Fable.ApplyInfo) =
  +        let makeHashSet forceFSharp args =
  +            makeDictionaryOrHashSet i.range i.returnType "Set" forceFSharp i.calleeTypeArgs.Head args
           match i.methodName with
           | ".ctor" ->
               let makeComparer (e: Fable.Expr) =
                   ccall_ e.Range e.Type "Comparer" "fromEqualityComparer" [e]
               match i.methodArgTypes with
               | [] | [IEnumerable] ->
  -                makeHashSet i.range i.returnType false i.calleeTypeArgs.Head i.args |> Some
  +                makeHashSet false i.args |> Some
               | [IEnumerable; IEqualityComparer] ->
                   [i.args.Head; makeComparer i.args.Tail.Head]
  -                |> makeHashSet i.range i.returnType true i.calleeTypeArgs.Head |> Some
  +                |> makeHashSet true |> Some
               | [IEqualityComparer] ->
                   [Fable.Value Fable.Null; makeComparer i.args.Head]
  -                |> makeHashSet i.range i.returnType true i.calleeTypeArgs.Head |> Some
  +                |> makeHashSet true |> Some
               | _ -> None
           | "count" ->
               makeGet i.range i.returnType i.callee.Value (makeStrConst "size") |> Some
  
positive.code:         CoreLibCall(modName, Some "create", false, args)
          |> makeCall i.range i.returnType
  
      let makeDictionary r t forceFSharpMap keyType args =
          let makeFSharpMap keyType args =
              match args with
              | [iterable] -> [iterable; makeComparer (Some keyType)]
              | args -> args
              |> ccall_ r t "Map" "create"
          if forceFSharpMap
          then makeFSharpMap keyType args
          else
              match keyType with
              | Fable.ExtendedNumber _ | Fable.Array _ | Fable.Tuple _ ->
                  makeFSharpMap keyType args
              | Fable.DeclaredType(ent, _) when ent.HasInterface("System.IComparable") ->
                  makeFSharpMap keyType args
              | _ ->
                  GlobalCall("Map", None, true, args) |> makeCall r t
  
      let makeHashSet r t forceFSharpSet valueType args =
          let makeFSharpSet valueType args =
              match args with
              | [iterable] -> [iterable; makeComparer (Some valueType)]
              | args -> args
              |> ccall_ r t "Set" "create"
          if forceFSharpSet
          then makeFSharpSet valueType args
          else
              match valueType with
              | (Fable.ExtendedNumber _ | Fable.Array _ | Fable.Tuple _) ->
                  makeFSharpSet valueType args
              | Fable.DeclaredType(ent, _) when ent.HasInterface("System.IComparable") ->
                  makeFSharpSet valueType args
              | _ ->
                  GlobalCall("Set", None, true, args) |> makeCall r t
  
  module AstPass =
      open Util
  
negative.code:             | Some(Fable.ExtendedNumber _) ->
                  emitNoInfo "(x,y) => x.CompareTo(y)" []
              | Some(Fable.DeclaredType(ent, _))
                  when ent.HasInterface "System.IComparable" ->
                  emitNoInfo "(x,y) => x.CompareTo(y)" []
              | Some _ | None ->
                  makeCoreRef "Util" (Some "compare")
  