(~~~) doesn't work on bigints

[drvink]

(~~~) doesn't work on bigints for some reason, but System.Numerics.BigInteger has op_OnesComplement, which does what we want.

> ~~~(1I);;

  ~~~(1I);;
  ----^^

stdin(57,5): error FS0001: The type 'BigInteger' does not support the operator '~~~'

> BigInteger.op_OnesComplement 1I;;
val it : BigInteger = -2 {IsEven = true;
                          IsOne = false;
                          IsPowerOfTwo = false;
                          IsZero = false;
                          Sign = -1;}
> BigInteger.op_OnesComplement -2I;;
val it : BigInteger = 1 {IsEven = false;
                         IsOne = true;
                         IsPowerOfTwo = true;
                         IsZero = false;
                         Sign = 1;}
> BigInteger.op_OnesComplement 0I;;
val it : BigInteger = -1 {IsEven = false;
                          IsOne = false;
                          IsPowerOfTwo = false;
                          IsZero = false;
                          Sign = -1;}
> BigInteger.op_OnesComplement -1I;;
val it : BigInteger = 0 {IsEven = true;
                         IsOne = false;
                         IsPowerOfTwo = false;
                         IsZero = true;
                         Sign = 0;}

In fact, op_OnesComplement is the correct name for this operator--it seems F# mixed up op_OnesComplement and op_LogicalNot. See also I.10.3.1, "Unary operators", in the CLI standard.

[dsyme]

Urgh, you are correct. A tentative F# 4.0 + FSharp.Core 4.4.0.0 fix is here: #458 . That allows op_OnesComplement operators to be used using ~~~x and op_LogicalNot operators to be used using !!!x.

In terms of compat, this really only affects the rare case of user-defined types with an explicit op_LogicalNot declared, and used via ~~~x in F# 3.x. If #458 is accepted, these uses will need to be changed to !!!x.

[drvink]

Looks like the fix won't be ready in time for 4.0 from the discussion you guys are having in #458, so just in case anyone runs into this and is looking for a workaround, you can do something like this in the meantime:

module Impl = 
  type CBits = 
    static member inline complement (x : int8) = ~~~x
    static member inline complement (x : uint8) = ~~~x
    static member inline complement (x : int16) = ~~~x
    static member inline complement (x : uint16) = ~~~x
    static member inline complement (x : int32) = ~~~x
    static member inline complement (x : uint32) = ~~~x
    static member inline complement (x : int64) = ~~~x
    static member inline complement (x : uint64) = ~~~x
    static member inline complement (x : bigint) = bigint.op_OnesComplement x

  let inline instance< ^a, ^b when
      (^a or ^b) :    (static member complement : ^b -> ^b)>
      (x : ^b) =
    ((^a or ^b) : (static member complement : ^b -> ^b) x)

let inline complement num = Impl.instance<CBits, _> num

[dsyme]

Thanks @drvink , that's very helpful

[dsyme]

This issue is now tracked at http://fslang.uservoice.com/forums/245727-f-language/suggestions/9168976-add-complement-and-logicalnot-operators-to-res. A proposed plan to address the design issue is linked there.

A workaround is above

[dsyme]

Closing this since it's now a language/library design issue (stemming from an design/implementation bug)