Is it possible to do compile-time execution in OCaml, similar to C++ template metaprogramming?

In C++, recursive templates and constant values as temp开发者_开发问答late parameters allows to do interesting examples of code generation and compile-time execution, such as the factorial.

Is it possible to do similar things in OCaml, using parametric polymorphism, functors, or other concepts?

The ocaml inteference system uses unification. You can consider it a computational device, and in this case it has a feeling of logic programming. But the possibilities are rather restricted as this was never one of the goals of the type system. As you will see in the page suggested by Jeffrey, type-level computations through unification are actually rather limited (hard to express eg. multiplication). Haskell has a more powerful constraint language, abut again I'm not sure logic programming in the type system is a good way to go.

The other part of the OCaml type system can do type-level computation is in its module and functor language. Functors allow to express type-level computations in a flavor that has been linked to the formal programming language Fω. You could probably encode church numerals at the type level in the module language, but I don't see what you could do with this, as it is seems quite difficult to retrieve the results in an useful, exploitable form. In particular, I don't see how to turn that type information back into values usable by your program, as C++ or D do with their compile-time constant computation.

So yes, the type system of OCaml (and most functional language, that would hold of SML, Haskell and Scala as well) has some computational strength, but no, I wouldn't expect to do particularly useful pre-computation with them; and it's certainly not standard practice among OCaml programmers. Types are best seen as types, that bring static guarantees about the values they classify.

You can do arithmetic in the OCaml type system; a very simple example appears on this other Stackoverflow page:

type level integers in ocaml

I imagine you could use this mechanism to calculate factorials in the type system. If you use the standard unary (Peano) encoding of numbers, the results are pretty ghastly once the numbers start to get big. So it would just be an interesting stunt.

If you want to see really interesting computations at the type level, you should look at Haskell. Some common extensions (available in GHC) allow arbitrary computations in the type system. I.e., the type system is Turing complete.