04/01/2007

[Lang] [F#] Présentation

F# est un langage récent, créé par Microsoft, pour laa plateforme .Net. Ce langage est directement inspiré d'OCaml. J'ai lu récemment plusieurs articles sur ce langage et je vous fais part de mes premières impressions.

 

En gros, on retrouve dans F# tout ce qui fait le charme d'OCaml, avec cependant quelques modifications loin d'être négligeables. Ce qu'on perd :

- le typage structurel, et c'est triste ;
- les arguments nommés (c'est fun, mais pas indispensable) ;
- les paramètres avec valeurs par défaut (idem).

Ce qu'on gagne :

Deux opérateurs : >> et >|

Où on retrouve les joies du Shell.

Ce sont 2 nouveaux opérateurs assez mignons (on peut les définir aussi dans
Caml, mais je n'y avais jamais pensé, et je ne les avais jamais rencontrés) qui ont été introduits :
# let (>>) f g x = g(f(x))
# let (|>) x f = f x

Par exemple :
# google |> getWords |> List.filter (fun s -> s = "href") |> List.length
# let countLinks = getWords >> List.filter (fun s -> s = "href") >> List.length
# google |> countLinks

Bref, on retrouve les joies du Shell en jouant avec les pipes. Moi, je
trouve ça joli.


Lightweight syntax

Où on retrouve les joies de Python.

Comme en Python, l'indentation peut faire partie de la syntaxe (pour
ceux qui n'aiment pas, c'est en option). Du coup, on peut écrire des
"let" sans "in", de l'impératif sans ";", des "for" sans "done", etc.

Caml avait déjà une syntaxe claire et concise, celle de F# l'est
encore plus ! :)

Surcharge d'opérateurs

Où on retrouve les joies du C++.

Hé oui, les opérateurs +., *., +/, */ et les autres sont
obsolètes. L'opérateur + est surchargé et accepte aussi bien des
entiers, des flottants, des big int... Et ça marche aussi pour la
concaténation des chaines. De quoi alléger encore plus le code. :)

Et bien sûr, on peut surcharger tous les opérateurs, un peu comme en C++.

Range comprehensions

Où on retrouve les joies d'Haskell.

On peut écrire des séquences très facilement (comme la commande "seq"
du Shell) :

# {0 .. 2};;
val it : seq = [ 0; 1; 2; ]

Ces opérateurs sont aussi surchargés, donc ça marche pareil avec des
flottants ou des big int. Mais ce qui est génial, c'est que c'est
l'évaluation paresseuse qui est utilisée.

En clair, on peut définir l'ensemble des entiers naturels :

# { 0I .. }

Ce sont des big int, donc on a vraiment *tous* les entiers naturels
dans cet ensemble (c'est pas limité à 32 bits).

On peut bien sûr faire des boucles "for" dessus :

# for i in { 1 .. 10 } do
printf "%d\\n" i

Et on peut même effectuer des calculs (même sur un ensemble infini !) :

# let range = {0 .. 10}
# range |> Seq.map (fun i -> (i, i * i));;
val it : seq = [ (0, 0); (1, 1); (2, 4); (3, 9) ... ]

Et puis aussi :

# let squares = { for i in (0 .. 10) -> (i,i*i) };;
val squares : seq = [ (0,0); (1,1); (2,4); (3,9); ... ]

Et aussi...

Une bibliothèque bien plus complète, du typage dynamique sur
demande, une utilisation des BigInt transparente, la facilité de
mélange avec les autres langages...


Par contre, ça nécessite .Net...