anchor.diff:  
   type Context = Fable.Transforms.FSharp2Fable.Context
   type ICompiler = Fable.Transforms.FSharp2Fable.IFableCompiler
  +
  +type Helper =
  +    static member ConstructorCall(consExpr: Expr, returnType: Type, args: Expr list,
  +                                  ?argTypes: Type list, ?loc: SourceLocation) =
  +        Operation(Call(ConstructorCall consExpr, argInfo None args argTypes), returnType, loc)
  +
  +    static member InstanceCall(callee: Expr, memb: string, returnType: Type, args: Expr list,
  +                               ?argTypes: Type list, ?loc: SourceLocation) =
  +        let kind = makeStrConst memb |> Some |> InstanceCall
  +        Operation(Call(kind, argInfo (Some callee) args argTypes), returnType, loc)
  +
  +    static member CoreCall(coreModule: string, coreMember: string, returnType: Type, args: Expr list,
  +                           ?argTypes: Type list, ?thisArg: Expr, ?loc: SourceLocation) =
  +        let info = argInfo thisArg args argTypes
  +        let funcExpr = Import(coreMember, coreModule, CoreLib, Any)
  +        Operation(Call(StaticCall funcExpr, info), returnType, loc)
  +
  +    static member GlobalCall(ident: string, returnType: Type, args: Expr list,
  +                             ?argTypes: Type list, ?thisArg: Expr, ?memb: string, ?loc: SourceLocation) =
  +        let funcExpr =
  +            match memb with
  +            | Some m -> get None Any (makeIdentExpr ident) m
  +            | None -> makeIdentExpr ident
  +        let info = argInfo thisArg args argTypes
  +        Operation(Call(StaticCall funcExpr, info), returnType, loc)
  +
  +    static member GlobalIdent(ident: string, memb: string, typ: Type, ?loc: SourceLocation) =
  +        get loc typ (makeIdentExpr ident) memb
   
   module private Helpers =
       let resolveArgTypes argTypes genArgs =
  
positive.code:     | [ExprType(Boolean | Char | String | Number _ | EnumType _) as left; right] ->
          match op with
          | Some op -> makeEqOp r left right op
          | None -> coreCall_ (Number Int32) "Util" "comparePrimitives" args
  
      | ExprType(Builtin(BclDateTime|BclDateTimeOffset))::_ ->
          coreCall_ (Number Int32) "Date" "compare" args |> wrapWith op
  
      | ExprType(Builtin(BclInt64|BclUInt64|BclBigInt as bt))::_ ->
          coreCall_ Boolean (coreModFor bt) "compare" args |> wrapWith op
  
      | ExprType(Array _ | List _ | Tuple _)::_ ->
          coreCall_ Boolean "Util" "compareArrays" args |> wrapWith op
      | ExprType(DeclaredType(ent,_))::_ when ent.IsFSharpUnion ->
          coreCall_ Boolean "Util" "compareArrays" args |> wrapWith op
  
      | ExprType(DeclaredType(ent,_))::_ when ent.IsFSharpRecord ->
          coreCall_ Boolean "Util" "compareObjects" args |> wrapWith op
  
      | _ -> coreCall_ (Number Int32) "Util" "compare" args |> wrapWith op
  
  let makeComparerFunction typArg =
      let t = FunctionType(DelegateType [typArg; typArg], Number Int32)
  
negative.code:     // | _ -> None
      // |> Option.map (makeJsObject r)
      // |> Option.defaultWith (fun () ->
          Helper.CoreCall("Util", "jsOptions", Any, [arg])
      // )
  
  // TODO: Try to compile as literal object
  