programming languages - pinecone - Lenguajes funcionales dirigidos a LLVM

make a programming language in java

Question

¿Hay algún idioma que se dirija a LLVM que:

• Están tipicamente tipificados
• Usar tipo de inferencia
• Son funcionales (es decir, expresiones lambda, cierres, listas primitivas, listas de comprensión, etc.)
• Tener características orientadas a objetos de primera clase (herencia, polimorfismo, mixins, etc.)
• Tener un sistema de tipo sofisticado (genéricos, covarianza y contravarianza, etc.)

Scala es todo esto, pero solo se dirige a la JVM. F # (y hasta cierto punto C #) es la mayoría si no todos estos, pero solo los objetivos .NET. ¿Qué lenguaje similar se dirige a LLVM?

Answer 1

Hay un backend Haskell (GHC) dirigido a LLVM.

También podría intentar usar F # a través de Mono-LLVM .

Además, el proyecto VMKit está implementando tanto la JVM como la .NET CLI sobre LLVM; todavía está en sus etapas iniciales, pero una vez que madura puede usarlo con F # o con cualquier lenguaje funcional de JVM (Scala, Clojure, etc.)

Answer 2

No estoy seguro de cuánto han progresado, pero pueden valer la pena agregar a la lista:

Scala para LLVM - https://github.com/greedy/scala/
Madera para LLVM - https://bitbucket.org/capitrane/timber-llvm
Mono para LLVM - Mono-LLVM

Answer 3

Sí ... clang . C ++ tiene todo en su lista, excepto la lista de comprensiones. También es el lenguaje LLVM insignia.

"Están estáticamente estáticos"

Sip

"Usar inferencia de tipo"

// 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

"Son funcionales (es decir, expresiones lambda, cierres, listas primitivas, listas de comprensión, etc.)"

Lambdas en c ++ se parece a [capture_spec](arglist...) { body } . Puede capturar variables cerradas por referencia (similar a lisp) de esta forma: [&]. Alternativamente, puede capturar por valor de la siguiente manera: [=].

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

En C ++ map, zip y reduce se llaman std :: transform y 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; });

También puede configurar las listas de comprensión usando una macro y un wrapper alrededor de std :: transform si realmente quiere ...

"Tener características orientadas a objetos de primera clase (herencia, polimorfismo, mixins, etc.)"

Por supuesto. C ++ permite despacho virtual + herencia múltiple + herencia de implementación. Nota: mixins es solo herencia de implementación. Solo necesita un mecanismo especial de "mixin" si su idioma prohíbe la herencia múltiple.

"Tener un sistema de tipo sofisticado (genéricos, covarianza y contravarianza, etc.)"

Las plantillas C ++ son el sistema de genéricos más poderoso en cualquier idioma, hasta donde yo sé.