F # Tipo de declaración posible ala Haskell?

He mirado varias fuentes: no parece posible declarar una definición de tipo de ala F # Haskell:F # Tipo de declaración posible ala Haskell?

' haskell type def: 
myFunc :: int -> int

me gustaría utilizar este tipo de estilo definición en Fa # - FSI es feliz para hacerme eco:

fsi> let myType x = x +1;; 

val myType : int -> int

Me gustaría ser explícito sobre el tipo de firma def en F # como en Haskell. ¿Hay alguna forma de hacer esto? Me gustaría escribir en Fa #:

//invalid F# 
myFunc : int -> int 
myFunc x = x*2

Fuente

2010-09-14 Kevin Won

@ Jon: posición interesante. ¿Por qué es esto 'conocido-ser-basura'? Es totalmente opcional en Haskell, y personalmente me resulta bastante útil como una forma de esbozar cómo quiero que mis tipos se alineen. Me interesa lo que ve el problema con el tipo Defs. –

@ Kevin: Recurrir a escribir anotaciones casi siempre refleja una deficiencia en el sistema de tipos, por lo general que las características avanzadas de otro modo dar lugar a mensajes de error ofuscado. Eso sucede cuando rebasas el punto óptimo que alcanzó ML al agregar formas de inferencia más avanzadas al sistema de tipos. La solución en OCaml era agregar anotaciones de tipo a las definiciones de argumento cuando se usaban variantes u objetos polimórficos. La solución en Haskell consistía en hacer que las anotaciones de tipos fueran ubicuas debido a la ubicuidad de las clases de tipos (y la ausencia de alternativas). –

@Jon: Gracias por la aclaración. Sin embargo, creo que estamos hablando de dos razones diferentes para estas anotaciones. No quiero anotaciones de tipo para el compilador: ¡lo quiero para mí! En otras palabras, les resulta útil aclarar en términos inequívocos lo que necesito que hagan las diferentes funciones.Me parece que simplemente resolviendo las firmas de tipo puedo avanzar mucho para resolver el problema. –

Si desea mantener las declaraciones de tipo legibles por separado de la aplicación, puede utilizar 'FSI' archivos (F # firma del archivo). El 'fsi' contiene solo los tipos y generalmente también comentarios: puede ver algunos buenos ejemplos en la fuente de las bibliotecas F #. Para ello se crea dos archivos como este:

// Test.fsi 
val myFunc : int -> int 

// Test.fs 
let myFunx x = x + 1

Esto funciona para proyectos compilados, pero no se puede utilizar este método fácilmente con F # interactivo.

Fuente

2010-09-14 22:27:22

Encuentro el estilo de definición de tipo Haskell (y el camino .fsi) como una forma útil de 'dibujar' en F #. ¿Alguna idea de por qué FSI no es compatible con esto? ¿Y por qué no puedes hacer estos sigs en línea? ¿Es eso más de la tradición OCaml? –

@Kevin: No estoy muy seguro, pero estoy de acuerdo en que la forma de Haskell parece más legible que las anotaciones mixtas de encabezado/tipo. Probablemente es la tradición OCaml, porque no creo que haya ningún problema técnico con esto. Escribirlos en línea tendría sentido ... (Otra pregunta es si vale la pena los recursos limitados del equipo F # en este momento) –

gracias Tomas. Solo para el registro, equipo F #, bonito por favor? anotaciones de tiempo en línea? –

Usted puede hacer esto en C# como tal para especificar el valor de retorno de myType.

let myType x : int = x + 1

También puede especificar el tipo del parámetro.

let myType (x : int) : int = x + 1

Hope this helps!

Fuente

2010-09-14 22:03:26 sholsapp

Cita: http://msdn.microsoft.com/en-us/library/dd233229.aspx – sholsapp

La forma más habitual es hacer let myFunc (x:int):int = x+1.

Si quieres estar más cerca del estilo de Haskell, también se puede hacer let myFunc : int -> int = fun x -> x+1.

Fuente

2010-09-14 22:04:15 sepp2k

Sé que puede especificar los tipos de esa manera con la definición de su función real; eso no es exactamente lo que estoy pidiendo. gracias sin embargo. –

@Kevin: asegúrese de comprender la diferencia entre una anotación de tipo y una definición de tipo. –

Consulte también The Basic Syntax of F# - Types (que discute este aspecto un poco menos de 'anotaciones de tipo').

Fuente

2010-09-14 22:43:58 Brian

Otra opción es el uso de "tipo abreviaturas" (http://msdn.microsoft.com/en-us/library/dd233246.aspx)

type myType = int -> int 
let (myFunc : myType) = (fun x -> x*2)

Fuente

2014-06-25 23:08:15 LuddyPants

-1

sí se puede, mediante el uso de las funciones lambda

myFunc : int -> int = 
    fun x -> x*2

esto también evita el problema en Haskell de escribir el nombre de la función dos veces.

Fuente

2015-10-19 07:52:22

esto es un duplicado de la respuesta de @sepp2k. – bytebuster

F # Tipo de declaración posible ala Haskell?

Respuesta

Cuestiones relacionadas