comparing F# and OCaml

Question

I know roughly how F# and OCaml differ in terms of "features" (e.g. functors, camlp4, units of measure...).

I wonder about the following: Concerning code that doesn't contain said features, is there a difference in coding style (other than say naming conventions) between F# and OCaml? To put it another way, if some (idiomatic) F# code can be translated in a straight forward way (maybe trivially) to OCaml, will this transformation necessarily lead to idiomatic Ocaml?

Edit: From the links provided by Guy Coder I guess that some "idiomatic" OCaml code might not directly translate to "idiomatic" F# code due to the fact that exceptions are much slower in F# (and more widely used in OCaml). What about the other direction? Will some F#ish OCaml code ever provoke a reaction in terms of "Don't do XX that way, the OCaml way to do XX is with exceptions instead of XY.."

Generally, what are the differences in using exceptions in OCaml when compared to the typical usage in F#. Are there other constructs that are differently used in the two languages (e.g. because of performance penalties in one language)?

Answer 1

Yes the translation will be considered idiomatic by many OCaml users for the most part. Since idiomatic is not an exact standard there is no way to measure how idiomatic.

The caveat is that you will have to modify some of the code to make use of features in one language that are not in the other. In particular if a functor is the idiomatic way to do it in OCaml, then you would have to convert the F# code to a Functor. Or if F# made extensive use of the .Net library code, then you would have to recreate those functions in OCaml or find an equivalent.

I have translated my share of ML and OCaml to F# and as you note, and what I refer to as the environment and ethos are what are really the big differences, e.g. functors, camlp4, units of measure, Visual Studio, time travel, NUnit, WPF, etc.

Remember that F# started as OCaml when being ported so for the most part there is still a lot in common.

If you want to see some significant amount of code done in OCaml and F# translated almost line for line take a look at the code for "Handbook of Practical Logic and Automated Reasoning" by John Harrison

F#

OCaml

Then you can judge for yourself.

I do have to note that the code for "Handbook of Practical Logic and Automated Reasoning" does not make use of classes, records, events, and the like. It is almost purely functions.

Another way to compare any two languages in general for idomaticness (OK so I coined that word) is to use Rosetta Code. Rosetta Code contains solutions to programming task written in many languages. So find a programming task, e.g. create a class and then look at the OCaml and F# versions.

Not all of the task are done in all of the languages, but any one can contribute or even suggest new task.