Funciones con los tipos de parámetros genéricos

Question

Estoy tratando de averiguar cómo definir una función que funcione en múltiples tipos de parámetros (por ejemplo, int e int64). Según tengo entendido, la sobrecarga de funciones no es posible en F # (sin duda el compilador se queja). Tomemos por ejemplo la siguiente función.

let sqrt_int = function 
    | n:int -> int (sqrt (float n)) 
    | n:int64 -> int64 (sqrt (float n)) 

El compilador, por supuesto, se queja de que la sintaxis no es válida (restricciones de tipo de coincidencia de patrones no son compatibles con lo que parece), aunque creo que esto ilustra lo que me gustaría lograr: una función que opera en varios tipos de parámetros y devuelve un valor del tipo correspondiente. Tengo la sensación de que esto es posible en F # usando una combinación de tipos genéricos/inferencia de tipo/coincidencia de patrones, pero la sintaxis me ha eludido. También he intentado usar el:? operador (pruebas de tipo dinámico) y cuando hace una cláusula en el bloque de coincidencia de patrones, pero esto todavía produce errores de todo tipo.

Como soy bastante nuevo en el lenguaje, es posible que esté tratando de hacer algo imposible aquí, por lo que le ruego me indique si hay una solución alternativa.

Answer 1

La sobrecarga suele ser un problema entre los lenguajes de escritura de tipo (al menos cuando, como F #, el sistema de tipos no es lo suficientemente potente como para contener clases de tipos). Hay una serie de opciones que tiene en F #:

• Uso sobrecarga en los métodos (miembros de un tipo), en cuyo caso la sobrecarga funciona de manera similar como en otros lenguajes .Net (que pueda miembros de sobrecarga ad-hoc, las llamadas provistas se pueden distinguir por el número/tipo de parámetros)
• Utilice restricciones de miembros "en línea", "^" y estáticos para la sobrecarga ad-hoc de funciones (esto es lo que la mayoría de los diversos operadores matemáticos necesitan para funcionar en int/float/etc; la sintaxis aquí es rara, esto se usa poco aparte de la biblioteca F #)
• Simula clases de tipo pasando un parámetro extra de diccionario de operaciones (esto es lo que INumeric hace en uno de el F # PowerPack li braries para generalizar varios algoritmos de matemáticas para los tipos definidos por el usuario arbitrarias)
• caer de nuevo a tipado dinámico (pasa en un parámetro 'obj', hacer una prueba de tipo dinámico, una excepción de tiempo de ejecución para el mal tipo)

para su ejemplo particular, probablemente sólo tiene que utilizar la sobrecarga de métodos:

type MathOps = 
    static member sqrt_int(x:int) = x |> float |> sqrt |> int 
    static member sqrt_int(x:int64) = x |> float |> sqrt |> int64 

let x = MathOps.sqrt_int 9 
let y = MathOps.sqrt_int 100L 

Answer 2

Sí, esto se puede hacer. Eche un vistazo al this hubFS thread.

En este caso, la solución sería:

let inline retype (x:'a) : 'b = (# "" x : 'b #) 
let inline sqrt_int (n:'a) = retype (sqrt (float n)) : 'a 

Advertencia: no en tiempo de compilación comprobación de tipos. Es decir. sqrt_int "blabla" compila bien, pero obtendrá FormatException en tiempo de ejecución.

Answer 3

no tomar distancia de las respuestas correctas que se facilitan, sino que puede, de hecho restricciones de tipo uso en la coincidencia de patrones. La sintaxis es la siguiente:

| :? type -> 

O si desea combinar la comprobación de tipos y de calidad:

| :? type as foo -> 

Answer 4

Ésta es otra manera el uso de cheques de tipo en tiempo de ejecución ...

let sqrt_int<'a> (x:'a) : 'a = // ' 
    match box x with 
    | :? int as i -> downcast (i |> float |> sqrt |> int |> box) 
    | :? int64 as i -> downcast (i |> float |> sqrt |> int64 |> box) 
    | _ -> failwith "boo" 

let a = sqrt_int 9 
let b = sqrt_int 100L 
let c = sqrt_int "foo" // boom 

Answer 5

Esto funciona:

type T = T with 
    static member ($) (T, n:int ) = int (sqrt (float n)) 
    static member ($) (T, n:int64) = int64 (sqrt (float n)) 

let inline sqrt_int (x:'t) :'t = T $ x 

Utiliza las restricciones estáticas y sobrecarga, lo que hace una búsqueda en tiempo de compilación del tipo de argumento.

Las restricciones estáticas se generan automáticamente en presencia de un operador (operador $ en este caso), pero siempre se puede escribir a mano:

type T = T with 
    static member Sqr (T, n:int ) = int (sqrt (float n)) 
    static member Sqr (T, n:int64) = int64 (sqrt (float n)) 

let inline sqrt_int (x:'N) :'N = ((^T or ^N) : (static member Sqr: ^T * ^N -> _) T, x) 

Más información este here.