anchor.diff:          CoreLibCall(modName, Some "create", false, args)
           |> makeCall i.range i.returnType
   
  -    let makeDictionary r t forceFSharpMap keyType args =
  -        let makeFSharpMap keyType args =
  +    let makeDictionaryOrHashSet r t modName forceFSharp typArg args =
  +        let makeFSharp typArg args =
               match args with
  -            | [iterable] -> [iterable; makeComparer (Some keyType)]
  +            | [iterable] -> [iterable; makeComparer (Some typArg)]
               | args -> args
  -            |> ccall_ r t "Map" "create"
  -        if forceFSharpMap
  -        then makeFSharpMap keyType args
  +            |> ccall_ r t modName "create"
  +        if forceFSharp
  +        then makeFSharp typArg args
           else
  -            match keyType with
  +            match typArg with
               | Fable.ExtendedNumber _ | Fable.Array _ | Fable.Tuple _ ->
  -                makeFSharpMap keyType args
  -            | Fable.DeclaredType(ent, _) when ent.HasInterface("System.IComparable") ->
  -                makeFSharpMap keyType args
  +                makeFSharp typArg args
  +            | Fable.DeclaredType(ent, _) when ent.HasInterface "System.IComparable"
  +                    && ent.FullName <> "System.TimeSpan"
  +                    && ent.FullName <> "System.Guid" ->
  +                makeFSharp typArg 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
  +                GlobalCall(modName, None, true, args) |> makeCall r t
   
   module AstPass =
       open Util
  
positive.code:             | Some(Fable.ExtendedNumber _) ->
                  emitNoInfo "(x,y) => x.CompareTo(y)" []
              | Some(Fable.DeclaredType(ent, _))
                  when ent.HasInterface "System.IComparable"
                      && ent.FullName <> "System.TimeSpan"
                      && ent.FullName <> "System.DateTime" ->
                  emitNoInfo "(x,y) => x.CompareTo(y)" []
              | Some _ | None ->
                  makeCoreRef "Util" (Some "compare")
  
negative.code:         | _ -> 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 false i.args |> Some
              | [IEnumerable; IEqualityComparer] ->
                  [i.args.Head; makeComparer i.args.Tail.Head]
                  |> makeHashSet true |> Some
              | [IEqualityComparer] ->
                  [Fable.Value Fable.Null; makeComparer i.args.Head]
                  |> makeHashSet true |> Some
              | _ -> None
          | "count" ->
              makeGet i.range i.returnType i.callee.Value (makeStrConst "size") |> Some
  