Tacit style de programmation utilisant F #

Question

Ce n'est pas un problème important en pratique, mais j'aimerais voir un exemple de tacit programming en F # où mes fonctions sans point peuvent avoir plusieurs arguments (pas sous la forme d'une liste ou d'un tuple) .

Et d'autre part, comment ces fonctions peuvent manipuler une structure de données complexe . J'essaie dans F # Interactive, mais je n'ai pas encore de succès.

J'ai essayé, par exemple:

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

Est-ce la bonne façon?

Et:

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

val it : string = "cd" 

Answer 1

F # ne contient pas certaines des fonctions de base qui sont disponibles dans Haskell (principalement parce que F # programmeurs préfèrent généralement le style explicite de la programmation et utiliser le style de Pointfree que dans les cas les plus évidents , où cela ne nuit pas à la lisibilité).

Cependant, vous pouvez définir quelques combinateurs de base comme celui-ci:

// 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) 

Maintenant, vous pouvez mettre en œuvre la fonction d'ajouter des longueurs de deux chaînes en utilisant combinators comme suit:

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

Ce construit deux fonctions qui appliquent String.length au premier/deuxième élément d'un tuple, puis les compose et ajoute ensuite les éléments du tuple en utilisant +. Le tout est enveloppé dans uncurry, de sorte que vous obtenez une fonction de type string -> string -> int.

Answer 2

En F #, l'arité des fonctions est fixé, de sorte que vous n'allez pouvoir écrire à la fois

(op) 1 2 

et

(op) 1 2 3 4 

pour tout opérateur donné op. Vous devrez utiliser une liste ou une autre structure de données si c'est ce que vous voulez. Si vous essayez simplement d'éviter les variables nommées, vous pouvez toujours faire "1 + 2 + 3 + 4". La façon la plus idiomatique d'ajouter une liste de nombres en F # est List.sum [1;2;3;4], ce qui évite également les variables.