Y at-il un compilateur Haskell ou préprocesseur qui utilise une évaluation stricte?

StackOverflow https://stackoverflow.com/questions/996052

Question

Je cherche un compilateur Haskell qui utilise une évaluation rigoureuse par défaut au lieu de l'évaluation paresseuse. Je voudrais simplement utiliser OCaml, mais la syntaxe de Haskell est tellement mieux (est pur, et a des caractéristiques fraîches et Haskell comme les classes de type) de qu'OCaml.

Je préfèrerais ne pas constamment mis !s et $!s tout mon programme. Un compilateur avec un commutateur ou un préprocesseur pour mettre dans les annotations de strictness serait vraiment sympa. Il serait également utile s'il y avait un moyen d'utiliser l'évaluation paresseuse dans certains endroits aussi, au cas où je veux quelque chose comme une liste infinie (je vais probablement jamais).

S'il vous plaît ne pas essayer de me convaincre que l'évaluation paresseuse est mieux, je vraiment besoin de la performance. IIRC, Simon Peyton Jones a même dit que l'évaluation paresseuse était pas vraiment nécessaire, il était là la plupart du temps pour les empêcher de faire l'impur de la langue.

Était-ce utile?

La solution

Si vous avez un compilateur Haskell qui utilise une évaluation stricte, il ne compile pas Haskell. Paresse non fait partie de la rigueur la spécification Haskell!

Cependant, il existe des alternatives.

  • DDC est une tentative de créer une variante explicitement paresseuse de Haskell qui soutient des choses comme la mise à jour destructive tout en conservant tout le reste de la bonté de Haskell. Il y a un problème: le compilateur est actuellement en α-temps, bien qu'il semble être au moins utile

    • .

  • Créer une préprocesseur, comme d'autres l'ont fait.

  • Apprendre à utiliser Haskell « le droit chemin ». Si vous pouvez simplifier votre cas de test à quelque chose qui est publiquement affichable, vous pouvez poster sur liste de diffusion Haskell-Café , où les gens sont très utiles avec ce genre de questions concernant les effets de la non-rigueur.

Autres conseils

  

Je préfèrerais ne pas constamment mis! S et $! S sur mon programme

Vous faites fausse route, si c'est la façon dont vous la programmation Haskell :) Vous ne aurez pas besoin de le faire. Utilisez GHC, utilisez -O2, utiliser des types de données strictes, le cas échéant, utiliser les paresseux, le cas échéant. Ne présumez pas la paresse va être un problème -. Il est une solution à beaucoup de problèmes

Il y a eu deux tentatives d'évaluation strictement Haskell dans le passé:

Mais les deux ont été concentrés sur coller à la sémantique non stricte de Haskell mais en utilisant une stratégie d'évaluation essentiellement stricte, plutôt que de changer réellement la sémantique, et ne jamais vraiment vu la lumière du jour.

Edit: la suggestion de Martijn de-plugin stricte semble idéal pour vos besoins comme il le fait en fait ce que vous voulez et l'auteur est toujours actif dans la communauté Haskell, je l'avais oublié ce

.

Voir aussi GHC stricte-plugin , un exemple pour cadre plugin de GHC, décrit dans la section Monade lecteur 12 .

Je ressens votre douleur. Mon plus grand PITA dans ma programmation au jour le jour traite avec les! @ # $% ^ & (Fuites d'espace.

Cependant, si elle aide, avec le temps que vous n'apprenez (la dure) sur la façon de faire face à cela, et il va mieux. Mais je suis toujours en attente pour Andy Gill à venir avec son profileur de fuite d'espace magique pour résoudre tous mes problèmes. (Je prends son commentaire hors main pour moi à la dernière ICFP qu'il avait imaginé cette idée fraîche comme une promesse de le mettre en œuvre.)

Je ne vais pas essayer de vous convaincre que l'évaluation paresseuse est la meilleure chose dans le monde, mais il y a certains points positifs à ce sujet. J'ai des programmes de traitement de flux qui Scoot listes paresseux par une variété de combinateurs qui fonctionnent heureusement sur gigaoctets de données en utilisant seulement 3,5 Mo de mémoire ou si (dont plus de 2 Mo est temps d'exécution GHC). Et quelqu'un plus intelligent que je me le faisait remarquer l'année dernière que vous voulez vraiment être très surpris, en tant que programmeur Haskell typique, combien vous dépendent de l'évaluation paresseuse.

Mais ce que nous avons vraiment besoin est un très bon livre sur le traitement à l'évaluation paresseuse dans le monde réel (qui est pas si différent du monde académique, vraiment, sauf qu'ils ne sont pas simplement un document publié, et nous obtenons des clients à venir après nous avec des couteaux) qui couvrira bien la plupart des questions relatives à cela et, plus important encore, nous donner un sens intuitif de ce qui va exploser notre tas et ce n'est pas.

Je ne pense pas que ce soit une chose nouvelle; Je suis sûr que d'autres langues et architectures ont été à travers aussi. Comment les premiers programmeurs de traiter avec des piles de matériel et tout ce qui, après tout? Pas si bien, je parie.

Je pense que est / a été strict. La prochaine est le plus proche fourchette d'évaluation spéculative de Robert Ennal pour GHC 5. La fourche spec_eval n'est pas stricte, mais évalue avec optimisme. Je ne sais pas si l'un de ceux qui sont encore en cours / utilisable / etc.

Utilisation nfdata et RNF partout est pas une solution car cela signifie traverser de façon répétée de grandes structures qui ont déjà été évalués.

Le chapitre introductif de la thèse de doctorat de Ben Lippmeier (environ DDC) est sur la meilleure critique de Haskell que je l'ai vu - il traite des questions de la paresse, la mise à jour destructive, transformateurs monade, etc. DDC a la paresse, mais vous devez demander explicitement, et il est considéré comme un effet, qui est suivi et géré par le système de type à effet de DDC.

J'ai vu récemment des travaux dans ce domaine:

https://ghc.haskell.org/trac/ghc/wiki/StrictPragma

Vous pouvez entendre un petit peu à ce sujet dans la GHC mise à jour du statut de SPJ ici:

http://youtu.be/Ex79K4lvJno?t=9m33s (Lien commence à la pièce concernée à 09h33)

  

Je cherche un compilateur Haskell qui utilise une évaluation rigoureuse par défaut au lieu de l'évaluation paresseuse.

Un tel compilateur ne serait pas un compilateur Haskell. Si vous vraiment voulez, vous pouvez envisager de mettre pragma du {-# LANGUAGE Strict #-} dans vos fichiers. Cela fonctionne avec GHC 8.0.2, 8.2.2 et 8.4.1, alias les trois dernières versions du compilateur.

  

Il serait également utile s'il y avait un moyen d'utiliser l'évaluation paresseuse dans certains endroits aussi, au cas où je veux quelque chose comme une liste infinie

Il n'y a pas cette méthode. Au lieu de cela, utiliser GHC comme il était prévu - comme langue paresseuse. Apprendre à penser à votre code, le profil, et utiliser les structures de données fonctionnelles correctement sera beaucoup plus utile que l'application sans réfléchir strictness pragma partout. GHC a déjà un analyseur de rigueur.

  

(je vais probablement jamais).

C'est exactement ce que les auteurs de LLVM-hs pensé quand ils ont choisi d'utiliser un état strict monade plutôt qu'un paresseux. Au lieu de cela, il a causé un bug inattendu sur la route. Paresse et main dans la main vont récursive.

  

S'il vous plaît ne pas essayer de me convaincre que l'évaluation paresseuse est mieux, je vraiment besoin de la performance.

Je suis ce douteux est en fait ce que vous voulez quand il n'augmente pas de manière fiable la performance d'un code Haskell tout en brisant simultanément le code existant et rendre les ressources existantes inutiles. Si cela est la façon dont vous avez l'intention d'écrire des programmes, s'il vous plaît utiliser juste OCaml ou Scala et laisser seul la communauté Haskell.

  

IIRC, Simon Peyton Jones a même dit que l'évaluation paresseuse était pas vraiment nécessaire, il y avait la plupart du temps pour les empêcher de faire l'impur de la langue.

Ce n'est pas vrai. Vous pouvez en savoir plus sur l'histoire réelle de Haskell ici

Il y a aussi seqaid , qui vise au milieu du spectre paresseux stricte.

  

Seqaid est un plugin GHC fournissant auto-instrumentation non-invasive de projets Haskell, par la rigueur dynamique (et de parallélisme) de contrôle. Cela va bientôt inclure l'optimisation pour le soulagement des fuites d'espace automatisé à l'aide strictification minimale.

Vous avez clairement fait votre esprit sur la valeur de l'évaluation stricte, mais je pense que vous manquez le point d'utiliser Haskell. évaluation paresseuse de Haskell permet des stratégies d'optimisation beaucoup plus souples à utiliser par le compilateur / interpréteur. Forcer votre propre remplace l'optimiseur rigueur. En fin de compte, en utilisant l'évaluation stricte excessive ne sera jamais aussi efficace que l'optimisation automatisée. Essayez une somme de pliage au cours d'une séquence de nombres dans GHCi, avec et sans évaluation paresseuse. Vous pouvez voir clairement la différence -. Dans ce cas, l'évaluation paresseuse est toujours plus rapide

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top