¿Deben eliminarse las anotaciones de tipo F # al refactorizar?

Question

En los casos en que estoy escribiendo una función antes de usarla en cualquier lugar, me resulta útil agregar anotaciones de tipo a sus parámetros. Esto significa que puedo autocompletar sus valores y (especialmente como un novato F #) no se confundirán por la inferencia tipo inesperada.

Sin embargo, una vez que la función está terminada, estoy tentado de eliminar las anotaciones de tipo de parámetro porque son feas. ¿Esto suena como algo razonable que hacer?

Espero que pueda depender de qué tipo de función estoy hablando. Por ejemplo, podría tener sentido para una función privada, pero no para una función pública.

Answer 1

Creo que depende de muchos factores. Aquí hay algunos argumentos a favor de dejar las anotaciones:

1. Las anotaciones de tipo pueden servir como una forma de documentación verificada por el compilador.
2. No modifique el código de trabajo sin una buena razón.
3. Algunas anotaciones de tipo pueden ser necesarias para la compilación, en cuyo caso quizás tenga sentido dejar todas ellas en lugar de eliminar solo las innecesarias para garantizar la coherencia.

Sin embargo, por otro lado, también hay algunas razones de peso para eliminarlos:

1. El compilador puede llegar a inferir tipos más generales, en cuyo caso se puede volver a utilizar las funciones en un conjunto más amplio de contextos.
2. Su código será más conciso, que puede encontrar para ser más legible.

Answer 2

No, no tiene ninguna ventaja. Se podría decir que hace que el programa sea más fácil de modificar después, o se ve mejor, pero en la práctica nunca funciona.

Lo más probable es que termines volviendo a escribir las anotaciones de todos modos, exactamente por la misma razón que las has agregado en primer lugar.

Answer 3

Es una cuestión de estilo personal; Yo los sacaría. A medida que mejora en la codificación de F #, es posible que tenga que pasar por la fase de anotación con menos frecuencia.

Answer 4

Por lo que vale la pena, mi estilo personal es mantener las anotaciones de las interfaces de módulos públicas utilizando archivos FSI, y borrar la mayoría de las anotaciones en los archivos de implementación del módulo fs (a menos que sean requeridas por la izquierda a la derecha inferencia de tipos). Con este esquema, es un gran problema cambiar la interfaz del módulo, y un trato menor para cambiar su implementación.

Answer 5

Creo que un argumento importante aquí es que eliminando las anotaciones de tipo cambian el significado de las fuentes.

De hecho, supongamos que hay un código fuente: let f (arg: MyType) = arg.ToString().
La fuente restringe arg para que sea del tipo MyType. Si algún código de cliente intenta pasar un argumento de otro tipo, simplemente no se compilará.
Esto también se aplica a Unit Tests. Con la anotación de tipo, es fácil ver que todas las pruebas unitarias llaman al f solo con argumentos de tipo MyType.

Si las anotaciones de tipos se retiran, el tipo de trabajo inferencia sin restricciones, pero las pruebas no están listas, siendo única prueba con MyType.

Por lo tanto, las anotaciones de eliminación de tipo se deben asociar con el cambio de las Pruebas unitarias, así como cualquier otra refactorización. Si estás listo para mejorar las pruebas, ve por ello. De lo contrario, puede estar buscando problemas, especialmente para una gran base de código.