Like abs, sign, etc. implemented in F #

Question

I found that:

abs -10 abs -10L 

both work. So I thought how F # did this and did a search in the source code:

  type AbsDynamicImplTable<'T>() = let AbsDynamic x = AbsDynamicImplTable<_>.Result x [<CompiledName("Abs")>] let inline abs (x: ^T) : ^T = AbsDynamic x when ^T : ^T = absImpl x 

And I'm confused with them.

As I know in functions like abs , we have to compare the input with 0, and for different types there are different 0s.

Thank.

Answer 1

To add some explanation to the code sent by ChaosPandion, the problem with F # functions such as abs is that they can work with any numeric type. It is impossible to express this only using generic F # /. NET files - the only supported restrictions are that this type parameter implements a specific interface or has a constructor, but there are no restrictions for numeric types.

Thus, F # also supports static constraints (a parameter of type ^a instead of the usual 'a ), and they are processed at compile time using inlining (this also explains why the function should be inline ). You can write your own function with static constraints using the built-in functions from LanguagePrimitives , which contains many useful functions that require certain restrictions:

 > let inline half (num: ^a) : ^a = LanguagePrimitives.DivideByInt< (^a) > num 2 ;; val inline half : ^a -> ^a when ^a : (static member DivideByInt : ^a * int -> ^a) > half 42.0;; val it : float = 21.0 > half 42.0f;; val it : float32 = 21.0f 

Note that restrictions are inferred - DivideByInt requires that the type has a DivideByInt member, so our function requires the same thing (and it will work with your own type if it also has this member, which is very useful!).

In addition to this, the abs implementation uses two additional tricks that are only allowed in the F # library - it specifies different code (which will be used when embedding) for different types (using when ^a:int = .... ) and the backup case, which uses the abs member, so it will work with any explicitly specified type or type with the abs member. Another trick is the retype function, which "changes the type" but does not contain any code. The only goal is to do a code type check, but it can be very dangerous, so this is only used in the F # library.

Answer 2

In fact, this Abs table will call this:

 let inline abs_impl (x: ^a) : ^a = (^a: (static member Abs : ^a -> ^a) (x)) when ^a : int32 = let x : int32 = retype x in if x >= 0 then x else -x when ^a : float = let x : float = retype x in if x >= 0.0 then x else -x when ^a : float32 = let x : float32 = retype x in if x >= 0.0f then x else -x when ^a : int64 = let x : int64 = retype x in if x >= 0L then x else -x when ^a : nativeint = let x : nativeint = retype x in if x >= 0n then x else -x when ^a : int16 = let x : int16 = retype x in if x >= 0s then x else -x when ^a : sbyte = let x : sbyte = retype x in if x >= 0y then x else -x when ^a : decimal = System.Math.Abs(retype x : decimal)