Commentaires pour Le blog de SpiceGuid

Commentaires sur Qu’est-ce qu’un langage fonctionnel ? par Le blog de SpiceGuid | Bonnes Pratiques Web | S...

Le blog de SpiceGuid | Bonnes Pratiques Web | S... — Wed, 10 Apr 2013 06:56:07 +0000

[…] Qu’est-ce qu’un langage fonctionnel ? […]

Commentaires sur Conférence F# à l’EPITA par spiceguid

spiceguid — Wed, 18 Nov 2009 20:59:28 +0000

C'est plus une question de plateforme que de recherche publique/privée. Par exemple Scala est issue de la recherche publique (EPFL) et ça marche très bien commercialement puisque Twitter et LinkedIn l'ont adopté.
Moi j'aime bien le code natif mais le dynamisme commercial est plus du côté web et JVM / dotnet. C'est d'ailleurs sans doute la faute à Microsoft qui tend à étouffer la concurrence commerciale sur le bureau.

En lui-même F# n'est pas du tout représentatif des technos fermées propriétaires et des pratiques de vente liée. Sans être un logiciel libre c'est un produit gratuit et dont la source est disponible.

Commentaires sur Conférence F# à l’EPITA par cacophrene

cacophrene — Wed, 18 Nov 2009 20:22:29 +0000

Salut !

Merci beaucoup pour ce message. Effectivement ça ouvre de nouveaux horizons (intéressants) sur la manière d'appréhender F# et le « mouvement » qu'il a contribué à mettre en route.

À titre personnel, donc sans réel argument de fond, je regrette un peu que ce soit une entreprise comme Microsoft qui ait su franchir le cap. Ça donne à penser sur la manière de gérer les politiques de recherche et les partenariats industriels en France (en informatique comme ailleurs; le problème est le même en biologie et sans doute dans la quasi totalité des disciplines scientifiques).

Bonne soirée,
Cacophrène

Commentaires sur Conférence F# à l’EPITA par spiceguid

spiceguid — Wed, 11 Nov 2009 19:40:05 +0000

La grande idée est avant tout pragmatique: il s'agit d'utiliser dotnet pour briser la barrière qui sépare les langages dits académiques des langages dits industriels.

En tant que langage F# est un peu moins ambitieux que ocaml, mais en tant qu'outil il a l'avantage de fournir immédiatement l'accès à la quasi totalité des ressources logicielles disponibles sur une plateforme très populaire.
Par ailleurs l'influence de F# sur C# et la plateforme dotnet en général se fait déjà sentir et elle est très positive à mon avis.

La question la plus évidente c'est: pourquoi ne pas avoir opté pour 100% de compatibilité avec ocaml ?
L'explication c'est la POO de ocaml qui est trop atypique et par conséquent invendable au public visé et qui se marrie mal avec le reste du parc logiciel dotnet.

F# se donne beaucoup plus de chances de réussir à prolonger l'existant en adoptant une POO proche de C#.
F# offre à la programmation fonctionnelle ce qu'elle n'a jamais eu auparavant: un chemin évolutionnaire au lieu d'un chemin révolutionnaire.

Commentaires sur Conférence F# à l’EPITA par cacophrene

cacophrene — Wed, 11 Nov 2009 18:48:03 +0000

Salut !

Bienheureux les gens de l'EPITA qui ont droit à une conférence sur F#, car on dit tout et son contraire sur ce nouveau langage.

Ce serait vraiment sympa d'avoir un bref résumé des grandes idées qui auront été développées lors de la conférence. J'imagine que beaucoup de caméliens se demandent, comme moi : pourquoi et comment F# ? Et pour l'instant les infos disponibles sur le net sont de qualité variable.

Cordialement,
Cacophrène

Commentaires sur Plus d’arguments sans application partielle par ylarvor

ylarvor — Mon, 05 Oct 2009 12:20:37 +0000

mes efforts portent leurs fruits, je comprends tes articles. Je n’en suis pas encore à librement écrire en programmation fonctionnel.

Commentaires sur Le type somme fermée de produits ouverts par gasche

gasche — Thu, 27 Aug 2009 00:11:01 +0000

Ici j’utilise un objet pour avoir des champs nommés, ce qui augmente la lisibilité quand tu as plus de 2/3 « champs » (au détriment de la concision, effectivement).

Effectivement, si tu pensais au sous-typage, il n’est pas utile dans ce cas : pour en profiter et avoir un type extensible, il faudrait rajouter des variantes polymophes et un type dérecursifié.

# type ('a, 'n) _tree = [ `Empty of 'e | `Black of 'b * 'n ]

constraint 'a = < e : 'e; b : 'b; .. >;;

# type 'a tree = ('a, 'a tree) _tree;;

(* -rectypes, sinon constructeur supplémentaire *)

# type ('a, 'n) _rbtree = [('a, 'n) _tree | `Red of 'r * 'n]

constraint 'a = < r : 'r; .. >;;

(* on n'a pas besoin de rementionner les autres champs dans la contrainte *)

# type 'a rbtree = ('a, 'a rbtree) _rbtree;;

# let test = `Black (1, `Empty ());;

val test : [> `Black of int * [> `Empty of unit ] ] = `Black (1, `Empty ())

# (test : _ tree);;

- : < b : int; e : unit; .. > tree = `Black (1, `Empty ())

# (test : _ rbtree);;

- : < b : int; e : unit; r : 'a; .. > rbtree = `Black (1, `Empty ())

Commentaires sur Le type somme fermée de produits ouverts par spiceguid

spiceguid — Thu, 27 Aug 2009 00:08:24 +0000

constraint ouvre des perspectives intéressantes, par exemple la composition au niveau des types :

type ('v,'u) compose =

'a -> 'c

constraint 'u = 'a -> 'b

constraint 'v = 'b -> 'c

Commentaires sur Le type somme fermée de produits ouverts par spiceguid

spiceguid — Wed, 26 Aug 2009 23:43:44 +0000

Il y a un intérêt spécifique à utiliser un type objet alors que ça marche aussi bien avec un type tuple ?

type 'a node =

| Empty of 'e

| Red of 'r * 'a node

| Black of 'b * 'a node

constraint 'a = 'e * 'r * 'b

C’est un peu moins verbeux :

# Black (1,Empty ());;

- : (unit * 'a * int) node = Black (1, Empty ())

Commentaires sur Le type somme fermée de produits ouverts par spiceguid

spiceguid — Wed, 26 Aug 2009 21:45:05 +0000

Oui c’est bof l’absence de prévisualisation sur les commentaires.

Bon, que dire, sinon que tu m’étonne toujours par ton expertise sur des aspects d’ocaml peu documentés.

Un exemple d’instanciation du type ‘a node :

type int_node =

< empty : unit; red : int; black : int > node

Qu’on pourrait dérouler comme ceci :

type int_node =

| Empty of unit

| Red of int * int_node

| Black of int * int_node

Inconvénient perceptible: les types inférés sont plus verbeux que si on avait juste plusieurs paramètres.

# Red (1,Empty ());;

- : < black : 'a; empty : unit; red : int > node = Red (1, Empty ())