Functional languages targeting the LLVM

Question

Are there any languages that target the LLVM that:

• Are statically typed
• Use type inference
• Are functional (i.e. lambda expressions, closures, list primitives, list comprehensions, etc.)
• Have first class object-oriented features (inheritance, polymorphism, mixins, etc.)
• Have a sophisticated type system (generics, covariance and contravariance, etc.)

Scala is all of these, but only targets the JVM. F# (and to some extent C#) is most if not all of these, but only targets .NET. What similar language targets the LLVM?

Answer 1

There's a Haskell (GHC) backend targeting the LLVM.

You could also try using F# through Mono-LLVM.

Also, the VMKit project is implementing both the JVM and the .NET CLI on top of LLVM; it's still in its early stages but once it matures you could use it with F#, or any JVM-targeting functional languages (Scala, Clojure, etc.)

Answer 2

I'm not sure how far these have progressed, but they may be worth adding to the list:

Scala for LLVM - https://github.com/greedy/scala/
Timber for LLVM - https://bitbucket.org/capitrane/timber-llvm
Mono for LLVM - http://www.mono-project.com/Mono_LLVM

Answer 3

Yes... clang. C++ has everything on your list except for list comprehensions. It is also the flagship LLVM language.

"Are statically typed"

Yup

"Use type inference"

// local type inference
auto var = 10;

// type inference on parameters to generic functions
template <typename T>
void my_function(T arg) {
    ...
}
my_function(1) // infers that T = int

// correctly handles more complicated cases where type is partially specified.
template <typename T>
void my_function(std::vector<T> arg) {
    ...
}
std::vector<int> my_vec = {1, 2, 3, 4};
my_function(my_vec) // infers that T = int

"Are functional (i.e. lambda expressions, closures, list primitives, list comprehensions, etc.)"

Lambdas in c++ look like [capture_spec](arglist...) { body }. You can either capture closed over variables by reference (similar to lisp) like so: [&]. Alternatively you can capture by value like so: [=].

int local = 10;
auto my_closure = [&]() { return local;};
my_closure(); // returns 10.

In C++ map, zip, and reduce are called std::transform and std::accumulate.

std::vector<int> vec = {1, 2, 3, 4};
int sum = std::accumulate(vec.begin(), vec.end(), [](int x, int y) { return x + y; });

You can also rig up list comprehensions using a macro and and a wrapper around std::transform if you really want...

"Have first class object-oriented features (inheritance, polymorphism, mixins, etc.)"

Of course. C++ allows virtual dispatch + multiple inheritance + implementation inheritance. Note: mixins are just implementation inheritance. You only need a special "mixin" mechanism if your language prohibits multiple inheritance.

"Have a sophisticated type system (generics, covariance and contravariance, etc.)"

C++ templates are the most powerful generics system in any language as far as I know.