Che cosa rende il sistema di tipi Haskell più "potente" rispetto ai sistemi di tipi di altre lingue?

Question

Lettura Disadvantages of Scala type system versus Haskell?, devo chiedere: cos'è, in particolare, che rende il sistema di tipo Haskell più potente dei sistemi di tipi di altri linguaggi (C, C++, Java). Apparentemente, anche Scala non può eseguire alcuni degli stessi poteri del sistema di tipi di Haskell. Che cosa è, in particolare, che rende il sistema di tipi di Haskell (inferenza di tipo Hindley-Milner) così potente? Puoi fare un esempio?

Answer 1

Una cosa che mi piace molto in altre lingue è il supporto di typclasses, che sono una soluzione elegante per molti problemi (incluse ad esempio le funzioni polyvariadic).

Utilizzando typeclasses, è estremamente facile da definire funzioni molto astratte, che sono ancora del tutto type-safe - come ad esempio questo Fibonacci-funzione:

fibs :: Num a => [a] 
fibs@(_:xs) = 0:1:zipWith (+) fibs xs 

Per esempio:

map (`div` 2) fibs  -- integral context 
(fibs !! 10) + 1.234  -- rational context 
map (:+ 1.0) fibs   -- Complex context 

È potrebbe anche definire il tuo tipo numerico per questo.

Answer 2

cosa si tratta, nello specifico, che rende il sistema tipo di Haskell

È stato progettato negli ultimi dieci anni per essere sia flessibile - come logica per la verifica di proprietà - e potente.

Il sistema di tipo Haskell è stato sviluppato nel corso degli anni per incoraggiare una disciplina di controllo statico relativamente flessibile ed espressiva, con diversi gruppi di ricercatori che identificano tecniche di sistema tipo che consentono nuove potenti classi di verifica in fase di compilazione. Scala è relativamente sottosviluppato in quella zona.

Ovvero, Haskell/GHC fornisce una logica potente e progettata per incoraggiare la programmazione a livello di tipo. Qualcosa di abbastanza unico nel mondo della programmazione funzionale.

Alcuni documenti che danno un sapore della direzione dello sforzo di ingegneria sul sistema di tipo di Haskell ha preso:

• Fun with type functions
• Associated types with class
• Fun with functional dependencies

Answer 3

Hindley-Milner non è un digita il sistema, ma un algoritmo di inferenza di tipo. Il sistema di tipo Haskell, nel corso della giornata, era in grado di essere completamente dedotto usando HM, ma quella nave ha navigato a lungo per il moderno Haskell con estensioni. (ML rimane in grado di essere completamente dedotto).

Probabilmente, la capacità di inferire principalmente o interamente tutti i tipi produce potenza in termini di espressività.

Ma questo non è in gran parte quello che penso sia la vera domanda.

Le carte che collegano indicano l'altro aspetto - che le estensioni del sistema di tipi di Haskell lo rendono completo (e che le famiglie di tipi moderni rendono il linguaggio completo più simile alla programmazione a livello di valore). Un altro bel articolo su questo argomento è il numero Faking It: Simulating Dependent Types in Haskell di McBride.

Il foglio nell'altro thread su Scala: "Classi di classi come oggetti e impli- citi" spiega perché in Scala si può effettivamente fare la maggior parte di questo anche se con un po 'più esplicitamente. Tendo a sentire, ma questo è più un sentimento rispetto alla vera esperienza di Scala, che il suo approccio più ad-hoc ed esplicito (quello che la discussione C++ chiama "nominale") è in ultima analisi un po 'disordinato.

Answer 4

Il linguaggio Haskell consente di scrivere codice più sicuro senza rinunciare alle funzionalità. La maggior parte delle lingue al giorno d'oggi commercializza funzionalità per la sicurezza: il linguaggio Haskell è lì per dimostrare che è possibile averli entrambi.

Possiamo vivere senza puntatori nulli, getti espliciti, digitazione libera e avere ancora un linguaggio perfettamente espressivo, in grado di produrre codice finale efficiente.

Di più, il sistema di tipo Haskell, insieme al suo approccio pigro per default e purezza per la codifica, ti dà una spinta in questioni complicate ma importanti come il parallelismo e la concorrenza.

Solo i miei due centesimi.

Answer 5

Facciamo un esempio molto semplice: Maybe di Haskell.

data Maybe a = Nothing | Just a 

In C++:

template <T> 
struct Maybe { 
    bool isJust; 
    T value; // IMPORTANT: must ignore when !isJust 
}; 

Consideriamo queste due firme di funzione, a Haskell:

sumJusts :: Num a => [Maybe a] -> a 

e C++:

template <T> T sumJusts(vector<maybe<T> >); 

Differenze:

• In C++ ci sono più errori possibili da fare. Il compilatore non controlla la regola di utilizzo di Maybe.
• Il tipo C++ di sumJusts non specifica che richiede + e trasmesso da 0. I messaggi di errore che compaiono quando le cose non funzionano sono criptici e strani. In Haskell il compilatore sarà solo si lamentano che il tipo non è un'istanza di Num, molto semplice ..

In breve, Haskell ha:

• ADT
• Type-classi
• A sintassi molto amichevole e buon supporto per i generici (che in C++ le persone cercano di evitare a causa di tutti i loro cripticismi)