Langage F# - conseils pour les débutants [fermé]

Question

On dirait qu'ici, dans StackOveflow, il y a un groupe de F# passionnés.

J'aimerais mieux connaître cette langue, donc, à part le théorie de la programmation fonctionnelle, pouvez-vous m'indiquer les meilleurs points de départ pour commencer à utiliser le langage F# ?Je veux dire, des tutoriels, des procédures, mais avant tout des exemples de travail pour avoir la chance de commencer à faire quelque chose et d'apprécier le langage.

Merci beaucoup

Andréa

Answer 1

Pas pour me prostituer horriblement, mais j'ai écrit quelques articles de présentation F# sur mon blog ici et ici.Chris Smith (un membre de l'équipe F# chez MS) a un article intitulé « F# en 20 minutes » - partie 1 et partie 2.

Notez que vous devez être prudent car le dernier CTP de F# (version 1.9.6.0) présente des modifications sérieuses par rapport aux versions précédentes, de sorte que certains exemples/tutoriels peuvent ne pas fonctionner sans modification.

Voici un bref aperçu de quelques trucs sympas, peut-être que je peux vous donner ici moi-même quelques indices qui sont clairement très bref et probablement pas génial mais j'espère que cela vous donnera quelque chose avec quoi jouer ! :-

Première remarque : la plupart des exemples sur Internet supposeront que la « syntaxe légère » est activée.Pour y parvenir, utilisez la ligne de code suivante : -

#light

Cela vous évite d'avoir à insérer certains mots-clés présents pour la compatibilité OCaml et également de devoir terminer chaque ligne par des points-virgules.Notez que l'utilisation de cette syntaxe signifie que l'indentation définit la portée.Cela deviendra clair dans les exemples ultérieurs, qui reposent tous sur l’activation d’une syntaxe légère.

Si vous utilisez le mode interactif, vous devez terminer toutes les instructions par des doubles points-virgules, par exemple : -

  > #light;;
  > let f x y = x + y;;

  val f : int -> int -> int

  > f 1 2;;
  val it : int = 3

Notez que le mode interactif renvoie un résultat 'val' après chaque ligne.Cela donne des informations importantes sur les définitions que nous faisons, par exemple 'val f :int -> int -> int' indique qu'une fonction qui prend deux entiers renvoie un int.

Notez que ce n'est qu'en interactif que nous devons terminer les lignes par des points-virgules, lors de la définition du code F#, nous en sommes libres :-)

Vous définissez des fonctions à l'aide du mot-clé 'let'.C'est probablement le mot-clé le plus important de tout F# et vous l'utiliserez beaucoup.Par exemple:-

let sumStuff x y = x + y
let sumStuffTuple (x, y) = x + y

Nous pouvons appeler ces fonctions ainsi : -

sumStuff 1 2
3
sumStuffTuple (1, 2)
3

Notez qu'il existe deux manières différentes de définir des fonctions ici : vous pouvez soit séparer les paramètres par des espaces, soit spécifier les paramètres dans des « tuples » (c'est-à-direvaleurs entre parenthèses séparées par des virgules).La différence est que nous pouvons utiliser « l'application partielle de fonctions » pour obtenir des fonctions qui prennent moins que les paramètres requis en utilisant la première approche, et non avec la seconde.Par exemple.:-

let sumStuff1 = sumStuff 1
sumStuff 2
3

Notez que nous obtenons une fonction à partir de l'expression « sumStuff 1 ».Lorsque nous pouvons transmettre des fonctions aussi facilement que des données, ce que l'on appelle le langage ayant des « fonctions de première classe », il s'agit d'un élément fondamental de tout langage fonctionnel tel que F#.

La correspondance de modèles est vraiment cool, c'est fondamentalement comme une instruction switch sous stéroïdes (oui, j'ai emprunté cette phrase à un autre F#-ist :-).Vous pouvez faire des choses comme : -

let someThing x =
  match x with
    | 0 -> "zero"
    | 1 -> "one"
    | 2 -> "two"
    | x when x < 0 -> "negative = " + x.ToString()
    | _ when x%2 = 0 -> "greater than two but even"
    | _ -> "greater than two but odd"

Notez que nous utilisons le symbole '_' lorsque nous voulons faire correspondre quelque chose mais que l'expression que nous renvoyons ne dépend pas de l'entrée.

Nous pouvons abréger la correspondance de modèles en utilisant les instructions if, elif et else selon les besoins : -

let negEvenOdd x = if x < 0 then "neg" elif x % 2 = 0 then "even" else "odd"

Les listes F# (qui sont implémentées sous forme de listes chaînées ci-dessous) peuvent être manipulées ainsi : -

let l1 = [1;2;3]
l1.[0]
1

let l2 = [1 .. 10]
List.length l2
10

let squares = [for i in 1..10 -> i * i]
squares
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let square x = x * x;;
let squares2 = List.map square [1..10]
squares2
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

let evenSquares = List.filter (fun x -> x % 2 = 0) squares
evenSqares
[4; 16; 36; 64; 100]

Notez que la fonction List.map « mappe » la fonction carré sur la liste de 1 à 10, c'est-à-direapplique la fonction à chaque élément.List.filter « filtre » une liste en renvoyant uniquement les valeurs de la liste qui transmettent la fonction de prédicat fournie.Notez également la syntaxe 'fun x -> f' - c'est le lambda F#.

Notez que nous n'avons défini aucun type dans l'ensemble - le compilateur/interprète F# « déduit » les types, c'est-à-diredétermine ce que vous attendez de l'utilisation.Par exemple:-

let f x = "hi " + x

Ici, le compilateur/interprète déterminera que x est une chaîne puisque vous effectuez une opération qui nécessite que x soit une chaîne.Il détermine également que le type de retour sera également une chaîne.

En cas d'ambiguïté, le compilateur fait des hypothèses, par exemple : -

let f x y = x + y

Ici, x et y peuvent être plusieurs types, mais la valeur par défaut du compilateur est int.Si vous souhaitez définir des types, vous pouvez utiliser l'annotation de type : -

let f (x:string) y = x + y

Notez également que nous avons dû mettre x:string entre parenthèses, nous devons souvent le faire pour séparer les parties d'une définition de fonction.

Deux opérateurs vraiment utiles et très utilisés en F# sont respectivement les opérateurs de transfert de canal et de composition de fonctions |> et >>.

Nous définissons |> ainsi : -

let (|>) x f = f x

Notez que vous pouvez définir des opérateurs en F#, c'est plutôt cool :-).

Cela vous permet d'écrire les choses de manière plus claire, par exemple : -

[1..10] |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Vous permettra d'obtenir les 10 premiers carrés pairs.C'est plus clair que :-

List.filter (fun x -> x % 2 = 0) (List.map (fun x -> x * x) [1..10])

Eh bien, du moins je le pense :-)

La composition des fonctions définie par l'opérateur >> est définie comme suit : -

let (>>) f g x = g(f(x))

C'est à dire.vous transférez une opération, seul le paramètre de la première fonction reste non spécifié.Ceci est utile car vous pouvez effectuer les opérations suivantes : -

let mapFilter = List.map (fun x -> x * x) >> List.filter (fun x -> x % 2 = 0)

Ici, mapFilter acceptera une liste et une entrée et renverra la liste filtrée comme auparavant.C'est une version abrégée de : -

let mapFilter = l |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)

Si nous voulons écrire des fonctions récursives, nous devons définir la fonction comme récursive en plaçant « rec » après let.Exemples ci-dessous.

Quelques trucs sympas :-

Factorielle

let rec fact x = if x <= 1 then 1 else x * fact (x-1)

nième nombre de Fibonacci

let rec fib n = if n <= 1 then n else fib (n-1) + fib (n-2)

FizzBuzz

let (/%) x y = x % y = 0
let fb = function
  | x when x /% 15 -> "FizzBuzz"
  | x when x /% 3  -> "Fizz"
  | x when x /% 5  -> "Buzz"
  | x              -> x.ToString()

[1..100] |> List.map (fb >> printfn "%s")

Quoi qu'il en soit, c'est un très bref aperçu, j'espère que ça aide un peu !!

Answer 2

Sans aucun doute, vous devriez acheter l'excellent livre de Don Syme "Expert F#".Le livre est très bien écrit et convient aussi bien aux débutants qu'aux experts.Vous y trouverez à la fois du matériel d'introduction et du matériel beaucoup plus stimulant.Avec près de 600 pages, c'est un bon rapport qualité/prix.

J'ai découvert que cela m'a appris de nombreuses techniques utiles pour écrire du C# plus fonctionnel et qu'il m'a fourni tout le matériel de référence dont j'avais besoin pour commencer à écrire des applications F# hébergées par Windows.

Le livre est publié par Apress et est accompagné d'un site Web à l'adresse :http://www.expert-fsharp.com/default.aspx

Answer 3

@kronoz - eh bien, merci beaucoup pour votre longue réponse, c'est un très bon point de départ.Je vais suivre vos conseils et chercher le livre mentionné par @vecstasy.

maintenant, laisse-moi coder :-)

let thanksalot = "thanks a lot"
printfn "%s" (thanksalot);;

Answer 4

j'ai lu Programmation fonctionnelle du monde réel

Avec des exemples en F# et C# par : Tomas Petricek

Jusqu'à présent, je le trouve très efficace pour enseigner les concepts F# en montrant les implémentations en C# sur le côté.Idéal pour les programmeurs OO.

Answer 5

Vérifiez Centre de développement F#.Il y a aussi hubFS, un forum dédié au F#.

Answer 6

Si vous disposez de la version CTP actuelle dans Visual Studio, elle vous permet de créer un projet de didacticiel F#, qui vous donne un Tutorial.fs, contenant exactement ce que son nom suggère.

Ce tutoriel pointe également vers une plus grande collection de Exemples F# chez Microsoft.

De plus, un projet d'échantillons F# est en cours sur CodePlex.

J'espère que cela t'aides,

Michel

Answer 7

Le premier chapitre de mon livre F# for Scientists est disponible gratuitement ici.Nous avons une série de programmes de jouets F# gratuits ici.Le premier article de notre F#.NET Journal est disponible gratuitement ici.