Bonjour , savez vous jusqu'à quel point ces langages sons similaires https://gist.github.com/ckirkendall/2934374 J'ai trouvé ce comparatif et je me suis amusé à exécuter le code Ocaml dans la console interactive F# et bien malgré quelques warnings le code se lance me donnant simplement un résultat différent . Je savais que F# était basé sur Ocaml mais je m'attendais à avoir des erreurs franches dans le code .

Salut !

Tiens, c'est marrant que ça marche tel quel en passant d'un langage à l'autre ! Pour le fait que le résultat soit différent, c'est normal, c'est simplement les valeurs qui sont hardcodées dans l'environnement qui différent d'un programme à l'autre, mais ça marche correctement.

En fait, F# reprend carrément tout le noyau d'OCaml, sans gros changement de syntaxe, donc y'a pas de raison qu'il y ait des problèmes sur un programme tout simple comme ça qui n'utilise pas trop de features avancées. Dans les commentaires un peu plus bas ( https://gist.github.com/ckirkendall/2934374#comment-528580 ), quelqu'un poste une version un peu plus "idiomatique" de la programmation Caml, avec le mot-clé "function" ; ça devrait encore passer en F# mais c'est plus dangereux à utiliser, F# ayant tendance à nécessiter un peu plus d'annotations de type que caml. Le message suivant utilise les variants polymorphes et là ça devrait plus passer en F#.

De façon assez générale, OCaml a un système de types / algo d'inférence de types plus avancés que ceux de F# (variants polymorphes, GADT), en contrepartie F# a des trucs un peu plus pratiques pour s'en servir comme "langage de tous les jours" (programmation GUI, compatibilité .NET, ...).

Concrètement, F# a de l'overloading (+, -, *, /, sqrt marchent sur les entiers comme sur les flottants, etc), alors que OCaml a un symbole pour chaque type : +, -, *, / pour les entiers, +., -., *., /. pour les flottants, etc. Idem, x.[i] pour accéder à un tableau, s.(i) pour une chaîne de caractères en OCaml, mais c'est du .[i] partout en F#.

Côté modules, OCaml a des foncteurs alors que F# n'en a pas. F# a des restrictions supplémentaires par rapport à caml : si dans la signature d'un module on déclare val f : int -> int, alors dans l'implémentation du module, on ne pourra pas donner une fonction f qui a un type plus général que int -> int. Par exemple, let f x = x sera refusé, il faut rajouter l'annotation let f (x:int) = x pour restreindre son type.

Une autre différence, OCaml peut faire des structures de données "infinies", comme par exemple une liste cyclique [1,2,3,1,2,3,1,2,3,1,2,3,.....], en déclarant let rec x = 1::2::3::x, c'est pas autorisé en F#.

Super ta réponse J'ai déjà testé F# vite fait avec Spritekit et c'est assez sympa.

 warning FS0025: Incomplete pattern matches on this expression. For example, the value '"aa"' may indicate a case not covered by the pattern(s).

type expression =
  | Number of int
  | Add of expression * expression
  | Multiply of expression * expression
  | Variable of string
val evaluate : env:(string -> int) -> _arg1:expression -> int
val environment : _arg1:string -> int
val expressiontree1 : expression =
  Add (Variable "a",Multiply (Number 2,Variable "b"))
val result : int = 11

Voilà ce que ça fait

Ah oui, le warning c'est à cause de son environnement

let environment (str: string) : 'a =
  match str with "a" -> 3 | "b" -> 4 | "c" -> 5

Il râle parce que c'est pas défini sur tous les éléments de type string, faudrait par exemple rajouter un cas par défaut dans le match, genre « | _ -> 42 » à la fin. Y'a le même warning en OCaml, les deux langages se comportent vraiment pareil sur ce bout de code