Estilo de programación tácito con F #

No es un problema prácticamente importante, pero me gustaría ver un ejemplo de tacit programming en F # donde mis funciones sin punto pueden tener múltiples argumentos (no en forma de lista o tupla) .Estilo de programación tácito con F #

Y en segundo lugar, cómo estas funciones pueden manipular una compleja estructura de datos. Lo estoy probando en F # Interactive, pero todavía no tengo éxito.

lo intentara, por ejemplo:

> (fun _ -> (fun _ -> (+))) 333 222 111 555

es así ¿verdad?

> (fun _ -> (fun _ -> (+))) "a" "b" "c" "d";; 

val it : string = "cd"

Fuente

2010-05-08 Bubba88

Debe usar "sin puntos" en lugar de "sin sentido". Es el término estándar. :) –

F # no contiene algunas de las funciones básicas que están disponibles en Haskell (principalmente porque F # programadores por lo general prefieren el estilo explícito de la programación y el uso de estilo pointfree sólo en los casos más evidentes , donde no afecta la legibilidad).

Sin embargo, puede definir unos combinadores básicos como esto:

// turns curried function into non-curried function and back 
let curry f (a, b) = f a b 
let uncurry f a b = f (a, b) 

// applies the function to the first/second element of a tuple 
let first f (a, b) = (f a, b) 
let second f (a, b) = (a, f b)

Ahora se puede implementar la función de añadir longitudes de dos cadenas utilizando combinadores de la siguiente manera:

let addLengths = 
    uncurry (((first String.length) >> (second String.length)) >> (curry (+)))

Esto construye dos funciones que aplica String.length al primer/segundo elemento de una tupla, luego los compone y luego agrega los elementos de la tupla usando +. Todo está envuelto en uncurry, por lo que obtienes una función del tipo string -> string -> int.

Fuente

2010-05-08 12:45:35

¡Lo he comprobado en FSI y funciona! Muchas gracias; por cierto, ¿podrías explicar cómo llegaste a esa sintaxis de composición de función de tupla? Me refiero a '(first String.length) >> (second String.length)' Me parece algo inusual;) – Bubba88

Eso se logra usando la composición de funciones '>>'. Por ejemplo 'f >> g' significa que para un argumento' x', llamará 'g (f (x))'. En el caso anterior, la primera función ('first String.length') convierte una tupla' string * string' en una tupla 'int * string' y la segunda función (' second String.length') lo convierte en 'int * int' que contiene las longitudes. –

Prácticamente está implementando flechas para F #;) Está bien, ¿por qué no? Las flechas se han inventado como una combinación de mónadas y programación tácita. – Dario

En F #, la aridad de funciones es fijo, por lo que no vas a ser capaz de escribir tanto

(op) 1 2

(op) 1 2 3 4

para cualquier operador dado op. Tendrá que usar una lista u otra estructura de datos si eso es lo que quiere. Si solo está tratando de evitar las variables con nombre, siempre puede hacer "1 + 2 + 3 + 4". La forma más idiomática de agregar una lista de números en F # es List.sum [1;2;3;4], que también evita las variables.

Fuente

2010-05-08 15:45:36 kvb

Estilo de programación tácito con F #

Respuesta

Cuestiones relacionadas