cómo son los abdominales, etc firmar implementado en C#

Question

encontré que:

abs -10 
abs -10L 

tanto trabajo. Así que me pregunté cómo F # implementó esto e hice una búsqueda en el código fuente:

type AbsDynamicImplTable<'T>() = 
    let AbsDynamic x   = AbsDynamicImplTable<_>.Result x 

    [<CompiledName("Abs")>] 
    let inline abs (x: ^T) : ^T = 
     AbsDynamic x 
     when ^T : ^T = absImpl x 

Y estoy confundido con estos.

Como sé en una función como abs, debemos comparar la entrada con 0, y hay diferentes 0 para diferentes tipos.

Gracias.

Answer 1

Para añadir alguna explicación para el código publicado por ChaosPandion, el problema con las funciones F # como abs es que se puede trabajar con cualquier tipo numérico. No hay forma de expresar esto simplemente usando los genéricos F # /. NET: las únicas restricciones admitidas son que el parámetro de tipo implementa una determinada interfaz o tiene un constructor, pero no hay restricciones para los tipos numéricos.

Por lo tanto, F # también es compatible con las restricciones estáticas (es el parámetro de tipo ^a lugar de costumbre 'a) y éstas se procesan en tiempo de compilación usando procesos en línea (esto también explica por qué la función tiene que ser inline). Usted puede escribir propia función con restricciones estáticas mediante el uso de las funciones incorporadas de LanguagePrimitives que contiene muchas funciones útiles que requieren algunas limitaciones:

> 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 

Tenga en cuenta que las restricciones se infieren - DivideByInt requiere que el tipo tiene DivideByInt miembro, por lo nuestra función requiere lo mismo (y funcionará con tu propio tipo si también tiene este miembro, ¡lo cual es bastante útil!).

Además de esto, la implementación de abs utiliza dos trucos adicionales que se permiten sólo en la # biblioteca F - especifica código diferente (que se utilizará cuando inlining) para diferentes tipos (utilizando when ^a:int = ....) y una caja de reserva, que usa el miembro Abs, por lo que funcionará con cualquier tipo enumerado explícitamente o un tipo con Abs miembro. Otro truco es la función retype, que "cambia el tipo", pero no contiene ningún código; el único propósito es hacer que el código revise el tipo, pero esto podría ser muy inseguro, por lo que se usa solo en las bibliotecas F #.

Answer 2

En realidad esa mesa Abs llamará a este:

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)