33 votes

Langages fonctionnels ciblant la LLVM

Existe-il des langues qui cible la LLVM que:

  • Sont statiquement typé
  • Utiliser l'inférence de type
  • Sont fonctionnels (c'est à dire les expressions lambda, les fermetures, la liste des primitives, interprétations de la liste, etc.)
  • Ont première classe des fonctionnalités orientées objet (héritage, polymorphisme, mixin, etc.)
  • Avoir un sophistiqué système de type (génériques, la covariance et la contravariance, etc.)

Scala est l'ensemble de ces, mais ne vise que la JVM. F# (et dans une certaine mesure, C#) est la plupart, si ce n'est la totalité, mais seulement des cibles .NET. Ce même langue cible le LLVM?

39voto

tzaman Points 13190

Il y a un Haskell (GHC) backend ciblant les LLVM.

Vous pouvez également essayer d'utiliser F# par Mono-LLVM.

Aussi, le VMKit projet est mise en œuvre à la fois la JVM et le .NET de la CLI sur le dessus de LLVM; il en est encore à ses débuts, mais une fois qu'il arrive à échéance, vous pouvez l'utiliser avec F#, ou toute JVM de ciblage des langages fonctionnels (Scala, Clojure, etc.)

13voto

T.R. Points 1293

Je ne sais pas dans quelle mesure ils ont progressé, mais ils mériteraient peut-être d'être ajoutés à la liste:

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

-3voto

catphive Points 1645

Oui... clang. C++ a tout sur votre liste, sauf pour les interprétations de la liste. C'est aussi le phare de LLVM langue.

"Sont statiquement typé"

Yup

"Utiliser l'inférence de type"

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

"Sont fonctionnels (c'est à dire les expressions lambda, les fermetures, la liste des primitives, interprétations de la liste, etc.)"

Les Lambdas en c++ ressemble [capture_spec](arglist...) { body }. Vous pouvez soit saisir fermé sur les variables par référence (similaire à lisp) comme suit: [&]. Sinon, vous pouvez capturer en valeur de la sorte: [=].

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

En C++ carte, zip, et de réduire sont appelés std::transform et 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; });

Vous pouvez également monter interprétations de la liste à l'aide d'une macro et et un wrapper autour de std::transform si vous voulez vraiment...

"Avez-première de la classe des fonctionnalités orientées objet (héritage, polymorphisme, mixin, etc.)"

Bien sûr. C++ permet virtuel envoi + l'héritage multiple + mise en œuvre de l'héritage. Remarque: mixin sont seulement la mise en place d'héritage. Vous avez seulement besoin d'une spéciale "mixin" mécanisme si votre langue interdit l'héritage multiple.

"Avoir un sophistiqué système de type (génériques, la covariance et la contravariance, etc.)"

Les modèles C++ sont les plus puissants des génériques système dans n'importe quelle langue autant que je sache.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by: