C'è un Haskell compilatore o un preprocessore che utilizza una severa valutazione?

Question

Sto cercando un Haskell compilatore che usi valutazione rigorosa di default al posto di lazy evaluation.Vorrei solo utilizzare OCaml, ma Haskell sintassi è molto meglio di OCaml (e Haskell è puro, e ha funzioni interessanti come il tipo di classi).

Mi piacerebbe molto piuttosto non mettere costantemente !s e $!s tutto il mio programma.Un compilatore con un interruttore o un preprocessore per mettere nel rigore annotazioni sarebbe davvero bello.Sarebbe anche utile se ci fosse un modo per utilizzare la lazy evaluation in alcuni luoghi troppo, solo nel caso in cui voglio qualcosa di simile a un elenco infinito (io probabilmente non lo farà mai).

Si prega di non cercare di convincere me che lazy evaluation è meglio, ho davvero bisogno di prestazioni.IIRC, Simon Peyton Jones anche detto che la lazy evaluation non era davvero necessario, era lì soprattutto per evitare che la lingua impura.

Answer 1

Se si dispone di un compilatore Haskell che utilizza la valutazione rigorosa, che non viene compilato Haskell. Pigrizia Non severità fa parte della specifica Haskell!

Tuttavia, ci sono alternative.

• DDC è un tentativo di creare una variante esplicitamente pigro di Haskell che sostiene cose come aggiornamento distruttiva pur mantenendo tutto il resto della bontà di Haskell. C'è un problema: il compilatore è attualmente solo in α-fase, anche se sembra essere almeno utilizzabili

.

• Creare un preprocessore, come altri hanno fatto.

• Imparare ad usare Haskell “nel modo giusto”. Se è possibile semplificare il vostro banco di prova a qualcosa che è pubblicamente visualizzabile, è possibile pubblicarlo su Haskell-Café mailing list , dove le persone sono molto disponibili con questo tipo di domande riguardanti gli effetti del non-severità.

Answer 2

  

mi piacerebbe molto, piuttosto non costantemente messo! S e $! Tutto finito il mio programma

Si sta facendo male, se è così che si programma Haskell :) Semplicemente non sarà necessario fare questo. Utilizzare GHC, usare -O2, utilizzare i tipi di dati rigorosi, se del caso, utilizzare più pigri quando opportuno. Non date per scontato pigrizia sta per essere un problema -. Si tratta di una soluzione ad un sacco di problemi

Answer 3

Ci sono stati due tentativi di valutare rigorosamente Haskell in passato:

• di Jan-Willem Maessen Desideroso Haskell
• Rob Ennals tesi di dottorato

Ma entrambi sono stati concentrati a attaccare alla semantica non-severe di Haskell ma utilizzando un per lo più rigorosa strategia di valutazione, piuttosto che realmente cambiare la semantica, né mai veramente visto la luce del giorno.

Modifica: suggerimento di Martijn di stretta-plugin sembra ideale per i vostri scopi, come fa in realtà ciò che si vuole e l'autore è ancora attivo nella comunità Haskell, avevo dimenticato su di esso

.

Answer 4

Si veda anche GHC-stretto-plugin , un esempio per di GHC quadro plug-in, descritta nel Monad Reader 12 .

Answer 5

Mi sento il vostro dolore. La mia più grande PITA nel mio giorno per giorno la programmazione a che fare con quelli! @ # $% ^ & (Perdite di spazio.

Tuttavia, se aiuta, con il tempo si si impara (il senso duro) su come affrontare questo, e lo fa stare meglio. Ma sto ancora aspettando per Andy Gill a venire fuori con la sua magica profiler spazio perdite per risolvere tutti i miei problemi. (Sto prendendo il suo commento fuori mano per me all'ultimo ICFP che aveva sognato questa idea fresco come una promessa per la sua attuazione.)

Non cercherò di convincervi che la valutazione pigra è la cosa migliore del mondo, ma ci sono alcuni buoni punti su di esso. Ho alcuni programmi di flusso di elaborazione che Scoot liste pigri attraverso qualsiasi varietà di combinatori che girano felicemente su gigabyte di dati durante l'utilizzo di soli 3,5 MB circa di memoria (di cui più di 2 MB è GHC runtime). E qualcuno più intelligente di me mi ha fatto notare l'anno scorso che si sarebbe davvero essere molto sorpreso, come un tipico programmatore Haskell, quanto dipendono valutazione pigra.

Ma che cosa abbiamo veramente bisogno è davvero un buon libro su come affrontare con la valutazione pigra nel mondo reale (che non è così diverso dal mondo accademico, in realtà, tranne che semplicemente non si ottiene un documento pubblicato, e otteniamo clienti venire dopo di noi con i coltelli) che coprirà adeguatamente la maggior parte delle questioni relative al presente e, soprattutto, ci danno un senso intuitivo di quello che sta succedendo per esplodere il nostro mucchio e ciò che non lo è.

Non credo che questa sia una cosa nuova; Sono sicuro che altri linguaggi e architetture sono stati attraverso anche questo. Come hanno fatto i primi programmatori di affrontare con le pile di hardware e tutto ciò che, dopo tutto? Non così bene, scommetto.

Answer 6

Credo che pH compilatore di Jan-Willem Maessan è / era rigoroso. Il prossimo più vicino è speculativa forchetta di valutazione di Robert Ennal per GHC 5. La forcella spec_eval non è rigida, ma invece viene valutata con ottimismo. Non so se uno di questi sono ancora in corso / utilizzabile / etc.

Answer 7

Utilizzando nfdata e RNF ovunque non è una soluzione perché significa più volte attraversare grandi strutture che sono già stati valutati.

Il capitolo introduttivo della tesi di dottorato di Ben Lippmeier (circa DDC) è circa il miglior critica del Haskell che ho visto - si discute questioni di pigrizia, aggiornamento distruttivo, trasformatori monade, ecc DDC ha pigrizia, ma si deve richiedere esplicitamente, ed è considerato un effetto, che viene monitorato e gestito dal sistema di tipo-effetto del DDC.

Answer 8

Recentemente ho visto un po 'di lavoro in questo settore:

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

Si sente un pochino su di esso in aggiornamento di stato GHC di SPJ qui:

http://youtu.be/Ex79K4lvJno?t=9m33s (Link inizia il pezzo rilevante a 09:33)

Answer 9

Sto cercando un Haskell compilatore che usi valutazione rigorosa di default al posto di lazy evaluation.

Un compilatore non sarebbe un Haskell compilatore.Se si davvero desidera, si potrebbe prendere in considerazione di mettere {-# LANGUAGE Strict #-} pragma di file.Questo funziona con GHC 8.0.2, 8.2.2, e 8.4.1, aka le ultime tre versioni del compilatore.

Sarebbe anche utile se ci fosse un modo per utilizzare la lazy evaluation in alcuni luoghi troppo, solo nel caso in cui voglio qualcosa di simile a un elenco infinito

Non c'è nessun tale metodo.Invece, utilizzare GHC come è stato inteso come un pigro lingua.Imparare a pensare il tuo codice, il profilo e l'uso funzionale di strutture di dati correttamente sarà di gran lunga più utili senza pensare di applicare il rigore pragma ovunque.GHC ha già un analizzatore di rigore.

(Io probabilmente non lo farà mai).

Che è esattamente quello che gli autori di llvm-hs pensiero quando si è scelto di utilizzare un rigoroso stato monade, piuttosto che un pigro.Invece, esso ha causato un imprevisto bug lungo la strada.La pigrizia e la ricorsione andare mano nella mano.

Si prega di non cercare di convincere me che lazy evaluation è meglio, ho davvero bisogno di prestazioni.

Io sono di dubbia questo è in realtà ciò che si vuole quando non affidabile aumentare le prestazioni di Haskell codice, mentre contemporaneamente la rottura di codice esistente e rendere le risorse esistenti inutile.Se questo è il modo che hai intenzione di scrivere programmi, si prega di utilizzare OCaml o Scala e lasciare il Haskell sola comunità.

IIRC, Simon Peyton Jones anche detto che la lazy evaluation non era davvero necessario, era lì soprattutto per evitare che la lingua impura.

Che non è vero.Si può leggere di più su la vera storia di Haskell qui

Answer 10

C'è anche seqaid , che mira al centro dello spettro pigro-severo.

  

Seqaid è un plugin che fornisce GHC non invasivo auto-strumentazione di progetti Haskell, per la severità dinamico (e parallelismo) di controllo. Questo sarà presto includono l'ottimizzazione per il sollievo spazio perdite automatizzato usando strictification minima.

Answer 11

È chiaramente avete fatto la vostra mente sul valore di una rigorosa valutazione, ma penso che manca il punto di usare Haskell. valutazione pigra di Haskell consente strategie di ottimizzazione molto più flessibili che possono essere impiegati dal compilatore / interprete. Forzare il proprio rigore prevale l'ottimizzatore. Alla fine, con eccessiva la valutazione rigorosa non sarà mai efficiente come l'ottimizzazione automatizzata. Prova una somma ripiegando una sequenza di numeri in GHCI, con e poi senza valutazione pigra. Si può vedere la differenza chiaramente -. In questo caso la valutazione pigra è sempre più veloce